Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 02483df4

History | View | Annotate | Download (106 KB)

1
/*
2
 * various utility functions for use within FFmpeg
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 "internal.h"
23
#include "libavcodec/opt.h"
24
#include "metadata.h"
25
#include "libavutil/avstring.h"
26
#include "riff.h"
27
#include <sys/time.h>
28
#include <time.h>
29
#include <strings.h>
30

    
31
#undef NDEBUG
32
#include <assert.h>
33

    
34
/**
35
 * @file libavformat/utils.c
36
 * various utility functions for use within FFmpeg
37
 */
38

    
39
unsigned avformat_version(void)
40
{
41
    return LIBAVFORMAT_VERSION_INT;
42
}
43

    
44
const char * avformat_configuration(void)
45
{
46
    return FFMPEG_CONFIGURATION;
47
}
48

    
49
const char * avformat_license(void)
50
{
51
#define LICENSE_PREFIX "libavformat license: "
52
    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
53
}
54

    
55
/* fraction handling */
56

    
57
/**
58
 * f = val + (num / den) + 0.5.
59
 *
60
 * 'num' is normalized so that it is such as 0 <= num < den.
61
 *
62
 * @param f fractional number
63
 * @param val integer value
64
 * @param num must be >= 0
65
 * @param den must be >= 1
66
 */
67
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
68
{
69
    num += (den >> 1);
70
    if (num >= den) {
71
        val += num / den;
72
        num = num % den;
73
    }
74
    f->val = val;
75
    f->num = num;
76
    f->den = den;
77
}
78

    
79
/**
80
 * Fractional addition to f: f = f + (incr / f->den).
81
 *
82
 * @param f fractional number
83
 * @param incr increment, can be positive or negative
84
 */
85
static void av_frac_add(AVFrac *f, int64_t incr)
86
{
87
    int64_t num, den;
88

    
89
    num = f->num + incr;
90
    den = f->den;
91
    if (num < 0) {
92
        f->val += num / den;
93
        num = num % den;
94
        if (num < 0) {
95
            num += den;
96
            f->val--;
97
        }
98
    } else if (num >= den) {
99
        f->val += num / den;
100
        num = num % den;
101
    }
102
    f->num = num;
103
}
104

    
105
/** head of registered input format linked list */
106
AVInputFormat *first_iformat = NULL;
107
/** head of registered output format linked list */
108
AVOutputFormat *first_oformat = NULL;
109

    
110
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
111
{
112
    if(f) return f->next;
113
    else  return first_iformat;
114
}
115

    
116
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
117
{
118
    if(f) return f->next;
119
    else  return first_oformat;
120
}
121

    
122
void av_register_input_format(AVInputFormat *format)
123
{
124
    AVInputFormat **p;
125
    p = &first_iformat;
126
    while (*p != NULL) p = &(*p)->next;
127
    *p = format;
128
    format->next = NULL;
129
}
130

    
131
void av_register_output_format(AVOutputFormat *format)
132
{
133
    AVOutputFormat **p;
134
    p = &first_oformat;
135
    while (*p != NULL) p = &(*p)->next;
136
    *p = format;
137
    format->next = NULL;
138
}
139

    
140
int match_ext(const char *filename, const char *extensions)
141
{
142
    const char *ext, *p;
143
    char ext1[32], *q;
144

    
145
    if(!filename)
146
        return 0;
147

    
148
    ext = strrchr(filename, '.');
149
    if (ext) {
150
        ext++;
151
        p = extensions;
152
        for(;;) {
153
            q = ext1;
154
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
155
                *q++ = *p++;
156
            *q = '\0';
157
            if (!strcasecmp(ext1, ext))
158
                return 1;
159
            if (*p == '\0')
160
                break;
161
            p++;
162
        }
163
    }
164
    return 0;
165
}
166

    
167
static int match_format(const char *name, const char *names)
168
{
169
    const char *p;
170
    int len, namelen;
171

    
172
    if (!name || !names)
173
        return 0;
174

    
175
    namelen = strlen(name);
176
    while ((p = strchr(names, ','))) {
177
        len = FFMAX(p - names, namelen);
178
        if (!strncasecmp(name, names, len))
179
            return 1;
180
        names = p+1;
181
    }
182
    return !strcasecmp(name, names);
183
}
184

    
185
AVOutputFormat *guess_format(const char *short_name, const char *filename,
186
                             const char *mime_type)
187
{
188
    AVOutputFormat *fmt, *fmt_found;
189
    int score_max, score;
190

    
191
    /* specific test for image sequences */
192
#if CONFIG_IMAGE2_MUXER
193
    if (!short_name && filename &&
194
        av_filename_number_test(filename) &&
195
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
196
        return guess_format("image2", NULL, NULL);
197
    }
198
#endif
199
    /* Find the proper file type. */
200
    fmt_found = NULL;
201
    score_max = 0;
202
    fmt = first_oformat;
203
    while (fmt != NULL) {
204
        score = 0;
205
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
206
            score += 100;
207
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
208
            score += 10;
209
        if (filename && fmt->extensions &&
210
            match_ext(filename, fmt->extensions)) {
211
            score += 5;
212
        }
213
        if (score > score_max) {
214
            score_max = score;
215
            fmt_found = fmt;
216
        }
217
        fmt = fmt->next;
218
    }
219
    return fmt_found;
220
}
221

    
222
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
223
                             const char *mime_type)
224
{
225
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
226

    
227
    if (fmt) {
228
        AVOutputFormat *stream_fmt;
229
        char stream_format_name[64];
230

    
231
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
232
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
233

    
234
        if (stream_fmt)
235
            fmt = stream_fmt;
236
    }
237

    
238
    return fmt;
239
}
240

    
241
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
242
                            const char *filename, const char *mime_type, enum CodecType type){
243
    if(type == CODEC_TYPE_VIDEO){
244
        enum CodecID codec_id= CODEC_ID_NONE;
245

    
246
#if CONFIG_IMAGE2_MUXER
247
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
248
            codec_id= av_guess_image2_codec(filename);
249
        }
250
#endif
251
        if(codec_id == CODEC_ID_NONE)
252
            codec_id= fmt->video_codec;
253
        return codec_id;
254
    }else if(type == CODEC_TYPE_AUDIO)
255
        return fmt->audio_codec;
256
    else
257
        return CODEC_ID_NONE;
258
}
259

    
260
AVInputFormat *av_find_input_format(const char *short_name)
261
{
262
    AVInputFormat *fmt;
263
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
264
        if (match_format(short_name, fmt->name))
265
            return fmt;
266
    }
267
    return NULL;
268
}
269

    
270
/* memory handling */
271

    
272

    
273
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
274
{
275
    int ret= av_new_packet(pkt, size);
276

    
277
    if(ret<0)
278
        return ret;
279

    
280
    pkt->pos= url_ftell(s);
281

    
282
    ret= get_buffer(s, pkt->data, size);
283
    if(ret<=0)
284
        av_free_packet(pkt);
285
    else
286
        av_shrink_packet(pkt, ret);
287

    
288
    return ret;
289
}
290

    
291

    
292
int av_filename_number_test(const char *filename)
293
{
294
    char buf[1024];
295
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
296
}
297

    
298
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
299
{
300
    AVInputFormat *fmt1, *fmt;
301
    int score;
302

    
303
    fmt = NULL;
304
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
305
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
306
            continue;
307
        score = 0;
308
        if (fmt1->read_probe) {
309
            score = fmt1->read_probe(pd);
310
        } else if (fmt1->extensions) {
311
            if (match_ext(pd->filename, fmt1->extensions)) {
312
                score = 50;
313
            }
314
        }
315
        if (score > *score_max) {
316
            *score_max = score;
317
            fmt = fmt1;
318
        }else if (score == *score_max)
319
            fmt = NULL;
320
    }
321
    return fmt;
322
}
323

    
324
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
325
    int score=0;
326
    return av_probe_input_format2(pd, is_opened, &score);
327
}
328

    
329
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
330
{
331
    AVInputFormat *fmt;
332
    fmt = av_probe_input_format2(pd, 1, &score);
333

    
334
    if (fmt) {
335
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
336
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
337
        if (!strcmp(fmt->name, "mp3")) {
338
            st->codec->codec_id = CODEC_ID_MP3;
339
            st->codec->codec_type = CODEC_TYPE_AUDIO;
340
        } else if (!strcmp(fmt->name, "ac3")) {
341
            st->codec->codec_id = CODEC_ID_AC3;
342
            st->codec->codec_type = CODEC_TYPE_AUDIO;
343
        } else if (!strcmp(fmt->name, "eac3")) {
344
            st->codec->codec_id = CODEC_ID_EAC3;
345
            st->codec->codec_type = CODEC_TYPE_AUDIO;
346
        } else if (!strcmp(fmt->name, "mpegvideo")) {
347
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
348
            st->codec->codec_type = CODEC_TYPE_VIDEO;
349
        } else if (!strcmp(fmt->name, "m4v")) {
350
            st->codec->codec_id = CODEC_ID_MPEG4;
351
            st->codec->codec_type = CODEC_TYPE_VIDEO;
352
        } else if (!strcmp(fmt->name, "h264")) {
353
            st->codec->codec_id = CODEC_ID_H264;
354
            st->codec->codec_type = CODEC_TYPE_VIDEO;
355
        } else if (!strcmp(fmt->name, "dts")) {
356
            st->codec->codec_id = CODEC_ID_DTS;
357
            st->codec->codec_type = CODEC_TYPE_AUDIO;
358
        }
359
    }
360
    return !!fmt;
361
}
362

    
363
/************************************************************/
364
/* input media file */
365

    
366
/**
367
 * Open a media file from an IO stream. 'fmt' must be specified.
368
 */
369
int av_open_input_stream(AVFormatContext **ic_ptr,
370
                         ByteIOContext *pb, const char *filename,
371
                         AVInputFormat *fmt, AVFormatParameters *ap)
372
{
373
    int err;
374
    AVFormatContext *ic;
375
    AVFormatParameters default_ap;
376

    
377
    if(!ap){
378
        ap=&default_ap;
379
        memset(ap, 0, sizeof(default_ap));
380
    }
381

    
382
    if(!ap->prealloced_context)
383
        ic = avformat_alloc_context();
384
    else
385
        ic = *ic_ptr;
386
    if (!ic) {
387
        err = AVERROR(ENOMEM);
388
        goto fail;
389
    }
390
    ic->iformat = fmt;
391
    ic->pb = pb;
392
    ic->duration = AV_NOPTS_VALUE;
393
    ic->start_time = AV_NOPTS_VALUE;
394
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
395

    
396
    /* allocate private data */
397
    if (fmt->priv_data_size > 0) {
398
        ic->priv_data = av_mallocz(fmt->priv_data_size);
399
        if (!ic->priv_data) {
400
            err = AVERROR(ENOMEM);
401
            goto fail;
402
        }
403
    } else {
404
        ic->priv_data = NULL;
405
    }
406

    
407
    if (ic->iformat->read_header) {
408
        err = ic->iformat->read_header(ic, ap);
409
        if (err < 0)
410
            goto fail;
411
    }
412

    
413
    if (pb && !ic->data_offset)
414
        ic->data_offset = url_ftell(ic->pb);
415

    
416
#if LIBAVFORMAT_VERSION_MAJOR < 53
417
    ff_metadata_demux_compat(ic);
418
#endif
419

    
420
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
421

    
422
    *ic_ptr = ic;
423
    return 0;
424
 fail:
425
    if (ic) {
426
        int i;
427
        av_freep(&ic->priv_data);
428
        for(i=0;i<ic->nb_streams;i++) {
429
            AVStream *st = ic->streams[i];
430
            if (st) {
431
                av_free(st->priv_data);
432
                av_free(st->codec->extradata);
433
            }
434
            av_free(st);
435
        }
436
    }
437
    av_free(ic);
438
    *ic_ptr = NULL;
439
    return err;
440
}
441

    
442
/** size of probe buffer, for guessing file type from file contents */
443
#define PROBE_BUF_MIN 2048
444
#define PROBE_BUF_MAX (1<<20)
445

    
446
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
447
                       AVInputFormat *fmt,
448
                       int buf_size,
449
                       AVFormatParameters *ap)
450
{
451
    int err, probe_size;
452
    AVProbeData probe_data, *pd = &probe_data;
453
    ByteIOContext *pb = NULL;
454
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
455

    
456
    pd->filename = "";
457
    if (filename)
458
        pd->filename = filename;
459
    pd->buf = NULL;
460
    pd->buf_size = 0;
461

    
462
    if (!fmt) {
463
        /* guess format if no file can be opened */
464
        fmt = av_probe_input_format(pd, 0);
465
    }
466

    
467
    /* Do not open file if the format does not need it. XXX: specific
468
       hack needed to handle RTSP/TCP */
469
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
470
        /* if no file needed do not try to open one */
471
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
472
            goto fail;
473
        }
