Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ b5a3541d

History | View | Annotate | Download (87.9 KB)

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

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

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

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

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

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

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

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

    
64
    if(!filename)
65
        return 0;
66

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

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

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

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

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

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

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

    
139
    return fmt;
140
}
141

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

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

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

    
171
/* memory handling */
172

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

    
179
int av_new_packet(AVPacket *pkt, int size)
180
{
181
    uint8_t *data;
182
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
183
        return AVERROR_NOMEM;
184
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
185
    if (!data)
186
        return AVERROR_NOMEM;
187
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
188

    
189
    av_init_packet(pkt);
190
    pkt->data = data;
191
    pkt->size = size;
192
    pkt->destruct = av_destruct_packet;
193
    return 0;
194
}
195

    
196
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
197
{
198
    int ret= av_new_packet(pkt, size);
199

    
200
    if(ret<0)
201
        return ret;
202

    
203
    pkt->pos= url_ftell(s);
204

    
205
    ret= get_buffer(s, pkt->data, size);
206
    if(ret<=0)
207
        av_free_packet(pkt);
208
    else
209
        pkt->size= ret;
210

    
211
    return ret;
212
}
213

    
214
int av_dup_packet(AVPacket *pkt)
215
{
216
    if (pkt->destruct != av_destruct_packet) {
217
        uint8_t *data;
218
        /* we duplicate the packet and don't forget to put the padding
219
           again */
220
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
221
            return AVERROR_NOMEM;
222
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
223
        if (!data) {
224
            return AVERROR_NOMEM;
225
        }
226
        memcpy(data, pkt->data, pkt->size);
227
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
228
        pkt->data = data;
229
        pkt->destruct = av_destruct_packet;
230
    }
231
    return 0;
232
}
233

    
234
int av_filename_number_test(const char *filename)
235
{
236
    char buf[1024];
237
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
238
}
239

    
240
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
241
{
242
    AVInputFormat *fmt1, *fmt;
243
    int score;
244

    
245
    fmt = NULL;
246
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
247
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
248
            continue;
249
        score = 0;
250
        if (fmt1->read_probe) {
251
            score = fmt1->read_probe(pd);
252
        } else if (fmt1->extensions) {
253
            if (match_ext(pd->filename, fmt1->extensions)) {
254
                score = 50;
255
            }
256
        }
257
        if (score > *score_max) {
258
            *score_max = score;
259
            fmt = fmt1;
260
        }
261
    }
262
    return fmt;
263
}
264

    
265
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
266
    int score=0;
267
    return av_probe_input_format2(pd, is_opened, &score);
268
}
269

    
270
/************************************************************/
271
/* input media file */
272

    
273
/**
274
 * Open a media file from an IO stream. 'fmt' must be specified.
275
 */
276
static const char* format_to_name(void* ptr)
277
{
278
    AVFormatContext* fc = (AVFormatContext*) ptr;
279
    if(fc->iformat) return fc->iformat->name;
280
    else if(fc->oformat) return fc->oformat->name;
281
    else return "NULL";
282
}
283

    
284
#define OFFSET(x) offsetof(AVFormatContext,x)
285
#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
286
//these names are too long to be readable
287
#define E AV_OPT_FLAG_ENCODING_PARAM
288
#define D AV_OPT_FLAG_DECODING_PARAM
289

    
290
static const AVOption options[]={
291
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
292
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
293
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
294
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
295
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
296
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
297
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
298
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
299
{"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},
300
{NULL},
301
};
302

    
303
#undef E
304
#undef D
305
#undef DEFAULT
306

    
307
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
308

    
309
static void avformat_get_context_defaults(AVFormatContext *s)
310
{
311
    memset(s, 0, sizeof(AVFormatContext));
312

    
313
    s->av_class = &av_format_context_class;
314

    
315
    av_opt_set_defaults(s);
316
}
317

    
318
AVFormatContext *av_alloc_format_context(void)
319
{
320
    AVFormatContext *ic;
321
    ic = av_malloc(sizeof(AVFormatContext));
322
    if (!ic) return ic;
323
    avformat_get_context_defaults(ic);
324
    ic->av_class = &av_format_context_class;
325
    return ic;
326
}
327

    
328
int av_open_input_stream(AVFormatContext **ic_ptr,
329
                         ByteIOContext *pb, const char *filename,
330
                         AVInputFormat *fmt, AVFormatParameters *ap)
331
{
332
    int err;
333
    AVFormatContext *ic;
334
    AVFormatParameters default_ap;
335

    
336
    if(!ap){
337
        ap=&default_ap;
338
        memset(ap, 0, sizeof(default_ap));
339
    }
340

    
341
    if(!ap->prealloced_context)
342
        ic = av_alloc_format_context();
343
    else
344
        ic = *ic_ptr;
345
    if (!ic) {
346
        err = AVERROR_NOMEM;
347
        goto fail;
348
    }
349
    ic->iformat = fmt;
350
    if (pb)
351
        ic->pb = *pb;
352
    ic->duration = AV_NOPTS_VALUE;
353
    ic->start_time = AV_NOPTS_VALUE;
354
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
355

    
356
    /* allocate private data */
357
    if (fmt->priv_data_size > 0) {
358
        ic->priv_data = av_mallocz(fmt->priv_data_size);
359
        if (!ic->priv_data) {
360
            err = AVERROR_NOMEM;
361
            goto fail;
362
        }
363
    } else {
364
        ic->priv_data = NULL;
365
    }
366

    
367
    err = ic->iformat->read_header(ic, ap);
368
    if (err < 0)
369
        goto fail;
370

    
371
    if (pb && !ic->data_offset)
372
        ic->data_offset = url_ftell(&ic->pb);
373

    
374
    *ic_ptr = ic;
375
    return 0;
376
 fail:
377
    if (ic) {
378
        av_freep(&ic->priv_data);
379
    }
380
    av_free(ic);
381
    *ic_ptr = NULL;
382
    return err;
383
}
384

    
385
/** Size of probe buffer, for guessing file type from file contents. */
386
#define PROBE_BUF_MIN 2048
387
#define PROBE_BUF_MAX (1<<20)
388

    
389
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
390
                       AVInputFormat *fmt,
391
                       int buf_size,
392
                       AVFormatParameters *ap)
393
{
394
    int err, must_open_file, file_opened, probe_size;
395
    AVProbeData probe_data, *pd = &probe_data;
396
    ByteIOContext pb1, *pb = &pb1;
397

    
398
    file_opened = 0;
399
    pd->filename = "";
400
    if (filename)
401
        pd->filename = filename;
402
    pd->buf = NULL;
403
    pd->buf_size = 0;
404

    
405
    if (!fmt) {
406
        /* guess format if no file can be opened  */
407
        fmt = av_probe_input_format(pd, 0);
408
    }
409

    
410
    /* do not open file if the format does not need it. XXX: specific
411
       hack needed to handle RTSP/TCP */
412
    must_open_file = 1;
413
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
414
        must_open_file = 0;
415
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
416
    }
417

    
418
    if (!fmt || must_open_file) {
419
        /* if no file needed do not try to open one */
420
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
421
            err = AVERROR_IO;
422
            goto fail;
423
        }
424
        file_opened = 1;
425
        if (buf_size > 0) {
426
            url_setbufsize(pb, buf_size);
427
        }
428

    
429
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
430
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
431
            /* read probe data */
432
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
433
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
434
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
435
                url_fclose(pb);
436
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
437
                    file_opened = 0;
438
                    err = AVERROR_IO;
439
                    goto fail;
440
                }
441
            }
442
            /* guess file format */
443
            fmt = av_probe_input_format2(pd, 1, &score);
444
        }
445
        av_freep(&pd->buf);
446
    }
447

    
448
    /* if still no format found, error */
449
    if (!fmt) {
450
        err = AVERROR_NOFMT;
451
        goto fail;
452
    }
453

    
454
    /* XXX: suppress this hack for redirectors */
455
#ifdef CONFIG_NETWORK
456
    if (fmt == &redir_demuxer) {
457
        err = redir_open(ic_ptr, pb);
458
        url_fclose(pb);
459
        return err;
460
    }
461
#endif
462

    
463
    /* check filename in case of an image number is expected */
464
    if (fmt->flags & AVFMT_NEEDNUMBER) {
465
        if (!av_filename_number_test(filename)) {
466
            err = AVERROR_NUMEXPECTED;
467
            goto fail;
468
        }
469
    }
470
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
471
    if (err)
472
        goto fail;
473
    return 0;
474
 fail:
475
    av_freep(&pd->buf);
476
    if (file_opened)
477
        url_fclose(pb);
478
    *ic_ptr = NULL;
479
    return err;
480

    
481
}
482

    
483
/*******************************************************/
484

    
485
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
486
{
487
    av_init_packet(pkt);
488
    return s->iformat->read_packet(s, pkt);
489
}
490

    
491
/**********************************************************/
492

    
493
/**
494
 * Get the number of samples of an audio frame. Return (-1) if error.
495
 */
496
static int get_audio_frame_size(AVCodecContext *enc, int size)
497
{
498
    int frame_size;
499

    
500
    if (enc->frame_size <= 1) {
501
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
502

    
503
        if (bits_per_sample) {
504
            if (enc->channels == 0)
505
                return -1;
506
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
507
        } else {
508
            /* used for example by ADPCM codecs */
509
            if (enc->bit_rate == 0)
510
                return -1;
511
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
512
        }
513
    } else {
514
        frame_size = enc->frame_size;
515
    }
516
    return frame_size;
517
}
518

    
519

    
520
/**
521
 * Return the frame duration in seconds, return 0 if not available.
522
 */
