Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ e8acf0ed

History | View | Annotate | Download (90.8 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 "opt.h"
23
#include "avstring.h"
24
#include "riff.h"
25
#include <sys/time.h>
26
#include <time.h>
27

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

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

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

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

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

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

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

    
67
    if(!filename)
68
        return 0;
69

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

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

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

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

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

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

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

    
142
    return fmt;
143
}
144

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

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

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

    
174
/* memory handling */
175

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

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

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

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

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

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

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

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

    
225
    return ret;
226
}
227

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

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

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

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

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

    
284
/************************************************************/
285
/* input media file */
286

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

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

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

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

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

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

    
327
    s->av_class = &av_format_context_class;
328

    
329
    av_opt_set_defaults(s);
330
}
331

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
485
}
486

    
487
/*******************************************************/
488

    
489
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
490
{
491
    av_init_packet(pkt);
492
    return s->iformat->read_packet(s, pkt);
493
}
494

    
495
/**********************************************************/
496

    
497
/**
498
 * Get the number of samples of an audio frame. Return (-1) if error.
499
 */
500
static int get_audio_frame_size(AVCodecContext *enc, int size)
501
{
502
    int frame_size;
503

    
504
    if (enc->frame_size <= 1) {
505
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
506

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

    
523

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

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

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

    
582
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
583
                                      int64_t dts, int64_t pts)
584
{
585
    AVStream *st= s->streams[stream_index];
586
    AVPacketList *pktl= s->packet_buffer;
587

    
588
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
589
        return;
590

    
591
    st->first_dts= dts - st->cur_dts;
592
    st->cur_dts= dts;
593

    
594
    for(; pktl; pktl= pktl->next){
595
        if(pktl->pkt.stream_index != stream_index)
596
            continue;
597
        //FIXME think more about this check
598
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
599
            pktl->pkt.pts += st->first_dts;
600

    
601
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
602
            pktl->pkt.dts += st->first_dts;
603

    
604
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
605
            st->start_time= pktl->pkt.pts;
606
    }
607
    if (st->start_time == AV_NOPTS_VALUE)
608
        st->start_time = pts;
609
}
610

    
611
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
612
                               AVCodecParserContext *pc, AVPacket *pkt)
613
{
614
    int num, den, presentation_delayed, delay, i;
615
    int64_t offset;
616

    
617
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
618
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
619
        pkt->dts -= 1LL<<st->pts_wrap_bits;
620
    }
621

    
622
    if (pkt->duration == 0) {
623
        compute_frame_duration(&num, &den, st, pc, pkt);
624
        if (den && num) {
625
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
626
        }
627
    }
628

    
629
    /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
630
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
631
        /* this will estimate bitrate based on this frame's duration and size */
632
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
633
        if(pkt->pts != AV_NOPTS_VALUE)
634
            pkt->pts += offset;
635
        if(pkt->dts != AV_NOPTS_VALUE)
636
            pkt->dts += offset;
637
    }
638

    
639
    /* do we have a video B frame ? */
640
    delay= st->codec->has_b_frames;
641
    presentation_delayed = 0;
642
    /* XXX: need has_b_frame, but cannot get it if the codec is
643
        not initialized */
644
    if (delay &&
645
        pc && pc->pict_type != FF_B_TYPE)
646
        presentation_delayed = 1;
647
    /* This may be redundant, but it should not hurt. */
648
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
649
        presentation_delayed = 1;
650

    
651
    if(st->cur_dts == AV_NOPTS_VALUE){
652
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
653
    }
654

    
655
//    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);
656
    /* interpolate PTS and DTS if they are not present */
657
    if(delay <=1){
658
        if (presentation_delayed) {
659
            /* DTS = decompression time stamp */
660
            /* PTS = presentation time stamp */
661
            if (pkt->dts == AV_NOPTS_VALUE)
662
                pkt->dts = st->last_IP_pts;
663
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
664
            if (pkt->dts == AV_NOPTS_VALUE)
665
                pkt->dts = st->cur_dts;
666

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

    
686
            /* presentation is not delayed : PTS and DTS are the same */
687
            if(pkt->pts == AV_NOPTS_VALUE)
688
                pkt->pts = pkt->dts;
689
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
690
            if(pkt->pts == AV_NOPTS_VALUE)
691
                pkt->pts = st->cur_dts;
692
            pkt->dts = pkt->pts;
693
            st->cur_dts = pkt->pts + pkt->duration;
694
        }
695
    }
696

    
697
    if(pkt->pts != AV_NOPTS_VALUE){
698
        st->pts_buffer[0]= pkt->pts;
699
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
700
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
701
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
702
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
703
        if(pkt->dts == AV_NOPTS_VALUE)
704
            pkt->dts= st->pts_buffer[0];
705
        if(delay>1){
706
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
707
        }
708
        if(pkt->dts > st->cur_dts)
709
            st->cur_dts = pkt->dts;
710
    }
711

    
712
//    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);
713

    
714
    /* update flags */
715
    if(is_intra_only(st->codec))
716
        pkt->flags |= PKT_FLAG_KEY;
717
    else if (pc) {
718
        pkt->flags = 0;
719
        /* key frame computation */
720
            if (pc->pict_type == FF_I_TYPE)
721
                pkt->flags |= PKT_FLAG_KEY;
722
    }
723
}
724

    
725
void av_destruct_packet_nofree(AVPacket *pkt)
726
{
727
    pkt->data = NULL; pkt->size = 0;
728
}
729

    
730
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
731
{
732
    AVStream *st;
733
    int len, ret, i;
734

    
735
    av_init_packet(pkt);
736

    
737
    for(;;) {
738
        /* select current input stream component */
739
        st = s->cur_st;
740
        if (st) {
741
            if (!st->need_parsing || !st->parser) {
742
                /* no parsing needed: we just output the packet as is */
743
                /* raw data support */
744
                *pkt = s->cur_pkt;
745
                compute_pkt_fields(s, st, NULL, pkt);
746
                s->cur_st = NULL;
747
                break;
748
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
749
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
750
                                      s->cur_ptr, s->cur_len,
751
                                      s->cur_pkt.pts, s->cur_pkt.dts);
752
                s->cur_pkt.pts = AV_NOPTS_VALUE;
753
                s->cur_pkt.dts = AV_NOPTS_VALUE;
754
                /* increment read pointer */
755
                s->cur_ptr += len;
756
                s->cur_len -= len;
757

    
758
                /* return packet if any */
759
                if (pkt->size) {
760
                got_packet:
761
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
762
                    pkt->duration = 0;
763
                    pkt->stream_index = st->index;
764
                    pkt->pts = st->parser->pts;
765
                    pkt->dts = st->parser->dts;
766
                    pkt->destruct = av_destruct_packet_nofree;
767
                    compute_pkt_fields(s, st, st->parser, pkt);
768

    
769
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
770
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
771
                                           0, 0, AVINDEX_KEYFRAME);
772
                    }
773

    
774
                    break;
775
                }
776
            } else {
777
                /* free packet */
778
                av_free_packet(&s->cur_pkt);
779
                s->cur_st = NULL;
780
            }
781
        } else {
782
            /* read next packet */
783
            ret = av_read_packet(s, &s->cur_pkt);
784
            if (ret < 0) {
785
                if (ret == AVERROR(EAGAIN))
786
                    return ret;
787
                /* return the last frames, if any */
788
                for(i = 0; i < s->nb_streams; i++) {
789
                    st = s->streams[i];
790
                    if (st->parser && st->need_parsing) {
791
                        av_parser_parse(st->parser, st->codec,
792
                                        &pkt->data, &pkt->size,
793
                                        NULL, 0,
794
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
795
                        if (pkt->size)
796
                            goto got_packet;
797
                    }
798
                }
799
                /* no more packets: really terminates parsing */
800
                return ret;
801
            }
802

    
803
            st = s->streams[s->cur_pkt.stream_index];
804
            if(st->codec->debug & FF_DEBUG_PTS)
805
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
806
                    s->cur_pkt.stream_index,
807
                    s->cur_pkt.pts,
808
                    s->cur_pkt.dts,
809
                    s->cur_pkt.size);
810

    
811
            s->cur_st = st;
812
            s->cur_ptr = s->cur_pkt.data;
813
            s->cur_len = s->cur_pkt.size;
814
            if (st->need_parsing && !st->parser) {
815
                st->parser = av_parser_init(st->codec->codec_id);
816
                if (!st->parser) {
817
                    /* no parser available : just output the raw packets */
818
                    st->need_parsing = AVSTREAM_PARSE_NONE;
819
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
820
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
821
                }
822
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
823
                    st->parser->last_frame_offset=
824
                    st->parser->cur_offset= s->cur_pkt.pos;
825
                }
826
            }