474
        if (buf_size > 0) {
475
            url_setbufsize(pb, buf_size);
476
        }
477

    
478
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
479
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
480
            /* read probe data */
481
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
482
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
483

    
484
            if ((int)pd->buf_size < 0) {
485
                err = pd->buf_size;
486
                goto fail;
487
            }
488

    
489
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
490
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
491
                url_fclose(pb);
492
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
493
                    pb = NULL;
494
                    err = AVERROR(EIO);
495
                    goto fail;
496
                }
497
            }
498
            /* guess file format */
499
            fmt = av_probe_input_format2(pd, 1, &score);
500
            if(fmt){
501
                if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
502
                    av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
503
                }else
504
                    av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
505
            }
506
        }
507
        av_freep(&pd->buf);
508
    }
509

    
510
    /* if still no format found, error */
511
    if (!fmt) {
512
        err = AVERROR_NOFMT;
513
        goto fail;
514
    }
515

    
516
    /* check filename in case an image number is expected */
517
    if (fmt->flags & AVFMT_NEEDNUMBER) {
518
        if (!av_filename_number_test(filename)) {
519
            err = AVERROR_NUMEXPECTED;
520
            goto fail;
521
        }
522
    }
523
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
524
    if (err)
525
        goto fail;
526
    return 0;
527
 fail:
528
    av_freep(&pd->buf);
529
    if (pb)
530
        url_fclose(pb);
531
    if (ap && ap->prealloced_context)
532
        av_free(*ic_ptr);
533
    *ic_ptr = NULL;
534
    return err;
535

    
536
}
537

    
538
/*******************************************************/
539

    
540
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
541
                               AVPacketList **plast_pktl){
542
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
543
    if (!pktl)
544
        return NULL;
545

    
546
    if (*packet_buffer)
547
        (*plast_pktl)->next = pktl;
548
    else
549
        *packet_buffer = pktl;
550

    
551
    /* add the packet in the buffered packet list */
552
    *plast_pktl = pktl;
553
    pktl->pkt= *pkt;
554
    return &pktl->pkt;
555
}
556

    
557
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
558
{
559
    int ret, i;
560
    AVStream *st;
561

    
562
    for(;;){
563
        AVPacketList *pktl = s->raw_packet_buffer;
564

    
565
        if (pktl) {
566
            *pkt = pktl->pkt;
567
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
568
               !s->streams[pkt->stream_index]->probe_packets ||
569
               s->raw_packet_buffer_remaining_size < pkt->size){
570
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
571
                av_freep(&pd->buf);
572
                pd->buf_size = 0;
573
                s->raw_packet_buffer = pktl->next;
574
                s->raw_packet_buffer_remaining_size += pkt->size;
575
                av_free(pktl);
576
                return 0;
577
            }
578
        }
579

    
580
        av_init_packet(pkt);
581
        ret= s->iformat->read_packet(s, pkt);
582
        if (ret < 0) {
583
            if (!pktl || ret == AVERROR(EAGAIN))
584
                return ret;
585
            for (i = 0; i < s->nb_streams; i++)
586
                s->streams[i]->probe_packets = 0;
587
            continue;
588
        }
589
        st= s->streams[pkt->stream_index];
590

    
591
        switch(st->codec->codec_type){
592
        case CODEC_TYPE_VIDEO:
593
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
594
            break;
595
        case CODEC_TYPE_AUDIO:
596
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
597
            break;
598
        case CODEC_TYPE_SUBTITLE:
599
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
600
            break;
601
        }
602

    
603
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
604
                     !st->probe_packets))
605
            return ret;
606

    
607
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
608
        s->raw_packet_buffer_remaining_size -= pkt->size;
609

    
610
        if(st->codec->codec_id == CODEC_ID_PROBE){
611
            AVProbeData *pd = &st->probe_data;
612
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
613
            --st->probe_packets;
614

    
615
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
616
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
617
            pd->buf_size += pkt->size;
618
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
619

    
620
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
621
                set_codec_from_probe_data(s, st, pd, 1);
622
                if(st->codec->codec_id != CODEC_ID_PROBE){
623
                    pd->buf_size=0;
624
                    av_freep(&pd->buf);
625
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
626
                }
627
            }
628
        }
629
    }
630
}
631

    
632
/**********************************************************/
633

    
634
/**
635
 * Get the number of samples of an audio frame. Return -1 on error.
636
 */
637
static int get_audio_frame_size(AVCodecContext *enc, int size)
638
{
639
    int frame_size;
640

    
641
    if(enc->codec_id == CODEC_ID_VORBIS)
642
        return -1;
643

    
644
    if (enc->frame_size <= 1) {
645
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
646

    
647
        if (bits_per_sample) {
648
            if (enc->channels == 0)
649
                return -1;
650
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
651
        } else {
652
            /* used for example by ADPCM codecs */
653
            if (enc->bit_rate == 0)
654
                return -1;
655
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
656
        }
657
    } else {
658
        frame_size = enc->frame_size;
659
    }
660
    return frame_size;
661
}
662

    
663

    
664
/**
665
 * Return the frame duration in seconds. Return 0 if not available.
666
 */
667
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
668
                                   AVCodecParserContext *pc, AVPacket *pkt)
669
{
670
    int frame_size;
671

    
672
    *pnum = 0;
673
    *pden = 0;
674
    switch(st->codec->codec_type) {
675
    case CODEC_TYPE_VIDEO:
676
        if(st->time_base.num*1000LL > st->time_base.den){
677
            *pnum = st->time_base.num;
678
            *pden = st->time_base.den;
679
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
680
            *pnum = st->codec->time_base.num;
681
            *pden = st->codec->time_base.den;
682
            if (pc && pc->repeat_pict) {
683
                *pnum = (*pnum) * (1 + pc->repeat_pict);
684
            }
685
        }
686
        break;
687
    case CODEC_TYPE_AUDIO:
688
        frame_size = get_audio_frame_size(st->codec, pkt->size);
689
        if (frame_size < 0)
690
            break;
691
        *pnum = frame_size;
692
        *pden = st->codec->sample_rate;
693
        break;
694
    default:
695
        break;
696
    }
697
}
698

    
699
static int is_intra_only(AVCodecContext *enc){
700
    if(enc->codec_type == CODEC_TYPE_AUDIO){
701
        return 1;
702
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
703
        switch(enc->codec_id){
704
        case CODEC_ID_MJPEG:
705
        case CODEC_ID_MJPEGB:
706
        case CODEC_ID_LJPEG:
707
        case CODEC_ID_RAWVIDEO:
708
        case CODEC_ID_DVVIDEO:
709
        case CODEC_ID_HUFFYUV:
710
        case CODEC_ID_FFVHUFF:
711
        case CODEC_ID_ASV1:
712
        case CODEC_ID_ASV2:
713
        case CODEC_ID_VCR1:
714
        case CODEC_ID_DNXHD:
715
        case CODEC_ID_JPEG2000:
716
            return 1;
717
        default: break;
718
        }
719
    }
720
    return 0;
721
}
722

    
723
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
724
                                      int64_t dts, int64_t pts)
725
{
726
    AVStream *st= s->streams[stream_index];
727
    AVPacketList *pktl= s->packet_buffer;
728

    
729
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
730
        return;
731

    
732
    st->first_dts= dts - st->cur_dts;
733
    st->cur_dts= dts;
734

    
735
    for(; pktl; pktl= pktl->next){
736
        if(pktl->pkt.stream_index != stream_index)
737
            continue;
738
        //FIXME think more about this check
739
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
740
            pktl->pkt.pts += st->first_dts;
741

    
742
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
743
            pktl->pkt.dts += st->first_dts;
744

    
745
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
746
            st->start_time= pktl->pkt.pts;
747
    }
748
    if (st->start_time == AV_NOPTS_VALUE)
749
        st->start_time = pts;
750
}
751

    
752
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
753
{
754
    AVPacketList *pktl= s->packet_buffer;
755
    int64_t cur_dts= 0;
756

    
757
    if(st->first_dts != AV_NOPTS_VALUE){
758
        cur_dts= st->first_dts;
759
        for(; pktl; pktl= pktl->next){
760
            if(pktl->pkt.stream_index == pkt->stream_index){
761
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
762
                    break;
763
                cur_dts -= pkt->duration;
764
            }
765
        }
766
        pktl= s->packet_buffer;
767
        st->first_dts = cur_dts;
768
    }else if(st->cur_dts)
769
        return;
770

    
771
    for(; pktl; pktl= pktl->next){
772
        if(pktl->pkt.stream_index != pkt->stream_index)
773
            continue;
774
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
775
           && !pktl->pkt.duration){
776
            pktl->pkt.dts= cur_dts;
777
            if(!st->codec->has_b_frames)
778
                pktl->pkt.pts= cur_dts;
779
            cur_dts += pkt->duration;
780
            pktl->pkt.duration= pkt->duration;
781
        }else
782
            break;
783
    }
784
    if(st->first_dts == AV_NOPTS_VALUE)
785
        st->cur_dts= cur_dts;
786
}
787

    
788
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
789
                               AVCodecParserContext *pc, AVPacket *pkt)
790
{
791
    int num, den, presentation_delayed, delay, i;
792
    int64_t offset;
793

    
794
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
795
        //FIXME Set low_delay = 0 when has_b_frames = 1
796
        st->codec->has_b_frames = 1;
797

    
798
    /* do we have a video B-frame ? */
799
    delay= st->codec->has_b_frames;
800
    presentation_delayed = 0;
801
    /* XXX: need has_b_frame, but cannot get it if the codec is
802
        not initialized */
803
    if (delay &&
804
        pc && pc->pict_type != FF_B_TYPE)
805
        presentation_delayed = 1;
806

    
807
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
808
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
809
        pkt->dts -= 1LL<<st->pts_wrap_bits;
810
    }
811

    
812
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
813
    // we take the conservative approach and discard both
814
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
815
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
816
        av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
817
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
818
    }
819

    
820
    if (pkt->duration == 0) {
821
        compute_frame_duration(&num, &den, st, pc, pkt);
822
        if (den && num) {
823
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
824

    
825
            if(pkt->duration != 0 && s->packet_buffer)
826
                update_initial_durations(s, st, pkt);
827
        }
828
    }
829

    
830
    /* correct timestamps with byte offset if demuxers only have timestamps
831
       on packet boundaries */
832
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
833
        /* this will estimate bitrate based on this frame's duration and size */
834
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
835
        if(pkt->pts != AV_NOPTS_VALUE)
836
            pkt->pts += offset;
837
        if(pkt->dts != AV_NOPTS_VALUE)
838
            pkt->dts += offset;
839
    }
840

    
841
    if (pc && pc->dts_sync_point >= 0) {
842
        // we have synchronization info from the parser
843
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
844
        if (den > 0) {
845
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
846
            if (pkt->dts != AV_NOPTS_VALUE) {
847
                // got DTS from the stream, update reference timestamp
848
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
849
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
850
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
851
                // compute DTS based on reference timestamp
852
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
853
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
854
            }
855
            if (pc->dts_sync_point > 0)
856
                st->reference_dts = pkt->dts; // new reference
857
        }
858
    }
859

    
860
    /* This may be redundant, but it should not hurt. */
861
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
862
        presentation_delayed = 1;
863

    
864
//    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);
865
    /* interpolate PTS and DTS if they are not present */
866
    //We skip H264 currently because delay and has_b_frames are not reliably set
867
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
868
        if (presentation_delayed) {
869
            /* DTS = decompression timestamp */
870
            /* PTS = presentation timestamp */
871
            if (pkt->dts == AV_NOPTS_VALUE)
872
                pkt->dts = st->last_IP_pts;
873
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
874
            if (pkt->dts == AV_NOPTS_VALUE)
875
                pkt->dts = st->cur_dts;
876

    
877
            /* this is tricky: the dts must be incremented by the duration
878
            of the frame we are displaying, i.e. the last I- or P-frame */
879
            if (st->last_IP_duration == 0)
880
                st->last_IP_duration = pkt->duration;
881
            if(pkt->dts != AV_NOPTS_VALUE)
882
                st->cur_dts = pkt->dts + st->last_IP_duration;
883
            st->last_IP_duration  = pkt->duration;
884
            st->last_IP_pts= pkt->pts;
885
            /* cannot compute PTS if not present (we can compute it only
886
            by knowing the future */
887
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
888
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
889
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
890
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
891
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
892
                    pkt->pts += pkt->duration;
893
    //                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);
894
                }