523
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
524
                                   AVCodecParserContext *pc, AVPacket *pkt)
525
{
526
    int frame_size;
527

    
528
    *pnum = 0;
529
    *pden = 0;
530
    switch(st->codec->codec_type) {
531
    case CODEC_TYPE_VIDEO:
532
        if(st->time_base.num*1000LL > st->time_base.den){
533
            *pnum = st->time_base.num;
534
            *pden = st->time_base.den;
535
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
536
            *pnum = st->codec->time_base.num;
537
            *pden = st->codec->time_base.den;
538
            if (pc && pc->repeat_pict) {
539
                *pden *= 2;
540
                *pnum = (*pnum) * (2 + pc->repeat_pict);
541
            }
542
        }
543
        break;
544
    case CODEC_TYPE_AUDIO:
545
        frame_size = get_audio_frame_size(st->codec, pkt->size);
546
        if (frame_size < 0)
547
            break;
548
        *pnum = frame_size;
549
        *pden = st->codec->sample_rate;
550
        break;
551
    default:
552
        break;
553
    }
554
}
555

    
556
static int is_intra_only(AVCodecContext *enc){
557
    if(enc->codec_type == CODEC_TYPE_AUDIO){
558
        return 1;
559
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
560
        switch(enc->codec_id){
561
        case CODEC_ID_MJPEG:
562
        case CODEC_ID_MJPEGB:
563
        case CODEC_ID_LJPEG:
564
        case CODEC_ID_RAWVIDEO:
565
        case CODEC_ID_DVVIDEO:
566
        case CODEC_ID_HUFFYUV:
567
        case CODEC_ID_FFVHUFF:
568
        case CODEC_ID_ASV1:
569
        case CODEC_ID_ASV2:
570
        case CODEC_ID_VCR1:
571
            return 1;
572
        default: break;
573
        }
574
    }
575
    return 0;
576
}
577

    
578
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
579
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
580
    int64_t delta= last_ts - mask/2;
581
    return  ((lsb - delta)&mask) + delta;
582
}
583

    
584
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
585
                               AVCodecParserContext *pc, AVPacket *pkt)
586
{
587
    int num, den, presentation_delayed, delay, i;
588
    int64_t offset;
589
    /* handle wrapping */
590
    if(st->cur_dts != AV_NOPTS_VALUE){
591
        if(pkt->pts != AV_NOPTS_VALUE)
592
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
593
        if(pkt->dts != AV_NOPTS_VALUE)
594
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
595
    }
596

    
597
    if (pkt->duration == 0) {
598
        compute_frame_duration(&num, &den, st, pc, pkt);
599
        if (den && num) {
600
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
601
        }
602
    }
603

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

    
614
    if(is_intra_only(st->codec))
615
        pkt->flags |= PKT_FLAG_KEY;
616

    
617
    /* do we have a video B frame ? */
618
    delay= st->codec->has_b_frames;
619
    presentation_delayed = 0;
620
    /* XXX: need has_b_frame, but cannot get it if the codec is
621
        not initialized */
622
    if (delay &&
623
        pc && pc->pict_type != FF_B_TYPE)
624
        presentation_delayed = 1;
625
    /* this may be redundant, but it shouldnt hurt */
626
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
627
        presentation_delayed = 1;
628

    
629
    if(st->cur_dts == AV_NOPTS_VALUE){
630
        st->cur_dts = -delay * pkt->duration;
631
    }
632

    
633
//    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);
634
    /* interpolate PTS and DTS if they are not present */
635
    if(delay <=1){
636
        if (presentation_delayed) {
637
            /* DTS = decompression time stamp */
638
            /* PTS = presentation time stamp */
639
            if (pkt->dts == AV_NOPTS_VALUE)
640
                pkt->dts = st->last_IP_pts;
641
            if (pkt->dts == AV_NOPTS_VALUE)
642
                pkt->dts = st->cur_dts;
643

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

    
663
            /* presentation is not delayed : PTS and DTS are the same */
664
            if(pkt->pts == AV_NOPTS_VALUE)
665
                pkt->pts = pkt->dts;
666
            if(pkt->pts == AV_NOPTS_VALUE)
667
                pkt->pts = st->cur_dts;
668
            pkt->dts = pkt->pts;
669
            st->cur_dts = pkt->pts + pkt->duration;
670
        }
671
    }
672

    
673
    if(pkt->pts != AV_NOPTS_VALUE){
674
        st->pts_buffer[0]= pkt->pts;
675
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
676
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
677
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
678
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
679
        if(pkt->dts == AV_NOPTS_VALUE)
680
            pkt->dts= st->pts_buffer[0];
681
        if(pkt->dts > st->cur_dts)
682
            st->cur_dts = pkt->dts;
683
    }
684

    
685
//    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);
686

    
687
    /* update flags */
688
    if (pc) {
689
        pkt->flags = 0;
690
        /* key frame computation */
691
            if (pc->pict_type == FF_I_TYPE)
692
                pkt->flags |= PKT_FLAG_KEY;
693
    }
694
}
695

    
696
void av_destruct_packet_nofree(AVPacket *pkt)
697
{
698
    pkt->data = NULL; pkt->size = 0;
699
}
700

    
701
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
702
{
703
    AVStream *st;
704
    int len, ret, i;
705

    
706
    av_init_packet(pkt);
707

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

    
729
                /* return packet if any */
730
                if (pkt->size) {
731
                got_packet:
732
                    pkt->duration = 0;
733
                    pkt->stream_index = st->index;
734
                    pkt->pts = st->parser->pts;
735
                    pkt->dts = st->parser->dts;
736
                    pkt->destruct = av_destruct_packet_nofree;
737
                    compute_pkt_fields(s, st, st->parser, pkt);
738

    
739
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
740
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
741
                                           0, 0, AVINDEX_KEYFRAME);
742
                    }
743

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

    
773
            st = s->streams[s->cur_pkt.stream_index];
774
            if(st->codec->debug & FF_DEBUG_PTS)
775
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
776
                    s->cur_pkt.stream_index,
777
                    s->cur_pkt.pts,
778
                    s->cur_pkt.dts,
779
                    s->cur_pkt.size);
780

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

    
806
    return 0;
807
}
808

    
809
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
810
{
811
    AVPacketList *pktl;
812
    int eof=0;
813
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
814

    
815
    for(;;){
816
        pktl = s->packet_buffer;
817
        if (pktl) {
818
            AVPacket *next_pkt= &pktl->pkt;
819

    
820
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
821
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
822
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
823
                       && next_pkt->dts < pktl->pkt.dts
824
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
825
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
826
                        next_pkt->pts= pktl->pkt.dts;
827
                    }
828
                    pktl= pktl->next;
829
                }
830
                pktl = s->packet_buffer;
831
            }
832

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

    
854
            /* duplicate the packet */
855
            if (av_dup_packet(pkt) < 0)
856
                return AVERROR_NOMEM;
857

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

    
860
            pktl = av_mallocz(sizeof(AVPacketList));
861
            if (!pktl)
862
                return AVERROR_NOMEM;
863

    
864
            /* add the packet in the buffered packet list */
865
            *plast_pktl = pktl;
866
            pktl->pkt= *pkt;
867
        }else{
868
            assert(!s->packet_buffer);
869
            return av_read_frame_internal(s, pkt);
870
        }
871
    }
872
}
873

    
874
/* XXX: suppress the packet queue */
875
static void flush_packet_queue(AVFormatContext *s)
876
{
877
    AVPacketList *pktl;
878

    
879
    for(;;) {
880
        pktl = s->packet_buffer;
881
        if (!pktl)
882
            break;
883
        s->packet_buffer = pktl->next;
884
        av_free_packet(&pktl->pkt);
885
        av_free(pktl);
886
    }
887
}
888

    
889
/*******************************************************/
890
/* seek support */
891

    
892
int av_find_default_stream_index(AVFormatContext *s)
893
{
894
    int i;
895
    AVStream *st;
896

    
897
    if (s->nb_streams <= 0)
898
        return -1;
899
    for(i = 0; i < s->nb_streams; i++) {
900
        st = s->streams[i];
901
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
902
            return i;
903
        }
904
    }
905
    return 0;
906
}
907

    
908
/**
909
 * Flush the frame reader.
910
 */
911
static void av_read_frame_flush(AVFormatContext *s)
912
{
913
    AVStream *st;
914
    int i;
915

    
916
    flush_packet_queue(s);
917

    
918
    /* free previous packet */
919
    if (s->cur_st) {
920
        if (s->cur_st->parser)
921
            av_free_packet(&s->cur_pkt);
922
        s->cur_st = NULL;
923
    }
924
    /* fail safe */
925
    s->cur_ptr = NULL;
926
    s->cur_len = 0;
927

    
928
    /* for each stream, reset read state */
929
    for(i = 0; i < s->nb_streams; i++) {
930
        st = s->streams[i];
931

    
932
        if (st->parser) {
933
            av_parser_close(st->parser);
934
            st->parser = NULL;
935
        }
936
        st->last_IP_pts = AV_NOPTS_VALUE;
937
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
938
    }
939
}
940

    
941
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
942
    int i;