827
        }
828
    }
829
    if(st->codec->debug & FF_DEBUG_PTS)
830
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
831
            pkt->stream_index,
832
            pkt->pts,
833
            pkt->dts,
834
            pkt->size);
835

    
836
    return 0;
837
}
838

    
839
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
840
    AVPacketList *pktl= s->packet_buffer;
841
    AVPacketList **plast_pktl= &s->packet_buffer;
842

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

    
845
    pktl = av_mallocz(sizeof(AVPacketList));
846
    if (!pktl)
847
        return NULL;
848

    
849
    /* add the packet in the buffered packet list */
850
    *plast_pktl = pktl;
851
    pktl->pkt= *pkt;
852
    return &pktl->pkt;
853
}
854

    
855
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
856
{
857
    AVPacketList *pktl;
858
    int eof=0;
859
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
860

    
861
    for(;;){
862
        pktl = s->packet_buffer;
863
        if (pktl) {
864
            AVPacket *next_pkt= &pktl->pkt;
865

    
866
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
867
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
868
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
869
                       && next_pkt->dts < pktl->pkt.dts
870
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
871
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
872
                        next_pkt->pts= pktl->pkt.dts;
873
                    }
874
                    pktl= pktl->next;
875
                }
876
                pktl = s->packet_buffer;
877
            }
878

    
879
            if(   next_pkt->pts != AV_NOPTS_VALUE
880
               || next_pkt->dts == AV_NOPTS_VALUE
881
               || !genpts || eof){
882
                /* read packet from packet buffer, if there is data */
883
                *pkt = *next_pkt;
884
                s->packet_buffer = pktl->next;
885
                av_free(pktl);
886
                return 0;
887
            }
888
        }
889
        if(genpts){
890
            int ret= av_read_frame_internal(s, pkt);
891
            if(ret<0){
892
                if(pktl && ret != AVERROR(EAGAIN)){
893
                    eof=1;
894
                    continue;
895
                }else
896
                    return ret;
897
            }
898

    
899
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
900
                return AVERROR(ENOMEM);
901
        }else{
902
            assert(!s->packet_buffer);
903
            return av_read_frame_internal(s, pkt);
904
        }
905
    }
906
}
907

    
908
/* XXX: suppress the packet queue */
909
static void flush_packet_queue(AVFormatContext *s)
910
{
911
    AVPacketList *pktl;
912

    
913
    for(;;) {
914
        pktl = s->packet_buffer;
915
        if (!pktl)
916
            break;
917
        s->packet_buffer = pktl->next;
918
        av_free_packet(&pktl->pkt);
919
        av_free(pktl);
920
    }
921
}
922

    
923
/*******************************************************/
924
/* seek support */
925

    
926
int av_find_default_stream_index(AVFormatContext *s)
927
{
928
    int i;
929
    AVStream *st;
930

    
931
    if (s->nb_streams <= 0)
932
        return -1;
933
    for(i = 0; i < s->nb_streams; i++) {
934
        st = s->streams[i];
935
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
936
            return i;
937
        }
938
    }
939
    return 0;
940
}
941

    
942
/**
943
 * Flush the frame reader.
944
 */
945
static void av_read_frame_flush(AVFormatContext *s)
946
{
947
    AVStream *st;
948
    int i;
949

    
950
    flush_packet_queue(s);
951

    
952
    /* free previous packet */
953
    if (s->cur_st) {
954
        if (s->cur_st->parser)
955
            av_free_packet(&s->cur_pkt);
956
        s->cur_st = NULL;
957
    }
958
    /* fail safe */
959
    s->cur_ptr = NULL;
960
    s->cur_len = 0;
961

    
962
    /* for each stream, reset read state */
963
    for(i = 0; i < s->nb_streams; i++) {
964
        st = s->streams[i];
965

    
966
        if (st->parser) {
967
            av_parser_close(st->parser);
968
            st->parser = NULL;
969
        }
970
        st->last_IP_pts = AV_NOPTS_VALUE;
971
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
972
    }
973
}
974

    
975
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
976
    int i;
977

    
978
    for(i = 0; i < s->nb_streams; i++) {
979
        AVStream *st = s->streams[i];
980

    
981
        st->cur_dts = av_rescale(timestamp,
982
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
983
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
984
    }
985
}
986

    
987
int av_add_index_entry(AVStream *st,
988
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
989
{
990
    AVIndexEntry *entries, *ie;
991
    int index;
992

    
993
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
994
        return -1;
995

    
996
    entries = av_fast_realloc(st->index_entries,
997
                              &st->index_entries_allocated_size,
998
                              (st->nb_index_entries + 1) *
999
                              sizeof(AVIndexEntry));
1000
    if(!entries)
1001
        return -1;
1002

    
1003
    st->index_entries= entries;
1004

    
1005
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1006

    
1007
    if(index<0){
1008
        index= st->nb_index_entries++;
1009
        ie= &entries[index];
1010
        assert(index==0 || ie[-1].timestamp < timestamp);
1011
    }else{
1012
        ie= &entries[index];
1013
        if(ie->timestamp != timestamp){
1014
            if(ie->timestamp <= timestamp)
1015
                return -1;
1016
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1017
            st->nb_index_entries++;
1018
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1019
            distance= ie->min_distance;
1020
    }
1021

    
1022
    ie->pos = pos;
1023
    ie->timestamp = timestamp;
1024
    ie->min_distance= distance;
1025
    ie->size= size;
1026
    ie->flags = flags;
1027

    
1028
    return index;
1029
}
1030

    
1031
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1032
                              int flags)
1033
{
1034
    AVIndexEntry *entries= st->index_entries;
1035
    int nb_entries= st->nb_index_entries;
1036
    int a, b, m;
1037
    int64_t timestamp;
1038

    
1039
    a = - 1;
1040
    b = nb_entries;
1041

    
1042
    while (b - a > 1) {
1043
        m = (a + b) >> 1;
1044
        timestamp = entries[m].timestamp;
1045
        if(timestamp >= wanted_timestamp)
1046
            b = m;
1047
        if(timestamp <= wanted_timestamp)
1048
            a = m;
1049
    }
1050
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1051

    
1052
    if(!(flags & AVSEEK_FLAG_ANY)){
1053
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1054
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1055
        }
1056
    }
1057

    
1058
    if(m == nb_entries)
1059
        return -1;
1060
    return  m;
1061
}
1062

    
1063
#define DEBUG_SEEK
1064

    
1065
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1066
    AVInputFormat *avif= s->iformat;
1067
    int64_t pos_min, pos_max, pos, pos_limit;
1068
    int64_t ts_min, ts_max, ts;
1069
    int index;
1070
    AVStream *st;
1071

    
1072
    if (stream_index < 0)
1073
        return -1;
1074

    
1075
#ifdef DEBUG_SEEK
1076
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1077
#endif
1078

    
1079
    ts_max=
1080
    ts_min= AV_NOPTS_VALUE;
1081
    pos_limit= -1; //gcc falsely says it may be uninitialized
1082

    
1083
    st= s->streams[stream_index];
1084
    if(st->index_entries){
1085
        AVIndexEntry *e;
1086

    
1087
        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()
1088
        index= FFMAX(index, 0);
1089
        e= &st->index_entries[index];
1090

    
1091
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1092
            pos_min= e->pos;
1093
            ts_min= e->timestamp;
1094
#ifdef DEBUG_SEEK
1095
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1096
               pos_min,ts_min);
1097
#endif
1098
        }else{
1099
            assert(index==0);
1100
        }
1101

    
1102
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1103
        assert(index < st->nb_index_entries);
1104
        if(index >= 0){
1105
            e= &st->index_entries[index];
1106
            assert(e->timestamp >= target_ts);
1107
            pos_max= e->pos;
1108
            ts_max= e->timestamp;
1109
            pos_limit= pos_max - e->min_distance;
1110
#ifdef DEBUG_SEEK
1111
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1112
               pos_max,pos_limit, ts_max);
1113
#endif
1114
        }
1115
    }
1116

    
1117
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1118
    if(pos<0)
1119
        return -1;
1120

    
1121
    /* do the seek */
1122
    url_fseek(s->pb, pos, SEEK_SET);
1123

    
1124
    av_update_cur_dts(s, st, ts);
