Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 9be51815

History | View | Annotate | Download (88 KB)

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

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

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

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

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

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

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

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

    
68
    if(!filename)
69
        return 0;
70

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

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

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

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

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

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

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

    
143
    return fmt;
144
}
145

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

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

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

    
175
/* memory handling */
176

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

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

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

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

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

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

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

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

    
226
    return ret;
227
}
228

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

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

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

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

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

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

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

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

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

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

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

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

    
328
    s->av_class = &av_format_context_class;
329

    
330
    av_opt_set_defaults(s);
331
}
332

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
496
}
497

    
498
/*******************************************************/
499

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

    
506
/**********************************************************/
507

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

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

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

    
534

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

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

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

    
593
static void update_initial_timestamps(AVFormatContext *s, int stream_index, int64_t dts){
594
    AVStream *st= s->streams[stream_index];
595
    AVPacketList *pktl= s->packet_buffer;
596

    
597
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
598
        return;
599

    
600
    st->first_dts= dts - st->cur_dts;
601
    st->cur_dts= dts;
602

    
603
    for(; pktl; pktl= pktl->next){
604
        if(pktl->pkt.stream_index != stream_index)
605
            continue;
606
        //FIXME think more about this check
607
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
608
            pktl->pkt.pts += st->first_dts;
609

    
610
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
611
            pktl->pkt.dts += st->first_dts;
612

    
613
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
614
            st->start_time= pktl->pkt.pts;
615
    }
616
}
617

    
618
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
619
                               AVCodecParserContext *pc, AVPacket *pkt)
620
{
621
    int num, den, presentation_delayed, delay, i;
622
    int64_t offset;
623

    
624
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
625
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
626
        pkt->dts -= 1LL<<st->pts_wrap_bits;
627
    }
628

    
629
    if (pkt->duration == 0) {
630
        compute_frame_duration(&num, &den, st, pc, pkt);
631
        if (den && num) {
632
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
633
        }
634
    }
635

    
636
    /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
637
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
638
        /* this will estimate bitrate based on this frame's duration and size */
639
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
640
        if(pkt->pts != AV_NOPTS_VALUE)
641
            pkt->pts += offset;
642
        if(pkt->dts != AV_NOPTS_VALUE)
643
            pkt->dts += offset;
644
    }
645

    
646
    if(is_intra_only(st->codec))
647
        pkt->flags |= PKT_FLAG_KEY;
648

    
649
    /* do we have a video B frame ? */
650
    delay= st->codec->has_b_frames;
651
    presentation_delayed = 0;
652
    /* XXX: need has_b_frame, but cannot get it if the codec is
653
        not initialized */
654
    if (delay &&
655
        pc && pc->pict_type != FF_B_TYPE)
656
        presentation_delayed = 1;
657
    /* This may be redundant, but it should not hurt. */
658
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
659
        presentation_delayed = 1;
660

    
661
    if(st->cur_dts == AV_NOPTS_VALUE){
662
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
663
    }
664

    
665
//    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);
666
    /* interpolate PTS and DTS if they are not present */
667
    if(delay <=1){
668
        if (presentation_delayed) {
669
            /* DTS = decompression time stamp */
670
            /* PTS = presentation time stamp */
671
            if (pkt->dts == AV_NOPTS_VALUE)
672
                pkt->dts = st->last_IP_pts;
673
            update_initial_timestamps(s, pkt->stream_index, pkt->dts);
674
            if (pkt->dts == AV_NOPTS_VALUE)
675
                pkt->dts = st->cur_dts;
676

    
677
            /* this is tricky: the dts must be incremented by the duration
678
            of the frame we are displaying, i.e. the last I or P frame */
679
            if (st->last_IP_duration == 0)
680
                st->last_IP_duration = pkt->duration;
681
            st->cur_dts = pkt->dts + st->last_IP_duration;
682
            st->last_IP_duration  = pkt->duration;
683
            st->last_IP_pts= pkt->pts;
684
            /* cannot compute PTS if not present (we can compute it only
685
            by knowing the futur */
686
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
687
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
688
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
689
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
690
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
691
                    pkt->pts += pkt->duration;
692
    //                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);
693
                }
694
            }
695

    
696
            /* presentation is not delayed : PTS and DTS are the same */
697
            if(pkt->pts == AV_NOPTS_VALUE)
698
                pkt->pts = pkt->dts;
699
            update_initial_timestamps(s, pkt->stream_index, pkt->pts);
700
            if(pkt->pts == AV_NOPTS_VALUE)
701
                pkt->pts = st->cur_dts;
702
            pkt->dts = pkt->pts;
703
            st->cur_dts = pkt->pts + pkt->duration;
704
        }
705
    }
