Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ c7385375

History | View | Annotate | Download (88.1 KB)

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

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

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

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

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

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

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

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

    
68
    if(!filename)
69
        return 0;
70

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

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

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

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

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

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

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

    
143
    return fmt;
144
}
145

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

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

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

    
175
/* memory handling */
176

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

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

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

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

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

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

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

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

    
226
    return ret;
227
}
228

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

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

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

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

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

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

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

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

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

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

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

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

    
328
    s->av_class = &av_format_context_class;
329

    
330
    av_opt_set_defaults(s);
331
}
332

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
495
}
496

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

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

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

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

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

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

    
533

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
742
    av_init_packet(pkt);
743

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

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

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

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

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

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

    
843
    return 0;
844
}
845

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

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

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

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

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

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

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

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

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

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

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

    
930
/*******************************************************/
931
/* seek support */
932

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

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

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

    
957
    flush_packet_queue(s);
958

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

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

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

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

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

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

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

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

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

    
1010
    st->index_entries= entries;
1011

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

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

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

    
1035
    return index;
1036
}
1037

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

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

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

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

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

    
1070
#define DEBUG_SEEK
1071

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

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

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

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

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

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

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

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

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

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

    
1131
    av_update_cur_dts(s, st, ts);
1132

    
1133
    return 0;
1134
}
1135

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1320
    return 0;
1321
}
1322

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

    
1328
    av_read_frame_flush(s);
1329

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

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

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

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

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

    
1359
/*******************************************************/
1360

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

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

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

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

    
1419
}
1420

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

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

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

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

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

    
1473
#define DURATION_MAX_READ_SIZE 250000
1474

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

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

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

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

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

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

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

    
1535
    url_fseek(&ic->pb, offset, SEEK_SET);
1536
    read_size = 0;
1537
    for(;;) {
1538
        if (read_size >= DURATION_MAX_READ_SIZE)
1539
            break;
1540
        /* if all info is available, we can stop */
1541
        for(i = 0;i < ic->nb_streams; i++) {
1542
            st = ic->streams[i];
1543
            if (st->duration == AV_NOPTS_VALUE)
1544
                break;
1545
        }
1546
        if (i == ic->nb_streams)
1547
            break;
1548

    
1549
        ret = av_read_packet(ic, pkt);
1550
        if (ret != 0)
1551
            break;
1552
        read_size += pkt->size;
1553
        st = ic->streams[pkt->stream_index];
1554
        if (pkt->pts != AV_NOPTS_VALUE) {
1555
            end_time = pkt->pts;
1556
            duration = end_time - st->start_time;
1557
            if (duration > 0) {
1558
                if (st->duration == AV_NOPTS_VALUE ||
1559
                    st->duration < duration)
1560
                    st->duration = duration;
1561
            }
1562
        }
1563
        av_free_packet(pkt);
1564
    }
1565

    
1566
    fill_all_stream_timings(ic);
1567

    
1568
    url_fseek(&ic->pb, old_offset, SEEK_SET);