1125

    
1126
    return 0;
1127
}
1128

    
1129
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 )){
1130
    int64_t pos, ts;
1131
    int64_t start_pos, filesize;
1132
    int no_change;
1133

    
1134
#ifdef DEBUG_SEEK
1135
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1136
#endif
1137

    
1138
    if(ts_min == AV_NOPTS_VALUE){
1139
        pos_min = s->data_offset;
1140
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1141
        if (ts_min == AV_NOPTS_VALUE)
1142
            return -1;
1143
    }
1144

    
1145
    if(ts_max == AV_NOPTS_VALUE){
1146
        int step= 1024;
1147
        filesize = url_fsize(s->pb);
1148
        pos_max = filesize - 1;
1149
        do{
1150
            pos_max -= step;
1151
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1152
            step += step;
1153
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1154
        if (ts_max == AV_NOPTS_VALUE)
1155
            return -1;
1156

    
1157
        for(;;){
1158
            int64_t tmp_pos= pos_max + 1;
1159
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1160
            if(tmp_ts == AV_NOPTS_VALUE)
1161
                break;
1162
            ts_max= tmp_ts;
1163
            pos_max= tmp_pos;
1164
            if(tmp_pos >= filesize)
1165
                break;
1166
        }
1167
        pos_limit= pos_max;
1168
    }
1169

    
1170
    if(ts_min > ts_max){
1171
        return -1;
1172
    }else if(ts_min == ts_max){
1173
        pos_limit= pos_min;
1174
    }
1175

    
1176
    no_change=0;
1177
    while (pos_min < pos_limit) {
1178
#ifdef DEBUG_SEEK
1179
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1180
               pos_min, pos_max,
1181
               ts_min, ts_max);
1182
#endif
1183
        assert(pos_limit <= pos_max);
1184

    
1185
        if(no_change==0){
1186
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1187
            // interpolate position (better than dichotomy)
1188
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1189
                + pos_min - approximate_keyframe_distance;
1190
        }else if(no_change==1){
1191
            // bisection, if interpolation failed to change min or max pos last time
1192
            pos = (pos_min + pos_limit)>>1;
1193
        }else{
1194
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1195
            pos=pos_min;
1196
        }
1197
        if(pos <= pos_min)
1198
            pos= pos_min + 1;
1199
        else if(pos > pos_limit)
1200
            pos= pos_limit;
1201
        start_pos= pos;
1202

    
1203
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1204
        if(pos == pos_max)
1205
            no_change++;
1206
        else
1207
            no_change=0;
1208
#ifdef DEBUG_SEEK
1209
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);
1210
#endif
1211
        if(ts == AV_NOPTS_VALUE){
1212
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1213
            return -1;
1214
        }
1215
        assert(ts != AV_NOPTS_VALUE);
1216
        if (target_ts <= ts) {
1217
            pos_limit = start_pos - 1;
1218
            pos_max = pos;
1219
            ts_max = ts;
1220
        }
1221
        if (target_ts >= ts) {
1222
            pos_min = pos;
1223
            ts_min = ts;
1224
        }
1225
    }
1226

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

    
1241
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1242
    int64_t pos_min, pos_max;
1243
#if 0
1244
    AVStream *st;
1245

1246
    if (stream_index < 0)
1247
        return -1;
1248

1249
    st= s->streams[stream_index];
1250
#endif
1251

    
1252
    pos_min = s->data_offset;
1253
    pos_max = url_fsize(s->pb) - 1;
1254

    
1255
    if     (pos < pos_min) pos= pos_min;
1256
    else if(pos > pos_max) pos= pos_max;
1257

    
1258
    url_fseek(s->pb, pos, SEEK_SET);
1259

    
1260
#if 0
1261
    av_update_cur_dts(s, st, ts);
1262
#endif
1263
    return 0;
1264
}
1265

    
1266
static int av_seek_frame_generic(AVFormatContext *s,
1267
                                 int stream_index, int64_t timestamp, int flags)