706

    
707
    if(pkt->pts != AV_NOPTS_VALUE){
708
        st->pts_buffer[0]= pkt->pts;
709
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
710
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
711
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
712
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
713
        if(pkt->dts == AV_NOPTS_VALUE)
714
            pkt->dts= st->pts_buffer[0];
715
        if(delay>1){
716
            update_initial_timestamps(s, pkt->stream_index, pkt->dts); // this should happen on the first packet
717
        }
718
        if(pkt->dts > st->cur_dts)
719
            st->cur_dts = pkt->dts;
720
    }
721

    
722
//    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);
723

    
724
    /* update flags */
725
    if (pc) {
726
        pkt->flags = 0;
727
        /* key frame computation */
728
            if (pc->pict_type == FF_I_TYPE)
729
                pkt->flags |= PKT_FLAG_KEY;
730
    }
731
}
732

    
733
void av_destruct_packet_nofree(AVPacket *pkt)
734
{
735
    pkt->data = NULL; pkt->size = 0;
736
}
737

    
738
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
739
{
740
    AVStream *st;
741
    int len, ret, i;
742

    
743
    av_init_packet(pkt);
744

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

    
766
                /* return packet if any */
767
                if (pkt->size) {
768
                got_packet:
769
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
770
                    pkt->duration = 0;
771
                    pkt->stream_index = st->index;
772
                    pkt->pts = st->parser->pts;
773
                    pkt->dts = st->parser->dts;
774
                    pkt->destruct = av_destruct_packet_nofree;
775
                    compute_pkt_fields(s, st, st->parser, pkt);
776

    
777
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
778
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
779
                                           0, 0, AVINDEX_KEYFRAME);
780
                    }
781

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

    
811
            st = s->streams[s->cur_pkt.stream_index];
812
            if(st->codec->debug & FF_DEBUG_PTS)
813
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
814
                    s->cur_pkt.stream_index,
815
                    s->cur_pkt.pts,
816
                    s->cur_pkt.dts,
817
                    s->cur_pkt.size);
818

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

    
844
    return 0;
845
}
846

    
847
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
848
    AVPacketList *pktl= s->packet_buffer;
849
    AVPacketList **plast_pktl= &s->packet_buffer;
850

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

    
853
    pktl = av_mallocz(sizeof(AVPacketList));
854
    if (!pktl)
855
        return NULL;
856

    
857
    /* add the packet in the buffered packet list */
858
    *plast_pktl = pktl;
859
    pktl->pkt= *pkt;
860
    return &pktl->pkt;
861
}
862

    
863
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
864
{
865
    AVPacketList *pktl;
866
    int eof=0;
867
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
868

    
869
    for(;;){
870
        pktl = s->packet_buffer;
871
        if (pktl) {
872
            AVPacket *next_pkt= &pktl->pkt;
873

    
874
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
875
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
876
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
877
                       && next_pkt->dts < pktl->pkt.dts
878
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
879
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
880
                        next_pkt->pts= pktl->pkt.dts;
881
                    }
882
                    pktl= pktl->next;
883
                }
884
                pktl = s->packet_buffer;
885
            }
886

    
887
            if(   next_pkt->pts != AV_NOPTS_VALUE
888
               || next_pkt->dts == AV_NOPTS_VALUE
889
               || !genpts || eof){
890
                /* read packet from packet buffer, if there is data */
891
                *pkt = *next_pkt;
892
                s->packet_buffer = pktl->next;
893
                av_free(pktl);
894
                return 0;
895
            }
896
        }
897
        if(genpts){
898
            int ret= av_read_frame_internal(s, pkt);
899
            if(ret<0){
900
                if(pktl && ret != AVERROR(EAGAIN)){
901
                    eof=1;
902
                    continue;
903
                }else
904
                    return ret;
905
            }
906

    
907
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
908
                return AVERROR(ENOMEM);
909
        }else{
910
            assert(!s->packet_buffer);
911
            return av_read_frame_internal(s, pkt);
912
        }
913
    }
914
}
915

    
916
/* XXX: suppress the packet queue */
917
static void flush_packet_queue(AVFormatContext *s)
918
{
919
    AVPacketList *pktl;
920

    
921
    for(;;) {
922
        pktl = s->packet_buffer;
923
        if (!pktl)
924
            break;
925
        s->packet_buffer = pktl->next;
926
        av_free_packet(&pktl->pkt);
927
        av_free(pktl);
928
    }
929
}
930

    
931
/*******************************************************/
932
/* seek support */
933

    
934
int av_find_default_stream_index(AVFormatContext *s)
935
{
936
    int i;
937
    AVStream *st;
938

    
939
    if (s->nb_streams <= 0)
940
        return -1;
941
    for(i = 0; i < s->nb_streams; i++) {
942
        st = s->streams[i];
943
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
944
            return i;
945
        }
946
    }
947
    return 0;
948
}
949

    
950
/**
951
 * Flush the frame reader.
952
 */