1569
}
1570

    
1571
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1572
{
1573
    int64_t file_size;
1574

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

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

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

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

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

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

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

    
1674
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1675
{
1676
    AVInputFormat *fmt;
1677
    fmt = av_probe_input_format2(pd, 1, &score);
1678

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

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

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

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

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

    
1735
/* absolute maximum size we read until we abort */
1736
#define MAX_READ_SIZE        5000000
1737

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

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

    
1758
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1759
    if (!duration_error) return AVERROR(ENOMEM);
1760

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

    
1778
    for(i=0;i<MAX_STREAMS;i++){
1779
        last_dts[i]= AV_NOPTS_VALUE;
1780
    }
1781

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

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

    
1838
        pkt= add_to_pktbuf(ic, &pkt1);
1839
        if(av_dup_packet(pkt) < 0)
1840
            return AVERROR(ENOMEM);
1841

    
1842
        read_size += pkt->size;
1843

    
1844
        st = ic->streams[pkt->stream_index];
1845
        if(codec_info_nb_frames[st->index]>1)
1846
            codec_info_duration[st->index] += pkt->duration;
1847
        if (pkt->duration != 0)
1848
            codec_info_nb_frames[st->index]++;
1849

    
1850
        {
1851
            int index= pkt->stream_index;
1852
            int64_t last= last_dts[index];
1853
            int64_t duration= pkt->dts - last;
1854

    
1855
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1856
                double dur= duration * av_q2d(st->time_base);
1857

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

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

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

    
1911
        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) {
1912
            break;
1913
        }
1914
        count++;
1915
    }
1916

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

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

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

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

    
1969
    av_estimate_timings(ic, old_offset);
1970

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

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

    
2014
    av_free(duration_error);
2015
    for(i=0;i<MAX_STREAMS;i++){
2016
        av_freep(&(probe_data[i].buf));
2017
    }
2018

    
2019
    return ret;
2020
}
2021

    
2022
/*******************************************************/
2023

    
2024
int av_read_play(AVFormatContext *s)
2025
{
2026
    if (!s->iformat->read_play)
2027
        return AVERROR(ENOSYS);
2028
    return s->iformat->read_play(s);
2029
}
2030

    
2031
int av_read_pause(AVFormatContext *s)
2032
{
2033
    if (!s->iformat->read_pause)
2034
        return AVERROR(ENOSYS);
2035
    return s->iformat->read_pause(s);
2036
}
2037

    
2038
void av_close_input_file(AVFormatContext *s)
2039
{
2040
    int i, must_open_file;
2041
    AVStream *st;
2042

    
2043
    /* free previous packet */
2044
    if (s->cur_st && s->cur_st->parser)
2045
        av_free_packet(&s->cur_pkt);
2046

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

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

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

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

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

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

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

    
2106
/************************************************************/
2107
/* output media file */
2108

    
2109
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2110
{
2111
    int ret;
2112

    
2113
    if (s->oformat->priv_data_size > 0) {
2114
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2115
        if (!s->priv_data)
2116
            return AVERROR(ENOMEM);
2117
    } else
2118
        s->priv_data = NULL;
2119

    
2120
    if (s->oformat->set_parameters) {
2121
        ret = s->oformat->set_parameters(s, ap);
2122
        if (ret < 0)
2123
            return ret;
2124
    }
2125
    return 0;
2126
}
2127

    
2128
int av_write_header(AVFormatContext *s)
2129
{
2130
    int ret, i;
2131
    AVStream *st;
2132

    
2133
    // some sanity checks
2134
    for(i=0;i<s->nb_streams;i++) {
2135
        st = s->streams[i];
2136

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

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

    
2168
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2169
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2170
        if (!s->priv_data)
2171
            return AVERROR(ENOMEM);
2172
    }
2173

    
2174
    if(s->oformat->write_header){
2175
        ret = s->oformat->write_header(s);
2176
        if (ret < 0)
2177
            return ret;
2178
    }
2179

    
2180
    /* init PTS generation */
2181
    for(i=0;i<s->nb_streams;i++) {
2182
        int64_t den = AV_NOPTS_VALUE;
2183
        st = s->streams[i];
2184

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

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

    
2209
//    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);
2210

    
2211
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2212
        return -1;*/
2213

    
2214
    /* duration field */
2215
    if (pkt->duration == 0) {
2216
        compute_frame_duration(&num, &den, st, NULL, pkt);
2217
        if (den && num) {
2218
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2219
        }
2220
    }
2221

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

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

    
2237
        pkt->dts= st->pts_buffer[0];
2238
    }
2239

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

    
2249
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2250
    st->cur_dts= pkt->dts;
2251
    st->pts.val= pkt->dts;
2252

    
2253
    /* update pts */
2254
    switch (st->codec->codec_type) {
2255
    case CODEC_TYPE_AUDIO:
2256
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2257

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

    
2273
static void truncate_ts(AVStream *st, AVPacket *pkt){
2274
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2275

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

    
2279
    if (pkt->pts != AV_NOPTS_VALUE)
2280
        pkt->pts &= pts_mask;
2281
    if (pkt->dts != AV_NOPTS_VALUE)
2282
        pkt->dts &= pts_mask;
2283
}
2284

    
2285
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2286
{
2287
    int ret;
2288

    
2289
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2290
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2291
        return ret;
2292

    
2293
    truncate_ts(s->streams[pkt->stream_index], pkt);
2294

    
2295
    ret= s->oformat->write_packet(s, pkt);
2296
    if(!ret)
2297
        ret= url_ferror(&s->pb);
2298
    return ret;
2299
}
2300

    
2301
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2302
    AVPacketList *pktl, **next_point, *this_pktl;
2303
    int stream_count=0;
2304
    int streams[MAX_STREAMS];
2305

    
2306
    if(pkt){
2307
        AVStream *st= s->streams[ pkt->stream_index];
2308

    
2309
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2310

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

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

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

    
2341
    if(s->nb_streams == stream_count || (flush && stream_count)){
2342
        pktl= s->packet_buffer;
2343
        *out= pktl->pkt;
2344

    
2345
        s->packet_buffer= pktl->next;
2346
        av_freep(&pktl);
2347
        return 1;
2348
    }else{
2349
        av_init_packet(out);
2350
        return 0;
2351
    }
2352
}
2353

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

    
2370
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2371
    AVStream *st= s->streams[ pkt->stream_index];
2372

    
2373
    //FIXME/XXX/HACK drop zero sized packets
2374
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2375
        return 0;
2376

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

    
2381
    if(pkt->dts == AV_NOPTS_VALUE)
2382
        return -1;
2383

    
2384
    for(;;){
2385
        AVPacket opkt;
2386
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2387
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2388
            return ret;
2389

    
2390
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2391
        ret= s->oformat->write_packet(s, &opkt);
2392

    
2393
        av_free_packet(&opkt);
2394
        pkt= NULL;
2395

    
2396
        if(ret<0)
2397
            return ret;
2398
        if(url_ferror(&s->pb))
2399
            return url_ferror(&s->pb);
2400
    }
2401
}
2402

    
2403
int av_write_trailer(AVFormatContext *s)
2404
{
2405
    int ret, i;
2406

    
2407
    for(;;){
2408
        AVPacket pkt;
2409
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2410
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2411
            goto fail;
2412
        if(!ret)
2413
            break;
2414

    
2415
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2416
        ret= s->oformat->write_packet(s, &pkt);
2417

    
2418
        av_free_packet(&pkt);
2419

    
2420
        if(ret<0)
2421
            goto fail;
2422
        if(url_ferror(&s->pb))
2423
            goto fail;
2424
    }
2425

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

    
2437
/* "user interface" functions */
2438

    
2439
void dump_format(AVFormatContext *ic,
2440
                 int index,
2441
                 const char *url,
2442
                 int is_output)
2443
{
2444
    int i, flags;
2445
    char buf[256];
2446

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

    
2514
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2515
{
2516
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2517
}
2518

    
2519
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2520
{
2521
    AVRational frame_rate;
2522
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2523
    *frame_rate_num= frame_rate.num;
2524
    *frame_rate_den= frame_rate.den;
2525
    return ret;
2526
}
2527

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

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

    
2557
#undef time
2558
    time_t now = time(0);
2559

    
2560
    len = strlen(datestr);
2561
    if (len > 0)
2562
        lastch = datestr[len - 1];
2563
    else
2564
        lastch = '\0';
2565
    is_utc = (lastch == 'z' || lastch == 'Z');
2566

    
2567
    memset(&dt, 0, sizeof(dt));
2568

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

    
2579
        if (!q) {
2580
            if (is_utc) {
2581
                dt = *gmtime(&now);
2582
            } else {
2583
                dt = *localtime(&now);
2584
            }
2585
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2586
        } else {
2587
            p = q;
2588
        }
2589

    
2590
        if (*p == 'T' || *p == 't' || *p == ' ')
2591
            p++;
2592

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

    
2612
    /* Now we have all the fields that we can get */
2613
    if (!q) {
2614
        if (duration)
2615
            return 0;
2616
        else
2617
            return now * INT64_C(1000000);
2618
    }
2619

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

    
2631
    t *= 1000000;
2632

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

    
2646
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2647
{
2648
    const char *p;
2649
    char tag[128], *q;
2650

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

    
2685
int av_get_frame_filename(char *buf, int buf_size,
2686
                          const char *path, int number)
2687
{
2688
    const char *p;
2689
    char *q, buf1[20], c;
2690
    int nd, len, percentd_found;
2691

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

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

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

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

    
2768
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2769
{
2770
    hex_dump_internal(NULL, f, 0, buf, size);
2771
}
2772

    
2773
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2774
{
2775
    hex_dump_internal(avcl, NULL, level, buf, size);
2776
}
2777

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

    
2804
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2805
{
2806
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2807
}
2808

    
2809
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2810
{
2811
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2812
}
2813

    
2814
void url_split(char *proto, int proto_size,
2815
               char *authorization, int authorization_size,
2816
               char *hostname, int hostname_size,
2817
               int *port_ptr,
2818
               char *path, int path_size,
2819
               const char *url)
2820
{
2821
    const char *p;
2822
    char *q;
2823
    int port;
2824

    
2825
    port = -1;
2826

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

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

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

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

    
2885
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2886
                     int pts_num, int pts_den)
2887
{
2888
    s->pts_wrap_bits = pts_wrap_bits;
2889
    s->time_base.num = pts_num;
2890
    s->time_base.den = pts_den;
2891
}
2892

    
2893
/* fraction handling */
2894

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

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

    
2927
    num = f->num + incr;
2928
    den = f->den;
2929
    if (num < 0) {
2930
        f->val += num / den;
2931
        num = num % den;
2932
        if (num < 0) {
2933
            num += den;
2934
            f->val--;
2935
        }
2936
    } else if (num >= den) {
2937
        f->val += num / den;
2938
        num = num % den;
2939
    }
2940
    f->num = num;
2941
}