895
            }
896

    
897
            /* presentation is not delayed : PTS and DTS are the same */
898
            if(pkt->pts == AV_NOPTS_VALUE)
899
                pkt->pts = pkt->dts;
900
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
901
            if(pkt->pts == AV_NOPTS_VALUE)
902
                pkt->pts = st->cur_dts;
903
            pkt->dts = pkt->pts;
904
            if(pkt->pts != AV_NOPTS_VALUE)
905
                st->cur_dts = pkt->pts + pkt->duration;
906
        }
907
    }
908

    
909
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
910
        st->pts_buffer[0]= pkt->pts;
911
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
912
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
913
        if(pkt->dts == AV_NOPTS_VALUE)
914
            pkt->dts= st->pts_buffer[0];
915
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
916
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
917
        }
918
        if(pkt->dts > st->cur_dts)
919
            st->cur_dts = pkt->dts;
920
    }
921

    
922
//    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);
923

    
924
    /* update flags */
925
    if(is_intra_only(st->codec))
926
        pkt->flags |= PKT_FLAG_KEY;
927
    else if (pc) {
928
        pkt->flags = 0;
929
        /* keyframe computation */
930
        if (pc->key_frame == 1)
931
            pkt->flags |= PKT_FLAG_KEY;
932
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
933
            pkt->flags |= PKT_FLAG_KEY;
934
    }
935
    if (pc)
936
        pkt->convergence_duration = pc->convergence_duration;
937
}
938

    
939

    
940
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
941
{
942
    AVStream *st;
943
    int len, ret, i;
944

    
945
    av_init_packet(pkt);
946

    
947
    for(;;) {
948
        /* select current input stream component */
949
        st = s->cur_st;
950
        if (st) {
951
            if (!st->need_parsing || !st->parser) {
952
                /* no parsing needed: we just output the packet as is */
953
                /* raw data support */
954
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
955
                compute_pkt_fields(s, st, NULL, pkt);
956
                s->cur_st = NULL;
957
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
958
                    (pkt->flags & PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
959
                    ff_reduce_index(s, st->index);
960
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
961
                }
962
                break;
963
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
964
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
965
                                       st->cur_ptr, st->cur_len,
966
                                       st->cur_pkt.pts, st->cur_pkt.dts,
967
                                       st->cur_pkt.pos);
968
                st->cur_pkt.pts = AV_NOPTS_VALUE;
969
                st->cur_pkt.dts = AV_NOPTS_VALUE;
970
                /* increment read pointer */
971
                st->cur_ptr += len;
972
                st->cur_len -= len;
973

    
974
                /* return packet if any */
975
                if (pkt->size) {
976
                got_packet:
977
                    pkt->duration = 0;
978
                    pkt->stream_index = st->index;
979
                    pkt->pts = st->parser->pts;
980
                    pkt->dts = st->parser->dts;
981
                    pkt->pos = st->parser->pos;
982
                    pkt->destruct = NULL;
983
                    compute_pkt_fields(s, st, st->parser, pkt);
984

    
985
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
986
                        ff_reduce_index(s, st->index);
987
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
988
                                           0, 0, AVINDEX_KEYFRAME);
989
                    }
990

    
991
                    break;
992
                }
993
            } else {
994
                /* free packet */
995
                av_free_packet(&st->cur_pkt);
996
                s->cur_st = NULL;
997
            }
998
        } else {
999
            AVPacket cur_pkt;
1000
            /* read next packet */
1001
            ret = av_read_packet(s, &cur_pkt);
1002
            if (ret < 0) {
1003
                if (ret == AVERROR(EAGAIN))
1004
                    return ret;
1005
                /* return the last frames, if any */
1006
                for(i = 0; i < s->nb_streams; i++) {
1007
                    st = s->streams[i];
1008
                    if (st->parser && st->need_parsing) {
1009
                        av_parser_parse2(st->parser, st->codec,
1010
                                        &pkt->data, &pkt->size,
1011
                                        NULL, 0,
1012
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1013
                                        AV_NOPTS_VALUE);
1014
                        if (pkt->size)
1015
                            goto got_packet;
1016
                    }
1017
                }
1018
                /* no more packets: really terminate parsing */
1019
                return ret;
1020
            }
1021
            st = s->streams[cur_pkt.stream_index];
1022
            st->cur_pkt= cur_pkt;
1023

    
1024
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1025
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1026
               st->cur_pkt.pts < st->cur_pkt.dts){
1027
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1028
                    st->cur_pkt.stream_index,
1029
                    st->cur_pkt.pts,
1030
                    st->cur_pkt.dts,
1031
                    st->cur_pkt.size);
1032
//                av_free_packet(&st->cur_pkt);
1033
//                return -1;
1034
            }
1035

    
1036
            if(s->debug & FF_FDEBUG_TS)
1037
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1038
                    st->cur_pkt.stream_index,
1039
                    st->cur_pkt.pts,
1040
                    st->cur_pkt.dts,
1041
                    st->cur_pkt.size,
1042
                    st->cur_pkt.duration,
1043
                    st->cur_pkt.flags);
1044

    
1045
            s->cur_st = st;
1046
            st->cur_ptr = st->cur_pkt.data;
1047
            st->cur_len = st->cur_pkt.size;
1048
            if (st->need_parsing && !st->parser) {
1049
                st->parser = av_parser_init(st->codec->codec_id);
1050
                if (!st->parser) {
1051
                    /* no parser available: just output the raw packets */
1052
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1053
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1054
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1055
                }
1056
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1057
                    st->parser->next_frame_offset=
1058
                    st->parser->cur_offset= st->cur_pkt.pos;
1059
                }
1060
            }
1061
        }
1062
    }
1063
    if(s->debug & FF_FDEBUG_TS)
1064
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1065
            pkt->stream_index,
1066
            pkt->pts,
1067
            pkt->dts,
1068
            pkt->size,
1069
            pkt->duration,
1070
            pkt->flags);
1071

    
1072
    return 0;
1073
}
1074

    
1075
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1076
{
1077
    AVPacketList *pktl;
1078
    int eof=0;
1079
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1080

    
1081
    for(;;){
1082
        pktl = s->packet_buffer;
1083
        if (pktl) {
1084
            AVPacket *next_pkt= &pktl->pkt;
1085

    
1086
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1087
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1088
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1089
                       && next_pkt->dts < pktl->pkt.dts
1090
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1091
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1092
                        next_pkt->pts= pktl->pkt.dts;
1093
                    }
1094
                    pktl= pktl->next;
1095
                }
1096
                pktl = s->packet_buffer;
1097
            }
1098

    
1099
            if(   next_pkt->pts != AV_NOPTS_VALUE
1100
               || next_pkt->dts == AV_NOPTS_VALUE
1101
               || !genpts || eof){
1102
                /* read packet from packet buffer, if there is data */
1103
                *pkt = *next_pkt;
1104
                s->packet_buffer = pktl->next;
1105
                av_free(pktl);
1106
                return 0;
1107
            }
1108
        }
1109
        if(genpts){
1110
            int ret= av_read_frame_internal(s, pkt);
1111
            if(ret<0){
1112
                if(pktl && ret != AVERROR(EAGAIN)){
1113
                    eof=1;
1114
                    continue;
1115
                }else
1116
                    return ret;
1117
            }
1118

    
1119
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1120
                                           &s->packet_buffer_end)) < 0)
1121
                return AVERROR(ENOMEM);
1122
        }else{
1123
            assert(!s->packet_buffer);
1124
            return av_read_frame_internal(s, pkt);
1125
        }
1126
    }
1127
}
1128

    
1129
/* XXX: suppress the packet queue */
1130
static void flush_packet_queue(AVFormatContext *s)
1131
{
1132
    AVPacketList *pktl;
1133

    
1134
    for(;;) {
1135
        pktl = s->packet_buffer;
1136
        if (!pktl)
1137
            break;
1138
        s->packet_buffer = pktl->next;
1139
        av_free_packet(&pktl->pkt);
1140
        av_free(pktl);
1141
    }
1142
    while(s->raw_packet_buffer){
1143
        pktl = s->raw_packet_buffer;
1144
        s->raw_packet_buffer = pktl->next;
1145
        av_free_packet(&pktl->pkt);
1146
        av_free(pktl);
1147
    }
1148
    s->packet_buffer_end=
1149
    s->raw_packet_buffer_end= NULL;
1150
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1151
}
1152

    
1153
/*******************************************************/
1154
/* seek support */
1155

    
1156
int av_find_default_stream_index(AVFormatContext *s)
1157
{
1158
    int first_audio_index = -1;
1159
    int i;
1160
    AVStream *st;
1161

    
1162
    if (s->nb_streams <= 0)
1163
        return -1;
1164
    for(i = 0; i < s->nb_streams; i++) {
1165
        st = s->streams[i];
1166
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1167
            return i;
1168
        }
1169
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1170
            first_audio_index = i;
1171
    }
1172
    return first_audio_index >= 0 ? first_audio_index : 0;
1173
}
1174

    
1175
/**
1176
 * Flush the frame reader.
1177
 */
1178
void av_read_frame_flush(AVFormatContext *s)
1179
{
1180
    AVStream *st;
1181
    int i, j;
1182

    
1183
    flush_packet_queue(s);
1184

    
1185
    s->cur_st = NULL;
1186

    
1187
    /* for each stream, reset read state */
1188
    for(i = 0; i < s->nb_streams; i++) {
1189
        st = s->streams[i];
1190

    
1191
        if (st->parser) {
1192
            av_parser_close(st->parser);
1193
            st->parser = NULL;
1194
            av_free_packet(&st->cur_pkt);
1195
        }
1196
        st->last_IP_pts = AV_NOPTS_VALUE;
1197
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1198
        st->reference_dts = AV_NOPTS_VALUE;
1199
        /* fail safe */
1200
        st->cur_ptr = NULL;
1201
        st->cur_len = 0;
1202

    
1203
        st->probe_packets = MAX_PROBE_PACKETS;
1204

    
1205
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1206
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1207
    }
1208
}
1209

    
1210
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1211
    int i;
1212

    
1213
    for(i = 0; i < s->nb_streams; i++) {
1214
        AVStream *st = s->streams[i];
1215

    
1216
        st->cur_dts = av_rescale(timestamp,
1217
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1218
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1219
    }
1220
}
1221

    
1222
void ff_reduce_index(AVFormatContext *s, int stream_index)
1223
{
1224
    AVStream *st= s->streams[stream_index];
1225
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1226

    
1227
    if((unsigned)st->nb_index_entries >= max_entries){
1228
        int i;
1229
        for(i=0; 2*i<st->nb_index_entries; i++)
1230
            st->index_entries[i]= st->index_entries[2*i];
1231
        st->nb_index_entries= i;
1232
    }
1233
}
1234

    
1235
int av_add_index_entry(AVStream *st,
1236
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1237
{
1238
    AVIndexEntry *entries, *ie;
1239
    int index;
1240

    
1241
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1242
        return -1;
1243

    
1244
    entries = av_fast_realloc(st->index_entries,
1245
                              &st->index_entries_allocated_size,
1246
                              (st->nb_index_entries + 1) *
1247
                              sizeof(AVIndexEntry));
1248
    if(!entries)
1249
        return -1;
1250

    
1251
    st->index_entries= entries;
1252

    
1253
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1254

    
1255
    if(index<0){
1256
        index= st->nb_index_entries++;
1257
        ie= &entries[index];
1258
        assert(index==0 || ie[-1].timestamp < timestamp);
1259
    }else{
1260
        ie= &entries[index];
1261
        if(ie->timestamp != timestamp){
1262
            if(ie->timestamp <= timestamp)
1263
                return -1;
1264
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1265
            st->nb_index_entries++;
1266
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1267
            distance= ie->min_distance;
1268
    }
1269

    
1270
    ie->pos = pos;
1271
    ie->timestamp = timestamp;
1272
    ie->min_distance= distance;
1273
    ie->size= size;
1274
    ie->flags = flags;
1275

    
1276
    return index;
1277
}
1278

    
1279
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1280
                              int flags)
1281
{
1282
    AVIndexEntry *entries= st->index_entries;
1283
    int nb_entries= st->nb_index_entries;
1284
    int a, b, m;
1285
    int64_t timestamp;
1286

    
1287
    a = - 1;
1288
    b = nb_entries;
1289

    
1290
    while (b - a > 1) {
1291
        m = (a + b) >> 1;
1292
        timestamp = entries[m].timestamp;
1293
        if(timestamp >= wanted_timestamp)
1294
            b = m;
1295
        if(timestamp <= wanted_timestamp)
1296
            a = m;
1297
    }
1298
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1299

    
1300
    if(!(flags & AVSEEK_FLAG_ANY)){
1301
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1302
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1303
        }
1304
    }
1305

    
1306
    if(m == nb_entries)
1307
        return -1;
1308
    return  m;
1309
}
1310

    
1311
#define DEBUG_SEEK
1312

    
1313
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1314
    AVInputFormat *avif= s->iformat;