953
static void av_read_frame_flush(AVFormatContext *s)
954
{
955
    AVStream *st;
956
    int i;
957

    
958
    flush_packet_queue(s);
959

    
960
    /* free previous packet */
961
    if (s->cur_st) {
962
        if (s->cur_st->parser)
963
            av_free_packet(&s->cur_pkt);
964
        s->cur_st = NULL;
965
    }
966
    /* fail safe */
967
    s->cur_ptr = NULL;
968
    s->cur_len = 0;
969

    
970
    /* for each stream, reset read state */
971
    for(i = 0; i < s->nb_streams; i++) {
972
        st = s->streams[i];
973

    
974
        if (st->parser) {
975
            av_parser_close(st->parser);
976
            st->parser = NULL;
977
        }
978
        st->last_IP_pts = AV_NOPTS_VALUE;
979
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
980
    }
981
}
982

    
983
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
984
    int i;
985

    
986
    for(i = 0; i < s->nb_streams; i++) {
987
        AVStream *st = s->streams[i];
988

    
989
        st->cur_dts = av_rescale(timestamp,
990
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
991
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
992
    }
993
}
994

    
995
int av_add_index_entry(AVStream *st,
996
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
997
{
998
    AVIndexEntry *entries, *ie;
999
    int index;
1000

    
1001
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1002
        return -1;
1003

    
1004
    entries = av_fast_realloc(st->index_entries,
1005
                              &st->index_entries_allocated_size,
1006
                              (st->nb_index_entries + 1) *
1007
                              sizeof(AVIndexEntry));
1008
    if(!entries)
1009
        return -1;
1010

    
1011
    st->index_entries= entries;
1012

    
1013
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1014

    
1015
    if(index<0){
1016
        index= st->nb_index_entries++;
1017
        ie= &entries[index];
1018
        assert(index==0 || ie[-1].timestamp < timestamp);
1019
    }else{
1020
        ie= &entries[index];
1021
        if(ie->timestamp != timestamp){
1022
            if(ie->timestamp <= timestamp)
1023
                return -1;
1024
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1025
            st->nb_index_entries++;
1026
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1027
            distance= ie->min_distance;
1028
    }
1029

    
1030
    ie->pos = pos;
1031
    ie->timestamp = timestamp;
1032
    ie->min_distance= distance;
1033
    ie->size= size;
1034
    ie->flags = flags;
1035

    
1036
    return index;
1037
}
1038

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

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

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

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

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

    
1071
#define DEBUG_SEEK
1072

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

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

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

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

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

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

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

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

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

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

    
1132
    av_update_cur_dts(s, st, ts);
1133

    
1134
    return 0;
1135
}
1136

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

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

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

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

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

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

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

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

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

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

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

1254
    if (stream_index < 0)
1255
        return -1;
1256

1257
    st= s->streams[stream_index];
1258
#endif
1259

    
1260
    pos_min = s->data_offset;
1261
    pos_max = url_fsize(&s->pb) - 1;
1262

    
1263
    if     (pos < pos_min) pos= pos_min;
1264
    else if(pos > pos_max) pos= pos_max;
1265

    
1266
    url_fseek(&s->pb, pos, SEEK_SET);
1267

    
1268
#if 0
1269
    av_update_cur_dts(s, st, ts);
1270
#endif
1271
    return 0;
1272
}
1273

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

    
1281
    st = s->streams[stream_index];
1282

    
1283
    index = av_index_search_timestamp(st, timestamp, flags);
1284

    
1285
    if(index < 0 || index==st->nb_index_entries-1){
1286
        int i;
1287
        AVPacket pkt;
1288

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

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

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

    
1319
    av_update_cur_dts(s, st, ie->timestamp);
1320

    
1321
    return 0;
1322
}
1323

    
1324
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1325
{
1326
    int ret;
1327
    AVStream *st;
1328

    
1329
    av_read_frame_flush(s);
1330

    
1331
    if(flags & AVSEEK_FLAG_BYTE)
1332
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1333

    
1334
    if(stream_index < 0){
1335
        stream_index= av_find_default_stream_index(s);
1336
        if(stream_index < 0)
1337
            return -1;
1338

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

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

    
1354
    if(s->iformat->read_timestamp)
1355
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1356
    else
1357
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1358
}
1359

    
1360
/*******************************************************/
1361

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

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

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

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

    
1420
}
1421

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

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

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

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

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

    
1471
#define DURATION_MAX_READ_SIZE 250000
1472

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

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

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

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

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

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

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

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

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

    
1557
    fill_all_stream_timings(ic);
1558

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1730
/* absolute maximum size we read until we abort */
1731
#define MAX_READ_SIZE        5000000
1732

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

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

    
1753
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1754
    if (!duration_error) return AVERROR(ENOMEM);
1755

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

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

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

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

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

    
1837
        read_size += pkt->size;
1838

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

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

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

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

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

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

    
1907
        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) {
1908
            break;
1909
        }
1910
        count++;
1911
    }
1912

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

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

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

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

    
1965
    av_estimate_timings(ic, old_offset);