1268
{
1269
    int index;
1270
    AVStream *st;
1271
    AVIndexEntry *ie;
1272

    
1273
    st = s->streams[stream_index];
1274

    
1275
    index = av_index_search_timestamp(st, timestamp, flags);
1276

    
1277
    if(index < 0 || index==st->nb_index_entries-1){
1278
        int i;
1279
        AVPacket pkt;
1280

    
1281
        if(st->index_entries && st->nb_index_entries){
1282
            ie= &st->index_entries[st->nb_index_entries-1];
1283
            url_fseek(s->pb, ie->pos, SEEK_SET);
1284
            av_update_cur_dts(s, st, ie->timestamp);
1285
        }else
1286
            url_fseek(s->pb, 0, SEEK_SET);
1287

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

    
1303
    av_read_frame_flush(s);
1304
    if (s->iformat->read_seek){
1305
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1306
            return 0;
1307
    }
1308
    ie = &st->index_entries[index];
1309
    url_fseek(s->pb, ie->pos, SEEK_SET);
1310

    
1311
    av_update_cur_dts(s, st, ie->timestamp);
1312

    
1313
    return 0;
1314
}
1315

    
1316
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1317
{
1318
    int ret;
1319
    AVStream *st;
1320

    
1321
    av_read_frame_flush(s);
1322

    
1323
    if(flags & AVSEEK_FLAG_BYTE)
1324
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1325

    
1326
    if(stream_index < 0){
1327
        stream_index= av_find_default_stream_index(s);
1328
        if(stream_index < 0)
1329
            return -1;
1330

    
1331
        st= s->streams[stream_index];
1332
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1333
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1334
    }
1335
    st= s->streams[stream_index];
1336

    
1337
    /* first, we try the format specific seek */
1338
    if (s->iformat->read_seek)
1339
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1340
    else
1341
        ret = -1;
1342
    if (ret >= 0) {
1343
        return 0;
1344
    }
1345

    
1346
    if(s->iformat->read_timestamp)
1347
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1348
    else
1349
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1350
}
1351

    
1352
/*******************************************************/
1353

    
1354
/**
1355
 * Returns TRUE if the stream has accurate duration in any stream.
1356
 *
1357
 * @return TRUE if the stream has accurate duration for at least one component.
1358
 */
1359
static int av_has_duration(AVFormatContext *ic)
1360
{
1361
    int i;
1362
    AVStream *st;
1363

    
1364
    for(i = 0;i < ic->nb_streams; i++) {
1365
        st = ic->streams[i];
1366
        if (st->duration != AV_NOPTS_VALUE)
1367
            return 1;
1368
    }
1369
    return 0;
1370
}
1371

    
1372
/**
1373
 * Estimate the stream timings from the one of each components.
1374
 *
1375
 * Also computes the global bitrate if possible.
1376
 */
1377
static void av_update_stream_timings(AVFormatContext *ic)
1378
{
1379
    int64_t start_time, start_time1, end_time, end_time1;
1380
    int64_t duration, duration1;
1381
    int i;
1382
    AVStream *st;
1383

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

    
1423
static void fill_all_stream_timings(AVFormatContext *ic)
1424
{
1425
    int i;
1426
    AVStream *st;
1427

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

    
1440
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1441
{
1442
    int64_t filesize, duration;
1443
    int bit_rate, i;
1444
    AVStream *st;
1445

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

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

    
1472
#define DURATION_MAX_READ_SIZE 250000
1473

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

    
1483
    /* free previous packet */
1484
    if (ic->cur_st && ic->cur_st->parser)
1485
        av_free_packet(&ic->cur_pkt);
1486
    ic->cur_st = NULL;
1487

    
1488
    /* flush packet queue */
1489
    flush_packet_queue(ic);
1490

    
1491
    for(i=0;i<ic->nb_streams;i++) {
1492
        st = ic->streams[i];
1493
        if (st->parser) {
1494
            av_parser_close(st->parser);
1495
            st->parser= NULL;
1496
        }
1497
    }
1498

    
1499
    /* we read the first packets to get the first PTS (not fully
1500
       accurate, but it is enough now) */
1501
    url_fseek(ic->pb, 0, SEEK_SET);
1502
    read_size = 0;
1503
    for(;;) {
1504
        if (read_size >= DURATION_MAX_READ_SIZE)
1505
            break;
1506
        /* if all info is available, we can stop */
1507
        for(i = 0;i < ic->nb_streams; i++) {
1508
            st = ic->streams[i];
1509
            if (st->start_time == AV_NOPTS_VALUE)
1510
                break;
1511
        }
1512
        if (i == ic->nb_streams)
1513
            break;
1514

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

    
1527
    /* estimate the end time (duration) */
1528
    /* XXX: may need to support wrapping */
1529
    filesize = ic->file_size;
1530
    offset = filesize - DURATION_MAX_READ_SIZE;
1531
    if (offset < 0)
1532
        offset = 0;
1533

    
1534
    url_fseek(ic->pb, offset, SEEK_SET);
1535
    read_size = 0;
1536
    for(;;) {
1537
        if (read_size >= DURATION_MAX_READ_SIZE)
1538
            break;
1539

    
1540
        ret = av_read_packet(ic, pkt);
1541
        if (ret != 0)
1542
            break;
1543
        read_size += pkt->size;
1544
        st = ic->streams[pkt->stream_index];
1545
        if (pkt->pts != AV_NOPTS_VALUE &&
1546
            st->start_time != AV_NOPTS_VALUE) {
1547
            end_time = pkt->pts;
1548
            duration = end_time - st->start_time;
1549
            if (duration > 0) {
1550
                if (st->duration == AV_NOPTS_VALUE ||
1551
                    st->duration < duration)
1552
                    st->duration = duration;
1553
            }
1554
        }
1555
        av_free_packet(pkt);
1556
    }
1557

    
1558
    fill_all_stream_timings(ic);
1559

    
1560
    url_fseek(ic->pb, old_offset, SEEK_SET);
1561
    for(i=0; i<ic->nb_streams; i++){
1562
        st= ic->streams[i];
1563
        st->cur_dts= st->first_dts;
1564
        st->last_IP_pts = AV_NOPTS_VALUE;
1565
    }
1566
}
1567

    
1568
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1569
{
1570
    int64_t file_size;
1571

    
1572
    /* get the file size, if possible */
1573
    if (ic->iformat->flags & AVFMT_NOFILE) {
1574
        file_size = 0;
1575
    } else {
1576
        file_size = url_fsize(ic->pb);
1577
        if (file_size < 0)
1578
            file_size = 0;
1579
    }
1580
    ic->file_size = file_size;
1581

    
1582
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1583
         !strcmp(ic->iformat->name, "mpegts")) &&
1584
        file_size && !ic->pb->is_streamed) {
1585
        /* get accurate estimate from the PTSes */
1586
        av_estimate_timings_from_pts(ic, old_offset);
1587
    } else if (av_has_duration(ic)) {
1588
        /* at least one components has timings - we use them for all
1589
           the components */
1590
        fill_all_stream_timings(ic);
1591
    } else {
1592
        /* less precise: use bit rate info */
1593
        av_estimate_timings_from_bit_rate(ic);
1594
    }
1595
    av_update_stream_timings(ic);
1596

    
1597
#if 0
1598
    {
1599
        int i;
1600
        AVStream *st;
1601
        for(i = 0;i < ic->nb_streams; i++) {
1602
            st = ic->streams[i];
1603
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1604
               i, (double)st->start_time / AV_TIME_BASE,
1605
               (double)st->duration / AV_TIME_BASE);
1606
        }
1607
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1608
               (double)ic->start_time / AV_TIME_BASE,
1609
               (double)ic->duration / AV_TIME_BASE,
1610
               ic->bit_rate / 1000);
1611
    }
1612
#endif
1613
}
1614

    
1615
static int has_codec_parameters(AVCodecContext *enc)
1616
{
1617
    int val;
1618
    switch(enc->codec_type) {
1619
    case CODEC_TYPE_AUDIO:
1620
        val = enc->sample_rate;
1621
        break;
1622
    case CODEC_TYPE_VIDEO:
1623
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1624
        break;
1625
    default:
1626
        val = 1;
1627
        break;
1628
    }
1629
    return (enc->codec_id != CODEC_ID_NONE && val != 0);
1630
}
1631

    
1632
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1633
{
1634
    int16_t *samples;
1635
    AVCodec *codec;
1636
    int got_picture, data_size, ret=0;
1637
    AVFrame picture;
1638

    
1639
  if(!st->codec->codec){
1640
    codec = avcodec_find_decoder(st->codec->codec_id);
1641
    if (!codec)
1642
        return -1;
1643
    ret = avcodec_open(st->codec, codec);
1644
    if (ret < 0)
1645
        return ret;
1646
  }
1647

    
1648
  if(!has_codec_parameters(st->codec)){
1649
    switch(st->codec->codec_type) {
1650
    case CODEC_TYPE_VIDEO:
1651
        ret = avcodec_decode_video(st->codec, &picture,
1652
                                   &got_picture, (uint8_t *)data, size);
1653
        break;
1654
    case CODEC_TYPE_AUDIO:
1655
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1656
        samples = av_malloc(data_size);
1657
        if (!samples)
1658
            goto fail;
1659
        ret = avcodec_decode_audio2(st->codec, samples,
1660
                                    &data_size, (uint8_t *)data, size);
1661
        av_free(samples);
1662
        break;
1663
    default:
1664
        break;
1665
    }
1666
  }
1667
 fail:
1668
    return ret;
1669
}
1670

    
1671
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1672
{
1673
    AVInputFormat *fmt;
1674
    fmt = av_probe_input_format2(pd, 1, &score);
1675

    
1676
    if (fmt) {
1677
        if (strncmp(fmt->name, "mp3", 3) == 0)
1678
            st->codec->codec_id = CODEC_ID_MP3;
1679
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1680
            st->codec->codec_id = CODEC_ID_AC3;
1681
    }
1682
    return !!fmt;
1683
}
1684

    
1685
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1686
{
1687
    while (tags->id != CODEC_ID_NONE) {
1688
        if (tags->id == id)
1689
            return tags->tag;
1690
        tags++;
1691
    }
1692
    return 0;
1693
}
1694

    
1695
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1696
{
1697
    int i;
1698
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1699
        if(tag == tags[i].tag)
1700
            return tags[i].id;
1701
    }
1702
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1703
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1704
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1705
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1706
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1707
            return tags[i].id;
1708
    }
1709
    return CODEC_ID_NONE;
1710
}
1711

    
1712
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1713
{
1714
    int i;
1715
    for(i=0; tags && tags[i]; i++){
1716
        int tag= codec_get_tag(tags[i], id);
1717
        if(tag) return tag;
1718
    }
1719
    return 0;
1720
}
1721

    
1722
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1723
{
1724
    int i;
1725
    for(i=0; tags && tags[i]; i++){
1726
        enum CodecID id= codec_get_id(tags[i], tag);
1727
        if(id!=CODEC_ID_NONE) return id;
1728
    }
1729
    return CODEC_ID_NONE;
1730
}
1731

    
1732
/* absolute maximum size we read until we abort */
1733
#define MAX_READ_SIZE        5000000
1734

    
1735
#define MAX_STD_TIMEBASES (60*12+5)
1736
static int get_std_framerate(int i){
1737
    if(i<60*12) return i*1001;
1738
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1739
}
1740

    
1741
int av_find_stream_info(AVFormatContext *ic)
1742
{
1743
    int i, count, ret, read_size, j;
1744
    AVStream *st;
1745
    AVPacket pkt1, *pkt;
1746
    int64_t last_dts[MAX_STREAMS];
1747
    int duration_count[MAX_STREAMS]={0};
1748
    double (*duration_error)[MAX_STD_TIMEBASES];
1749
    offset_t old_offset = url_ftell(ic->pb);
1750
    int64_t codec_info_duration[MAX_STREAMS]={0};
1751
    int codec_info_nb_frames[MAX_STREAMS]={0};
1752
    AVProbeData probe_data[MAX_STREAMS];
1753
    int codec_identified[MAX_STREAMS]={0};
1754

    
1755
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1756
    if (!duration_error) return AVERROR(ENOMEM);
1757

    
1758
    for(i=0;i<ic->nb_streams;i++) {
1759
        st = ic->streams[i];
1760
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1761
/*            if(!st->time_base.num)
1762
                st->time_base= */
1763
            if(!st->codec->time_base.num)
1764
                st->codec->time_base= st->time_base;
1765
        }
1766
        //only for the split stuff
1767
        if (!st->parser) {
1768
            st->parser = av_parser_init(st->codec->codec_id);
1769
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1770
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1771
            }
1772
        }
1773
    }
1774

    
1775
    for(i=0;i<MAX_STREAMS;i++){
1776
        last_dts[i]= AV_NOPTS_VALUE;
1777
    }
1778

    
1779
    memset(probe_data, 0, sizeof(probe_data));
1780
    count = 0;