1315
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1316
    int64_t ts_min, ts_max, ts;
1317
    int index;
1318
    int64_t ret;
1319
    AVStream *st;
1320

    
1321
    if (stream_index < 0)
1322
        return -1;
1323

    
1324
#ifdef DEBUG_SEEK
1325
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1326
#endif
1327

    
1328
    ts_max=
1329
    ts_min= AV_NOPTS_VALUE;
1330
    pos_limit= -1; //gcc falsely says it may be uninitialized
1331

    
1332
    st= s->streams[stream_index];
1333
    if(st->index_entries){
1334
        AVIndexEntry *e;
1335

    
1336
        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()
1337
        index= FFMAX(index, 0);
1338
        e= &st->index_entries[index];
1339

    
1340
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1341
            pos_min= e->pos;
1342
            ts_min= e->timestamp;
1343
#ifdef DEBUG_SEEK
1344
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1345
                   pos_min,ts_min);
1346
#endif
1347
        }else{
1348
            assert(index==0);
1349
        }
1350

    
1351
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1352
        assert(index < st->nb_index_entries);
1353
        if(index >= 0){
1354
            e= &st->index_entries[index];
1355
            assert(e->timestamp >= target_ts);
1356
            pos_max= e->pos;
1357
            ts_max= e->timestamp;
1358
            pos_limit= pos_max - e->min_distance;
1359
#ifdef DEBUG_SEEK
1360
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1361
                   pos_max,pos_limit, ts_max);
1362
#endif
1363
        }
1364
    }
1365

    
1366
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1367
    if(pos<0)
1368
        return -1;
1369

    
1370
    /* do the seek */
1371
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1372
        return ret;
1373

    
1374
    av_update_cur_dts(s, st, ts);
1375

    
1376
    return 0;
1377
}
1378

    
1379
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 )){
1380
    int64_t pos, ts;
1381
    int64_t start_pos, filesize;
1382
    int no_change;
1383

    
1384
#ifdef DEBUG_SEEK
1385
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1386
#endif
1387

    
1388
    if(ts_min == AV_NOPTS_VALUE){
1389
        pos_min = s->data_offset;
1390
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1391
        if (ts_min == AV_NOPTS_VALUE)
1392
            return -1;
1393
    }
1394

    
1395
    if(ts_max == AV_NOPTS_VALUE){
1396
        int step= 1024;
1397
        filesize = url_fsize(s->pb);
1398
        pos_max = filesize - 1;
1399
        do{
1400
            pos_max -= step;
1401
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1402
            step += step;
1403
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1404
        if (ts_max == AV_NOPTS_VALUE)
1405
            return -1;
1406

    
1407
        for(;;){
1408
            int64_t tmp_pos= pos_max + 1;
1409
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1410
            if(tmp_ts == AV_NOPTS_VALUE)
1411
                break;
1412
            ts_max= tmp_ts;
1413
            pos_max= tmp_pos;
1414
            if(tmp_pos >= filesize)
1415
                break;
1416
        }
1417
        pos_limit= pos_max;
1418
    }
1419

    
1420
    if(ts_min > ts_max){
1421
        return -1;
1422
    }else if(ts_min == ts_max){
1423
        pos_limit= pos_min;
1424
    }
1425

    
1426
    no_change=0;
1427
    while (pos_min < pos_limit) {
1428
#ifdef DEBUG_SEEK
1429
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1430
               pos_min, pos_max,
1431
               ts_min, ts_max);
1432
#endif
1433
        assert(pos_limit <= pos_max);
1434

    
1435
        if(no_change==0){
1436
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1437
            // interpolate position (better than dichotomy)
1438
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1439
                + pos_min - approximate_keyframe_distance;
1440
        }else if(no_change==1){
1441
            // bisection, if interpolation failed to change min or max pos last time
1442
            pos = (pos_min + pos_limit)>>1;
1443
        }else{
1444
            /* linear search if bisection failed, can only happen if there
1445
               are very few or no keyframes between min/max */
1446
            pos=pos_min;
1447
        }
1448
        if(pos <= pos_min)
1449
            pos= pos_min + 1;
1450
        else if(pos > pos_limit)
1451
            pos= pos_limit;
1452
        start_pos= pos;
1453

    
1454
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1455
        if(pos == pos_max)
1456
            no_change++;
1457
        else
1458
            no_change=0;
1459
#ifdef DEBUG_SEEK
1460
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1461
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1462
               start_pos, no_change);
1463
#endif
1464
        if(ts == AV_NOPTS_VALUE){
1465
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1466
            return -1;
1467
        }
1468
        assert(ts != AV_NOPTS_VALUE);
1469
        if (target_ts <= ts) {
1470
            pos_limit = start_pos - 1;
1471
            pos_max = pos;
1472
            ts_max = ts;
1473
        }
1474
        if (target_ts >= ts) {
1475
            pos_min = pos;
1476
            ts_min = ts;
1477
        }
1478
    }
1479

    
1480
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1481
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1482
#ifdef DEBUG_SEEK
1483
    pos_min = pos;
1484
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1485
    pos_min++;
1486
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1487
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1488
           pos, ts_min, target_ts, ts_max);
1489
#endif
1490
    *ts_ret= ts;
1491
    return pos;
1492
}
1493

    
1494
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1495
    int64_t pos_min, pos_max;
1496
#if 0
1497
    AVStream *st;
1498

1499
    if (stream_index < 0)
1500
        return -1;
1501

1502
    st= s->streams[stream_index];
1503
#endif
1504

    
1505
    pos_min = s->data_offset;
1506
    pos_max = url_fsize(s->pb) - 1;
1507

    
1508
    if     (pos < pos_min) pos= pos_min;
1509
    else if(pos > pos_max) pos= pos_max;
1510

    
1511
    url_fseek(s->pb, pos, SEEK_SET);
1512

    
1513
#if 0
1514
    av_update_cur_dts(s, st, ts);
1515
#endif
1516
    return 0;
1517
}
1518

    
1519
static int av_seek_frame_generic(AVFormatContext *s,
1520
                                 int stream_index, int64_t timestamp, int flags)
1521
{
1522
    int index;
1523
    int64_t ret;
1524
    AVStream *st;
1525
    AVIndexEntry *ie;
1526

    
1527
    st = s->streams[stream_index];
1528

    
1529
    index = av_index_search_timestamp(st, timestamp, flags);
1530

    
1531
    if(index < 0 || index==st->nb_index_entries-1){
1532
        int i;
1533
        AVPacket pkt;
1534

    
1535
        if(st->nb_index_entries){
1536
            assert(st->index_entries);
1537
            ie= &st->index_entries[st->nb_index_entries-1];
1538
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1539
                return ret;
1540
            av_update_cur_dts(s, st, ie->timestamp);
1541
        }else{
1542
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1543
                return ret;
1544
        }
1545
        for(i=0;; i++) {
1546
            int ret;
1547
            do{
1548
                ret = av_read_frame(s, &pkt);
1549
            }while(ret == AVERROR(EAGAIN));
1550
            if(ret<0)
1551
                break;
1552
            av_free_packet(&pkt);
1553
            if(stream_index == pkt.stream_index){
1554
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1555
                    break;
1556
            }
1557
        }
1558
        index = av_index_search_timestamp(st, timestamp, flags);
1559
    }
1560
    if (index < 0)
1561
        return -1;
1562

    
1563
    av_read_frame_flush(s);
1564
    if (s->iformat->read_seek){
1565
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1566
            return 0;
1567
    }
1568
    ie = &st->index_entries[index];
1569
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1570
        return ret;
1571
    av_update_cur_dts(s, st, ie->timestamp);
1572

    
1573
    return 0;
1574
}
1575

    
1576
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1577
{
1578
    int ret;
1579
    AVStream *st;
1580

    
1581
    av_read_frame_flush(s);
1582

    
1583
    if(flags & AVSEEK_FLAG_BYTE)
1584
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1585

    
1586
    if(stream_index < 0){
1587
        stream_index= av_find_default_stream_index(s);
1588
        if(stream_index < 0)
1589
            return -1;
1590

    
1591
        st= s->streams[stream_index];
1592
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1593
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1594
    }
1595

    
1596
    /* first, we try the format specific seek */
1597
    if (s->iformat->read_seek)
1598
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1599
    else
1600
        ret = -1;
1601
    if (ret >= 0) {
1602
        return 0;
1603
    }
1604

    
1605
    if(s->iformat->read_timestamp)
1606
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1607
    else
1608
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1609
}
1610

    
1611
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1612
{
1613
    if(min_ts > ts || max_ts < ts)
1614
        return -1;
1615

    
1616
    av_read_frame_flush(s);
1617

    
1618
    if (s->iformat->read_seek2)
1619
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1620

    
1621
    if(s->iformat->read_timestamp){
1622
        //try to seek via read_timestamp()
1623
    }
1624

    
1625
    //Fallback to old API if new is not implemented but old is
1626
    //Note the old has somewat different sematics
1627
    if(s->iformat->read_seek || 1)
1628
        return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1629

    
1630
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1631
}
1632

    
1633
/*******************************************************/
1634

    
1635
/**
1636
 * Returns TRUE if the stream has accurate duration in any stream.
1637
 *
1638
 * @return TRUE if the stream has accurate duration for at least one component.
1639
 */
1640
static int av_has_duration(AVFormatContext *ic)
1641
{
1642
    int i;
1643
    AVStream *st;
1644

    
1645
    for(i = 0;i < ic->nb_streams; i++) {
1646
        st = ic->streams[i];
1647
        if (st->duration != AV_NOPTS_VALUE)
1648
            return 1;
1649
    }
1650
    return 0;
1651
}
1652

    
1653
/**
1654
 * Estimate the stream timings from the one of each components.
1655
 *
1656
 * Also computes the global bitrate if possible.
1657
 */
1658
static void av_update_stream_timings(AVFormatContext *ic)
1659
{
1660
    int64_t start_time, start_time1, end_time, end_time1;
1661
    int64_t duration, duration1;
1662
    int i;
1663
    AVStream *st;
1664

    
1665
    start_time = INT64_MAX;
1666
    end_time = INT64_MIN;
1667
    duration = INT64_MIN;
1668
    for(i = 0;i < ic->nb_streams; i++) {
1669
        st = ic->streams[i];
1670
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1671
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1672
            if (start_time1 < start_time)
1673
                start_time = start_time1;
1674
            if (st->duration != AV_NOPTS_VALUE) {
1675
                end_time1 = start_time1
1676
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1677
                if (end_time1 > end_time)
1678
                    end_time = end_time1;
1679
            }
1680
        }
1681
        if (st->duration != AV_NOPTS_VALUE) {
1682
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1683
            if (duration1 > duration)
1684
                duration = duration1;
1685
        }
1686
    }
1687
    if (start_time != INT64_MAX) {
1688
        ic->start_time = start_time;
1689
        if (end_time != INT64_MIN) {
1690
            if (end_time - start_time > duration)
1691
                duration = end_time - start_time;
1692
        }
1693
    }
1694
    if (duration != INT64_MIN) {
1695
        ic->duration = duration;
1696
        if (ic->file_size > 0) {
1697
            /* compute the bitrate */
1698
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1699
                (double)ic->duration;
1700
        }
1701
    }