1966

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

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

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

    
2015
    return ret;
2016
}
2017

    
2018
/*******************************************************/
2019

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

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

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

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

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

    
2068
AVStream *av_new_stream(AVFormatContext *s, int id)
2069
{
2070
    AVStream *st;
2071
    int i;
2072

    
2073
    if (s->nb_streams >= MAX_STREAMS)
2074
        return NULL;
2075

    
2076
    st = av_mallocz(sizeof(AVStream));
2077
    if (!st)
2078
        return NULL;
2079

    
2080
    st->codec= avcodec_alloc_context();
2081
    if (s->iformat) {
2082
        /* no default bitrate if decoding */
2083
        st->codec->bit_rate = 0;
2084
    }
2085
    st->index = s->nb_streams;
2086
    st->id = id;
2087
    st->start_time = AV_NOPTS_VALUE;
2088
    st->duration = AV_NOPTS_VALUE;
2089
    st->cur_dts = AV_NOPTS_VALUE;
2090
    st->first_dts = AV_NOPTS_VALUE;
2091

    
2092
    /* default pts settings is MPEG like */
2093
    av_set_pts_info(st, 33, 1, 90000);
2094
    st->last_IP_pts = AV_NOPTS_VALUE;
2095
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2096
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2097

    
2098
    s->streams[s->nb_streams++] = st;
2099
    return st;
2100
}
2101

    
2102
/************************************************************/
2103
/* output media file */
2104

    
2105
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2106
{
2107
    int ret;
2108

    
2109
    if (s->oformat->priv_data_size > 0) {
2110
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2111
        if (!s->priv_data)
2112
            return AVERROR(ENOMEM);
2113
    } else
2114
        s->priv_data = NULL;
2115

    
2116
    if (s->oformat->set_parameters) {
2117
        ret = s->oformat->set_parameters(s, ap);
2118
        if (ret < 0)
2119
            return ret;
2120
    }
2121
    return 0;
2122
}
2123

    
2124
int av_write_header(AVFormatContext *s)
2125
{
2126
    int ret, i;
2127
    AVStream *st;
2128

    
2129
    // some sanity checks
2130
    for(i=0;i<s->nb_streams;i++) {
2131
        st = s->streams[i];
2132

    
2133
        switch (st->codec->codec_type) {
2134
        case CODEC_TYPE_AUDIO:
2135
            if(st->codec->sample_rate<=0){
2136
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2137
                return -1;
2138
            }
2139
            break;
2140
        case CODEC_TYPE_VIDEO:
2141
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2142
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2143
                return -1;
2144
            }
2145
            if(st->codec->width<=0 || st->codec->height<=0){
2146
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2147
                return -1;
2148
            }
2149
            break;
2150
        }
2151

    
2152
        if(s->oformat->codec_tag){
2153
            if(st->codec->codec_tag){
2154
                //FIXME
2155
                //check that tag + id is in the table
2156
                //if neither is in the table -> ok
2157
                //if tag is in the table with another id -> FAIL
2158
                //if id is in the table with another tag -> FAIL unless strict < ?
2159
            }else
2160
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2161
        }
2162
    }
2163

    
2164
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2165
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2166
        if (!s->priv_data)
2167
            return AVERROR(ENOMEM);
2168
    }
2169

    
2170
    if(s->oformat->write_header){
2171
        ret = s->oformat->write_header(s);
2172
        if (ret < 0)
2173
            return ret;
2174
    }
2175

    
2176
    /* init PTS generation */
2177
    for(i=0;i<s->nb_streams;i++) {
2178
        int64_t den = AV_NOPTS_VALUE;
2179
        st = s->streams[i];
2180

    
2181
        switch (st->codec->codec_type) {
2182
        case CODEC_TYPE_AUDIO:
2183
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2184
            break;
2185
        case CODEC_TYPE_VIDEO:
2186
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2187
            break;
2188
        default:
2189
            break;
2190
        }
2191
        if (den != AV_NOPTS_VALUE) {
2192
            if (den <= 0)
2193
                return AVERROR_INVALIDDATA;
2194
            av_frac_init(&st->pts, 0, 0, den);
2195
        }
2196
    }
2197
    return 0;
2198
}
2199

    
2200
//FIXME merge with compute_pkt_fields
2201
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2202
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2203
    int num, den, frame_size, i;
2204

    
2205
//    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);
2206

    
2207
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2208
        return -1;*/
2209

    
2210
    /* duration field */
2211
    if (pkt->duration == 0) {
2212
        compute_frame_duration(&num, &den, st, NULL, pkt);
2213
        if (den && num) {
2214
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2215
        }
2216
    }
2217

    
2218
    //XXX/FIXME this is a temporary hack until all encoders output pts
2219
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2220
        pkt->dts=
2221
//        pkt->pts= st->cur_dts;
2222
        pkt->pts= st->pts.val;