943

    
944
    for(i = 0; i < s->nb_streams; i++) {
945
        AVStream *st = s->streams[i];
946

    
947
        st->cur_dts = av_rescale(timestamp,
948
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
949
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
950
    }
951
}
952

    
953
int av_add_index_entry(AVStream *st,
954
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
955
{
956
    AVIndexEntry *entries, *ie;
957
    int index;
958

    
959
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
960
        return -1;
961

    
962
    entries = av_fast_realloc(st->index_entries,
963
                              &st->index_entries_allocated_size,
964
                              (st->nb_index_entries + 1) *
965
                              sizeof(AVIndexEntry));
966
    if(!entries)
967
        return -1;
968

    
969
    st->index_entries= entries;
970

    
971
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
972

    
973
    if(index<0){
974
        index= st->nb_index_entries++;
975
        ie= &entries[index];
976
        assert(index==0 || ie[-1].timestamp < timestamp);
977
    }else{
978
        ie= &entries[index];
979
        if(ie->timestamp != timestamp){
980
            if(ie->timestamp <= timestamp)
981
                return -1;
982
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
983
            st->nb_index_entries++;
984
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
985
            distance= ie->min_distance;
986
    }
987

    
988
    ie->pos = pos;
989
    ie->timestamp = timestamp;
990
    ie->min_distance= distance;
991
    ie->size= size;
992
    ie->flags = flags;
993

    
994
    return index;
995
}
996

    
997
/**
998
 * build an index for raw streams using a parser.
999
 */
1000
static void av_build_index_raw(AVFormatContext *s)
1001
{
1002
    AVPacket pkt1, *pkt = &pkt1;
1003
    int ret;
1004
    AVStream *st;
1005

    
1006
    st = s->streams[0];
1007
    av_read_frame_flush(s);
1008
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1009

    
1010
    for(;;) {
1011
        ret = av_read_frame(s, pkt);
1012
        if (ret < 0)
1013
            break;
1014
        if (pkt->stream_index == 0 && st->parser &&
1015
            (pkt->flags & PKT_FLAG_KEY)) {
1016
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1017
                            0, 0, AVINDEX_KEYFRAME);
1018
        }
1019
        av_free_packet(pkt);
1020
    }
1021
}
1022

    
1023
/**
1024
 * Returns TRUE if we deal with a raw stream.
1025
 *
1026
 * Raw codec data and parsing needed.
1027
 */
1028
static int is_raw_stream(AVFormatContext *s)
1029
{
1030
    AVStream *st;
1031

    
1032
    if (s->nb_streams != 1)
1033
        return 0;
1034
    st = s->streams[0];
1035
    if (!st->need_parsing)
1036
        return 0;
1037
    return 1;
1038
}
1039

    
1040
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1041
                              int flags)
1042
{
1043
    AVIndexEntry *entries= st->index_entries;
1044
    int nb_entries= st->nb_index_entries;
1045
    int a, b, m;
1046
    int64_t timestamp;
1047

    
1048
    a = - 1;
1049
    b = nb_entries;
1050

    
1051
    while (b - a > 1) {
1052
        m = (a + b) >> 1;
1053
        timestamp = entries[m].timestamp;
1054
        if(timestamp >= wanted_timestamp)
1055
            b = m;
1056
        if(timestamp <= wanted_timestamp)
1057
            a = m;
1058
    }
1059
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1060

    
1061
    if(!(flags & AVSEEK_FLAG_ANY)){
1062
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1063
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1064
        }
1065
    }
1066

    
1067
    if(m == nb_entries)
1068
        return -1;
1069
    return  m;
1070
}
1071

    
1072
#define DEBUG_SEEK
1073

    
1074
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1075
    AVInputFormat *avif= s->iformat;
1076
    int64_t pos_min, pos_max, pos, pos_limit;
1077
    int64_t ts_min, ts_max, ts;
1078
    int index;
1079
    AVStream *st;
1080

    
1081
    if (stream_index < 0)
1082
        return -1;
1083

    
1084
#ifdef DEBUG_SEEK
1085
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1086
#endif
1087

    
1088
    ts_max=
1089
    ts_min= AV_NOPTS_VALUE;
1090
    pos_limit= -1; //gcc falsely says it may be uninitalized
1091

    
1092
    st= s->streams[stream_index];
1093
    if(st->index_entries){
1094
        AVIndexEntry *e;
1095

    
1096
        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()
1097
        index= FFMAX(index, 0);
1098
        e= &st->index_entries[index];
1099

    
1100
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1101
            pos_min= e->pos;
1102
            ts_min= e->timestamp;
1103
#ifdef DEBUG_SEEK
1104
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1105
               pos_min,ts_min);
1106
#endif
1107
        }else{
1108
            assert(index==0);
1109
        }
1110

    
1111
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1112
        assert(index < st->nb_index_entries);
1113
        if(index >= 0){
1114
            e= &st->index_entries[index];
1115
            assert(e->timestamp >= target_ts);
1116
            pos_max= e->pos;
1117
            ts_max= e->timestamp;
1118
            pos_limit= pos_max - e->min_distance;
1119
#ifdef DEBUG_SEEK
1120
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1121
               pos_max,pos_limit, ts_max);
1122
#endif
1123
        }
1124
    }
1125

    
1126
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1127
    if(pos<0)
1128
        return -1;
1129

    
1130
    /* do the seek */
1131
    url_fseek(&s->pb, pos, SEEK_SET);
1132

    
1133
    av_update_cur_dts(s, st, ts);
1134

    
1135
    return 0;
1136
}
1137

    
1138
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 )){
1139
    int64_t pos, ts;
1140
    int64_t start_pos, filesize;
1141
    int no_change;
1142

    
1143
#ifdef DEBUG_SEEK
1144
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1145
#endif
1146

    
1147
    if(ts_min == AV_NOPTS_VALUE){
1148
        pos_min = s->data_offset;
1149
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1150
        if (ts_min == AV_NOPTS_VALUE)
1151
            return -1;
1152
    }
1153

    
1154
    if(ts_max == AV_NOPTS_VALUE){
1155
        int step= 1024;
1156
        filesize = url_fsize(&s->pb);
1157
        pos_max = filesize - 1;
1158
        do{
1159
            pos_max -= step;
1160
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1161
            step += step;
1162
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1163
        if (ts_max == AV_NOPTS_VALUE)
1164
            return -1;
1165

    
1166
        for(;;){
1167
            int64_t tmp_pos= pos_max + 1;
1168
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1169
            if(tmp_ts == AV_NOPTS_VALUE)
1170
                break;
1171
            ts_max= tmp_ts;
1172
            pos_max= tmp_pos;
1173
            if(tmp_pos >= filesize)
1174
                break;
1175
        }
1176
        pos_limit= pos_max;
1177
    }
1178

    
1179
    if(ts_min > ts_max){
1180
        return -1;
1181
    }else if(ts_min == ts_max){
1182
        pos_limit= pos_min;
1183
    }
1184

    
1185
    no_change=0;
1186
    while (pos_min < pos_limit) {
1187
#ifdef DEBUG_SEEK
1188
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1189
               pos_min, pos_max,
1190
               ts_min, ts_max);
1191
#endif
1192
        assert(pos_limit <= pos_max);
1193

    
1194
        if(no_change==0){
1195
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1196
            // interpolate position (better than dichotomy)
1197
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1198
                + pos_min - approximate_keyframe_distance;
1199
        }else if(no_change==1){
1200
            // bisection, if interpolation failed to change min or max pos last time
1201
            pos = (pos_min + pos_limit)>>1;
1202
        }else{
1203
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1204
            pos=pos_min;
1205
        }
1206
        if(pos <= pos_min)
1207
            pos= pos_min + 1;
1208
        else if(pos > pos_limit)
1209
            pos= pos_limit;
1210
        start_pos= pos;
1211

    
1212
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1213
        if(pos == pos_max)
1214
            no_change++;
1215
        else
1216
            no_change=0;
1217
#ifdef DEBUG_SEEK
1218
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);
1219
#endif
1220
        assert(ts != AV_NOPTS_VALUE);
1221
        if (target_ts <= ts) {
1222
            pos_limit = start_pos - 1;
1223
            pos_max = pos;
1224
            ts_max = ts;
1225
        }
1226
        if (target_ts >= ts) {
1227
            pos_min = pos;
1228
            ts_min = ts;
1229
        }
1230
    }
1231

    
1232
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1233
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1234
#ifdef DEBUG_SEEK
1235
    pos_min = pos;
1236
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1237
    pos_min++;
1238
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1239
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1240
           pos, ts_min, target_ts, ts_max);
1241
#endif
1242
    *ts_ret= ts;
1243
    return pos;
1244
}
1245

    
1246
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1247
    int64_t pos_min, pos_max;
1248
#if 0
1249
    AVStream *st;
1250

1251
    if (stream_index < 0)
1252
        return -1;
1253

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

    
1257
    pos_min = s->data_offset;
1258
    pos_max = url_fsize(&s->pb) - 1;
1259

    
1260
    if     (pos < pos_min) pos= pos_min;
1261
    else if(pos > pos_max) pos= pos_max;
1262

    
1263
    url_fseek(&s->pb, pos, SEEK_SET);
1264

    
1265
#if 0
1266
    av_update_cur_dts(s, st, ts);
1267
#endif
1268
    return 0;
1269
}
1270

    
1271
static int av_seek_frame_generic(AVFormatContext *s,
1272
                                 int stream_index, int64_t timestamp, int flags)