1702
}
1703

    
1704
static void fill_all_stream_timings(AVFormatContext *ic)
1705
{
1706
    int i;
1707
    AVStream *st;
1708

    
1709
    av_update_stream_timings(ic);
1710
    for(i = 0;i < ic->nb_streams; i++) {
1711
        st = ic->streams[i];
1712
        if (st->start_time == AV_NOPTS_VALUE) {
1713
            if(ic->start_time != AV_NOPTS_VALUE)
1714
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1715
            if(ic->duration != AV_NOPTS_VALUE)
1716
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1717
        }
1718
    }
1719
}
1720

    
1721
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1722
{
1723
    int64_t filesize, duration;
1724
    int bit_rate, i;
1725
    AVStream *st;
1726

    
1727
    /* if bit_rate is already set, we believe it */
1728
    if (ic->bit_rate == 0) {
1729
        bit_rate = 0;
1730
        for(i=0;i<ic->nb_streams;i++) {
1731
            st = ic->streams[i];
1732
            bit_rate += st->codec->bit_rate;
1733
        }
1734
        ic->bit_rate = bit_rate;
1735
    }
1736

    
1737
    /* if duration is already set, we believe it */
1738
    if (ic->duration == AV_NOPTS_VALUE &&
1739
        ic->bit_rate != 0 &&
1740
        ic->file_size != 0)  {
1741
        filesize = ic->file_size;
1742
        if (filesize > 0) {
1743
            for(i = 0; i < ic->nb_streams; i++) {
1744
                st = ic->streams[i];
1745
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1746
                if (st->duration == AV_NOPTS_VALUE)
1747
                    st->duration = duration;
1748
            }
1749
        }
1750
    }
1751
}
1752

    
1753
#define DURATION_MAX_READ_SIZE 250000
1754

    
1755
/* only usable for MPEG-PS streams */
1756
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1757
{
1758
    AVPacket pkt1, *pkt = &pkt1;
1759
    AVStream *st;
1760
    int read_size, i, ret;
1761
    int64_t end_time, start_time[MAX_STREAMS];
1762
    int64_t filesize, offset, duration;
1763

    
1764
    ic->cur_st = NULL;
1765

    
1766
    /* flush packet queue */
1767
    flush_packet_queue(ic);
1768

    
1769
    for(i=0;i<ic->nb_streams;i++) {
1770
        st = ic->streams[i];
1771
        if(st->start_time != AV_NOPTS_VALUE){
1772
            start_time[i]= st->start_time;
1773
        }else if(st->first_dts != AV_NOPTS_VALUE){
1774
            start_time[i]= st->first_dts;
1775
        }else
1776
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1777

    
1778
        if (st->parser) {
1779
            av_parser_close(st->parser);
1780
            st->parser= NULL;
1781
            av_free_packet(&st->cur_pkt);
1782
        }
1783
    }
1784

    
1785
    /* estimate the end time (duration) */
1786
    /* XXX: may need to support wrapping */
1787
    filesize = ic->file_size;
1788
    offset = filesize - DURATION_MAX_READ_SIZE;
1789
    if (offset < 0)
1790
        offset = 0;
1791

    
1792
    url_fseek(ic->pb, offset, SEEK_SET);
1793
    read_size = 0;
1794
    for(;;) {
1795
        if (read_size >= DURATION_MAX_READ_SIZE)
1796
            break;
1797

    
1798
        do{
1799
            ret = av_read_packet(ic, pkt);
1800
        }while(ret == AVERROR(EAGAIN));
1801
        if (ret != 0)
1802
            break;
1803
        read_size += pkt->size;
1804
        st = ic->streams[pkt->stream_index];
1805
        if (pkt->pts != AV_NOPTS_VALUE &&
1806
            start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1807
            end_time = pkt->pts;
1808
            duration = end_time - start_time[pkt->stream_index];
1809
            if (duration > 0) {
1810
                if (st->duration == AV_NOPTS_VALUE ||
1811
                    st->duration < duration)
1812
                    st->duration = duration;
1813
            }
1814
        }
1815
        av_free_packet(pkt);
1816
    }
1817

    
1818
    fill_all_stream_timings(ic);
1819

    
1820
    url_fseek(ic->pb, old_offset, SEEK_SET);
1821
    for(i=0; i<ic->nb_streams; i++){
1822
        st= ic->streams[i];
1823
        st->cur_dts= st->first_dts;
1824
        st->last_IP_pts = AV_NOPTS_VALUE;
1825
    }
1826
}
1827

    
1828
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1829
{
1830
    int64_t file_size;
1831

    
1832
    /* get the file size, if possible */
1833
    if (ic->iformat->flags & AVFMT_NOFILE) {
1834
        file_size = 0;
1835
    } else {
1836
        file_size = url_fsize(ic->pb);
1837
        if (file_size < 0)
1838
            file_size = 0;
1839
    }
1840
    ic->file_size = file_size;
1841

    
1842
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1843
         !strcmp(ic->iformat->name, "mpegts")) &&
1844
        file_size && !url_is_streamed(ic->pb)) {
1845
        /* get accurate estimate from the PTSes */
1846
        av_estimate_timings_from_pts(ic, old_offset);
1847
    } else if (av_has_duration(ic)) {
1848
        /* at least one component has timings - we use them for all
1849
           the components */
1850
        fill_all_stream_timings(ic);
1851
    } else {
1852
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1853
        /* less precise: use bitrate info */
1854
        av_estimate_timings_from_bit_rate(ic);
1855
    }
1856
    av_update_stream_timings(ic);
1857

    
1858
#if 0
1859
    {
1860
        int i;
1861
        AVStream *st;
1862
        for(i = 0;i < ic->nb_streams; i++) {
1863
            st = ic->streams[i];
1864
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1865
               i, (double)st->start_time / AV_TIME_BASE,
1866
               (double)st->duration / AV_TIME_BASE);
1867
        }
1868
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1869
               (double)ic->start_time / AV_TIME_BASE,
1870
               (double)ic->duration / AV_TIME_BASE,
1871
               ic->bit_rate / 1000);
1872
    }
1873
#endif
1874
}
1875

    
1876
static int has_codec_parameters(AVCodecContext *enc)
1877
{
1878
    int val;
1879
    switch(enc->codec_type) {
1880
    case CODEC_TYPE_AUDIO:
1881
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1882
        if(!enc->frame_size &&
1883
           (enc->codec_id == CODEC_ID_VORBIS ||
1884
            enc->codec_id == CODEC_ID_AAC ||
1885
            enc->codec_id == CODEC_ID_MP3 ||
1886
            enc->codec_id == CODEC_ID_SPEEX))
1887
            return 0;
1888
        break;
1889
    case CODEC_TYPE_VIDEO:
1890
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1891
        break;
1892
    default:
1893
        val = 1;
1894
        break;
1895
    }
1896
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1897
}
1898

    
1899
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1900
{
1901
    int16_t *samples;
1902
    AVCodec *codec;
1903
    int got_picture, data_size, ret=0;
1904
    AVFrame picture;
1905

    
1906
    if(!st->codec->codec){
1907
        codec = avcodec_find_decoder(st->codec->codec_id);
1908
        if (!codec)
1909
            return -1;
1910
        ret = avcodec_open(st->codec, codec);
1911
        if (ret < 0)
1912
            return ret;
1913
    }
1914

    
1915
    if(!has_codec_parameters(st->codec)){
1916
        switch(st->codec->codec_type) {
1917
        case CODEC_TYPE_VIDEO:
1918
            avcodec_get_frame_defaults(&picture);
1919
            ret = avcodec_decode_video2(st->codec, &picture,
1920
                                        &got_picture, avpkt);
1921
            break;
1922
        case CODEC_TYPE_AUDIO:
1923
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1924
            samples = av_malloc(data_size);
1925
            if (!samples)
1926
                goto fail;
1927
            ret = avcodec_decode_audio3(st->codec, samples,
1928
                                        &data_size, avpkt);
1929
            av_free(samples);
1930
            break;
1931
        default:
1932
            break;
1933
        }
1934
    }
1935
 fail:
1936
    return ret;
1937
}
1938

    
1939
unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
1940
{
1941
    while (tags->id != CODEC_ID_NONE) {
1942
        if (tags->id == id)
1943
            return tags->tag;
1944
        tags++;
1945
    }
1946
    return 0;
1947
}
1948

    
1949
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
1950
{
1951
    int i;
1952
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1953
        if(tag == tags[i].tag)
1954
            return tags[i].id;
1955
    }
1956
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1957
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1958
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1959
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1960
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1961
            return tags[i].id;
1962
    }
1963
    return CODEC_ID_NONE;
1964
}
1965

    
1966
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1967
{
1968
    int i;
1969
    for(i=0; tags && tags[i]; i++){
1970
        int tag= ff_codec_get_tag(tags[i], id);
1971
        if(tag) return tag;
1972
    }
1973
    return 0;
1974
}
1975

    
1976
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1977
{
1978
    int i;
1979
    for(i=0; tags && tags[i]; i++){
1980
        enum CodecID id= ff_codec_get_id(tags[i], tag);
1981
        if(id!=CODEC_ID_NONE) return id;
1982
    }
1983
    return CODEC_ID_NONE;
1984
}
1985

    
1986
static void compute_chapters_end(AVFormatContext *s)
1987
{
1988
    unsigned int i;
1989

    
1990
    for (i=0; i+1<s->nb_chapters; i++)
1991
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1992
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1993
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1994
            s->chapters[i]->end = s->chapters[i+1]->start;
1995
        }
1996

    
1997
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1998
        assert(s->start_time != AV_NOPTS_VALUE);
1999
        assert(s->duration > 0);
2000
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2001
                                           AV_TIME_BASE_Q,
2002
                                           s->chapters[i]->time_base);
2003
    }
2004
}
2005

    
2006
#define MAX_STD_TIMEBASES (60*12+5)
2007
static int get_std_framerate(int i){
2008
    if(i<60*12) return i*1001;
2009
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2010
}
2011

    
2012
/*
2013
 * Is the time base unreliable.
2014
 * This is a heuristic to balance between quick acceptance of the values in
2015
 * the headers vs. some extra checks.
2016
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2017
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2018
 * And there are "variable" fps files this needs to detect as well.
2019
 */
2020
static int tb_unreliable(AVCodecContext *c){
2021
    if(   c->time_base.den >= 101L*c->time_base.num
2022
       || c->time_base.den <    5L*c->time_base.num
2023
/*       || c->codec_tag == AV_RL32("DIVX")
2024
       || c->codec_tag == AV_RL32("XVID")*/
2025
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2026
       || c->codec_id == CODEC_ID_H264
2027
       )
2028
        return 1;
2029
    return 0;
2030
}
2031

    
2032
int av_find_stream_info(AVFormatContext *ic)
2033
{
2034
    int i, count, ret, read_size, j;
2035
    AVStream *st;
2036
    AVPacket pkt1, *pkt;
2037
    int64_t last_dts[MAX_STREAMS];
2038
    int64_t duration_gcd[MAX_STREAMS]={0};
2039
    int duration_count[MAX_STREAMS]={0};
2040
    double (*duration_error)[MAX_STD_TIMEBASES];
2041
    int64_t old_offset = url_ftell(ic->pb);
2042
    int64_t codec_info_duration[MAX_STREAMS]={0};
2043
    int codec_info_nb_frames[MAX_STREAMS]={0};
2044

    
2045
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2046
    if (!duration_error) return AVERROR(ENOMEM);
2047

    
2048
    for(i=0;i<ic->nb_streams;i++) {
2049
        st = ic->streams[i];
2050
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2051
/*            if(!st->time_base.num)
2052
                st->time_base= */
2053
            if(!st->codec->time_base.num)
2054
                st->codec->time_base= st->time_base;
2055
        }
2056
        //only for the split stuff
2057
        if (!st->parser) {
2058
            st->parser = av_parser_init(st->codec->codec_id);
2059
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2060
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2061
            }
2062
        }
2063
    }
2064

    
2065
    for(i=0;i<MAX_STREAMS;i++){
2066
        last_dts[i]= AV_NOPTS_VALUE;
2067
    }
2068

    
2069
    count = 0;
2070
    read_size = 0;
2071
    for(;;) {
2072
        if(url_interrupt_cb()){
2073
            ret= AVERROR(EINTR);
2074
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2075
            break;
2076
        }
2077

    
2078
        /* check if one codec still needs to be handled */
2079
        for(i=0;i<ic->nb_streams;i++) {
2080
            st = ic->streams[i];
2081
            if (!has_codec_parameters(st->codec))
2082
                break;
2083
            /* variable fps and no guess at the real fps */
2084
            if(   tb_unreliable(st->codec)
2085
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2086
                break;
2087
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2088
                break;
2089
            if(st->first_dts == AV_NOPTS_VALUE)
2090
                break;
2091
        }
2092
        if (i == ic->nb_streams) {
2093
            /* NOTE: if the format has no header, then we need to read
2094
               some packets to get most of the streams, so we cannot
2095
               stop here */
2096
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2097
                /* if we found the info for all the codecs, we can stop */
2098
                ret = count;
2099
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2100
                break;
2101
            }
2102
        }
2103
        /* we did not get all the codec info, but we read too much data */
2104
        if (read_size >= ic->probesize) {
2105
            ret = count;
2106
            av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2107
            break;
2108
        }
2109

    
2110
        /* NOTE: a new stream can be added there if no header in file
2111
           (AVFMTCTX_NOHEADER) */
2112
        ret = av_read_frame_internal(ic, &pkt1);
2113
        if(ret == AVERROR(EAGAIN))
2114
            continue;
2115
        if (ret < 0) {
2116
            /* EOF or error */
2117
            ret = -1; /* we could not have all the codec parameters before EOF */
2118
            for(i=0;i<ic->nb_streams;i++) {
2119
                st = ic->streams[i];
2120
                if (!has_codec_parameters(st->codec)){
2121
                    char buf[256];
2122
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2123
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2124
                } else {
2125
                    ret = 0;
2126
                }
2127
            }
2128
            break;
2129
        }
2130

    
2131
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2132
        if(av_dup_packet(pkt) < 0) {
2133
            av_free(duration_error);
2134
            return AVERROR(ENOMEM);
2135
        }
2136

    
2137
        read_size += pkt->size;
2138

    
2139
        st = ic->streams[pkt->stream_index];
2140
        if(codec_info_nb_frames[st->index]>1) {
2141
            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){
2142
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2143
                break;
2144
            }
2145
            codec_info_duration[st->index] += pkt->duration;
2146
        }