2223
    }
2224

    
2225
    //calculate dts from pts
2226
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2227
        st->pts_buffer[0]= pkt->pts;
2228
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2229
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2230
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2231
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2232

    
2233
        pkt->dts= st->pts_buffer[0];
2234
    }
2235

    
2236
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2237
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2238
        return -1;
2239
    }
2240
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2241
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2242
        return -1;
2243
    }
2244

    
2245
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2246
    st->cur_dts= pkt->dts;
2247
    st->pts.val= pkt->dts;
2248

    
2249
    /* update pts */
2250
    switch (st->codec->codec_type) {
2251
    case CODEC_TYPE_AUDIO:
2252
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2253

    
2254
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2255
           but it would be better if we had the real timestamps from the encoder */
2256
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2257
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2258
        }
2259
        break;
2260
    case CODEC_TYPE_VIDEO:
2261
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2262
        break;
2263
    default:
2264
        break;
2265
    }
2266
    return 0;
2267
}
2268

    
2269
static void truncate_ts(AVStream *st, AVPacket *pkt){
2270
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2271

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

    
2275
    if (pkt->pts != AV_NOPTS_VALUE)
2276
        pkt->pts &= pts_mask;
2277
    if (pkt->dts != AV_NOPTS_VALUE)
2278
        pkt->dts &= pts_mask;
2279
}
2280

    
2281
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2282
{
2283
    int ret;
2284

    
2285
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2286
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2287
        return ret;
2288

    
2289
    truncate_ts(s->streams[pkt->stream_index], pkt);
2290

    
2291
    ret= s->oformat->write_packet(s, pkt);
2292
    if(!ret)
2293
        ret= url_ferror(&s->pb);
2294
    return ret;
2295
}
2296

    
2297
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2298
    AVPacketList *pktl, **next_point, *this_pktl;
2299
    int stream_count=0;
2300
    int streams[MAX_STREAMS];
2301

    
2302
    if(pkt){
2303
        AVStream *st= s->streams[ pkt->stream_index];
2304

    
2305
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2306

    
2307
        this_pktl = av_mallocz(sizeof(AVPacketList));
2308
        this_pktl->pkt= *pkt;
2309
        if(pkt->destruct == av_destruct_packet)
2310
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2311
        else
2312
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2313

    
2314
        next_point = &s->packet_buffer;
2315
        while(*next_point){
2316
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2317
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2318
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2319
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2320
                break;
2321
            next_point= &(*next_point)->next;
2322
        }
2323
        this_pktl->next= *next_point;
2324
        *next_point= this_pktl;
2325
    }
2326

    
2327
    memset(streams, 0, sizeof(streams));
2328
    pktl= s->packet_buffer;
2329
    while(pktl){
2330
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2331
        if(streams[ pktl->pkt.stream_index ] == 0)
2332
            stream_count++;
2333
        streams[ pktl->pkt.stream_index ]++;
2334
        pktl= pktl->next;
2335
    }
2336

    
2337
    if(s->nb_streams == stream_count || (flush && stream_count)){
2338
        pktl= s->packet_buffer;
2339
        *out= pktl->pkt;
2340

    
2341
        s->packet_buffer= pktl->next;
2342
        av_freep(&pktl);
2343
        return 1;
2344
    }else{
2345
        av_init_packet(out);
2346
        return 0;
2347
    }
2348
}
2349

    
2350
/**
2351
 * Interleaves a AVPacket correctly so it can be muxed.
2352
 * @param out the interleaved packet will be output here
2353
 * @param in the input packet
2354
 * @param flush 1 if no further packets are available as input and all
2355
 *              remaining packets should be output
2356
 * @return 1 if a packet was output, 0 if no packet could be output,
2357
 *         < 0 if an error occured
2358
 */
2359
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2360
    if(s->oformat->interleave_packet)
2361
        return s->oformat->interleave_packet(s, out, in, flush);
2362
    else
2363
        return av_interleave_packet_per_dts(s, out, in, flush);
2364
}
2365

    
2366
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2367
    AVStream *st= s->streams[ pkt->stream_index];
2368

    
2369
    //FIXME/XXX/HACK drop zero sized packets
2370
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2371
        return 0;
2372

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

    
2377
    if(pkt->dts == AV_NOPTS_VALUE)
2378
        return -1;
2379

    
2380
    for(;;){
2381
        AVPacket opkt;
2382
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2383
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2384
            return ret;
2385

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

    
2389
        av_free_packet(&opkt);
2390
        pkt= NULL;
2391

    
2392
        if(ret<0)
2393
            return ret;
2394
        if(url_ferror(&s->pb))
2395
            return url_ferror(&s->pb);
2396
    }