1273
{
1274
    int index;
1275
    AVStream *st;
1276
    AVIndexEntry *ie;
1277

    
1278
    st = s->streams[stream_index];
1279

    
1280
    index = av_index_search_timestamp(st, timestamp, flags);
1281

    
1282
    if(index < 0 || index==st->nb_index_entries-1){
1283
        int i;
1284
        AVPacket pkt;
1285

    
1286
        if(st->index_entries && st->nb_index_entries){
1287
            ie= &st->index_entries[st->nb_index_entries-1];
1288
            url_fseek(&s->pb, ie->pos, SEEK_SET);
1289
            av_update_cur_dts(s, st, ie->timestamp);
1290
        }else
1291
            url_fseek(&s->pb, 0, SEEK_SET);
1292

    
1293
        for(i=0;; i++) {
1294
            int ret = av_read_frame(s, &pkt);
1295
            if(ret<0)
1296
                break;
1297
            av_free_packet(&pkt);
1298
            if(stream_index == pkt.stream_index){
1299
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1300
                    break;
1301
            }
1302
        }
1303
        index = av_index_search_timestamp(st, timestamp, flags);
1304
    }
1305
    if (index < 0)
1306
        return -1;
1307

    
1308
    av_read_frame_flush(s);
1309
    if (s->iformat->read_seek){
1310
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1311
            return 0;
1312
    }
1313
    ie = &st->index_entries[index];
1314
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1315

    
1316
    av_update_cur_dts(s, st, ie->timestamp);
1317

    
1318
    return 0;
1319
}
1320

    
1321
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1322
{
1323
    int ret;
1324
    AVStream *st;
1325

    
1326
    av_read_frame_flush(s);
1327

    
1328
    if(flags & AVSEEK_FLAG_BYTE)
1329
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1330

    
1331
    if(stream_index < 0){
1332
        stream_index= av_find_default_stream_index(s);
1333
        if(stream_index < 0)
1334
            return -1;
1335

    
1336
        st= s->streams[stream_index];
1337
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1338
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1339
    }
1340
    st= s->streams[stream_index];
1341

    
1342
    /* first, we try the format specific seek */
1343
    if (s->iformat->read_seek)
1344
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1345
    else
1346
        ret = -1;
1347
    if (ret >= 0) {
1348
        return 0;
1349
    }
1350

    
1351
    if(s->iformat->read_timestamp)
1352
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1353
    else
1354
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1355
}
1356

    
1357
/*******************************************************/
1358

    
1359
/**
1360
 * Returns TRUE if the stream has accurate timings in any stream.
1361
 *
1362
 * @return TRUE if the stream has accurate timings for at least one component.
1363
 */
1364
static int av_has_timings(AVFormatContext *ic)
1365
{
1366
    int i;
1367
    AVStream *st;
1368

    
1369
    for(i = 0;i < ic->nb_streams; i++) {
1370
        st = ic->streams[i];
1371
        if (st->start_time != AV_NOPTS_VALUE &&
1372
            st->duration != AV_NOPTS_VALUE)
1373
            return 1;
1374
    }
1375
    return 0;
1376
}
1377

    
1378
/**
1379
 * Estimate the stream timings from the one of each components.
1380
 *
1381
 * Also computes the global bitrate if possible.
1382
 */
1383
static void av_update_stream_timings(AVFormatContext *ic)
1384
{
1385
    int64_t start_time, start_time1, end_time, end_time1;
1386
    int i;
1387
    AVStream *st;
1388

    
1389
    start_time = INT64_MAX;
1390
    end_time = INT64_MIN;
1391
    for(i = 0;i < ic->nb_streams; i++) {
1392
        st = ic->streams[i];
1393
        if (st->start_time != AV_NOPTS_VALUE) {
1394
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1395
            if (start_time1 < start_time)
1396
                start_time = start_time1;
1397
            if (st->duration != AV_NOPTS_VALUE) {
1398
                end_time1 = start_time1
1399
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1400
                if (end_time1 > end_time)
1401
                    end_time = end_time1;
1402
            }
1403
        }
1404
    }
1405
    if (start_time != INT64_MAX) {
1406
        ic->start_time = start_time;
1407
        if (end_time != INT64_MIN) {
1408
            ic->duration = end_time - start_time;
1409
            if (ic->file_size > 0) {
1410
                /* compute the bit rate */
1411
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1412
                    (double)ic->duration;
1413
            }
1414
        }
1415
    }
1416

    
1417
}
1418

    
1419
static void fill_all_stream_timings(AVFormatContext *ic)
1420
{
1421
    int i;
1422
    AVStream *st;
1423

    
1424
    av_update_stream_timings(ic);
1425
    for(i = 0;i < ic->nb_streams; i++) {
1426
        st = ic->streams[i];
1427
        if (st->start_time == AV_NOPTS_VALUE) {
1428
            if(ic->start_time != AV_NOPTS_VALUE)
1429
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1430
            if(ic->duration != AV_NOPTS_VALUE)
1431
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1432
        }
1433
    }
1434
}
1435

    
1436
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1437
{
1438
    int64_t filesize, duration;
1439
    int bit_rate, i;
1440
    AVStream *st;
1441

    
1442
    /* if bit_rate is already set, we believe it */
1443
    if (ic->bit_rate == 0) {
1444
        bit_rate = 0;
1445
        for(i=0;i<ic->nb_streams;i++) {
1446
            st = ic->streams[i];
1447
            bit_rate += st->codec->bit_rate;
1448
        }
1449
        ic->bit_rate = bit_rate;
1450
    }
1451

    
1452
    /* if duration is already set, we believe it */
1453
    if (ic->duration == AV_NOPTS_VALUE &&
1454
        ic->bit_rate != 0 &&
1455
        ic->file_size != 0)  {
1456
        filesize = ic->file_size;
1457
        if (filesize > 0) {
1458
            for(i = 0; i < ic->nb_streams; i++) {
1459
                st = ic->streams[i];
1460
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1461
                if (st->start_time == AV_NOPTS_VALUE ||
1462
                    st->duration == AV_NOPTS_VALUE) {
1463
                    st->start_time = 0;
1464
                    st->duration = duration;
1465
                }
1466
            }
1467
        }
1468
    }
1469
}
1470

    
1471
#define DURATION_MAX_READ_SIZE 250000
1472

    
1473
/* only usable for MPEG-PS streams */
1474
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1475
{
1476
    AVPacket pkt1, *pkt = &pkt1;
1477
    AVStream *st;
1478
    int read_size, i, ret;
1479
    int64_t end_time;
1480
    int64_t filesize, offset, duration;
1481

    
1482
    av_read_frame_flush(ic);
1483

    
1484
    /* we read the first packets to get the first PTS (not fully
1485
       accurate, but it is enough now) */
1486
    url_fseek(&ic->pb, 0, SEEK_SET);
1487
    read_size = 0;
1488
    for(;;) {
1489
        if (read_size >= DURATION_MAX_READ_SIZE)
1490
            break;
1491
        /* if all info is available, we can stop */
1492
        for(i = 0;i < ic->nb_streams; i++) {
1493
            st = ic->streams[i];
1494
            if (st->start_time == AV_NOPTS_VALUE)
1495
                break;
1496
        }
1497
        if (i == ic->nb_streams)
1498
            break;
1499

    
1500
        ret = av_read_packet(ic, pkt);
1501
        if (ret != 0)
1502
            break;
1503
        read_size += pkt->size;
1504
        st = ic->streams[pkt->stream_index];
1505
        if (pkt->pts != AV_NOPTS_VALUE) {
1506
            if (st->start_time == AV_NOPTS_VALUE)
1507
                st->start_time = pkt->pts;
1508
        }
1509
        av_free_packet(pkt);
1510
    }
1511

    
1512
    /* estimate the end time (duration) */
1513
    /* XXX: may need to support wrapping */
1514
    filesize = ic->file_size;
1515
    offset = filesize - DURATION_MAX_READ_SIZE;
1516
    if (offset < 0)
1517
        offset = 0;
1518

    
1519
    url_fseek(&ic->pb, offset, SEEK_SET);
1520
    read_size = 0;
1521
    for(;;) {
1522
        if (read_size >= DURATION_MAX_READ_SIZE)
1523
            break;
1524
        /* if all info is available, we can stop */
1525
        for(i = 0;i < ic->nb_streams; i++) {
1526
            st = ic->streams[i];
1527
            if (st->duration == AV_NOPTS_VALUE)
1528
                break;
1529
        }
1530
        if (i == ic->nb_streams)
1531
            break;
1532

    
1533
        ret = av_read_packet(ic, pkt);
1534
        if (ret != 0)
1535
            break;
1536
        read_size += pkt->size;
1537
        st = ic->streams[pkt->stream_index];
1538
        if (pkt->pts != AV_NOPTS_VALUE) {
1539
            end_time = pkt->pts;
1540
            duration = end_time - st->start_time;
1541
            if (duration > 0) {
1542
                if (st->duration == AV_NOPTS_VALUE ||
1543
                    st->duration < duration)
1544
                    st->duration = duration;
1545
            }
1546
        }
1547
        av_free_packet(pkt);
1548
    }
1549

    
1550
    fill_all_stream_timings(ic);
1551

    
1552
    url_fseek(&ic->pb, old_offset, SEEK_SET);
1553
}
1554

    
1555
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1556
{
1557
    int64_t file_size;
1558

    
1559
    /* get the file size, if possible */
1560
    if (ic->iformat->flags & AVFMT_NOFILE) {
1561
        file_size = 0;
1562
    } else {
1563
        file_size = url_fsize(&ic->pb);
1564
        if (file_size < 0)
1565
            file_size = 0;
1566
    }
1567
    ic->file_size = file_size;
1568

    
1569
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1570
         !strcmp(ic->iformat->name, "mpegts")) &&