2147
        if (pkt->duration != 0)
2148
            codec_info_nb_frames[st->index]++;
2149

    
2150
        {
2151
            int index= pkt->stream_index;
2152
            int64_t last= last_dts[index];
2153
            int64_t duration= pkt->dts - last;
2154

    
2155
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2156
                double dur= duration * av_q2d(st->time_base);
2157

    
2158
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2159
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2160
                if(duration_count[index] < 2)
2161
                    memset(duration_error[index], 0, sizeof(*duration_error));
2162
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2163
                    int framerate= get_std_framerate(i);
2164
                    int ticks= lrintf(dur*framerate/(1001*12));
2165
                    double error= dur - ticks*1001*12/(double)framerate;
2166
                    duration_error[index][i] += error*error;
2167
                }
2168
                duration_count[index]++;
2169
                // ignore the first 4 values, they might have some random jitter
2170
                if (duration_count[index] > 3)
2171
                    duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2172
            }
2173
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2174
                last_dts[pkt->stream_index]= pkt->dts;
2175
        }
2176
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2177
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2178
            if(i){
2179
                st->codec->extradata_size= i;
2180
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2181
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2182
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2183
            }
2184
        }
2185

    
2186
        /* if still no information, we try to open the codec and to
2187
           decompress the frame. We try to avoid that in most cases as
2188
           it takes longer and uses more memory. For MPEG-4, we need to
2189
           decompress for QuickTime. */
2190
        if (!has_codec_parameters(st->codec))
2191
            try_decode_frame(st, pkt);
2192

    
2193
        count++;
2194
    }
2195

    
2196
    // close codecs which were opened in try_decode_frame()
2197
    for(i=0;i<ic->nb_streams;i++) {
2198
        st = ic->streams[i];
2199
        if(st->codec->codec)
2200
            avcodec_close(st->codec);
2201
    }
2202
    for(i=0;i<ic->nb_streams;i++) {
2203
        st = ic->streams[i];
2204
        if(codec_info_nb_frames[i]>2)
2205
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2206
                     (codec_info_nb_frames[i]-2)*(int64_t)st->time_base.den,
2207
                      codec_info_duration[i]    *(int64_t)st->time_base.num, 60000);
2208
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2209
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2210
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2211

    
2212
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2213
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2214
            // ipmovie.c produces.
2215
            if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
2216
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
2217
            if(duration_count[i]
2218
               && tb_unreliable(st->codec) /*&&
2219
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2220
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2221
                int num = 0;
2222
                double best_error= 2*av_q2d(st->time_base);
2223
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2224

    
2225
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2226
                    double error= duration_error[i][j] * get_std_framerate(j);
2227
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2228
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2229
                    if(error < best_error){
2230
                        best_error= error;
2231
                        num = get_std_framerate(j);
2232
                    }
2233
                }
2234
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2235
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2236
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2237
            }
2238

    
2239
            if (!st->r_frame_rate.num){
2240
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2241
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2242
                    st->r_frame_rate.num = st->codec->time_base.den;
2243
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2244
                }else{
2245
                    st->r_frame_rate.num = st->time_base.den;
2246
                    st->r_frame_rate.den = st->time_base.num;
2247
                }
2248
            }
2249
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2250
            if(!st->codec->bits_per_coded_sample)
2251
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2252
        }
2253
    }
2254

    
2255
    av_estimate_timings(ic, old_offset);
2256

    
2257
    compute_chapters_end(ic);
2258

    
2259
#if 0
2260
    /* correct DTS for B-frame streams with no timestamps */
2261
    for(i=0;i<ic->nb_streams;i++) {
2262
        st = ic->streams[i];
2263
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2264
            if(b-frames){
2265
                ppktl = &ic->packet_buffer;
2266
                while(ppkt1){
2267
                    if(ppkt1->stream_index != i)
2268
                        continue;
2269
                    if(ppkt1->pkt->dts < 0)
2270
                        break;
2271
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2272
                        break;
2273
                    ppkt1->pkt->dts -= delta;
2274
                    ppkt1= ppkt1->next;
2275
                }
2276
                if(ppkt1)
2277
                    continue;
2278
                st->cur_dts -= delta;
2279
            }
2280
        }
2281
    }
2282
#endif
2283

    
2284
    av_free(duration_error);
2285

    
2286
    return ret;
2287
}
2288

    
2289
/*******************************************************/
2290

    
2291
int av_read_play(AVFormatContext *s)
2292
{
2293
    if (s->iformat->read_play)
2294
        return s->iformat->read_play(s);
2295
    if (s->pb)
2296
        return av_url_read_fpause(s->pb, 0);
2297
    return AVERROR(ENOSYS);
2298
}
2299

    
2300
int av_read_pause(AVFormatContext *s)
2301
{
2302
    if (s->iformat->read_pause)
2303
        return s->iformat->read_pause(s);
2304
    if (s->pb)
2305
        return av_url_read_fpause(s->pb, 1);
2306
    return AVERROR(ENOSYS);
2307
}
2308

    
2309
void av_close_input_stream(AVFormatContext *s)
2310
{
2311
    int i;
2312
    AVStream *st;
2313

    
2314
    if (s->iformat->read_close)
2315
        s->iformat->read_close(s);
2316
    for(i=0;i<s->nb_streams;i++) {
2317
        /* free all data in a stream component */
2318
        st = s->streams[i];
2319
        if (st->parser) {
2320
            av_parser_close(st->parser);
2321
            av_free_packet(&st->cur_pkt);
2322
        }
2323
        av_metadata_free(&st->metadata);
2324
        av_free(st->index_entries);
2325
        av_free(st->codec->extradata);
2326
        av_free(st->codec);
2327
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2328
        av_free(st->filename);
2329
#endif
2330
        av_free(st->priv_data);
2331
        av_free(st);
2332
    }
2333
    for(i=s->nb_programs-1; i>=0; i--) {
2334
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2335
        av_freep(&s->programs[i]->provider_name);
2336
        av_freep(&s->programs[i]->name);
2337
#endif
2338
        av_metadata_free(&s->programs[i]->metadata);
2339
        av_freep(&s->programs[i]->stream_index);
2340
        av_freep(&s->programs[i]);
2341
    }
2342
    av_freep(&s->programs);
2343
    flush_packet_queue(s);
2344
    av_freep(&s->priv_data);
2345
    while(s->nb_chapters--) {
2346
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2347
        av_free(s->chapters[s->nb_chapters]->title);
2348
#endif
2349
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2350
        av_free(s->chapters[s->nb_chapters]);
2351
    }
2352
    av_freep(&s->chapters);
2353
    av_metadata_free(&s->metadata);
2354
    av_free(s);
2355
}
2356

    
2357
void av_close_input_file(AVFormatContext *s)
2358
{
2359
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2360
    av_close_input_stream(s);
2361
    if (pb)
2362
        url_fclose(pb);
2363
}
2364

    
2365
AVStream *av_new_stream(AVFormatContext *s, int id)
2366
{
2367
    AVStream *st;
2368
    int i;
2369

    
2370
    if (s->nb_streams >= MAX_STREAMS)
2371
        return NULL;
2372

    
2373
    st = av_mallocz(sizeof(AVStream));
2374
    if (!st)
2375
        return NULL;
2376

    
2377
    st->codec= avcodec_alloc_context();
2378
    if (s->iformat) {
2379
        /* no default bitrate if decoding */
2380
        st->codec->bit_rate = 0;
2381
    }
2382
    st->index = s->nb_streams;
2383
    st->id = id;
2384
    st->start_time = AV_NOPTS_VALUE;
2385
    st->duration = AV_NOPTS_VALUE;
2386
        /* we set the current DTS to 0 so that formats without any timestamps
2387
           but durations get some timestamps, formats with some unknown
2388
           timestamps have their first few packets buffered and the
2389
           timestamps corrected before they are returned to the user */
2390
    st->cur_dts = 0;
2391
    st->first_dts = AV_NOPTS_VALUE;
2392
    st->probe_packets = MAX_PROBE_PACKETS;
2393

    
2394
    /* default pts setting is MPEG-like */
2395
    av_set_pts_info(st, 33, 1, 90000);
2396
    st->last_IP_pts = AV_NOPTS_VALUE;
2397
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2398
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2399
    st->reference_dts = AV_NOPTS_VALUE;
2400

    
2401
    st->sample_aspect_ratio = (AVRational){0,1};
2402

    
2403
    s->streams[s->nb_streams++] = st;
2404
    return st;
2405
}
2406

    
2407
AVProgram *av_new_program(AVFormatContext *ac, int id)
2408
{
2409
    AVProgram *program=NULL;
2410
    int i;
2411

    
2412
#ifdef DEBUG_SI
2413
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2414
#endif
2415

    
2416
    for(i=0; i<ac->nb_programs; i++)
2417
        if(ac->programs[i]->id == id)
2418
            program = ac->programs[i];
2419

    
2420
    if(!program){
2421
        program = av_mallocz(sizeof(AVProgram));
2422
        if (!program)
2423
            return NULL;
2424
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2425
        program->discard = AVDISCARD_NONE;
2426
    }
2427
    program->id = id;
2428

    
2429
    return program;
2430
}
2431

    
2432
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2433
{
2434
    AVChapter *chapter = NULL;
2435
    int i;
2436

    
2437
    for(i=0; i<s->nb_chapters; i++)
2438
        if(s->chapters[i]->id == id)
2439
            chapter = s->chapters[i];
2440

    
2441
    if(!chapter){
2442
        chapter= av_mallocz(sizeof(AVChapter));
2443
        if(!chapter)
2444
            return NULL;
2445
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2446
    }
2447
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2448
    av_free(chapter->title);
2449
#endif
2450
    av_metadata_set(&chapter->metadata, "title", title);
2451
    chapter->id    = id;
2452
    chapter->time_base= time_base;
2453
    chapter->start = start;
2454
    chapter->end   = end;
2455

    
2456
    return chapter;
2457
}
2458

    
2459
/************************************************************/
2460
/* output media file */
2461

    
2462
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2463
{
2464
    int ret;
2465

    
2466
    if (s->oformat->priv_data_size > 0) {
2467
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2468
        if (!s->priv_data)
2469
            return AVERROR(ENOMEM);
2470
    } else
2471
        s->priv_data = NULL;
2472

    
2473
    if (s->oformat->set_parameters) {
2474
        ret = s->oformat->set_parameters(s, ap);
2475
        if (ret < 0)
2476
            return ret;
2477
    }
2478
    return 0;
2479
}
2480

    
2481
int av_write_header(AVFormatContext *s)
2482
{
2483
    int ret, i;
2484
    AVStream *st;
2485

    
2486
    // some sanity checks
2487
    for(i=0;i<s->nb_streams;i++) {
2488
        st = s->streams[i];
2489

    
2490
        switch (st->codec->codec_type) {
2491
        case CODEC_TYPE_AUDIO:
2492
            if(st->codec->sample_rate<=0){
2493
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2494
                return -1;
2495
            }
2496
            if(!st->codec->block_align)
2497
                st->codec->block_align = st->codec->channels *
2498
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2499
            break;
2500
        case CODEC_TYPE_VIDEO:
2501
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2502
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2503
                return -1;
2504
            }
2505
            if(st->codec->width<=0 || st->codec->height<=0){
2506
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2507
                return -1;
2508
            }
2509
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2510
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2511
                return -1;
2512
            }
2513
            break;
2514
        }