2397
}
2398

    
2399
int av_write_trailer(AVFormatContext *s)
2400
{
2401
    int ret, i;
2402

    
2403
    for(;;){
2404
        AVPacket pkt;
2405
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2406
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2407
            goto fail;
2408
        if(!ret)
2409
            break;
2410

    
2411
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2412
        ret= s->oformat->write_packet(s, &pkt);
2413

    
2414
        av_free_packet(&pkt);
2415

    
2416
        if(ret<0)
2417
            goto fail;
2418
        if(url_ferror(&s->pb))
2419
            goto fail;
2420
    }
2421

    
2422
    if(s->oformat->write_trailer)
2423
        ret = s->oformat->write_trailer(s);
2424
fail:
2425
    if(ret == 0)
2426
       ret=url_ferror(&s->pb);
2427
    for(i=0;i<s->nb_streams;i++)
2428
        av_freep(&s->streams[i]->priv_data);
2429
    av_freep(&s->priv_data);
2430
    return ret;
2431
}
2432

    
2433
/* "user interface" functions */
2434

    
2435
void dump_format(AVFormatContext *ic,
2436
                 int index,
2437
                 const char *url,
2438
                 int is_output)
2439
{
2440
    int i, flags;
2441
    char buf[256];
2442

    
2443
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2444
            is_output ? "Output" : "Input",
2445
            index,
2446
            is_output ? ic->oformat->name : ic->iformat->name,
2447
            is_output ? "to" : "from", url);
2448
    if (!is_output) {
2449
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2450
        if (ic->duration != AV_NOPTS_VALUE) {
2451
            int hours, mins, secs, us;
2452
            secs = ic->duration / AV_TIME_BASE;
2453
            us = ic->duration % AV_TIME_BASE;
2454
            mins = secs / 60;
2455
            secs %= 60;
2456
            hours = mins / 60;
2457
            mins %= 60;
2458
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2459
                   (10 * us) / AV_TIME_BASE);
2460
        } else {
2461
            av_log(NULL, AV_LOG_INFO, "N/A");
2462
        }
2463
        if (ic->start_time != AV_NOPTS_VALUE) {
2464
            int secs, us;
2465
            av_log(NULL, AV_LOG_INFO, ", start: ");
2466
            secs = ic->start_time / AV_TIME_BASE;
2467
            us = ic->start_time % AV_TIME_BASE;
2468
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2469
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2470
        }
2471
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2472
        if (ic->bit_rate) {
2473
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2474
        } else {
2475
            av_log(NULL, AV_LOG_INFO, "N/A");
2476
        }
2477
        av_log(NULL, AV_LOG_INFO, "\n");
2478
    }
2479
    for(i=0;i<ic->nb_streams;i++) {
2480
        AVStream *st = ic->streams[i];
2481
        int g= ff_gcd(st->time_base.num, st->time_base.den);
2482
        avcodec_string(buf, sizeof(buf), st->codec, is_output);
2483
        av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2484
        /* the pid is an important information, so we display it */
2485
        /* XXX: add a generic system */
2486
        if (is_output)
2487
            flags = ic->oformat->flags;
2488
        else
2489
            flags = ic->iformat->flags;
2490
        if (flags & AVFMT_SHOW_IDS) {
2491
            av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2492
        }
2493
        if (strlen(st->language) > 0) {
2494
            av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2495
        }
2496
        av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2497
        av_log(NULL, AV_LOG_INFO, ": %s", buf);
2498
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2499
            if(st->r_frame_rate.den && st->r_frame_rate.num)
2500
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2501
/*            else if(st->time_base.den && st->time_base.num)
2502
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2503
            else
2504
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2505
        }
2506
        av_log(NULL, AV_LOG_INFO, "\n");
2507
    }
2508
}
2509

    
2510
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2511
{
2512
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2513
}
2514

    
2515
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2516
{
2517
    AVRational frame_rate;
2518
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2519
    *frame_rate_num= frame_rate.num;
2520
    *frame_rate_den= frame_rate.den;
2521
    return ret;
2522
}
2523

    
2524
/**
2525
 * gets the current time in micro seconds.
2526
 */
2527
int64_t av_gettime(void)
2528
{
2529
    struct timeval tv;
2530
    gettimeofday(&tv,NULL);
2531
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2532
}
2533

    
2534
int64_t parse_date(const char *datestr, int duration)
2535
{
2536
    const char *p;
2537
    int64_t t;
2538
    struct tm dt;
2539
    int i;
2540
    static const char *date_fmt[] = {
2541
        "%Y-%m-%d",
2542
        "%Y%m%d",
2543
    };
2544
    static const char *time_fmt[] = {
2545
        "%H:%M:%S",
2546
        "%H%M%S",
2547
    };
2548
    const char *q;
2549
    int is_utc, len;
2550
    char lastch;
2551
    int negative = 0;
2552

    
2553
#undef time
2554
    time_t now = time(0);
2555

    
2556
    len = strlen(datestr);
2557
    if (len > 0)
2558
        lastch = datestr[len - 1];
2559
    else
2560
        lastch = '\0';
2561
    is_utc = (lastch == 'z' || lastch == 'Z');
2562

    
2563
    memset(&dt, 0, sizeof(dt));
2564

    
2565
    p = datestr;
2566
    q = NULL;
2567
    if (!duration) {
2568
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2569
            q = small_strptime(p, date_fmt[i], &dt);
2570
            if (q) {
2571
                break;
2572
            }
2573
        }
2574

    
2575
        if (!q) {
2576
            if (is_utc) {
2577
                dt = *gmtime(&now);
2578
            } else {
2579
                dt = *localtime(&now);
2580
            }
2581
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2582
        } else {
2583
            p = q;
2584
        }
2585

    
2586
        if (*p == 'T' || *p == 't' || *p == ' ')
2587
            p++;
2588

    
2589
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2590
            q = small_strptime(p, time_fmt[i], &dt);
2591
            if (q) {
2592
                break;
2593
            }
2594
        }
2595
    } else {
2596
        if (p[0] == '-') {
2597
            negative = 1;
2598
            ++p;
2599
        }
2600
        q = small_strptime(p, time_fmt[0], &dt);
2601
        if (!q) {
2602
            dt.tm_sec = strtol(p, (char **)&q, 10);
2603
            dt.tm_min = 0;
2604
            dt.tm_hour = 0;
2605
        }
2606
    }