1571
        file_size && !ic->pb.is_streamed) {
1572
        /* get accurate estimate from the PTSes */
1573
        av_estimate_timings_from_pts(ic, old_offset);
1574
    } else if (av_has_timings(ic)) {
1575
        /* at least one components has timings - we use them for all
1576
           the components */
1577
        fill_all_stream_timings(ic);
1578
    } else {
1579
        /* less precise: use bit rate info */
1580
        av_estimate_timings_from_bit_rate(ic);
1581
    }
1582
    av_update_stream_timings(ic);
1583

    
1584
#if 0
1585
    {
1586
        int i;
1587
        AVStream *st;
1588
        for(i = 0;i < ic->nb_streams; i++) {
1589
            st = ic->streams[i];
1590
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1591
               i, (double)st->start_time / AV_TIME_BASE,
1592
               (double)st->duration / AV_TIME_BASE);
1593
        }
1594
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1595
               (double)ic->start_time / AV_TIME_BASE,
1596
               (double)ic->duration / AV_TIME_BASE,
1597
               ic->bit_rate / 1000);
1598
    }
1599
#endif
1600
}
1601

    
1602
static int has_codec_parameters(AVCodecContext *enc)
1603
{
1604
    int val;
1605
    switch(enc->codec_type) {
1606
    case CODEC_TYPE_AUDIO:
1607
        val = enc->sample_rate;
1608
        break;
1609
    case CODEC_TYPE_VIDEO:
1610
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1611
        break;
1612
    default:
1613
        val = 1;
1614
        break;
1615
    }
1616
    return (val != 0);
1617
}
1618

    
1619
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1620
{
1621
    int16_t *samples;
1622
    AVCodec *codec;
1623
    int got_picture, data_size, ret=0;
1624
    AVFrame picture;
1625

    
1626
  if(!st->codec->codec){
1627
    codec = avcodec_find_decoder(st->codec->codec_id);
1628
    if (!codec)
1629
        return -1;
1630
    ret = avcodec_open(st->codec, codec);
1631
    if (ret < 0)
1632
        return ret;
1633
  }
1634

    
1635
  if(!has_codec_parameters(st->codec)){
1636
    switch(st->codec->codec_type) {
1637
    case CODEC_TYPE_VIDEO:
1638
        ret = avcodec_decode_video(st->codec, &picture,
1639
                                   &got_picture, (uint8_t *)data, size);
1640
        break;
1641
    case CODEC_TYPE_AUDIO:
1642
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1643
        samples = av_malloc(data_size);
1644
        if (!samples)
1645
            goto fail;
1646
        ret = avcodec_decode_audio2(st->codec, samples,
1647
                                    &data_size, (uint8_t *)data, size);
1648
        av_free(samples);
1649
        break;
1650
    default:
1651
        break;
1652
    }
1653
  }
1654
 fail:
1655
    return ret;
1656
}
1657

    
1658
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1659
{
1660
    AVInputFormat *fmt;
1661
    fmt = av_probe_input_format2(pd, 1, &score);
1662

    
1663
    if (fmt) {
1664
        if (strncmp(fmt->name, "mp3", 3) == 0)
1665
            st->codec->codec_id = CODEC_ID_MP3;
1666
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1667
            st->codec->codec_id = CODEC_ID_AC3;
1668
    }
1669
    return fmt;
1670
}
1671

    
1672
/* absolute maximum size we read until we abort */
1673
#define MAX_READ_SIZE        5000000
1674

    
1675
#define MAX_STD_TIMEBASES (60*12+5)
1676
static int get_std_framerate(int i){
1677
    if(i<60*12) return i*1001;
1678
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1679
}
1680

    
1681
int av_find_stream_info(AVFormatContext *ic)
1682
{
1683
    int i, count, ret, read_size, j;
1684
    AVStream *st;
1685
    AVPacket pkt1, *pkt;
1686
    AVPacketList *pktl=NULL, **ppktl;
1687
    int64_t last_dts[MAX_STREAMS];
1688
    int duration_count[MAX_STREAMS]={0};
1689
    double (*duration_error)[MAX_STD_TIMEBASES];
1690
    offset_t old_offset = url_ftell(&ic->pb);
1691
    int64_t codec_info_duration[MAX_STREAMS]={0};
1692
    int codec_info_nb_frames[MAX_STREAMS]={0};
1693
    AVProbeData probe_data[MAX_STREAMS];
1694
    int codec_identified[MAX_STREAMS]={0};
1695

    
1696
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1697
    if (!duration_error) return AVERROR_NOMEM;
1698

    
1699
    for(i=0;i<ic->nb_streams;i++) {
1700
        st = ic->streams[i];
1701
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1702
/*            if(!st->time_base.num)
1703
                st->time_base= */
1704
            if(!st->codec->time_base.num)
1705
                st->codec->time_base= st->time_base;
1706
        }
1707
        //only for the split stuff
1708
        if (!st->parser) {
1709
            st->parser = av_parser_init(st->codec->codec_id);
1710
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1711
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1712
            }
1713
        }
1714
    }
1715

    
1716
    for(i=0;i<MAX_STREAMS;i++){
1717
        last_dts[i]= AV_NOPTS_VALUE;
1718
    }
1719

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

    
1756
        /* NOTE: a new stream can be added there if no header in file
1757
           (AVFMTCTX_NOHEADER) */
1758
        ret = av_read_frame_internal(ic, &pkt1);
1759
        if (ret < 0) {
1760
            /* EOF or error */
1761
            ret = -1; /* we could not have all the codec parameters before EOF */
1762
            for(i=0;i<ic->nb_streams;i++) {
1763
                st = ic->streams[i];
1764
                if (!has_codec_parameters(st->codec)){
1765
                    char buf[256];
1766
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1767
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1768
                } else {
1769
                    ret = 0;
1770
                }
1771
            }
1772
            break;
1773
        }
1774

    
1775
        pktl = av_mallocz(sizeof(AVPacketList));
1776
        if (!pktl) {
1777
            ret = AVERROR_NOMEM;
1778
            break;
1779
        }
1780

    
1781
        /* add the packet in the buffered packet list */
1782
        *ppktl = pktl;
1783
        ppktl = &pktl->next;
1784

    
1785
        pkt = &pktl->pkt;
1786
        *pkt = pkt1;
1787

    
1788
        /* duplicate the packet */
1789
        if (av_dup_packet(pkt) < 0) {
1790
            ret = AVERROR_NOMEM;
1791
            break;
1792
        }
1793

    
1794
        read_size += pkt->size;
1795

    
1796
        st = ic->streams[pkt->stream_index];
1797
        if(codec_info_nb_frames[st->index]>1)
1798
            codec_info_duration[st->index] += pkt->duration;
1799
        if (pkt->duration != 0)
1800
            codec_info_nb_frames[st->index]++;
1801

    
1802
        {
1803
            int index= pkt->stream_index;
1804
            int64_t last= last_dts[index];
1805
            int64_t duration= pkt->dts - last;
1806

    
1807
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1808
                double dur= duration * av_q2d(st->time_base);
1809

    
1810
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1811
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1812
                if(duration_count[index] < 2)
1813
                    memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1814
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1815
                    int framerate= get_std_framerate(i);
1816
                    int ticks= lrintf(dur*framerate/(1001*12));
1817
                    double error= dur - ticks*1001*12/(double)framerate;
1818
                    duration_error[index][i] += error*error;
1819
                }
1820
                duration_count[index]++;
1821
            }
1822
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1823
                last_dts[pkt->stream_index]= pkt->dts;
1824

    
1825
            if (st->codec->codec_id == CODEC_ID_NONE) {
1826
                AVProbeData *pd = &(probe_data[st->index]);
1827
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1828
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1829
                pd->buf_size += pkt->size;
1830
            }
1831
        }
1832
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1833
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1834
            if(i){
1835
                st->codec->extradata_size= i;
1836
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1837
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1838
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1839
            }
1840
        }
1841

    
1842
        /* if still no information, we try to open the codec and to
1843
           decompress the frame. We try to avoid that in most cases as
1844
           it takes longer and uses more memory. For MPEG4, we need to
1845
           decompress for Quicktime. */