1781
    read_size = 0;
1782
    for(;;) {
1783
        /* check if one codec still needs to be handled */
1784
        for(i=0;i<ic->nb_streams;i++) {
1785
            st = ic->streams[i];
1786
            if (!has_codec_parameters(st->codec))
1787
                break;
1788
            /* variable fps and no guess at the real fps */
1789
            if(   (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1790
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1791
                break;
1792
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1793
                break;
1794
            if(st->first_dts == AV_NOPTS_VALUE)
1795
                break;
1796
        }
1797
        if (i == ic->nb_streams) {
1798
            /* NOTE: if the format has no header, then we need to read
1799
               some packets to get most of the streams, so we cannot
1800
               stop here */
1801
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1802
                /* if we found the info for all the codecs, we can stop */
1803
                ret = count;
1804
                break;
1805
            }
1806
        }
1807
        /* we did not get all the codec info, but we read too much data */
1808
        if (read_size >= MAX_READ_SIZE) {
1809
            ret = count;
1810
            break;
1811
        }
1812

    
1813
        /* NOTE: a new stream can be added there if no header in file
1814
           (AVFMTCTX_NOHEADER) */
1815
        ret = av_read_frame_internal(ic, &pkt1);
1816
        if (ret < 0) {
1817
            /* EOF or error */
1818
            ret = -1; /* we could not have all the codec parameters before EOF */
1819
            for(i=0;i<ic->nb_streams;i++) {
1820
                st = ic->streams[i];
1821
                if (!has_codec_parameters(st->codec)){
1822
                    char buf[256];
1823
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1824
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1825
                } else {
1826
                    ret = 0;
1827
                }
1828
            }
1829
            break;
1830
        }
1831

    
1832
        pkt= add_to_pktbuf(ic, &pkt1);
1833
        if(av_dup_packet(pkt) < 0)
1834
            return AVERROR(ENOMEM);
1835

    
1836
        read_size += pkt->size;
1837

    
1838
        st = ic->streams[pkt->stream_index];
1839
        if(codec_info_nb_frames[st->index]>1)
1840
            codec_info_duration[st->index] += pkt->duration;
1841
        if (pkt->duration != 0)
1842
            codec_info_nb_frames[st->index]++;
1843

    
1844
        {
1845
            int index= pkt->stream_index;
1846
            int64_t last= last_dts[index];
1847
            int64_t duration= pkt->dts - last;
1848

    
1849
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1850
                double dur= duration * av_q2d(st->time_base);
1851

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

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

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

    
1906
        if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1907
            break;
1908
        }
1909
        count++;
1910
    }
1911

    
1912
    // close codecs which where opened in try_decode_frame()
1913
    for(i=0;i<ic->nb_streams;i++) {
1914
        st = ic->streams[i];
1915
        if(st->codec->codec)
1916
            avcodec_close(st->codec);
1917
    }
1918
    for(i=0;i<ic->nb_streams;i++) {
1919
        st = ic->streams[i];
1920
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1921
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1922
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1923

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

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

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

    
1964
    av_estimate_timings(ic, old_offset);
1965

    
1966
    for(i=0;i<ic->nb_streams;i++) {
1967
        st = ic->streams[i];
1968
        if (codec_identified[st->index])
1969
            break;
1970
    }
1971
    //FIXME this is a mess
1972
    if(i!=ic->nb_streams){
1973
        av_read_frame_flush(ic);
1974
        for(i=0;i<ic->nb_streams;i++) {
1975
            st = ic->streams[i];
1976
            if (codec_identified[st->index]) {
1977
                av_seek_frame(ic, st->index, 0.0, 0);
1978
            }
1979
            st->cur_dts= st->first_dts;
1980
        }
1981
        url_fseek(ic->pb, ic->data_offset, SEEK_SET);
1982
    }
1983

    
1984
#if 0
1985
    /* correct DTS for b frame streams with no timestamps */
1986
    for(i=0;i<ic->nb_streams;i++) {
1987
        st = ic->streams[i];
1988
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1989
            if(b-frames){
1990
                ppktl = &ic->packet_buffer;
1991
                while(ppkt1){
1992
                    if(ppkt1->stream_index != i)
1993
                        continue;
1994
                    if(ppkt1->pkt->dts < 0)
1995
                        break;
1996
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1997
                        break;
1998
                    ppkt1->pkt->dts -= delta;
1999
                    ppkt1= ppkt1->next;
2000
                }
2001
                if(ppkt1)
2002
                    continue;
2003
                st->cur_dts -= delta;
2004
            }
2005
        }
2006
    }
2007
#endif
2008

    
2009
    av_free(duration_error);
2010
    for(i=0;i<MAX_STREAMS;i++){
2011
        av_freep(&(probe_data[i].buf));
2012
    }
2013

    
2014
    return ret;
2015
}
2016

    
2017
/*******************************************************/
2018

    
2019
int av_read_play(AVFormatContext *s)
2020
{
2021
    if (!s->iformat->read_play)
2022
        return AVERROR(ENOSYS);
2023
    return s->iformat->read_play(s);
2024
}
2025

    
2026
int av_read_pause(AVFormatContext *s)
2027
{
2028
    if (!s->iformat->read_pause)
2029
        return AVERROR(ENOSYS);
2030
    return s->iformat->read_pause(s);
2031
}
2032

    
2033
void av_close_input_file(AVFormatContext *s)
2034
{
2035
    int i, must_open_file;
2036
    AVStream *st;
2037

    
2038
    /* free previous packet */
2039
    if (s->cur_st && s->cur_st->parser)
2040
        av_free_packet(&s->cur_pkt);
2041

    
2042
    if (s->iformat->read_close)
2043
        s->iformat->read_close(s);
2044
    for(i=0;i<s->nb_streams;i++) {
2045
        /* free all data in a stream component */
2046
        st = s->streams[i];
2047
        if (st->parser) {
2048
            av_parser_close(st->parser);
2049
        }
2050
        av_free(st->index_entries);
2051
        av_free(st->codec->extradata);
2052
        av_free(st->codec);
2053
        av_free(st);
2054
    }
2055
    for(i=s->nb_programs-1; i>=0; i--) {
2056
        av_freep(&s->programs[i]->provider_name);
2057
        av_freep(&s->programs[i]->name);
2058
        av_freep(&s->programs[i]->stream_index);
2059
        av_freep(&s->programs[i]);
2060
    }
2061
    flush_packet_queue(s);
2062
    must_open_file = 1;
2063
    if (s->iformat->flags & AVFMT_NOFILE) {
2064
        must_open_file = 0;
2065
    }
2066
    if (must_open_file) {
2067
        url_fclose(s->pb);
2068
    }
2069
    av_freep(&s->priv_data);
2070
    av_free(s);
2071
}
2072

    
2073
AVStream *av_new_stream(AVFormatContext *s, int id)
2074
{
2075
    AVStream *st;
2076
    int i;
2077

    
2078
    if (s->nb_streams >= MAX_STREAMS)
2079
        return NULL;
2080

    
2081
    st = av_mallocz(sizeof(AVStream));
2082
    if (!st)
2083
        return NULL;
2084

    
2085
    st->codec= avcodec_alloc_context();
2086
    if (s->iformat) {
2087
        /* no default bitrate if decoding */
2088
        st->codec->bit_rate = 0;
2089
    }
2090
    st->index = s->nb_streams;
2091
    st->id = id;
2092
    st->start_time = AV_NOPTS_VALUE;
2093
    st->duration = AV_NOPTS_VALUE;
2094
    st->cur_dts = AV_NOPTS_VALUE;
2095
    st->first_dts = AV_NOPTS_VALUE;
2096

    
2097
    /* default pts settings is MPEG like */
2098
    av_set_pts_info(st, 33, 1, 90000);
2099
    st->last_IP_pts = AV_NOPTS_VALUE;
2100
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2101
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2102

    
2103
    s->streams[s->nb_streams++] = st;
2104
    return st;
2105
}
2106

    
2107
AVProgram *av_new_program(AVFormatContext *ac, int id)
2108
{
2109
    AVProgram *program=NULL;
2110
    int i;
2111

    
2112
#ifdef DEBUG_SI
2113
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2114
#endif
2115

    
2116
    for(i=0; i<ac->nb_programs; i++)
2117
        if(ac->programs[i]->id == id)
2118
            program = ac->programs[i];
2119

    
2120
    if(!program){
2121
        program = av_mallocz(sizeof(AVProgram));
2122
        if (!program)
2123
            return NULL;
2124
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2125
        program->discard = AVDISCARD_NONE;
2126
    }
2127
    program->id = id;
2128

    
2129
    return program;
2130
}
2131

    
2132
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2133
{
2134
    assert(!provider_name == !name);
2135
    if(name){
2136
        av_free(program->provider_name);
2137
        av_free(program->         name);
2138
        program->provider_name = av_strdup(provider_name);
2139
        program->         name = av_strdup(         name);
2140
    }
2141
}
2142

    
2143

    
2144
/************************************************************/
2145
/* output media file */
2146

    
2147
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2148
{
2149
    int ret;
2150

    
2151
    if (s->oformat->priv_data_size > 0) {
2152
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2153
        if (!s->priv_data)
2154
            return AVERROR(ENOMEM);
2155
    } else
2156
        s->priv_data = NULL;
2157

    
2158
    if (s->oformat->set_parameters) {
2159
        ret = s->oformat->set_parameters(s, ap);
2160
        if (ret < 0)
2161
            return ret;
2162
    }
2163
    return 0;
2164
}
2165

    
2166
int av_write_header(AVFormatContext *s)
2167
{
2168
    int ret, i;
2169
    AVStream *st;
2170

    
2171
    // some sanity checks
2172
    for(i=0;i<s->nb_streams;i++) {
2173
        st = s->streams[i];
2174

    
2175
        switch (st->codec->codec_type) {
2176
        case CODEC_TYPE_AUDIO:
2177
            if(st->codec->sample_rate<=0){
2178
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2179
                return -1;
2180
            }
2181
            break;
2182
        case CODEC_TYPE_VIDEO:
2183
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2184
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2185
                return -1;
2186
            }
2187
            if(st->codec->width<=0 || st->codec->height<=0){
2188
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2189
                return -1;
2190
            }
2191
            break;
2192
        }
2193

    
2194
        if(s->oformat->codec_tag){
2195
            if(st->codec->codec_tag){
2196
                //FIXME
2197
                //check that tag + id is in the table
2198
                //if neither is in the table -> ok
2199
                //if tag is in the table with another id -> FAIL
2200
                //if id is in the table with another tag -> FAIL unless strict < ?
2201
            }else
2202
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2203
        }
2204
    }