2607

    
2608
    /* Now we have all the fields that we can get */
2609
    if (!q) {
2610
        if (duration)
2611
            return 0;
2612
        else
2613
            return now * INT64_C(1000000);
2614
    }
2615

    
2616
    if (duration) {
2617
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2618
    } else {
2619
        dt.tm_isdst = -1;       /* unknown */
2620
        if (is_utc) {
2621
            t = mktimegm(&dt);
2622
        } else {
2623
            t = mktime(&dt);
2624
        }
2625
    }
2626

    
2627
    t *= 1000000;
2628

    
2629
    if (*q == '.') {
2630
        int val, n;
2631
        q++;
2632
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2633
            if (!isdigit(*q))
2634
                break;
2635
            val += n * (*q - '0');
2636
        }
2637
        t += val;
2638
    }
2639
    return negative ? -t : t;
2640
}
2641

    
2642
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2643
{
2644
    const char *p;
2645
    char tag[128], *q;
2646

    
2647
    p = info;
2648
    if (*p == '?')
2649
        p++;
2650
    for(;;) {
2651
        q = tag;
2652
        while (*p != '\0' && *p != '=' && *p != '&') {
2653
            if ((q - tag) < sizeof(tag) - 1)
2654
                *q++ = *p;
2655
            p++;
2656
        }
2657
        *q = '\0';
2658
        q = arg;
2659
        if (*p == '=') {
2660
            p++;
2661
            while (*p != '&' && *p != '\0') {
2662
                if ((q - arg) < arg_size - 1) {
2663
                    if (*p == '+')
2664
                        *q++ = ' ';
2665
                    else
2666
                        *q++ = *p;
2667
                }
2668
                p++;
2669
            }
2670
            *q = '\0';
2671
        }
2672
        if (!strcmp(tag, tag1))
2673
            return 1;
2674
        if (*p != '&')
2675
            break;
2676
        p++;
2677
    }
2678
    return 0;
2679
}
2680

    
2681
int av_get_frame_filename(char *buf, int buf_size,
2682
                          const char *path, int number)
2683
{
2684
    const char *p;
2685
    char *q, buf1[20], c;
2686
    int nd, len, percentd_found;
2687

    
2688
    q = buf;
2689
    p = path;
2690
    percentd_found = 0;
2691
    for(;;) {
2692
        c = *p++;
2693
        if (c == '\0')
2694
            break;
2695
        if (c == '%') {
2696
            do {
2697
                nd = 0;
2698
                while (isdigit(*p)) {
2699
                    nd = nd * 10 + *p++ - '0';
2700
                }
2701
                c = *p++;
2702
            } while (isdigit(c));
2703

    
2704
            switch(c) {
2705
            case '%':
2706
                goto addchar;
2707
            case 'd':
2708
                if (percentd_found)
2709
                    goto fail;
2710
                percentd_found = 1;
2711
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2712
                len = strlen(buf1);
2713
                if ((q - buf + len) > buf_size - 1)
2714
                    goto fail;
2715
                memcpy(q, buf1, len);
2716
                q += len;
2717
                break;
2718
            default:
2719
                goto fail;
2720
            }
2721
        } else {
2722
        addchar:
2723
            if ((q - buf) < buf_size - 1)
2724
                *q++ = c;
2725
        }
2726
    }
2727
    if (!percentd_found)
2728
        goto fail;
2729
    *q = '\0';
2730
    return 0;
2731
 fail:
2732
    *q = '\0';
2733
    return -1;
2734
}
2735

    
2736
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2737
{
2738
    int len, i, j, c;
2739
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2740

    
2741
    for(i=0;i<size;i+=16) {
2742
        len = size - i;
2743
        if (len > 16)
2744
            len = 16;
2745
        PRINT("%08x ", i);
2746
        for(j=0;j<16;j++) {
2747
            if (j < len)
2748
                PRINT(" %02x", buf[i+j]);
2749
            else
2750
                PRINT("   ");
2751
        }
2752
        PRINT(" ");
2753
        for(j=0;j<len;j++) {
2754
            c = buf[i+j];
2755
            if (c < ' ' || c > '~')
2756
                c = '.';
2757
            PRINT("%c", c);
2758
        }
2759
        PRINT("\n");
2760
    }
2761
#undef PRINT
2762
}
2763

    
2764
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2765
{
2766
    hex_dump_internal(NULL, f, 0, buf, size);
2767
}
2768

    
2769
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2770
{
2771
    hex_dump_internal(avcl, NULL, level, buf, size);
2772
}
2773

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

    
2800
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2801
{
2802
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2803
}
2804

    
2805
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2806
{
2807
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2808
}
2809

    
2810
void url_split(char *proto, int proto_size,
2811
               char *authorization, int authorization_size,
2812
               char *hostname, int hostname_size,
2813
               int *port_ptr,
2814
               char *path, int path_size,
2815
               const char *url)