2515

    
2516
        if(s->oformat->codec_tag){
2517
            if(st->codec->codec_tag){
2518
                //FIXME
2519
                //check that tag + id is in the table
2520
                //if neither is in the table -> OK
2521
                //if tag is in the table with another id -> FAIL
2522
                //if id is in the table with another tag -> FAIL unless strict < ?
2523
            }else
2524
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2525
        }
2526

    
2527
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2528
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2529
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2530
    }
2531

    
2532
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2533
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2534
        if (!s->priv_data)
2535
            return AVERROR(ENOMEM);
2536
    }
2537

    
2538
#if LIBAVFORMAT_VERSION_MAJOR < 53
2539
    ff_metadata_mux_compat(s);
2540
#endif
2541

    
2542
    if(s->oformat->write_header){
2543
        ret = s->oformat->write_header(s);
2544
        if (ret < 0)
2545
            return ret;
2546
    }
2547

    
2548
    /* init PTS generation */
2549
    for(i=0;i<s->nb_streams;i++) {
2550
        int64_t den = AV_NOPTS_VALUE;
2551
        st = s->streams[i];
2552

    
2553
        switch (st->codec->codec_type) {
2554
        case CODEC_TYPE_AUDIO:
2555
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2556
            break;
2557
        case CODEC_TYPE_VIDEO:
2558
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2559
            break;
2560
        default:
2561
            break;
2562
        }
2563
        if (den != AV_NOPTS_VALUE) {
2564
            if (den <= 0)
2565
                return AVERROR_INVALIDDATA;
2566
            av_frac_init(&st->pts, 0, 0, den);
2567
        }
2568
    }
2569
    return 0;
2570
}
2571

    
2572
//FIXME merge with compute_pkt_fields
2573
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2574
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2575
    int num, den, frame_size, i;
2576

    
2577
//    av_log(s, 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);
2578

    
2579
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2580
        return -1;*/
2581

    
2582
    /* duration field */
2583
    if (pkt->duration == 0) {
2584
        compute_frame_duration(&num, &den, st, NULL, pkt);
2585
        if (den && num) {
2586
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2587
        }
2588
    }
2589

    
2590
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2591
        pkt->pts= pkt->dts;
2592

    
2593
    //XXX/FIXME this is a temporary hack until all encoders output pts
2594
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2595
        pkt->dts=
2596
//        pkt->pts= st->cur_dts;
2597
        pkt->pts= st->pts.val;
2598
    }
2599

    
2600
    //calculate dts from pts
2601
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2602
        st->pts_buffer[0]= pkt->pts;
2603
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2604
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2605
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2606
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2607

    
2608
        pkt->dts= st->pts_buffer[0];
2609
    }
2610

    
2611
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2612
        av_log(s, AV_LOG_ERROR,
2613
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2614
               st->index, st->cur_dts, pkt->dts);
2615
        return -1;
2616
    }
2617
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2618
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2619
        return -1;
2620
    }
2621

    
2622
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2623
    st->cur_dts= pkt->dts;
2624
    st->pts.val= pkt->dts;
2625

    
2626
    /* update pts */
2627
    switch (st->codec->codec_type) {
2628
    case CODEC_TYPE_AUDIO:
2629
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2630

    
2631
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2632
           likely equal to the encoder delay, but it would be better if we
2633
           had the real timestamps from the encoder */
2634
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2635
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2636
        }
2637
        break;
2638
    case CODEC_TYPE_VIDEO:
2639
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2640
        break;
2641
    default:
2642
        break;
2643
    }
2644
    return 0;
2645
}
2646

    
2647
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2648
{
2649
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2650

    
2651
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2652
        return ret;
2653

    
2654
    ret= s->oformat->write_packet(s, pkt);
2655
    if(!ret)
2656
        ret= url_ferror(s->pb);
2657
    return ret;
2658
}
2659

    
2660
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2661
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2662
{
2663
    AVPacketList **next_point, *this_pktl;
2664

    
2665
    this_pktl = av_mallocz(sizeof(AVPacketList));
2666
    this_pktl->pkt= *pkt;
2667
    pkt->destruct= NULL;             // do not free original but only the copy
2668
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2669

    
2670
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2671
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2672
    }else
2673
        next_point = &s->packet_buffer;
2674

    
2675
    if(*next_point){
2676
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2677
            while(!compare(s, &(*next_point)->pkt, pkt)){
2678
                next_point= &(*next_point)->next;
2679
            }
2680
            goto next_non_null;
2681
        }else{
2682
            next_point = &(s->packet_buffer_end->next);
2683
        }
2684
    }
2685
    assert(!*next_point);
2686

    
2687
    s->packet_buffer_end= this_pktl;
2688
next_non_null:
2689

    
2690
    this_pktl->next= *next_point;
2691

    
2692
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2693
    *next_point= this_pktl;
2694
}
2695

    
2696
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2697
{
2698
    AVStream *st = s->streams[ pkt ->stream_index];
2699
    AVStream *st2= s->streams[ next->stream_index];
2700
    int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2701
    int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2702

    
2703
    if (pkt->dts == AV_NOPTS_VALUE)
2704
        return 0;
2705

    
2706
    return next->dts * left > pkt->dts * right; //FIXME this can overflow
2707
}
2708

    
2709
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2710
    AVPacketList *pktl;
2711
    int stream_count=0;
2712
    int i;
2713

    
2714
    if(pkt){
2715
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2716
    }
2717

    
2718
    for(i=0; i < s->nb_streams; i++)
2719
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2720

    
2721
    if(stream_count && (s->nb_streams == stream_count || flush)){
2722
        pktl= s->packet_buffer;
2723
        *out= pktl->pkt;
2724

    
2725
        s->packet_buffer= pktl->next;
2726
        if(!s->packet_buffer)
2727
            s->packet_buffer_end= NULL;
2728

    
2729
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2730
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2731
        av_freep(&pktl);
2732
        return 1;
2733
    }else{
2734
        av_init_packet(out);
2735
        return 0;
2736
    }
2737
}
2738

    
2739
/**
2740
 * Interleaves an AVPacket correctly so it can be muxed.
2741
 * @param out the interleaved packet will be output here
2742
 * @param in the input packet
2743
 * @param flush 1 if no further packets are available as input and all
2744
 *              remaining packets should be output
2745
 * @return 1 if a packet was output, 0 if no packet could be output,
2746
 *         < 0 if an error occurred
2747
 */
2748
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2749
    if(s->oformat->interleave_packet)
2750
        return s->oformat->interleave_packet(s, out, in, flush);
2751
    else
2752
        return av_interleave_packet_per_dts(s, out, in, flush);
2753
}
2754

    
2755
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2756
    AVStream *st= s->streams[ pkt->stream_index];
2757

    
2758
    //FIXME/XXX/HACK drop zero sized packets
2759
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2760
        return 0;
2761

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

    
2766
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2767
        return -1;
2768

    
2769
    for(;;){
2770
        AVPacket opkt;
2771
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2772
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2773
            return ret;
2774

    
2775
        ret= s->oformat->write_packet(s, &opkt);
2776

    
2777
        av_free_packet(&opkt);
2778
        pkt= NULL;
2779

    
2780
        if(ret<0)
2781
            return ret;
2782
        if(url_ferror(s->pb))
2783
            return url_ferror(s->pb);
2784
    }
2785
}
2786

    
2787
int av_write_trailer(AVFormatContext *s)
2788
{
2789
    int ret, i;
2790

    
2791
    for(;;){
2792
        AVPacket pkt;
2793
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2794
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2795
            goto fail;
2796
        if(!ret)
2797
            break;
2798

    
2799
        ret= s->oformat->write_packet(s, &pkt);
2800

    
2801
        av_free_packet(&pkt);
2802

    
2803
        if(ret<0)
2804
            goto fail;
2805
        if(url_ferror(s->pb))
2806
            goto fail;
2807
    }
2808

    
2809
    if(s->oformat->write_trailer)
2810
        ret = s->oformat->write_trailer(s);
2811
fail:
2812
    if(ret == 0)
2813
       ret=url_ferror(s->pb);
2814
    for(i=0;i<s->nb_streams;i++)
2815
        av_freep(&s->streams[i]->priv_data);
2816
    av_freep(&s->priv_data);
2817
    return ret;
2818
}
2819

    
2820
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2821
{
2822
    int i, j;
2823
    AVProgram *program=NULL;
2824
    void *tmp;
2825

    
2826
    if (idx >= ac->nb_streams) {
2827
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2828
        return;
2829
    }
2830

    
2831
    for(i=0; i<ac->nb_programs; i++){
2832
        if(ac->programs[i]->id != progid)
2833
            continue;
2834
        program = ac->programs[i];
2835
        for(j=0; j<program->nb_stream_indexes; j++)
2836
            if(program->stream_index[j] == idx)
2837
                return;
2838

    
2839
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2840
        if(!tmp)
2841
            return;
2842
        program->stream_index = tmp;
2843
        program->stream_index[program->nb_stream_indexes++] = idx;
2844
        return;
2845
    }
2846
}
2847

    
2848
static void print_fps(double d, const char *postfix){
2849
    uint64_t v= lrintf(d*100);
2850
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2851
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2852
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2853
}
2854

    
2855
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2856
{
2857
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2858
        AVMetadataTag *tag=NULL;
2859

    
2860
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2861
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2862
            if(strcmp("language", tag->key))
2863
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
2864
        }
2865
    }
2866
}
2867

    
2868
/* "user interface" functions */
2869
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2870
{
2871
    char buf[256];
2872
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2873
    AVStream *st = ic->streams[i];
2874
    int g = av_gcd(st->time_base.num, st->time_base.den);
2875
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2876
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2877
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2878
    /* the pid is an important information, so we display it */
2879
    /* XXX: add a generic system */
2880
    if (flags & AVFMT_SHOW_IDS)
2881
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2882
    if (lang)
2883
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2884
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2885
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2886
    if (st->sample_aspect_ratio.num && // default
2887
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2888
        AVRational display_aspect_ratio;
2889
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2890
                  st->codec->width*st->sample_aspect_ratio.num,
2891
                  st->codec->height*st->sample_aspect_ratio.den,
2892
                  1024*1024);
2893
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2894
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2895
                 display_aspect_ratio.num, display_aspect_ratio.den);
2896
    }
2897
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2898
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
2899
            print_fps(av_q2d(st->avg_frame_rate), "fps");
2900
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2901
            print_fps(av_q2d(st->r_frame_rate), "tbr");
2902
        if(st->time_base.den && st->time_base.num)
2903
            print_fps(1/av_q2d(st->time_base), "tbn");
2904
        if(st->codec->time_base.den && st->codec->time_base.num)
2905
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
2906
    }
2907
    av_log(NULL, AV_LOG_INFO, "\n");
2908
    dump_metadata(NULL, st->metadata, "    ");
2909
}
2910

    
2911
void dump_format(AVFormatContext *ic,
2912
                 int index,
2913
                 const char *url,
2914
                 int is_output)
2915
{
2916
    int i;
2917
    uint8_t *printed = av_mallocz(ic->nb_streams);
2918
    if (ic->nb_streams && !printed)
2919
        return;
2920

    
2921
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2922
            is_output ? "Output" : "Input",
2923
            index,
2924
            is_output ? ic->oformat->name : ic->iformat->name,
2925
            is_output ? "to" : "from", url);
2926
    dump_metadata(NULL, ic->metadata, "  ");
2927
    if (!is_output) {
2928
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2929
        if (ic->duration != AV_NOPTS_VALUE) {
2930
            int hours, mins, secs, us;
2931
            secs = ic->duration / AV_TIME_BASE;
2932
            us = ic->duration % AV_TIME_BASE;
2933
            mins = secs / 60;
2934
            secs %= 60;
2935
            hours = mins / 60;
2936
            mins %= 60;
2937
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2938
                   (100 * us) / AV_TIME_BASE);
2939
        } else {
2940
            av_log(NULL, AV_LOG_INFO, "N/A");
2941
        }
2942
        if (ic->start_time != AV_NOPTS_VALUE) {
2943
            int secs, us;
2944
            av_log(NULL, AV_LOG_INFO, ", start: ");
2945
            secs = ic->start_time / AV_TIME_BASE;
2946
            us = ic->start_time % AV_TIME_BASE;
2947
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2948
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2949
        }
2950
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2951
        if (ic->bit_rate) {
2952
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2953
        } else {
2954
            av_log(NULL, AV_LOG_INFO, "N/A");
2955
        }
2956
        av_log(NULL, AV_LOG_INFO, "\n");
2957
    }