2205

    
2206
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2207
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2208
        if (!s->priv_data)
2209
            return AVERROR(ENOMEM);
2210
    }
2211

    
2212
    if(s->oformat->write_header){
2213
        ret = s->oformat->write_header(s);
2214
        if (ret < 0)
2215
            return ret;
2216
    }
2217

    
2218
    /* init PTS generation */
2219
    for(i=0;i<s->nb_streams;i++) {
2220
        int64_t den = AV_NOPTS_VALUE;
2221
        st = s->streams[i];
2222

    
2223
        switch (st->codec->codec_type) {
2224
        case CODEC_TYPE_AUDIO:
2225
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2226
            break;
2227
        case CODEC_TYPE_VIDEO:
2228
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2229
            break;
2230
        default:
2231
            break;
2232
        }
2233
        if (den != AV_NOPTS_VALUE) {
2234
            if (den <= 0)
2235
                return AVERROR_INVALIDDATA;
2236
            av_frac_init(&st->pts, 0, 0, den);
2237
        }
2238
    }
2239
    return 0;
2240
}
2241

    
2242
//FIXME merge with compute_pkt_fields
2243
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2244
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2245
    int num, den, frame_size, i;
2246

    
2247
//    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);
2248

    
2249
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2250
        return -1;*/
2251

    
2252
    /* duration field */
2253
    if (pkt->duration == 0) {
2254
        compute_frame_duration(&num, &den, st, NULL, pkt);
2255
        if (den && num) {
2256
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2257
        }
2258
    }
2259

    
2260
    //XXX/FIXME this is a temporary hack until all encoders output pts
2261
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2262
        pkt->dts=
2263
//        pkt->pts= st->cur_dts;
2264
        pkt->pts= st->pts.val;
2265
    }
2266

    
2267
    //calculate dts from pts
2268
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2269
        st->pts_buffer[0]= pkt->pts;
2270
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2271
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2272
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2273
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2274

    
2275
        pkt->dts= st->pts_buffer[0];
2276
    }
2277

    
2278
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2279
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2280
        return -1;
2281
    }
2282
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2283
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2284
        return -1;
2285
    }
2286

    
2287
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2288
    st->cur_dts= pkt->dts;
2289
    st->pts.val= pkt->dts;
2290

    
2291
    /* update pts */
2292
    switch (st->codec->codec_type) {
2293
    case CODEC_TYPE_AUDIO:
2294
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2295

    
2296
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2297
           but it would be better if we had the real timestamps from the encoder */
2298
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2299
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2300
        }
2301
        break;
2302
    case CODEC_TYPE_VIDEO:
2303
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2304
        break;
2305
    default:
2306
        break;
2307
    }
2308
    return 0;
2309
}
2310

    
2311
static void truncate_ts(AVStream *st, AVPacket *pkt){
2312
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2313

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

    
2317
    if (pkt->pts != AV_NOPTS_VALUE)
2318
        pkt->pts &= pts_mask;
2319
    if (pkt->dts != AV_NOPTS_VALUE)
2320
        pkt->dts &= pts_mask;
2321
}
2322

    
2323
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2324
{
2325
    int ret;
2326

    
2327
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2328
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2329
        return ret;
2330

    
2331
    truncate_ts(s->streams[pkt->stream_index], pkt);
2332

    
2333
    ret= s->oformat->write_packet(s, pkt);
2334
    if(!ret)
2335
        ret= url_ferror(s->pb);
2336
    return ret;
2337
}
2338

    
2339
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2340
    AVPacketList *pktl, **next_point, *this_pktl;
2341
    int stream_count=0;
2342
    int streams[MAX_STREAMS];
2343

    
2344
    if(pkt){
2345
        AVStream *st= s->streams[ pkt->stream_index];
2346

    
2347
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2348

    
2349
        this_pktl = av_mallocz(sizeof(AVPacketList));
2350
        this_pktl->pkt= *pkt;
2351
        if(pkt->destruct == av_destruct_packet)
2352
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2353
        else
2354
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2355

    
2356
        next_point = &s->packet_buffer;
2357
        while(*next_point){
2358
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2359
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2360
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2361
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2362
                break;
2363
            next_point= &(*next_point)->next;
2364
        }
2365
        this_pktl->next= *next_point;
2366
        *next_point= this_pktl;
2367
    }
2368

    
2369
    memset(streams, 0, sizeof(streams));
2370
    pktl= s->packet_buffer;
2371
    while(pktl){
2372
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2373
        if(streams[ pktl->pkt.stream_index ] == 0)
2374
            stream_count++;
2375
        streams[ pktl->pkt.stream_index ]++;
2376
        pktl= pktl->next;
2377
    }
2378

    
2379
    if(s->nb_streams == stream_count || (flush && stream_count)){
2380
        pktl= s->packet_buffer;
2381
        *out= pktl->pkt;
2382

    
2383
        s->packet_buffer= pktl->next;
2384
        av_freep(&pktl);
2385
        return 1;
2386
    }else{
2387
        av_init_packet(out);
2388
        return 0;
2389
    }
2390
}
2391

    
2392
/**
2393
 * Interleaves a AVPacket correctly so it can be muxed.
2394
 * @param out the interleaved packet will be output here
2395
 * @param in the input packet
2396
 * @param flush 1 if no further packets are available as input and all
2397
 *              remaining packets should be output
2398
 * @return 1 if a packet was output, 0 if no packet could be output,
2399
 *         < 0 if an error occured
2400
 */
2401
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2402
    if(s->oformat->interleave_packet)
2403
        return s->oformat->interleave_packet(s, out, in, flush);
2404
    else
2405
        return av_interleave_packet_per_dts(s, out, in, flush);
2406
}
2407

    
2408
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2409
    AVStream *st= s->streams[ pkt->stream_index];
2410

    
2411
    //FIXME/XXX/HACK drop zero sized packets
2412
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2413
        return 0;
2414

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

    
2419
    if(pkt->dts == AV_NOPTS_VALUE)
2420
        return -1;
2421

    
2422
    for(;;){
2423
        AVPacket opkt;
2424
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2425
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2426
            return ret;
2427

    
2428
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2429
        ret= s->oformat->write_packet(s, &opkt);
2430

    
2431
        av_free_packet(&opkt);
2432
        pkt= NULL;
2433

    
2434
        if(ret<0)
2435
            return ret;
2436
        if(url_ferror(s->pb))
2437
            return url_ferror(s->pb);
2438
    }