1846
        if (!has_codec_parameters(st->codec) /*&&
1847
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1848
             st->codec->codec_id == CODEC_ID_H264 ||
1849
             st->codec->codec_id == CODEC_ID_H263 ||
1850
             st->codec->codec_id == CODEC_ID_H261 ||
1851
             st->codec->codec_id == CODEC_ID_VORBIS ||
1852
             st->codec->codec_id == CODEC_ID_MJPEG ||
1853
             st->codec->codec_id == CODEC_ID_PNG ||
1854
             st->codec->codec_id == CODEC_ID_PAM ||
1855
             st->codec->codec_id == CODEC_ID_PGM ||
1856
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1857
             st->codec->codec_id == CODEC_ID_PBM ||
1858
             st->codec->codec_id == CODEC_ID_PPM ||
1859
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1860
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1861
            try_decode_frame(st, pkt->data, pkt->size);
1862

    
1863
        if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1864
            break;
1865
        }
1866
        count++;
1867
    }
1868

    
1869
    // close codecs which where opened in try_decode_frame()
1870
    for(i=0;i<ic->nb_streams;i++) {
1871
        st = ic->streams[i];
1872
        if(st->codec->codec)
1873
            avcodec_close(st->codec);
1874
    }
1875
    for(i=0;i<ic->nb_streams;i++) {
1876
        st = ic->streams[i];
1877
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1878
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1879
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1880

    
1881
            if(duration_count[i]
1882
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1883
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1884
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1885
                double best_error= 2*av_q2d(st->time_base);
1886
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
1887

    
1888
                for(j=1; j<MAX_STD_TIMEBASES; j++){
1889
                    double error= duration_error[i][j] * get_std_framerate(j);
1890
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1891
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1892
                    if(error < best_error){
1893
                        best_error= error;
1894
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1895
                    }
1896
                }
1897
            }
1898

    
1899
            if (!st->r_frame_rate.num){
1900
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1901
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1902
                    st->r_frame_rate.num = st->codec->time_base.den;
1903
                    st->r_frame_rate.den = st->codec->time_base.num;
1904
                }else{
1905
                    st->r_frame_rate.num = st->time_base.den;
1906
                    st->r_frame_rate.den = st->time_base.num;
1907
                }
1908
            }
1909
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1910
            if (st->codec->codec_id == CODEC_ID_NONE) {
1911
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 0);
1912
                if (codec_identified[st->index]) {
1913
                    st->need_parsing = AVSTREAM_PARSE_FULL;
1914
                }
1915
            }
1916
            if(!st->codec->bits_per_sample)
1917
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1918
        }
1919
    }
1920

    
1921
    av_estimate_timings(ic, old_offset);
1922

    
1923
    for(i=0;i<ic->nb_streams;i++) {
1924
        st = ic->streams[i];
1925
        if (codec_identified[st->index]) {
1926
            av_read_frame_flush(ic);
1927
            av_seek_frame(ic, st->index, 0.0, 0);
1928
            url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1929
        }
1930
    }
1931

    
1932
#if 0
1933
    /* correct DTS for b frame streams with no timestamps */
1934
    for(i=0;i<ic->nb_streams;i++) {
1935
        st = ic->streams[i];
1936
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1937
            if(b-frames){
1938
                ppktl = &ic->packet_buffer;
1939
                while(ppkt1){
1940
                    if(ppkt1->stream_index != i)
1941
                        continue;
1942
                    if(ppkt1->pkt->dts < 0)
1943
                        break;
1944
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1945
                        break;
1946
                    ppkt1->pkt->dts -= delta;
1947
                    ppkt1= ppkt1->next;
1948
                }
1949
                if(ppkt1)
1950
                    continue;
1951
                st->cur_dts -= delta;
1952
            }
1953
        }
1954
    }
1955
#endif
1956

    
1957
    av_free(duration_error);
1958
    for(i=0;i<MAX_STREAMS;i++){
1959
        av_freep(&(probe_data[i].buf));
1960
    }
1961

    
1962
    return ret;
1963
}
1964

    
1965
/*******************************************************/
1966

    
1967
int av_read_play(AVFormatContext *s)
1968
{
1969
    if (!s->iformat->read_play)
1970
        return AVERROR_NOTSUPP;
1971
    return s->iformat->read_play(s);
1972
}
1973

    
1974
int av_read_pause(AVFormatContext *s)
1975
{
1976
    if (!s->iformat->read_pause)
1977
        return AVERROR_NOTSUPP;
1978
    return s->iformat->read_pause(s);
1979
}
1980

    
1981
void av_close_input_file(AVFormatContext *s)
1982
{
1983
    int i, must_open_file;
1984
    AVStream *st;
1985

    
1986
    /* free previous packet */
1987
    if (s->cur_st && s->cur_st->parser)
1988
        av_free_packet(&s->cur_pkt);
1989

    
1990
    if (s->iformat->read_close)
1991
        s->iformat->read_close(s);
1992
    for(i=0;i<s->nb_streams;i++) {
1993
        /* free all data in a stream component */
1994
        st = s->streams[i];
1995
        if (st->parser) {
1996
            av_parser_close(st->parser);
1997
        }
1998
        av_free(st->index_entries);
1999
        av_free(st->codec->extradata);
2000
        av_free(st->codec);
2001
        av_free(st);
2002
    }
2003
    flush_packet_queue(s);
2004
    must_open_file = 1;
2005
    if (s->iformat->flags & AVFMT_NOFILE) {
2006
        must_open_file = 0;
2007
    }
2008
    if (must_open_file) {
2009
        url_fclose(&s->pb);
2010
    }
2011
    av_freep(&s->priv_data);
2012
    av_free(s);
2013
}
2014

    
2015
AVStream *av_new_stream(AVFormatContext *s, int id)
2016
{
2017
    AVStream *st;
2018
    int i;
2019

    
2020
    if (s->nb_streams >= MAX_STREAMS)
2021
        return NULL;
2022

    
2023
    st = av_mallocz(sizeof(AVStream));
2024
    if (!st)
2025
        return NULL;
2026

    
2027
    st->codec= avcodec_alloc_context();
2028
    if (s->iformat) {
2029
        /* no default bitrate if decoding */
2030
        st->codec->bit_rate = 0;
2031
    }
2032
    st->index = s->nb_streams;
2033
    st->id = id;
2034
    st->start_time = AV_NOPTS_VALUE;
2035
    st->duration = AV_NOPTS_VALUE;
2036
    st->cur_dts = AV_NOPTS_VALUE;
2037

    
2038
    /* default pts settings is MPEG like */
2039
    av_set_pts_info(st, 33, 1, 90000);
2040
    st->last_IP_pts = AV_NOPTS_VALUE;
2041
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2042
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2043

    
2044
    s->streams[s->nb_streams++] = st;
2045
    return st;
2046
}
2047

    
2048
/************************************************************/
2049
/* output media file */
2050

    
2051
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2052
{
2053
    int ret;
2054

    
2055
    if (s->oformat->priv_data_size > 0) {
2056
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2057
        if (!s->priv_data)
2058
            return AVERROR_NOMEM;
2059
    } else
2060
        s->priv_data = NULL;
2061

    
2062
    if (s->oformat->set_parameters) {
2063
        ret = s->oformat->set_parameters(s, ap);
2064
        if (ret < 0)
2065
            return ret;
2066
    }
2067
    return 0;
2068
}
2069

    
2070
int av_write_header(AVFormatContext *s)
2071
{
2072
    int ret, i;
2073
    AVStream *st;
2074

    
2075
    // some sanity checks
2076
    for(i=0;i<s->nb_streams;i++) {
2077
        st = s->streams[i];
2078

    
2079
        switch (st->codec->codec_type) {
2080
        case CODEC_TYPE_AUDIO:
2081
            if(st->codec->sample_rate<=0){
2082
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2083
                return -1;
2084
            }
2085
            break;
2086
        case CODEC_TYPE_VIDEO:
2087
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2088
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2089
                return -1;
2090
            }
2091
            if(st->codec->width<=0 || st->codec->height<=0){
2092
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2093
                return -1;
2094
            }
2095
            break;
2096
        }
2097

    
2098
        if(s->oformat->codec_tag){
2099
            if(st->codec->codec_tag){
2100
                //FIXME
2101
                //check that tag + id is in the table
2102
                //if neither is in the table -> ok
2103
                //if tag is in the table with another id -> FAIL
2104
                //if id is in the table with another tag -> FAIL unless strict < ?
2105
            }else
2106
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2107
        }
2108
    }
2109

    
2110
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2111
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2112
        if (!s->priv_data)
2113
            return AVERROR_NOMEM;
2114
    }
2115

    
2116
    if(s->oformat->write_header){
2117
        ret = s->oformat->write_header(s);
2118
        if (ret < 0)
2119
            return ret;
2120
    }
2121

    
2122
    /* init PTS generation */
2123
    for(i=0;i<s->nb_streams;i++) {
2124
        int64_t den = AV_NOPTS_VALUE;
2125
        st = s->streams[i];
2126

    
2127
        switch (st->codec->codec_type) {
2128
        case CODEC_TYPE_AUDIO:
2129
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2130
            break;
2131
        case CODEC_TYPE_VIDEO:
2132
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2133
            break;
2134
        default:
2135
            break;
2136
        }
2137
        if (den != AV_NOPTS_VALUE) {
2138
            if (den <= 0)
2139
                return AVERROR_INVALIDDATA;
2140
            av_frac_init(&st->pts, 0, 0, den);
2141
        }
2142
    }
2143
    return 0;
2144
}
2145

    
2146
//FIXME merge with compute_pkt_fields
2147
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2148
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2149
    int num, den, frame_size, i;
2150

    
2151
//    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);
2152

    
2153
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2154
        return -1;*/
2155

    
2156
    /* duration field */
2157
    if (pkt->duration == 0) {
2158
        compute_frame_duration(&num, &den, st, NULL, pkt);
2159
        if (den && num) {
2160
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2161
        }
2162
    }
2163

    
2164
    //XXX/FIXME this is a temporary hack until all encoders output pts
2165
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2166
        pkt->dts=
2167
//        pkt->pts= st->cur_dts;
2168
        pkt->pts= st->pts.val;
2169
    }
2170

    
2171
    //calculate dts from pts
2172
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2173
        st->pts_buffer[0]= pkt->pts;
2174
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2175
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2176
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2177
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2178

    
2179
        pkt->dts= st->pts_buffer[0];
2180
    }
2181

    
2182
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2183
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64" st:%d\n", st->cur_dts, pkt->dts, st->index);
2184
        return -1;
2185
    }
2186
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2187
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts (%"PRId64" < %"PRId64")\n",
2188
               pkt->pts, pkt->dts);
2189
        return -1;
2190
    }
2191

    
2192
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2193
    st->cur_dts= pkt->dts;
2194
    st->pts.val= pkt->dts;
2195

    
2196
    /* update pts */
2197
    switch (st->codec->codec_type) {
2198
    case CODEC_TYPE_AUDIO:
2199
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2200

    
2201
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2202
           but it would be better if we had the real timestamps from the encoder */
2203
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2204
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2205
        }
2206
        break;
2207
    case CODEC_TYPE_VIDEO:
2208
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2209
        break;
2210
    default:
2211
        break;
2212
    }
2213
    return 0;
2214
}
2215

    
2216
static void truncate_ts(AVStream *st, AVPacket *pkt){
2217
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2218

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

    
2222
    if (pkt->pts != AV_NOPTS_VALUE)
2223
        pkt->pts &= pts_mask;
2224
    if (pkt->dts != AV_NOPTS_VALUE)
2225
        pkt->dts &= pts_mask;
2226
}
2227

    
2228
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2229
{
2230
    int ret;
2231

    
2232
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2233
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2234
        return ret;
2235

    
2236
    truncate_ts(s->streams[pkt->stream_index], pkt);
2237

    
2238
    ret= s->oformat->write_packet(s, pkt);
2239
    if(!ret)
2240
        ret= url_ferror(&s->pb);
2241
    return ret;
2242
}
2243

    
2244
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2245
    AVPacketList *pktl, **next_point, *this_pktl;
2246
    int stream_count=0;
2247
    int streams[MAX_STREAMS];
2248

    
2249
    if(pkt){
2250
        AVStream *st= s->streams[ pkt->stream_index];
2251

    
2252
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2253

    
2254
        this_pktl = av_mallocz(sizeof(AVPacketList));
2255
        this_pktl->pkt= *pkt;
2256
        if(pkt->destruct == av_destruct_packet)
2257
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2258
        else
2259
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2260

    
2261
        next_point = &s->packet_buffer;
2262
        while(*next_point){
2263
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2264
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2265
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2266
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2267
                break;
2268
            next_point= &(*next_point)->next;
2269
        }
2270
        this_pktl->next= *next_point;
2271
        *next_point= this_pktl;
2272
    }
2273

    
2274
    memset(streams, 0, sizeof(streams));
2275
    pktl= s->packet_buffer;
2276
    while(pktl){
2277
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2278
        if(streams[ pktl->pkt.stream_index ] == 0)
2279
            stream_count++;
2280
        streams[ pktl->pkt.stream_index ]++;
2281
        pktl= pktl->next;
2282
    }
2283

    
2284
    if(s->nb_streams == stream_count || (flush && stream_count)){
2285
        pktl= s->packet_buffer;
2286
        *out= pktl->pkt;
2287

    
2288
        s->packet_buffer= pktl->next;
2289
        av_freep(&pktl);
2290
        return 1;
2291
    }else{
2292
        av_init_packet(out);
2293
        return 0;
2294
    }
2295
}
2296

    
2297
/**
2298
 * Interleaves a AVPacket correctly so it can be muxed.
2299
 * @param out the interleaved packet will be output here
2300
 * @param in the input packet
2301
 * @param flush 1 if no further packets are available as input and all
2302
 *              remaining packets should be output
2303
 * @return 1 if a packet was output, 0 if no packet could be output,
2304
 *         < 0 if an error occured
2305
 */
2306
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2307
    if(s->oformat->interleave_packet)
2308
        return s->oformat->interleave_packet(s, out, in, flush);
2309
    else
2310
        return av_interleave_packet_per_dts(s, out, in, flush);
2311
}
2312

    
2313
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2314
    AVStream *st= s->streams[ pkt->stream_index];
2315

    
2316
    //FIXME/XXX/HACK drop zero sized packets
2317
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2318
        return 0;
2319

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

    
2324
    if(pkt->dts == AV_NOPTS_VALUE)
2325
        return -1;
2326

    
2327
    for(;;){
2328
        AVPacket opkt;
2329
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2330
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2331
            return ret;
2332

    
2333
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2334
        ret= s->oformat->write_packet(s, &opkt);
2335

    
2336
        av_free_packet(&opkt);
2337
        pkt= NULL;
2338

    
2339
        if(ret<0)
2340
            return ret;
2341
        if(url_ferror(&s->pb))
2342
            return url_ferror(&s->pb);
2343
    }
2344
}
2345

    
2346
int av_write_trailer(AVFormatContext *s)
2347
{
2348
    int ret, i;
2349

    
2350
    for(;;){
2351
        AVPacket pkt;
2352
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2353
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2354
            goto fail;
2355
        if(!ret)
2356
            break;
2357

    
2358
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2359
        ret= s->oformat->write_packet(s, &pkt);
2360

    
2361
        av_free_packet(&pkt);
2362

    
2363
        if(ret<0)
2364
            goto fail;
2365
        if(url_ferror(&s->pb))
2366
            goto fail;
2367
    }
2368

    
2369
    if(s->oformat->write_trailer)
2370
        ret = s->oformat->write_trailer(s);
2371
fail:
2372
    if(ret == 0)
2373
       ret=url_ferror(&s->pb);
2374
    for(i=0;i<s->nb_streams;i++)
2375
        av_freep(&s->streams[i]->priv_data);
2376
    av_freep(&s->priv_data);
2377
    return ret;
2378
}
2379

    
2380
/* "user interface" functions */
2381

    
2382
void dump_format(AVFormatContext *ic,
2383
                 int index,
2384
                 const char *url,
2385
                 int is_output)
2386
{
2387
    int i, flags;
2388
    char buf[256];
2389

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

    
2457
typedef struct {
2458
    const char *abv;
2459
    int width, height;
2460
    int frame_rate, frame_rate_base;
2461
} AbvEntry;
2462

    
2463
static AbvEntry frame_abvs[] = {
2464
    { "ntsc",      720, 480, 30000, 1001 },
2465
    { "pal",       720, 576,    25,    1 },
2466
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2467
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2468
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2469
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2470
    { "film",      352, 240,    24,    1 },
2471
    { "ntsc-film", 352, 240, 24000, 1001 },
2472
    { "sqcif",     128,  96,     0,    0 },
2473
    { "qcif",      176, 144,     0,    0 },
2474
    { "cif",       352, 288,     0,    0 },
2475
    { "4cif",      704, 576,     0,    0 },
2476
};
2477

    
2478
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2479
{
2480
    int i;
2481
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2482
    const char *p;
2483
    int frame_width = 0, frame_height = 0;
2484

    
2485
    for(i=0;i<n;i++) {
2486
        if (!strcmp(frame_abvs[i].abv, str)) {
2487
            frame_width = frame_abvs[i].width;
2488
            frame_height = frame_abvs[i].height;
2489
            break;
2490
        }
2491
    }
2492
    if (i == n) {
2493
        p = str;
2494
        frame_width = strtol(p, (char **)&p, 10);
2495
        if (*p)
2496
            p++;
2497
        frame_height = strtol(p, (char **)&p, 10);
2498
    }
2499
    if (frame_width <= 0 || frame_height <= 0)
2500
        return -1;
2501
    *width_ptr = frame_width;
2502
    *height_ptr = frame_height;
2503
    return 0;
2504
}
2505

    
2506
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2507
{
2508
    int i;
2509
    char* cp;
2510

    
2511
    /* First, we check our abbreviation table */
2512
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2513
         if (!strcmp(frame_abvs[i].abv, arg)) {
2514
             *frame_rate = frame_abvs[i].frame_rate;
2515
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2516
             return 0;
2517
         }
2518

    
2519
    /* Then, we try to parse it as fraction */
2520
    cp = strchr(arg, '/');
2521
    if (!cp)
2522
        cp = strchr(arg, ':');
2523
    if (cp) {
2524
        char* cpp;
2525
        *frame_rate = strtol(arg, &cpp, 10);
2526
        if (cpp != arg || cpp == cp)
2527
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2528
        else
2529
           *frame_rate = 0;
2530
    }
2531
    else {
2532
        /* Finally we give up and parse it as double */
2533
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2534
        *frame_rate_base = time_base.den;
2535
        *frame_rate = time_base.num;
2536
    }
2537
    if (!*frame_rate || !*frame_rate_base)
2538
        return -1;
2539
    else
2540
        return 0;
2541
}
2542

    
2543
int64_t parse_date(const char *datestr, int duration)
2544
{
2545
    const char *p;
2546
    int64_t t;
2547
    struct tm dt;
2548
    int i;
2549
    static const char *date_fmt[] = {
2550
        "%Y-%m-%d",
2551
        "%Y%m%d",
2552
    };
2553
    static const char *time_fmt[] = {
2554
        "%H:%M:%S",
2555
        "%H%M%S",
2556
    };
2557
    const char *q;
2558
    int is_utc, len;
2559
    char lastch;
2560
    int negative = 0;
2561

    
2562
#undef time
2563
    time_t now = time(0);
2564

    
2565
    len = strlen(datestr);
2566
    if (len > 0)
2567
        lastch = datestr[len - 1];
2568
    else
2569
        lastch = '\0';
2570
    is_utc = (lastch == 'z' || lastch == 'Z');
2571

    
2572
    memset(&dt, 0, sizeof(dt));
2573

    
2574
    p = datestr;
2575
    q = NULL;
2576
    if (!duration) {
2577
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2578
            q = small_strptime(p, date_fmt[i], &dt);
2579
            if (q) {
2580
                break;
2581
            }
2582
        }
2583

    
2584
        if (!q) {
2585
            if (is_utc) {
2586
                dt = *gmtime(&now);
2587
            } else {
2588
                dt = *localtime(&now);
2589
            }
2590
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2591
        } else {
2592
            p = q;
2593
        }
2594

    
2595
        if (*p == 'T' || *p == 't' || *p == ' ')
2596
            p++;
2597

    
2598
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2599
            q = small_strptime(p, time_fmt[i], &dt);
2600
            if (q) {
2601
                break;
2602
            }
2603
        }
2604
    } else {
2605
        if (p[0] == '-') {
2606
            negative = 1;
2607
            ++p;
2608
        }
2609
        q = small_strptime(p, time_fmt[0], &dt);
2610
        if (!q) {
2611
            dt.tm_sec = strtol(p, (char **)&q, 10);
2612
            dt.tm_min = 0;
2613
            dt.tm_hour = 0;
2614
        }
2615
    }