2958
    if(ic->nb_programs) {
2959
        int j, k, total = 0;
2960
        for(j=0; j<ic->nb_programs; j++) {
2961
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
2962
                                                  "name", NULL, 0);
2963
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2964
                   name ? name->value : "");
2965
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
2966
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
2967
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2968
                printed[ic->programs[j]->stream_index[k]] = 1;
2969
            }
2970
            total += ic->programs[j]->nb_stream_indexes;
2971
        }
2972
        if (total < ic->nb_streams)
2973
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
2974
    }
2975
    for(i=0;i<ic->nb_streams;i++)
2976
        if (!printed[i])
2977
            dump_stream_format(ic, i, index, is_output);
2978

    
2979
    av_free(printed);
2980
}
2981

    
2982
#if LIBAVFORMAT_VERSION_MAJOR < 53
2983
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2984
{
2985
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2986
}
2987

    
2988
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2989
{
2990
    AVRational frame_rate;
2991
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2992
    *frame_rate_num= frame_rate.num;
2993
    *frame_rate_den= frame_rate.den;
2994
    return ret;
2995
}
2996
#endif
2997

    
2998
int64_t av_gettime(void)
2999
{
3000
    struct timeval tv;
3001
    gettimeofday(&tv,NULL);
3002
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3003
}
3004

    
3005
int64_t parse_date(const char *datestr, int duration)
3006
{
3007
    const char *p;
3008
    int64_t t;
3009
    struct tm dt;
3010
    int i;
3011
    static const char * const date_fmt[] = {
3012
        "%Y-%m-%d",
3013
        "%Y%m%d",
3014
    };
3015
    static const char * const time_fmt[] = {
3016
        "%H:%M:%S",
3017
        "%H%M%S",
3018
    };
3019
    const char *q;
3020
    int is_utc, len;
3021
    char lastch;
3022
    int negative = 0;
3023

    
3024
#undef time
3025
    time_t now = time(0);
3026

    
3027
    len = strlen(datestr);
3028
    if (len > 0)
3029
        lastch = datestr[len - 1];
3030
    else
3031
        lastch = '\0';
3032
    is_utc = (lastch == 'z' || lastch == 'Z');
3033

    
3034
    memset(&dt, 0, sizeof(dt));
3035

    
3036
    p = datestr;
3037
    q = NULL;
3038
    if (!duration) {
3039
        if (!strncasecmp(datestr, "now", len))
3040
            return (int64_t) now * 1000000;
3041

    
3042
        /* parse the year-month-day part */
3043
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3044
            q = small_strptime(p, date_fmt[i], &dt);
3045
            if (q) {
3046
                break;
3047
            }
3048
        }
3049

    
3050
        /* if the year-month-day part is missing, then take the
3051
         * current year-month-day time */
3052
        if (!q) {
3053
            if (is_utc) {
3054
                dt = *gmtime(&now);
3055
            } else {
3056
                dt = *localtime(&now);
3057
            }
3058
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3059
        } else {
3060
            p = q;
3061
        }
3062

    
3063
        if (*p == 'T' || *p == 't' || *p == ' ')
3064
            p++;
3065

    
3066
        /* parse the hour-minute-second part */
3067
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3068
            q = small_strptime(p, time_fmt[i], &dt);
3069
            if (q) {
3070
                break;
3071
            }
3072
        }
3073
    } else {
3074
        /* parse datestr as a duration */
3075
        if (p[0] == '-') {
3076
            negative = 1;
3077
            ++p;
3078
        }
3079
        /* parse datestr as HH:MM:SS */
3080
        q = small_strptime(p, time_fmt[0], &dt);
3081
        if (!q) {
3082
            /* parse datestr as S+ */
3083
            dt.tm_sec = strtol(p, (char **)&q, 10);
3084
            if (q == p)
3085
                /* the parsing didn't succeed */
3086
                return INT64_MIN;
3087
            dt.tm_min = 0;
3088
            dt.tm_hour = 0;
3089
        }
3090
    }
3091

    
3092
    /* Now we have all the fields that we can get */
3093
    if (!q) {
3094
        return INT64_MIN;
3095
    }
3096

    
3097
    if (duration) {
3098
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3099
    } else {
3100
        dt.tm_isdst = -1;       /* unknown */
3101
        if (is_utc) {
3102
            t = mktimegm(&dt);
3103
        } else {
3104
            t = mktime(&dt);
3105
        }
3106
    }
3107

    
3108
    t *= 1000000;
3109

    
3110
    /* parse the .m... part */
3111
    if (*q == '.') {
3112
        int val, n;
3113
        q++;
3114
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3115
            if (!isdigit(*q))
3116
                break;
3117
            val += n * (*q - '0');
3118
        }
3119
        t += val;
3120
    }
3121
    return negative ? -t : t;
3122
}
3123

    
3124
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3125
{
3126
    const char *p;
3127
    char tag[128], *q;
3128

    
3129
    p = info;
3130
    if (*p == '?')
3131
        p++;
3132
    for(;;) {
3133
        q = tag;
3134
        while (*p != '\0' && *p != '=' && *p != '&') {
3135
            if ((q - tag) < sizeof(tag) - 1)
3136
                *q++ = *p;
3137
            p++;
3138
        }
3139
        *q = '\0';
3140
        q = arg;
3141
        if (*p == '=') {
3142
            p++;
3143
            while (*p != '&' && *p != '\0') {
3144
                if ((q - arg) < arg_size - 1) {
3145
                    if (*p == '+')
3146
                        *q++ = ' ';
3147
                    else
3148
                        *q++ = *p;
3149
                }
3150
                p++;
3151
            }
3152
            *q = '\0';
3153
        }
3154
        if (!strcmp(tag, tag1))
3155
            return 1;
3156
        if (*p != '&')
3157
            break;
3158
        p++;
3159
    }
3160
    return 0;
3161
}
3162

    
3163
int av_get_frame_filename(char *buf, int buf_size,
3164
                          const char *path, int number)
3165
{
3166
    const char *p;
3167
    char *q, buf1[20], c;
3168
    int nd, len, percentd_found;
3169

    
3170
    q = buf;
3171
    p = path;
3172
    percentd_found = 0;
3173
    for(;;) {
3174
        c = *p++;
3175
        if (c == '\0')
3176
            break;
3177
        if (c == '%') {
3178
            do {
3179
                nd = 0;
3180
                while (isdigit(*p)) {
3181
                    nd = nd * 10 + *p++ - '0';
3182
                }
3183
                c = *p++;
3184
            } while (isdigit(c));
3185

    
3186
            switch(c) {
3187
            case '%':
3188
                goto addchar;
3189
            case 'd':
3190
                if (percentd_found)
3191
                    goto fail;
3192
                percentd_found = 1;
3193
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3194
                len = strlen(buf1);
3195
                if ((q - buf + len) > buf_size - 1)
3196
                    goto fail;
3197
                memcpy(q, buf1, len);
3198
                q += len;
3199
                break;
3200
            default:
3201
                goto fail;
3202
            }
3203
        } else {
3204
        addchar:
3205
            if ((q - buf) < buf_size - 1)
3206
                *q++ = c;
3207
        }
3208
    }
3209
    if (!percentd_found)
3210
        goto fail;
3211
    *q = '\0';
3212
    return 0;
3213
 fail:
3214
    *q = '\0';
3215
    return -1;
3216
}
3217

    
3218
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3219
{
3220
    int len, i, j, c;
3221
#undef fprintf
3222
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3223

    
3224
    for(i=0;i<size;i+=16) {
3225
        len = size - i;
3226
        if (len > 16)
3227
            len = 16;
3228
        PRINT("%08x ", i);
3229
        for(j=0;j<16;j++) {
3230
            if (j < len)
3231
                PRINT(" %02x", buf[i+j]);
3232
            else
3233
                PRINT("   ");
3234
        }
3235
        PRINT(" ");
3236
        for(j=0;j<len;j++) {
3237
            c = buf[i+j];
3238
            if (c < ' ' || c > '~')
3239
                c = '.';
3240
            PRINT("%c", c);
3241
        }
3242
        PRINT("\n");
3243
    }
3244
#undef PRINT
3245
}
3246

    
3247
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3248
{
3249
    hex_dump_internal(NULL, f, 0, buf, size);
3250
}
3251

    
3252
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3253
{
3254
    hex_dump_internal(avcl, NULL, level, buf, size);
3255
}
3256

    
3257
 //FIXME needs to know the time_base
3258
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3259
{
3260
#undef fprintf
3261
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3262
    PRINT("stream #%d:\n", pkt->stream_index);
3263
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3264
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3265
    /* DTS is _always_ valid after av_read_frame() */
3266
    PRINT("  dts=");
3267
    if (pkt->dts == AV_NOPTS_VALUE)
3268
        PRINT("N/A");
3269
    else
3270
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3271
    /* PTS may not be known if B-frames are present. */
3272
    PRINT("  pts=");
3273
    if (pkt->pts == AV_NOPTS_VALUE)
3274
        PRINT("N/A");
3275
    else
3276
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3277
    PRINT("\n");
3278
    PRINT("  size=%d\n", pkt->size);
3279
#undef PRINT
3280
    if (dump_payload)
3281
        av_hex_dump(f, pkt->data, pkt->size);
3282
}
3283

    
3284
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3285
{
3286
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3287
}
3288

    
3289
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3290
{
3291
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3292
}
3293

    
3294
void url_split(char *proto, int proto_size,
3295
               char *authorization, int authorization_size,
3296
               char *hostname, int hostname_size,
3297
               int *port_ptr,
3298
               char *path, int path_size,
3299
               const char *url)
3300
{
3301
    const char *p, *ls, *at, *col, *brk;
3302

    
3303
    if (port_ptr)               *port_ptr = -1;
3304
    if (proto_size > 0)         proto[0] = 0;
3305
    if (authorization_size > 0) authorization[0] = 0;
3306
    if (hostname_size > 0)      hostname[0] = 0;
3307
    if (path_size > 0)          path[0] = 0;
3308

    
3309
    /* parse protocol */
3310
    if ((p = strchr(url, ':'))) {
3311
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3312
        p++; /* skip ':' */
3313
        if (*p == '/') p++;
3314
        if (*p == '/') p++;
3315
    } else {
3316
        /* no protocol means plain filename */
3317
        av_strlcpy(path, url, path_size);
3318
        return;
3319
    }
3320

    
3321
    /* separate path from hostname */
3322
    ls = strchr(p, '/');
3323
    if(!ls)
3324
        ls = strchr(p, '?');
3325
    if(ls)
3326
        av_strlcpy(path, ls, path_size);
3327
    else
3328
        ls = &p[strlen(p)]; // XXX
3329

    
3330
    /* the rest is hostname, use that to parse auth/port */
3331
    if (ls != p) {
3332
        /* authorization (user[:pass]@hostname) */
3333
        if ((at = strchr(p, '@')) && at < ls) {
3334
            av_strlcpy(authorization, p,
3335
                       FFMIN(authorization_size, at + 1 - p));
3336
            p = at + 1; /* skip '@' */
3337
        }
3338

    
3339
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3340
            /* [host]:port */
3341
            av_strlcpy(hostname, p + 1,
3342
                       FFMIN(hostname_size, brk - p));
3343
            if (brk[1] == ':' && port_ptr)
3344
                *port_ptr = atoi(brk + 2);
3345
        } else if ((col = strchr(p, ':')) && col < ls) {
3346
            av_strlcpy(hostname, p,
3347
                       FFMIN(col + 1 - p, hostname_size));
3348
            if (port_ptr) *port_ptr = atoi(col + 1);
3349
        } else
3350
            av_strlcpy(hostname, p,
3351
                       FFMIN(ls + 1 - p, hostname_size));
3352
    }
3353
}
3354

    
3355
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3356
{
3357
    int i;
3358
    static const char hex_table[16] = { '0', '1', '2', '3',
3359
                                        '4', '5', '6', '7',
3360
                                        '8', '9', 'A', 'B',
3361
                                        'C', 'D', 'E', 'F' };
3362

    
3363
    for(i = 0; i < s; i++) {
3364
        buff[i * 2]     = hex_table[src[i] >> 4];
3365
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3366
    }
3367

    
3368
    return buff;
3369
}
3370

    
3371
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3372
                     unsigned int pts_num, unsigned int pts_den)
3373
{
3374
    s->pts_wrap_bits = pts_wrap_bits;
3375

    
3376
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3377
        if(s->time_base.num != pts_num)
3378
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3379
    }else
3380
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3381

    
3382
    if(!s->time_base.num || !s->time_base.den)
3383
        s->time_base.num= s->time_base.den= 0;
3384
}