2439
}
2440

    
2441
int av_write_trailer(AVFormatContext *s)
2442
{
2443
    int ret, i;
2444

    
2445
    for(;;){
2446
        AVPacket pkt;
2447
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2448
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2449
            goto fail;
2450
        if(!ret)
2451
            break;
2452

    
2453
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2454
        ret= s->oformat->write_packet(s, &pkt);
2455

    
2456
        av_free_packet(&pkt);
2457

    
2458
        if(ret<0)
2459
            goto fail;
2460
        if(url_ferror(s->pb))
2461
            goto fail;
2462
    }
2463

    
2464
    if(s->oformat->write_trailer)
2465
        ret = s->oformat->write_trailer(s);
2466
fail:
2467
    if(ret == 0)
2468
       ret=url_ferror(s->pb);
2469
    for(i=0;i<s->nb_streams;i++)
2470
        av_freep(&s->streams[i]->priv_data);
2471
    av_freep(&s->priv_data);
2472
    return ret;
2473
}
2474

    
2475
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2476
{
2477
    int i, j;
2478
    AVProgram *program=NULL;
2479
    void *tmp;
2480

    
2481
    for(i=0; i<ac->nb_programs; i++){
2482
        if(ac->programs[i]->id != progid)
2483
            continue;
2484
        program = ac->programs[i];
2485
        for(j=0; j<program->nb_stream_indexes; j++)
2486
            if(program->stream_index[j] == idx)
2487
                return;
2488

    
2489
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2490
        if(!tmp)
2491
            return;
2492
        program->stream_index = tmp;
2493
        program->stream_index[program->nb_stream_indexes++] = idx;
2494
        return;
2495
    }
2496
}
2497

    
2498
/* "user interface" functions */
2499
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2500
{
2501
    char buf[256];
2502
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2503
    AVStream *st = ic->streams[i];
2504
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2505
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2506
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2507
    /* the pid is an important information, so we display it */
2508
    /* XXX: add a generic system */
2509
    if (flags & AVFMT_SHOW_IDS)
2510
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2511
    if (strlen(st->language) > 0)
2512
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2513
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2514
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2515
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2516
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2517
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2518
/*      else if(st->time_base.den && st->time_base.num)
2519
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2520
        else
2521
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2522
    }
2523
    av_log(NULL, AV_LOG_INFO, "\n");
2524
}
2525

    
2526
void dump_format(AVFormatContext *ic,
2527
                 int index,
2528
                 const char *url,
2529
                 int is_output)
2530
{
2531
    int i;
2532

    
2533
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2534
            is_output ? "Output" : "Input",
2535
            index,
2536
            is_output ? ic->oformat->name : ic->iformat->name,
2537
            is_output ? "to" : "from", url);
2538
    if (!is_output) {
2539
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2540
        if (ic->duration != AV_NOPTS_VALUE) {
2541
            int hours, mins, secs, us;
2542
            secs = ic->duration / AV_TIME_BASE;
2543
            us = ic->duration % AV_TIME_BASE;
2544
            mins = secs / 60;
2545
            secs %= 60;
2546
            hours = mins / 60;
2547
            mins %= 60;
2548
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2549
                   (10 * us) / AV_TIME_BASE);
2550
        } else {
2551
            av_log(NULL, AV_LOG_INFO, "N/A");
2552
        }
2553
        if (ic->start_time != AV_NOPTS_VALUE) {
2554
            int secs, us;
2555
            av_log(NULL, AV_LOG_INFO, ", start: ");
2556
            secs = ic->start_time / AV_TIME_BASE;
2557
            us = ic->start_time % AV_TIME_BASE;
2558
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2559
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2560
        }
2561
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2562
        if (ic->bit_rate) {
2563
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2564
        } else {
2565
            av_log(NULL, AV_LOG_INFO, "N/A");
2566
        }
2567
        av_log(NULL, AV_LOG_INFO, "\n");
2568
    }
2569
    if(ic->nb_programs) {
2570
        int j, k;
2571
        for(j=0; j<ic->nb_programs; j++) {
2572
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2573
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2574
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2575
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2576
         }
2577
    } else
2578
    for(i=0;i<ic->nb_streams;i++)
2579
        dump_stream_format(ic, i, index, is_output);
2580
}
2581

    
2582
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2583
{
2584
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2585
}
2586

    
2587
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2588
{
2589
    AVRational frame_rate;
2590
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2591
    *frame_rate_num= frame_rate.num;
2592
    *frame_rate_den= frame_rate.den;
2593
    return ret;
2594
}
2595

    
2596
/**
2597
 * gets the current time in micro seconds.
2598
 */
2599
int64_t av_gettime(void)
2600
{
2601
    struct timeval tv;
2602
    gettimeofday(&tv,NULL);
2603
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2604
}
2605

    
2606
int64_t parse_date(const char *datestr, int duration)
2607
{
2608
    const char *p;
2609
    int64_t t;
2610
    struct tm dt;
2611
    int i;
2612
    static const char *date_fmt[] = {
2613
        "%Y-%m-%d",
2614
        "%Y%m%d",
2615
    };
2616
    static const char *time_fmt[] = {
2617
        "%H:%M:%S",
2618
        "%H%M%S",
2619
    };
2620
    const char *q;
2621
    int is_utc, len;
2622
    char lastch;
2623
    int negative = 0;
2624

    
2625
#undef time
2626
    time_t now = time(0);
2627

    
2628
    len = strlen(datestr);
2629
    if (len > 0)
2630
        lastch = datestr[len - 1];
2631
    else
2632
        lastch = '\0';
2633
    is_utc = (lastch == 'z' || lastch == 'Z');
2634

    
2635
    memset(&dt, 0, sizeof(dt));
2636

    
2637
    p = datestr;
2638
    q = NULL;
2639
    if (!duration) {
2640
        /* parse the year-month-day part */
2641
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2642
            q = small_strptime(p, date_fmt[i], &dt);
2643
            if (q) {
2644
                break;
2645
            }
2646
        }
2647

    
2648
        /* if the year-month-day part is missing, then take the
2649
         * current year-month-day time */
2650
        if (!q) {
2651
            if (is_utc) {
2652
                dt = *gmtime(&now);
2653
            } else {
2654
                dt = *localtime(&now);
2655
            }
2656
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2657
        } else {
2658
            p = q;
2659
        }
2660

    
2661
        if (*p == 'T' || *p == 't' || *p == ' ')
2662
            p++;
2663

    
2664
        /* parse the hour-minute-second part */
2665
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2666
            q = small_strptime(p, time_fmt[i], &dt);
2667
            if (q) {
2668
                break;
2669
            }
2670
        }
2671
    } else {
2672
        /* parse datestr as a duration */
2673
        if (p[0] == '-') {
2674
            negative = 1;
2675
            ++p;
2676
        }
2677
        /* parse datestr as HH:MM:SS */
2678
        q = small_strptime(p, time_fmt[0], &dt);
2679
        if (!q) {
2680
            /* parse datestr as S+ */
2681
            dt.tm_sec = strtol(p, (char **)&q, 10);
2682
            if (q == p)
2683
                /* the parsing didn't succeed */
2684
                return INT64_MIN;
2685
            dt.tm_min = 0;
2686
            dt.tm_hour = 0;
2687
        }
2688
    }
2689

    
2690
    /* Now we have all the fields that we can get */
2691
    if (!q) {
2692
        return INT64_MIN;
2693
    }
2694

    
2695
    if (duration) {
2696
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2697
    } else {
2698
        dt.tm_isdst = -1;       /* unknown */
2699
        if (is_utc) {
2700
            t = mktimegm(&dt);
2701
        } else {
2702
            t = mktime(&dt);
2703
        }
2704
    }
2705

    
2706
    t *= 1000000;
2707

    
2708
    /* parse the .m... part */
2709
    if (*q == '.') {
2710
        int val, n;
2711
        q++;
2712
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2713
            if (!isdigit(*q))
2714
                break;
2715
            val += n * (*q - '0');
2716
        }
2717
        t += val;
2718
    }
2719
    return negative ? -t : t;