2616

    
2617
    /* Now we have all the fields that we can get */
2618
    if (!q) {
2619
        if (duration)
2620
            return 0;
2621
        else
2622
            return now * INT64_C(1000000);
2623
    }
2624

    
2625
    if (duration) {
2626
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2627
    } else {
2628
        dt.tm_isdst = -1;       /* unknown */
2629
        if (is_utc) {
2630
            t = mktimegm(&dt);
2631
        } else {
2632
            t = mktime(&dt);
2633
        }
2634
    }
2635

    
2636
    t *= 1000000;
2637

    
2638
    if (*q == '.') {
2639
        int val, n;
2640
        q++;
2641
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2642
            if (!isdigit(*q))
2643
                break;
2644
            val += n * (*q - '0');
2645
        }
2646
        t += val;
2647
    }
2648
    return negative ? -t : t;
2649
}
2650

    
2651
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2652
{
2653
    const char *p;
2654
    char tag[128], *q;
2655

    
2656
    p = info;
2657
    if (*p == '?')
2658
        p++;
2659
    for(;;) {
2660
        q = tag;
2661
        while (*p != '\0' && *p != '=' && *p != '&') {
2662
            if ((q - tag) < sizeof(tag) - 1)
2663
                *q++ = *p;
2664
            p++;
2665
        }
2666
        *q = '\0';
2667
        q = arg;
2668
        if (*p == '=') {
2669
            p++;
2670
            while (*p != '&' && *p != '\0') {
2671
                if ((q - arg) < arg_size - 1) {
2672
                    if (*p == '+')
2673
                        *q++ = ' ';
2674
                    else
2675
                        *q++ = *p;
2676
                }
2677
                p++;
2678
            }
2679
            *q = '\0';
2680
        }
2681
        if (!strcmp(tag, tag1))
2682
            return 1;
2683
        if (*p != '&')
2684
            break;
2685
        p++;
2686
    }
2687
    return 0;
2688
}
2689

    
2690
int av_get_frame_filename(char *buf, int buf_size,
2691
                          const char *path, int number)
2692
{
2693
    const char *p;
2694
    char *q, buf1[20], c;
2695
    int nd, len, percentd_found;
2696

    
2697
    q = buf;
2698
    p = path;
2699
    percentd_found = 0;
2700
    for(;;) {
2701
        c = *p++;
2702
        if (c == '\0')
2703
            break;
2704
        if (c == '%') {
2705
            do {
2706
                nd = 0;
2707
                while (isdigit(*p)) {
2708
                    nd = nd * 10 + *p++ - '0';
2709
                }
2710
                c = *p++;
2711
            } while (isdigit(c));
2712

    
2713
            switch(c) {
2714
            case '%':
2715
                goto addchar;
2716
            case 'd':
2717
                if (percentd_found)
2718
                    goto fail;
2719
                percentd_found = 1;
2720
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2721
                len = strlen(buf1);
2722
                if ((q - buf + len) > buf_size - 1)
2723
                    goto fail;
2724
                memcpy(q, buf1, len);
2725
                q += len;
2726
                break;
2727
            default:
2728
                goto fail;
2729
            }
2730
        } else {
2731
        addchar:
2732
            if ((q - buf) < buf_size - 1)
2733
                *q++ = c;
2734
        }
2735
    }
2736
    if (!percentd_found)
2737
        goto fail;
2738
    *q = '\0';
2739
    return 0;
2740
 fail:
2741
    *q = '\0';
2742
    return -1;
2743
}
2744

    
2745
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2746
{
2747
    int len, i, j, c;
2748
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2749

    
2750
    for(i=0;i<size;i+=16) {
2751
        len = size - i;
2752
        if (len > 16)
2753
            len = 16;
2754
        PRINT("%08x ", i);
2755
        for(j=0;j<16;j++) {
2756
            if (j < len)
2757
                PRINT(" %02x", buf[i+j]);
2758
            else
2759
                PRINT("   ");
2760
        }
2761
        PRINT(" ");
2762
        for(j=0;j<len;j++) {
2763
            c = buf[i+j];
2764
            if (c < ' ' || c > '~')
2765
                c = '.';
2766
            PRINT("%c", c);
2767
        }
2768
        PRINT("\n");
2769
    }
2770
#undef PRINT
2771
}
2772

    
2773
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2774
{
2775
    hex_dump_internal(NULL, f, 0, buf, size);
2776
}
2777

    
2778
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2779
{
2780
    hex_dump_internal(avcl, NULL, level, buf, size);
2781
}
2782

    
2783
 //FIXME needs to know the time_base
2784
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2785
{
2786
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2787
    PRINT("stream #%d:\n", pkt->stream_index);
2788
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2789
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2790
    /* DTS is _always_ valid after av_read_frame() */
2791
    PRINT("  dts=");
2792
    if (pkt->dts == AV_NOPTS_VALUE)
2793
        PRINT("N/A");
2794
    else
2795
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2796
    /* PTS may be not known if B frames are present */
2797
    PRINT("  pts=");
2798
    if (pkt->pts == AV_NOPTS_VALUE)
2799
        PRINT("N/A");
2800
    else
2801
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2802
    PRINT("\n");
2803
    PRINT("  size=%d\n", pkt->size);
2804
#undef PRINT
2805
    if (dump_payload)
2806
        av_hex_dump(f, pkt->data, pkt->size);
2807
}
2808

    
2809
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2810
{
2811
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2812
}
2813

    
2814
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2815
{
2816
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2817
}
2818

    
2819
void url_split(char *proto, int proto_size,
2820
               char *authorization, int authorization_size,
2821
               char *hostname, int hostname_size,
2822
               int *port_ptr,
2823
               char *path, int path_size,
2824
               const char *url)
2825
{
2826
    const char *p;
2827
    char *q;
2828
    int port;
2829

    
2830
    port = -1;
2831

    
2832
    p = url;
2833
    q = proto;
2834
    while (*p != ':' && *p != '\0') {
2835
        if ((q - proto) < proto_size - 1)
2836
            *q++ = *p;
2837
        p++;
2838
    }
2839
    if (proto_size > 0)
2840
        *q = '\0';
2841
    if (authorization_size > 0)
2842
        authorization[0] = '\0';
2843
    if (*p == '\0') {
2844
        if (proto_size > 0)
2845
            proto[0] = '\0';
2846
        if (hostname_size > 0)
2847
            hostname[0] = '\0';
2848
        p = url;
2849
    } else {
2850
        char *at,*slash; // PETR: position of '@' character and '/' character
2851

    
2852
        p++;
2853
        if (*p == '/')
2854
            p++;
2855
        if (*p == '/')
2856
            p++;
2857
        at = strchr(p,'@'); // PETR: get the position of '@'
2858
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2859
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2860

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

    
2863
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2864
            if (*p == '@') {    // PETR: passed '@'
2865
              if (authorization_size > 0)
2866
                  *q = '\0';
2867
              q = hostname;
2868
              at = NULL;
2869
            } else if (!at) {   // PETR: hostname
2870
              if ((q - hostname) < hostname_size - 1)
2871
                  *q++ = *p;
2872
            } else {
2873
              if ((q - authorization) < authorization_size - 1)
2874
                *q++ = *p;
2875
            }
2876
            p++;
2877
        }
2878
        if (hostname_size > 0)
2879
            *q = '\0';
2880
        if (*p == ':') {
2881
            p++;
2882
            port = strtoul(p, (char **)&p, 10);
2883
        }
2884
    }
2885
    if (port_ptr)
2886
        *port_ptr = port;
2887
    pstrcpy(path, path_size, p);
2888
}
2889

    
2890
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2891
                     int pts_num, int pts_den)
2892
{
2893
    s->pts_wrap_bits = pts_wrap_bits;
2894
    s->time_base.num = pts_num;
2895
    s->time_base.den = pts_den;
2896
}
2897

    
2898
/* fraction handling */
2899

    
2900
/**
2901
 * f = val + (num / den) + 0.5.
2902
 *
2903
 * 'num' is normalized so that it is such as 0 <= num < den.
2904
 *
2905
 * @param f fractional number
2906
 * @param val integer value
2907
 * @param num must be >= 0
2908
 * @param den must be >= 1
2909
 */
2910
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2911
{
2912
    num += (den >> 1);
2913
    if (num >= den) {
2914
        val += num / den;
2915
        num = num % den;
2916
    }
2917
    f->val = val;
2918
    f->num = num;
2919
    f->den = den;
2920
}
2921

    
2922
/**
2923
 * Fractionnal addition to f: f = f + (incr / f->den).
2924
 *
2925
 * @param f fractional number
2926
 * @param incr increment, can be positive or negative
2927
 */
2928
static void av_frac_add(AVFrac *f, int64_t incr)
2929
{
2930
    int64_t num, den;
2931

    
2932
    num = f->num + incr;
2933
    den = f->den;
2934
    if (num < 0) {
2935
        f->val += num / den;
2936
        num = num % den;
2937
        if (num < 0) {
2938
            num += den;
2939
            f->val--;
2940
        }
2941
    } else if (num >= den) {
2942
        f->val += num / den;
2943
        num = num % den;
2944
    }
2945
    f->num = num;
2946
}