2816
{
2817
    const char *p;
2818
    char *q;
2819
    int port;
2820

    
2821
    port = -1;
2822

    
2823
    p = url;
2824
    q = proto;
2825
    while (*p != ':' && *p != '\0') {
2826
        if ((q - proto) < proto_size - 1)
2827
            *q++ = *p;
2828
        p++;
2829
    }
2830
    if (proto_size > 0)
2831
        *q = '\0';
2832
    if (authorization_size > 0)
2833
        authorization[0] = '\0';
2834
    if (*p == '\0') {
2835
        if (proto_size > 0)
2836
            proto[0] = '\0';
2837
        if (hostname_size > 0)
2838
            hostname[0] = '\0';
2839
        p = url;
2840
    } else {
2841
        char *at,*slash; // PETR: position of '@' character and '/' character
2842

    
2843
        p++;
2844
        if (*p == '/')
2845
            p++;
2846
        if (*p == '/')
2847
            p++;
2848
        at = strchr(p,'@'); // PETR: get the position of '@'
2849
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2850
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2851

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

    
2854
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2855
            if (*p == '@') {    // PETR: passed '@'
2856
              if (authorization_size > 0)
2857
                  *q = '\0';
2858
              q = hostname;
2859
              at = NULL;
2860
            } else if (!at) {   // PETR: hostname
2861
              if ((q - hostname) < hostname_size - 1)
2862
                  *q++ = *p;
2863
            } else {
2864
              if ((q - authorization) < authorization_size - 1)
2865
                *q++ = *p;
2866
            }
2867
            p++;
2868
        }
2869
        if (hostname_size > 0)
2870
            *q = '\0';
2871
        if (*p == ':') {
2872
            p++;
2873
            port = strtoul(p, (char **)&p, 10);
2874
        }
2875
    }
2876
    if (port_ptr)
2877
        *port_ptr = port;
2878
    av_strlcpy(path, p, path_size);
2879
}
2880

    
2881
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2882
                     int pts_num, int pts_den)
2883
{
2884
    s->pts_wrap_bits = pts_wrap_bits;
2885
    s->time_base.num = pts_num;
2886
    s->time_base.den = pts_den;
2887
}
2888

    
2889
/* fraction handling */
2890

    
2891
/**
2892
 * f = val + (num / den) + 0.5.
2893
 *
2894
 * 'num' is normalized so that it is such as 0 <= num < den.
2895
 *
2896
 * @param f fractional number
2897
 * @param val integer value
2898
 * @param num must be >= 0
2899
 * @param den must be >= 1
2900
 */
2901
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2902
{
2903
    num += (den >> 1);
2904
    if (num >= den) {
2905
        val += num / den;
2906
        num = num % den;
2907
    }
2908
    f->val = val;
2909
    f->num = num;
2910
    f->den = den;
2911
}
2912

    
2913
/**
2914
 * Fractionnal addition to f: f = f + (incr / f->den).
2915
 *
2916
 * @param f fractional number
2917
 * @param incr increment, can be positive or negative
2918
 */
2919
static void av_frac_add(AVFrac *f, int64_t incr)
2920
{
2921
    int64_t num, den;
2922

    
2923
    num = f->num + incr;
2924
    den = f->den;
2925
    if (num < 0) {
2926
        f->val += num / den;
2927
        num = num % den;
2928
        if (num < 0) {
2929
            num += den;
2930
            f->val--;
2931
        }
2932
    } else if (num >= den) {
2933
        f->val += num / den;
2934
        num = num % den;
2935
    }
2936
    f->num = num;
2937
}