2720
}
2721

    
2722
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2723
{
2724
    const char *p;
2725
    char tag[128], *q;
2726

    
2727
    p = info;
2728
    if (*p == '?')
2729
        p++;
2730
    for(;;) {
2731
        q = tag;
2732
        while (*p != '\0' && *p != '=' && *p != '&') {
2733
            if ((q - tag) < sizeof(tag) - 1)
2734
                *q++ = *p;
2735
            p++;
2736
        }
2737
        *q = '\0';
2738
        q = arg;
2739
        if (*p == '=') {
2740
            p++;
2741
            while (*p != '&' && *p != '\0') {
2742
                if ((q - arg) < arg_size - 1) {
2743
                    if (*p == '+')
2744
                        *q++ = ' ';
2745
                    else
2746
                        *q++ = *p;
2747
                }
2748
                p++;
2749
            }
2750
            *q = '\0';
2751
        }
2752
        if (!strcmp(tag, tag1))
2753
            return 1;
2754
        if (*p != '&')
2755
            break;
2756
        p++;
2757
    }
2758
    return 0;
2759
}
2760

    
2761
int av_get_frame_filename(char *buf, int buf_size,
2762
                          const char *path, int number)
2763
{
2764
    const char *p;
2765
    char *q, buf1[20], c;
2766
    int nd, len, percentd_found;
2767

    
2768
    q = buf;
2769
    p = path;
2770
    percentd_found = 0;
2771
    for(;;) {
2772
        c = *p++;
2773
        if (c == '\0')
2774
            break;
2775
        if (c == '%') {
2776
            do {
2777
                nd = 0;
2778
                while (isdigit(*p)) {
2779
                    nd = nd * 10 + *p++ - '0';
2780
                }
2781
                c = *p++;
2782
            } while (isdigit(c));
2783

    
2784
            switch(c) {
2785
            case '%':
2786
                goto addchar;
2787
            case 'd':
2788
                if (percentd_found)
2789
                    goto fail;
2790
                percentd_found = 1;
2791
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2792
                len = strlen(buf1);
2793
                if ((q - buf + len) > buf_size - 1)
2794
                    goto fail;
2795
                memcpy(q, buf1, len);
2796
                q += len;
2797
                break;
2798
            default:
2799
                goto fail;
2800
            }
2801
        } else {
2802
        addchar:
2803
            if ((q - buf) < buf_size - 1)
2804
                *q++ = c;
2805
        }
2806
    }
2807
    if (!percentd_found)
2808
        goto fail;
2809
    *q = '\0';
2810
    return 0;
2811
 fail:
2812
    *q = '\0';
2813
    return -1;
2814
}
2815

    
2816
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2817
{
2818
    int len, i, j, c;
2819
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2820

    
2821
    for(i=0;i<size;i+=16) {
2822
        len = size - i;
2823
        if (len > 16)
2824
            len = 16;
2825
        PRINT("%08x ", i);
2826
        for(j=0;j<16;j++) {
2827
            if (j < len)
2828
                PRINT(" %02x", buf[i+j]);
2829
            else
2830
                PRINT("   ");
2831
        }
2832
        PRINT(" ");
2833
        for(j=0;j<len;j++) {
2834
            c = buf[i+j];
2835
            if (c < ' ' || c > '~')
2836
                c = '.';
2837
            PRINT("%c", c);
2838
        }
2839
        PRINT("\n");
2840
    }
2841
#undef PRINT
2842
}
2843

    
2844
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2845
{
2846
    hex_dump_internal(NULL, f, 0, buf, size);
2847
}
2848

    
2849
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2850
{
2851
    hex_dump_internal(avcl, NULL, level, buf, size);
2852
}
2853

    
2854
 //FIXME needs to know the time_base
2855
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2856
{
2857
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2858
    PRINT("stream #%d:\n", pkt->stream_index);
2859
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2860
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2861
    /* DTS is _always_ valid after av_read_frame() */
2862
    PRINT("  dts=");
2863
    if (pkt->dts == AV_NOPTS_VALUE)
2864
        PRINT("N/A");
2865
    else
2866
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2867
    /* PTS may be not known if B frames are present */
2868
    PRINT("  pts=");
2869
    if (pkt->pts == AV_NOPTS_VALUE)
2870
        PRINT("N/A");
2871
    else
2872
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2873
    PRINT("\n");
2874
    PRINT("  size=%d\n", pkt->size);
2875
#undef PRINT
2876
    if (dump_payload)
2877
        av_hex_dump(f, pkt->data, pkt->size);
2878
}
2879

    
2880
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2881
{
2882
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2883
}
2884

    
2885
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2886
{
2887
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2888
}
2889

    
2890
void url_split(char *proto, int proto_size,
2891
               char *authorization, int authorization_size,
2892
               char *hostname, int hostname_size,
2893
               int *port_ptr,
2894
               char *path, int path_size,
2895
               const char *url)
2896
{
2897
    const char *p, *ls, *at, *col, *brk, *q;
2898

    
2899
    if (port_ptr)               *port_ptr = -1;
2900
    if (proto_size > 0)         proto[0] = 0;
2901
    if (authorization_size > 0) authorization[0] = 0;
2902
    if (hostname_size > 0)      hostname[0] = 0;
2903
    if (path_size > 0)          path[0] = 0;
2904

    
2905
    /* parse protocol */
2906
    if ((p = strchr(url, ':'))) {
2907
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2908
        p++; /* skip ':' */
2909
        if (*p == '/') p++;
2910
        if (*p == '/') p++;
2911
    } else {
2912
        /* no protocol means plain filename */
2913
        av_strlcpy(path, url, path_size);
2914
        return;
2915
    }
2916

    
2917
    /* separate path from hostname */
2918
    if ((ls = strchr(p, '/'))) {
2919
        if ((q = strchr(ls, '?')))
2920
            av_strlcpy(path, ls, FFMIN(path_size, q - ls + 1));
2921
        else
2922
            av_strlcpy(path, ls, path_size);
2923
    } else if (!(ls = strchr(p, '?')))
2924
        ls = &p[strlen(p)]; // XXX
2925

    
2926
    /* the rest is hostname, use that to parse auth/port */
2927
    if (ls != p) {
2928
        /* authorization (user[:pass]@hostname) */
2929
        if ((at = strchr(p, '@')) && at < ls) {
2930
            av_strlcpy(authorization, p,
2931
                       FFMIN(authorization_size, at + 1 - p));
2932
            p = at + 1; /* skip '@' */
2933
        }
2934

    
2935
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
2936
            /* [host]:port */
2937
            av_strlcpy(hostname, p + 1,
2938
                       FFMIN(hostname_size, brk - p));
2939
            if (brk[1] == ':' && port_ptr)
2940
                *port_ptr = atoi(brk + 2);
2941
        } else if ((col = strchr(p, ':')) && col < ls) {
2942
            av_strlcpy(hostname, p,
2943
                       FFMIN(col + 1 - p, hostname_size));
2944
            if (port_ptr) *port_ptr = atoi(col + 1);
2945
        } else
2946
            av_strlcpy(hostname, p,
2947
                       FFMIN(ls + 1 - p, hostname_size));
2948
    }
2949
}
2950

    
2951
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2952
                     int pts_num, int pts_den)
2953
{
2954
    s->pts_wrap_bits = pts_wrap_bits;
2955
    s->time_base.num = pts_num;
2956
    s->time_base.den = pts_den;
2957
}
2958

    
2959
/* fraction handling */
2960

    
2961
/**
2962
 * f = val + (num / den) + 0.5.
2963
 *
2964
 * 'num' is normalized so that it is such as 0 <= num < den.
2965
 *
2966
 * @param f fractional number
2967
 * @param val integer value
2968
 * @param num must be >= 0
2969
 * @param den must be >= 1
2970
 */
2971
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2972
{
2973
    num += (den >> 1);
2974
    if (num >= den) {
2975
        val += num / den;
2976
        num = num % den;
2977
    }
2978
    f->val = val;
2979
    f->num = num;
2980
    f->den = den;
2981
}
2982

    
2983
/**
2984
 * Fractionnal addition to f: f = f + (incr / f->den).
2985
 *
2986
 * @param f fractional number
2987
 * @param incr increment, can be positive or negative
2988
 */
2989
static void av_frac_add(AVFrac *f, int64_t incr)
2990
{
2991
    int64_t num, den;
2992

    
2993
    num = f->num + incr;
2994
    den = f->den;
2995
    if (num < 0) {
2996
        f->val += num / den;
2997
        num = num % den;
2998
        if (num < 0) {
2999
            num += den;
3000
            f->val--;
3001
        }
3002
    } else if (num >= den) {
3003
        f->val += num / den;
3004
        num = num % den;
3005
    }
3006
    f->num = num;
3007
}