Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ e18027ac

History | View | Annotate | Download (105 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
/* fraction handling */
45

    
46
/**
47
 * f = val + (num / den) + 0.5.
48
 *
49
 * 'num' is normalized so that it is such as 0 <= num < den.
50
 *
51
 * @param f fractional number
52
 * @param val integer value
53
 * @param num must be >= 0
54
 * @param den must be >= 1
55
 */
56
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
57
{
58
    num += (den >> 1);
59
    if (num >= den) {
60
        val += num / den;
61
        num = num % den;
62
    }
63
    f->val = val;
64
    f->num = num;
65
    f->den = den;
66
}
67

    
68
/**
69
 * Fractional addition to f: f = f + (incr / f->den).
70
 *
71
 * @param f fractional number
72
 * @param incr increment, can be positive or negative
73
 */
74
static void av_frac_add(AVFrac *f, int64_t incr)
75
{
76
    int64_t num, den;
77

    
78
    num = f->num + incr;
79
    den = f->den;
80
    if (num < 0) {
81
        f->val += num / den;
82
        num = num % den;
83
        if (num < 0) {
84
            num += den;
85
            f->val--;
86
        }
87
    } else if (num >= den) {
88
        f->val += num / den;
89
        num = num % den;
90
    }
91
    f->num = num;
92
}
93

    
94
/** head of registered input format linked list */
95
AVInputFormat *first_iformat = NULL;
96
/** head of registered output format linked list */
97
AVOutputFormat *first_oformat = NULL;
98

    
99
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
100
{
101
    if(f) return f->next;
102
    else  return first_iformat;
103
}
104

    
105
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
106
{
107
    if(f) return f->next;
108
    else  return first_oformat;
109
}
110

    
111
void av_register_input_format(AVInputFormat *format)
112
{
113
    AVInputFormat **p;
114
    p = &first_iformat;
115
    while (*p != NULL) p = &(*p)->next;
116
    *p = format;
117
    format->next = NULL;
118
}
119

    
120
void av_register_output_format(AVOutputFormat *format)
121
{
122
    AVOutputFormat **p;
123
    p = &first_oformat;
124
    while (*p != NULL) p = &(*p)->next;
125
    *p = format;
126
    format->next = NULL;
127
}
128

    
129
int match_ext(const char *filename, const char *extensions)
130
{
131
    const char *ext, *p;
132
    char ext1[32], *q;
133

    
134
    if(!filename)
135
        return 0;
136

    
137
    ext = strrchr(filename, '.');
138
    if (ext) {
139
        ext++;
140
        p = extensions;
141
        for(;;) {
142
            q = ext1;
143
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
144
                *q++ = *p++;
145
            *q = '\0';
146
            if (!strcasecmp(ext1, ext))
147
                return 1;
148
            if (*p == '\0')
149
                break;
150
            p++;
151
        }
152
    }
153
    return 0;
154
}
155

    
156
static int match_format(const char *name, const char *names)
157
{
158
    const char *p;
159
    int len, namelen;
160

    
161
    if (!name || !names)
162
        return 0;
163

    
164
    namelen = strlen(name);
165
    while ((p = strchr(names, ','))) {
166
        len = FFMAX(p - names, namelen);
167
        if (!strncasecmp(name, names, len))
168
            return 1;
169
        names = p+1;
170
    }
171
    return !strcasecmp(name, names);
172
}
173

    
174
AVOutputFormat *guess_format(const char *short_name, const char *filename,
175
                             const char *mime_type)
176
{
177
    AVOutputFormat *fmt, *fmt_found;
178
    int score_max, score;
179

    
180
    /* specific test for image sequences */
181
#if CONFIG_IMAGE2_MUXER
182
    if (!short_name && filename &&
183
        av_filename_number_test(filename) &&
184
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
185
        return guess_format("image2", NULL, NULL);
186
    }
187
#endif
188
    /* Find the proper file type. */
189
    fmt_found = NULL;
190
    score_max = 0;
191
    fmt = first_oformat;
192
    while (fmt != NULL) {
193
        score = 0;
194
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
195
            score += 100;
196
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
197
            score += 10;
198
        if (filename && fmt->extensions &&
199
            match_ext(filename, fmt->extensions)) {
200
            score += 5;
201
        }
202
        if (score > score_max) {
203
            score_max = score;
204
            fmt_found = fmt;
205
        }
206
        fmt = fmt->next;
207
    }
208
    return fmt_found;
209
}
210

    
211
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
212
                             const char *mime_type)
213
{
214
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
215

    
216
    if (fmt) {
217
        AVOutputFormat *stream_fmt;
218
        char stream_format_name[64];
219

    
220
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
221
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
222

    
223
        if (stream_fmt)
224
            fmt = stream_fmt;
225
    }
226

    
227
    return fmt;
228
}
229

    
230
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
231
                            const char *filename, const char *mime_type, enum CodecType type){
232
    if(type == CODEC_TYPE_VIDEO){
233
        enum CodecID codec_id= CODEC_ID_NONE;
234

    
235
#if CONFIG_IMAGE2_MUXER
236
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
237
            codec_id= av_guess_image2_codec(filename);
238
        }
239
#endif
240
        if(codec_id == CODEC_ID_NONE)
241
            codec_id= fmt->video_codec;
242
        return codec_id;
243
    }else if(type == CODEC_TYPE_AUDIO)
244
        return fmt->audio_codec;
245
    else
246
        return CODEC_ID_NONE;
247
}
248

    
249
AVInputFormat *av_find_input_format(const char *short_name)
250
{
251
    AVInputFormat *fmt;
252
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
253
        if (match_format(short_name, fmt->name))
254
            return fmt;
255
    }
256
    return NULL;
257
}
258

    
259
/* memory handling */
260

    
261

    
262
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
263
{
264
    int ret= av_new_packet(pkt, size);
265

    
266
    if(ret<0)
267
        return ret;
268

    
269
    pkt->pos= url_ftell(s);
270

    
271
    ret= get_buffer(s, pkt->data, size);
272
    if(ret<=0)
273
        av_free_packet(pkt);
274
    else
275
        av_shrink_packet(pkt, ret);
276

    
277
    return ret;
278
}
279

    
280

    
281
int av_filename_number_test(const char *filename)
282
{
283
    char buf[1024];
284
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
285
}
286

    
287
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
288
{
289
    AVInputFormat *fmt1, *fmt;
290
    int score;
291

    
292
    fmt = NULL;
293
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
294
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
295
            continue;
296
        score = 0;
297
        if (fmt1->read_probe) {
298
            score = fmt1->read_probe(pd);
299
        } else if (fmt1->extensions) {
300
            if (match_ext(pd->filename, fmt1->extensions)) {
301
                score = 50;
302
            }
303
        }
304
        if (score > *score_max) {
305
            *score_max = score;
306
            fmt = fmt1;
307
        }else if (score == *score_max)
308
            fmt = NULL;
309
    }
310
    return fmt;
311
}
312

    
313
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
314
    int score=0;
315
    return av_probe_input_format2(pd, is_opened, &score);
316
}
317

    
318
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
319
{
320
    AVInputFormat *fmt;
321
    fmt = av_probe_input_format2(pd, 1, &score);
322

    
323
    if (fmt) {
324
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
325
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
326
        if (!strcmp(fmt->name, "mp3")) {
327
            st->codec->codec_id = CODEC_ID_MP3;
328
            st->codec->codec_type = CODEC_TYPE_AUDIO;
329
        } else if (!strcmp(fmt->name, "ac3")) {
330
            st->codec->codec_id = CODEC_ID_AC3;
331
            st->codec->codec_type = CODEC_TYPE_AUDIO;
332
        } else if (!strcmp(fmt->name, "mpegvideo")) {
333
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
334
            st->codec->codec_type = CODEC_TYPE_VIDEO;
335
        } else if (!strcmp(fmt->name, "m4v")) {
336
            st->codec->codec_id = CODEC_ID_MPEG4;
337
            st->codec->codec_type = CODEC_TYPE_VIDEO;
338
        } else if (!strcmp(fmt->name, "h264")) {
339
            st->codec->codec_id = CODEC_ID_H264;
340
            st->codec->codec_type = CODEC_TYPE_VIDEO;
341
        } else if (!strcmp(fmt->name, "dts")) {
342
            st->codec->codec_id = CODEC_ID_DTS;
343
            st->codec->codec_type = CODEC_TYPE_AUDIO;
344
        }
345
    }
346
    return !!fmt;
347
}
348

    
349
/************************************************************/
350
/* input media file */
351

    
352
/**
353
 * Open a media file from an IO stream. 'fmt' must be specified.
354
 */
355
int av_open_input_stream(AVFormatContext **ic_ptr,
356
                         ByteIOContext *pb, const char *filename,
357
                         AVInputFormat *fmt, AVFormatParameters *ap)
358
{
359
    int err;
360
    AVFormatContext *ic;
361
    AVFormatParameters default_ap;
362

    
363
    if(!ap){
364
        ap=&default_ap;
365
        memset(ap, 0, sizeof(default_ap));
366
    }
367

    
368
    if(!ap->prealloced_context)
369
        ic = avformat_alloc_context();
370
    else
371
        ic = *ic_ptr;
372
    if (!ic) {
373
        err = AVERROR(ENOMEM);
374
        goto fail;
375
    }
376
    ic->iformat = fmt;
377
    ic->pb = pb;
378
    ic->duration = AV_NOPTS_VALUE;
379
    ic->start_time = AV_NOPTS_VALUE;
380
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
381

    
382
    /* allocate private data */
383
    if (fmt->priv_data_size > 0) {
384
        ic->priv_data = av_mallocz(fmt->priv_data_size);
385
        if (!ic->priv_data) {
386
            err = AVERROR(ENOMEM);
387
            goto fail;
388
        }
389
    } else {
390
        ic->priv_data = NULL;
391
    }
392

    
393
    if (ic->iformat->read_header) {
394
        err = ic->iformat->read_header(ic, ap);
395
        if (err < 0)
396
            goto fail;
397
    }
398

    
399
    if (pb && !ic->data_offset)
400
        ic->data_offset = url_ftell(ic->pb);
401

    
402
#if LIBAVFORMAT_VERSION_MAJOR < 53
403
    ff_metadata_demux_compat(ic);
404
#endif
405

    
406
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
407

    
408
    *ic_ptr = ic;
409
    return 0;
410
 fail:
411
    if (ic) {
412
        int i;
413
        av_freep(&ic->priv_data);
414
        for(i=0;i<ic->nb_streams;i++) {
415
            AVStream *st = ic->streams[i];
416
            if (st) {
417
                av_free(st->priv_data);
418
                av_free(st->codec->extradata);
419
            }
420
            av_free(st);
421
        }
422
    }
423
    av_free(ic);
424
    *ic_ptr = NULL;
425
    return err;
426
}
427

    
428
/** size of probe buffer, for guessing file type from file contents */
429
#define PROBE_BUF_MIN 2048
430
#define PROBE_BUF_MAX (1<<20)
431

    
432
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
433
                       AVInputFormat *fmt,
434
                       int buf_size,
435
                       AVFormatParameters *ap)
436
{
437
    int err, probe_size;
438
    AVProbeData probe_data, *pd = &probe_data;
439
    ByteIOContext *pb = NULL;
440
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
441

    
442
    pd->filename = "";
443
    if (filename)
444
        pd->filename = filename;
445
    pd->buf = NULL;
446
    pd->buf_size = 0;
447

    
448
    if (!fmt) {
449
        /* guess format if no file can be opened */
450
        fmt = av_probe_input_format(pd, 0);
451
    }
452

    
453
    /* Do not open file if the format does not need it. XXX: specific
454
       hack needed to handle RTSP/TCP */
455
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
456
        /* if no file needed do not try to open one */
457
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
458
            goto fail;
459
        }
460
        if (buf_size > 0) {
461
            url_setbufsize(pb, buf_size);
462
        }
463

    
464
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
465
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
466
            /* read probe data */
467
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
468
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
469
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
470
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
471
                url_fclose(pb);
472
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
473
                    pb = NULL;
474
                    err = AVERROR(EIO);
475
                    goto fail;
476
                }
477
            }
478
            /* guess file format */
479
            fmt = av_probe_input_format2(pd, 1, &score);
480
            if(fmt){
481
                if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
482
                    av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
483
                }else
484
                    av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
485
            }
486
        }
487
        av_freep(&pd->buf);
488
    }
489

    
490
    /* if still no format found, error */
491
    if (!fmt) {
492
        err = AVERROR_NOFMT;
493
        goto fail;
494
    }
495

    
496
    /* check filename in case an image number is expected */
497
    if (fmt->flags & AVFMT_NEEDNUMBER) {
498
        if (!av_filename_number_test(filename)) {
499
            err = AVERROR_NUMEXPECTED;
500
            goto fail;
501
        }
502
    }
503
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
504
    if (err)
505
        goto fail;
506
    return 0;
507
 fail:
508
    av_freep(&pd->buf);
509
    if (pb)
510
        url_fclose(pb);
511
    if (ap && ap->prealloced_context)
512
        av_free(*ic_ptr);
513
    *ic_ptr = NULL;
514
    return err;
515

    
516
}
517

    
518
/*******************************************************/
519

    
520
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
521
                               AVPacketList **plast_pktl){
522
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
523
    if (!pktl)
524
        return NULL;
525

    
526
    if (*packet_buffer)
527
        (*plast_pktl)->next = pktl;
528
    else
529
        *packet_buffer = pktl;
530

    
531
    /* add the packet in the buffered packet list */
532
    *plast_pktl = pktl;
533
    pktl->pkt= *pkt;
534
    return &pktl->pkt;
535
}
536

    
537
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
538
{
539
    int ret, i;
540
    AVStream *st;
541

    
542
    for(;;){
543
        AVPacketList *pktl = s->raw_packet_buffer;
544

    
545
        if (pktl) {
546
            *pkt = pktl->pkt;
547
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
548
               !s->streams[pkt->stream_index]->probe_packets ||
549
               s->raw_packet_buffer_remaining_size < pkt->size){
550
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
551
                av_freep(&pd->buf);
552
                pd->buf_size = 0;
553
                s->raw_packet_buffer = pktl->next;
554
                s->raw_packet_buffer_remaining_size += pkt->size;
555
                av_free(pktl);
556
                return 0;
557
            }
558
        }
559

    
560
        av_init_packet(pkt);
561
        ret= s->iformat->read_packet(s, pkt);
562
        if (ret < 0) {
563
            if (!pktl || ret == AVERROR(EAGAIN))
564
                return ret;
565
            for (i = 0; i < s->nb_streams; i++)
566
                s->streams[i]->probe_packets = 0;
567
            continue;
568
        }
569
        st= s->streams[pkt->stream_index];
570

    
571
        switch(st->codec->codec_type){
572
        case CODEC_TYPE_VIDEO:
573
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
574
            break;
575
        case CODEC_TYPE_AUDIO:
576
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
577
            break;
578
        case CODEC_TYPE_SUBTITLE:
579
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
580
            break;
581
        }
582

    
583
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
584
                     !st->probe_packets))
585
            return ret;
586

    
587
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
588
        s->raw_packet_buffer_remaining_size -= pkt->size;
589

    
590
        if(st->codec->codec_id == CODEC_ID_PROBE){
591
            AVProbeData *pd = &st->probe_data;
592

    
593
            --st->probe_packets;
594

    
595
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
596
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
597
            pd->buf_size += pkt->size;
598
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
599

    
600
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
601
                set_codec_from_probe_data(s, st, pd, 1);
602
                if(st->codec->codec_id != CODEC_ID_PROBE){
603
                    pd->buf_size=0;
604
                    av_freep(&pd->buf);
605
                }
606
            }
607
        }
608
    }
609
}
610

    
611
/**********************************************************/
612

    
613
/**
614
 * Get the number of samples of an audio frame. Return -1 on error.
615
 */
616
static int get_audio_frame_size(AVCodecContext *enc, int size)
617
{
618
    int frame_size;
619

    
620
    if(enc->codec_id == CODEC_ID_VORBIS)
621
        return -1;
622

    
623
    if (enc->frame_size <= 1) {
624
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
625

    
626
        if (bits_per_sample) {
627
            if (enc->channels == 0)
628
                return -1;
629
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
630
        } else {
631
            /* used for example by ADPCM codecs */
632
            if (enc->bit_rate == 0)
633
                return -1;
634
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
635
        }
636
    } else {
637
        frame_size = enc->frame_size;
638
    }
639
    return frame_size;
640
}
641

    
642

    
643
/**
644
 * Return the frame duration in seconds. Return 0 if not available.
645
 */
646
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
647
                                   AVCodecParserContext *pc, AVPacket *pkt)
648
{
649
    int frame_size;
650

    
651
    *pnum = 0;
652
    *pden = 0;
653
    switch(st->codec->codec_type) {
654
    case CODEC_TYPE_VIDEO:
655
        if(st->time_base.num*1000LL > st->time_base.den){
656
            *pnum = st->time_base.num;
657
            *pden = st->time_base.den;
658
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
659
            *pnum = st->codec->time_base.num;
660
            *pden = st->codec->time_base.den;
661
            if (pc && pc->repeat_pict) {
662
                *pnum = (*pnum) * (1 + pc->repeat_pict);
663
            }
664
        }
665
        break;
666
    case CODEC_TYPE_AUDIO:
667
        frame_size = get_audio_frame_size(st->codec, pkt->size);
668
        if (frame_size < 0)
669
            break;
670
        *pnum = frame_size;
671
        *pden = st->codec->sample_rate;
672
        break;
673
    default:
674
        break;
675
    }
676
}
677

    
678
static int is_intra_only(AVCodecContext *enc){
679
    if(enc->codec_type == CODEC_TYPE_AUDIO){
680
        return 1;
681
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
682
        switch(enc->codec_id){
683
        case CODEC_ID_MJPEG:
684
        case CODEC_ID_MJPEGB:
685
        case CODEC_ID_LJPEG:
686
        case CODEC_ID_RAWVIDEO:
687
        case CODEC_ID_DVVIDEO:
688
        case CODEC_ID_HUFFYUV:
689
        case CODEC_ID_FFVHUFF:
690
        case CODEC_ID_ASV1:
691
        case CODEC_ID_ASV2:
692
        case CODEC_ID_VCR1:
693
        case CODEC_ID_DNXHD:
694
        case CODEC_ID_JPEG2000:
695
            return 1;
696
        default: break;
697
        }
698
    }
699
    return 0;
700
}
701

    
702
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
703
                                      int64_t dts, int64_t pts)
704
{
705
    AVStream *st= s->streams[stream_index];
706
    AVPacketList *pktl= s->packet_buffer;
707

    
708
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
709
        return;
710

    
711
    st->first_dts= dts - st->cur_dts;
712
    st->cur_dts= dts;
713

    
714
    for(; pktl; pktl= pktl->next){
715
        if(pktl->pkt.stream_index != stream_index)
716
            continue;
717
        //FIXME think more about this check
718
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
719
            pktl->pkt.pts += st->first_dts;
720

    
721
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
722
            pktl->pkt.dts += st->first_dts;
723

    
724
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
725
            st->start_time= pktl->pkt.pts;
726
    }
727
    if (st->start_time == AV_NOPTS_VALUE)
728
        st->start_time = pts;
729
}
730

    
731
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
732
{
733
    AVPacketList *pktl= s->packet_buffer;
734
    int64_t cur_dts= 0;
735

    
736
    if(st->first_dts != AV_NOPTS_VALUE){
737
        cur_dts= st->first_dts;
738
        for(; pktl; pktl= pktl->next){
739
            if(pktl->pkt.stream_index == pkt->stream_index){
740
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
741
                    break;
742
                cur_dts -= pkt->duration;
743
            }
744
        }
745
        pktl= s->packet_buffer;
746
        st->first_dts = cur_dts;
747
    }else if(st->cur_dts)
748
        return;
749

    
750
    for(; pktl; pktl= pktl->next){
751
        if(pktl->pkt.stream_index != pkt->stream_index)
752
            continue;
753
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
754
           && !pktl->pkt.duration){
755
            pktl->pkt.dts= cur_dts;
756
            if(!st->codec->has_b_frames)
757
                pktl->pkt.pts= cur_dts;
758
            cur_dts += pkt->duration;
759
            pktl->pkt.duration= pkt->duration;
760
        }else
761
            break;
762
    }
763
    if(st->first_dts == AV_NOPTS_VALUE)
764
        st->cur_dts= cur_dts;
765
}
766

    
767
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
768
                               AVCodecParserContext *pc, AVPacket *pkt)
769
{
770
    int num, den, presentation_delayed, delay, i;
771
    int64_t offset;
772

    
773
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
774
        //FIXME Set low_delay = 0 when has_b_frames = 1
775
        st->codec->has_b_frames = 1;
776

    
777
    /* do we have a video B-frame ? */
778
    delay= st->codec->has_b_frames;
779
    presentation_delayed = 0;
780
    /* XXX: need has_b_frame, but cannot get it if the codec is
781
        not initialized */
782
    if (delay &&
783
        pc && pc->pict_type != FF_B_TYPE)
784
        presentation_delayed = 1;
785

    
786
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
787
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
788
        pkt->dts -= 1LL<<st->pts_wrap_bits;
789
    }
790

    
791
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
792
    // we take the conservative approach and discard both
793
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
794
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
795
        av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
796
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
797
    }
798

    
799
    if (pkt->duration == 0) {
800
        compute_frame_duration(&num, &den, st, pc, pkt);
801
        if (den && num) {
802
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
803

    
804
            if(pkt->duration != 0 && s->packet_buffer)
805
                update_initial_durations(s, st, pkt);
806
        }
807
    }
808

    
809
    /* correct timestamps with byte offset if demuxers only have timestamps
810
       on packet boundaries */
811
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
812
        /* this will estimate bitrate based on this frame's duration and size */
813
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
814
        if(pkt->pts != AV_NOPTS_VALUE)
815
            pkt->pts += offset;
816
        if(pkt->dts != AV_NOPTS_VALUE)
817
            pkt->dts += offset;
818
    }
819

    
820
    if (pc && pc->dts_sync_point >= 0) {
821
        // we have synchronization info from the parser
822
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
823
        if (den > 0) {
824
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
825
            if (pkt->dts != AV_NOPTS_VALUE) {
826
                // got DTS from the stream, update reference timestamp
827
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
828
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
829
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
830
                // compute DTS based on reference timestamp
831
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
832
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
833
            }
834
            if (pc->dts_sync_point > 0)
835
                st->reference_dts = pkt->dts; // new reference
836
        }
837
    }
838

    
839
    /* This may be redundant, but it should not hurt. */
840
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
841
        presentation_delayed = 1;
842

    
843
//    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);
844
    /* interpolate PTS and DTS if they are not present */
845
    //We skip H264 currently because delay and has_b_frames are not reliably set
846
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
847
        if (presentation_delayed) {
848
            /* DTS = decompression timestamp */
849
            /* PTS = presentation timestamp */
850
            if (pkt->dts == AV_NOPTS_VALUE)
851
                pkt->dts = st->last_IP_pts;
852
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
853
            if (pkt->dts == AV_NOPTS_VALUE)
854
                pkt->dts = st->cur_dts;
855

    
856
            /* this is tricky: the dts must be incremented by the duration
857
            of the frame we are displaying, i.e. the last I- or P-frame */
858
            if (st->last_IP_duration == 0)
859
                st->last_IP_duration = pkt->duration;
860
            if(pkt->dts != AV_NOPTS_VALUE)
861
                st->cur_dts = pkt->dts + st->last_IP_duration;
862
            st->last_IP_duration  = pkt->duration;
863
            st->last_IP_pts= pkt->pts;
864
            /* cannot compute PTS if not present (we can compute it only
865
            by knowing the future */
866
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
867
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
868
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
869
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
870
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
871
                    pkt->pts += pkt->duration;
872
    //                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);
873
                }
874
            }
875

    
876
            /* presentation is not delayed : PTS and DTS are the same */
877
            if(pkt->pts == AV_NOPTS_VALUE)
878
                pkt->pts = pkt->dts;
879
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
880
            if(pkt->pts == AV_NOPTS_VALUE)
881
                pkt->pts = st->cur_dts;
882
            pkt->dts = pkt->pts;
883
            if(pkt->pts != AV_NOPTS_VALUE)
884
                st->cur_dts = pkt->pts + pkt->duration;
885
        }
886
    }
887

    
888
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
889
        st->pts_buffer[0]= pkt->pts;
890
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
891
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
892
        if(pkt->dts == AV_NOPTS_VALUE)
893
            pkt->dts= st->pts_buffer[0];
894
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
895
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
896
        }
897
        if(pkt->dts > st->cur_dts)
898
            st->cur_dts = pkt->dts;
899
    }
900

    
901
//    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);
902

    
903
    /* update flags */
904
    if(is_intra_only(st->codec))
905
        pkt->flags |= PKT_FLAG_KEY;
906
    else if (pc) {
907
        pkt->flags = 0;
908
        /* keyframe computation */
909
        if (pc->key_frame == 1)
910
            pkt->flags |= PKT_FLAG_KEY;
911
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
912
            pkt->flags |= PKT_FLAG_KEY;
913
    }
914
    if (pc)
915
        pkt->convergence_duration = pc->convergence_duration;
916
}
917

    
918

    
919
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
920
{
921
    AVStream *st;
922
    int len, ret, i;
923

    
924
    av_init_packet(pkt);
925

    
926
    for(;;) {
927
        /* select current input stream component */
928
        st = s->cur_st;
929
        if (st) {
930
            if (!st->need_parsing || !st->parser) {
931
                /* no parsing needed: we just output the packet as is */
932
                /* raw data support */
933
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
934
                compute_pkt_fields(s, st, NULL, pkt);
935
                s->cur_st = NULL;
936
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
937
                    (pkt->flags & PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
938
                    ff_reduce_index(s, st->index);
939
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
940
                }
941
                break;
942
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
943
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
944
                                       st->cur_ptr, st->cur_len,
945
                                       st->cur_pkt.pts, st->cur_pkt.dts,
946
                                       st->cur_pkt.pos);
947
                st->cur_pkt.pts = AV_NOPTS_VALUE;
948
                st->cur_pkt.dts = AV_NOPTS_VALUE;
949
                /* increment read pointer */
950
                st->cur_ptr += len;
951
                st->cur_len -= len;
952

    
953
                /* return packet if any */
954
                if (pkt->size) {
955
                got_packet:
956
                    pkt->duration = 0;
957
                    pkt->stream_index = st->index;
958
                    pkt->pts = st->parser->pts;
959
                    pkt->dts = st->parser->dts;
960
                    pkt->pos = st->parser->pos;
961
                    pkt->destruct = NULL;
962
                    compute_pkt_fields(s, st, st->parser, pkt);
963

    
964
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
965
                        ff_reduce_index(s, st->index);
966
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
967
                                           0, 0, AVINDEX_KEYFRAME);
968
                    }
969

    
970
                    break;
971
                }
972
            } else {
973
                /* free packet */
974
                av_free_packet(&st->cur_pkt);
975
                s->cur_st = NULL;
976
            }
977
        } else {
978
            AVPacket cur_pkt;
979
            /* read next packet */
980
            ret = av_read_packet(s, &cur_pkt);
981
            if (ret < 0) {
982
                if (ret == AVERROR(EAGAIN))
983
                    return ret;
984
                /* return the last frames, if any */
985
                for(i = 0; i < s->nb_streams; i++) {
986
                    st = s->streams[i];
987
                    if (st->parser && st->need_parsing) {
988
                        av_parser_parse2(st->parser, st->codec,
989
                                        &pkt->data, &pkt->size,
990
                                        NULL, 0,
991
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
992
                                        AV_NOPTS_VALUE);
993
                        if (pkt->size)
994
                            goto got_packet;
995
                    }
996
                }
997
                /* no more packets: really terminate parsing */
998
                return ret;
999
            }
1000
            st = s->streams[cur_pkt.stream_index];
1001
            st->cur_pkt= cur_pkt;
1002

    
1003
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1004
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1005
               st->cur_pkt.pts < st->cur_pkt.dts){
1006
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1007
                    st->cur_pkt.stream_index,
1008
                    st->cur_pkt.pts,
1009
                    st->cur_pkt.dts,
1010
                    st->cur_pkt.size);
1011
//                av_free_packet(&st->cur_pkt);
1012
//                return -1;
1013
            }
1014

    
1015
            if(s->debug & FF_FDEBUG_TS)
1016
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
1017
                    st->cur_pkt.stream_index,
1018
                    st->cur_pkt.pts,
1019
                    st->cur_pkt.dts,
1020
                    st->cur_pkt.size,
1021
                    st->cur_pkt.flags);
1022

    
1023
            s->cur_st = st;
1024
            st->cur_ptr = st->cur_pkt.data;
1025
            st->cur_len = st->cur_pkt.size;
1026
            if (st->need_parsing && !st->parser) {
1027
                st->parser = av_parser_init(st->codec->codec_id);
1028
                if (!st->parser) {
1029
                    /* no parser available: just output the raw packets */
1030
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1031
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1032
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1033
                }
1034
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1035
                    st->parser->next_frame_offset=
1036
                    st->parser->cur_offset= st->cur_pkt.pos;
1037
                }
1038
            }
1039
        }
1040
    }
1041
    if(s->debug & FF_FDEBUG_TS)
1042
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1043
            pkt->stream_index,
1044
            pkt->pts,
1045
            pkt->dts,
1046
            pkt->size,
1047
            pkt->flags);
1048

    
1049
    return 0;
1050
}
1051

    
1052
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1053
{
1054
    AVPacketList *pktl;
1055
    int eof=0;
1056
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1057

    
1058
    for(;;){
1059
        pktl = s->packet_buffer;
1060
        if (pktl) {
1061
            AVPacket *next_pkt= &pktl->pkt;
1062

    
1063
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1064
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1065
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1066
                       && next_pkt->dts < pktl->pkt.dts
1067
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1068
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1069
                        next_pkt->pts= pktl->pkt.dts;
1070
                    }
1071
                    pktl= pktl->next;
1072
                }
1073
                pktl = s->packet_buffer;
1074
            }
1075

    
1076
            if(   next_pkt->pts != AV_NOPTS_VALUE
1077
               || next_pkt->dts == AV_NOPTS_VALUE
1078
               || !genpts || eof){
1079
                /* read packet from packet buffer, if there is data */
1080
                *pkt = *next_pkt;
1081
                s->packet_buffer = pktl->next;
1082
                av_free(pktl);
1083
                return 0;
1084
            }
1085
        }
1086
        if(genpts){
1087
            int ret= av_read_frame_internal(s, pkt);
1088
            if(ret<0){
1089
                if(pktl && ret != AVERROR(EAGAIN)){
1090
                    eof=1;
1091
                    continue;
1092
                }else
1093
                    return ret;
1094
            }
1095

    
1096
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1097
                                           &s->packet_buffer_end)) < 0)
1098
                return AVERROR(ENOMEM);
1099
        }else{
1100
            assert(!s->packet_buffer);
1101
            return av_read_frame_internal(s, pkt);
1102
        }
1103
    }
1104
}
1105

    
1106
/* XXX: suppress the packet queue */
1107
static void flush_packet_queue(AVFormatContext *s)
1108
{
1109
    AVPacketList *pktl;
1110

    
1111
    for(;;) {
1112
        pktl = s->packet_buffer;
1113
        if (!pktl)
1114
            break;
1115
        s->packet_buffer = pktl->next;
1116
        av_free_packet(&pktl->pkt);
1117
        av_free(pktl);
1118
    }
1119
    while(s->raw_packet_buffer){
1120
        pktl = s->raw_packet_buffer;
1121
        s->raw_packet_buffer = pktl->next;
1122
        av_free_packet(&pktl->pkt);
1123
        av_free(pktl);
1124
    }
1125
    s->packet_buffer_end=
1126
    s->raw_packet_buffer_end= NULL;
1127
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1128
}
1129

    
1130
/*******************************************************/
1131
/* seek support */
1132

    
1133
int av_find_default_stream_index(AVFormatContext *s)
1134
{
1135
    int first_audio_index = -1;
1136
    int i;
1137
    AVStream *st;
1138

    
1139
    if (s->nb_streams <= 0)
1140
        return -1;
1141
    for(i = 0; i < s->nb_streams; i++) {
1142
        st = s->streams[i];
1143
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1144
            return i;
1145
        }
1146
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1147
            first_audio_index = i;
1148
    }
1149
    return first_audio_index >= 0 ? first_audio_index : 0;
1150
}
1151

    
1152
/**
1153
 * Flush the frame reader.
1154
 */
1155
void av_read_frame_flush(AVFormatContext *s)
1156
{
1157
    AVStream *st;
1158
    int i;
1159

    
1160
    flush_packet_queue(s);
1161

    
1162
    s->cur_st = NULL;
1163

    
1164
    /* for each stream, reset read state */
1165
    for(i = 0; i < s->nb_streams; i++) {
1166
        st = s->streams[i];
1167

    
1168
        if (st->parser) {
1169
            av_parser_close(st->parser);
1170
            st->parser = NULL;
1171
            av_free_packet(&st->cur_pkt);
1172
        }
1173
        st->last_IP_pts = AV_NOPTS_VALUE;
1174
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1175
        st->reference_dts = AV_NOPTS_VALUE;
1176
        /* fail safe */
1177
        st->cur_ptr = NULL;
1178
        st->cur_len = 0;
1179

    
1180
        st->probe_packets = MAX_PROBE_PACKETS;
1181
    }
1182
}
1183

    
1184
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1185
    int i;
1186

    
1187
    for(i = 0; i < s->nb_streams; i++) {
1188
        AVStream *st = s->streams[i];
1189

    
1190
        st->cur_dts = av_rescale(timestamp,
1191
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1192
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1193
    }
1194
}
1195

    
1196
void ff_reduce_index(AVFormatContext *s, int stream_index)
1197
{
1198
    AVStream *st= s->streams[stream_index];
1199
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1200

    
1201
    if((unsigned)st->nb_index_entries >= max_entries){
1202
        int i;
1203
        for(i=0; 2*i<st->nb_index_entries; i++)
1204
            st->index_entries[i]= st->index_entries[2*i];
1205
        st->nb_index_entries= i;
1206
    }
1207
}
1208

    
1209
int av_add_index_entry(AVStream *st,
1210
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1211
{
1212
    AVIndexEntry *entries, *ie;
1213
    int index;
1214

    
1215
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1216
        return -1;
1217

    
1218
    entries = av_fast_realloc(st->index_entries,
1219
                              &st->index_entries_allocated_size,
1220
                              (st->nb_index_entries + 1) *
1221
                              sizeof(AVIndexEntry));
1222
    if(!entries)
1223
        return -1;
1224

    
1225
    st->index_entries= entries;
1226

    
1227
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1228

    
1229
    if(index<0){
1230
        index= st->nb_index_entries++;
1231
        ie= &entries[index];
1232
        assert(index==0 || ie[-1].timestamp < timestamp);
1233
    }else{
1234
        ie= &entries[index];
1235
        if(ie->timestamp != timestamp){
1236
            if(ie->timestamp <= timestamp)
1237
                return -1;
1238
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1239
            st->nb_index_entries++;
1240
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1241
            distance= ie->min_distance;
1242
    }
1243

    
1244
    ie->pos = pos;
1245
    ie->timestamp = timestamp;
1246
    ie->min_distance= distance;
1247
    ie->size= size;
1248
    ie->flags = flags;
1249

    
1250
    return index;
1251
}
1252

    
1253
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1254
                              int flags)
1255
{
1256
    AVIndexEntry *entries= st->index_entries;
1257
    int nb_entries= st->nb_index_entries;
1258
    int a, b, m;
1259
    int64_t timestamp;
1260

    
1261
    a = - 1;
1262
    b = nb_entries;
1263

    
1264
    while (b - a > 1) {
1265
        m = (a + b) >> 1;
1266
        timestamp = entries[m].timestamp;
1267
        if(timestamp >= wanted_timestamp)
1268
            b = m;
1269
        if(timestamp <= wanted_timestamp)
1270
            a = m;
1271
    }
1272
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1273

    
1274
    if(!(flags & AVSEEK_FLAG_ANY)){
1275
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1276
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1277
        }
1278
    }
1279

    
1280
    if(m == nb_entries)
1281
        return -1;
1282
    return  m;
1283
}
1284

    
1285
#define DEBUG_SEEK
1286

    
1287
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1288
    AVInputFormat *avif= s->iformat;
1289
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1290
    int64_t ts_min, ts_max, ts;
1291
    int index;
1292
    AVStream *st;
1293

    
1294
    if (stream_index < 0)
1295
        return -1;
1296

    
1297
#ifdef DEBUG_SEEK
1298
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1299
#endif
1300

    
1301
    ts_max=
1302
    ts_min= AV_NOPTS_VALUE;
1303
    pos_limit= -1; //gcc falsely says it may be uninitialized
1304

    
1305
    st= s->streams[stream_index];
1306
    if(st->index_entries){
1307
        AVIndexEntry *e;
1308

    
1309
        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()
1310
        index= FFMAX(index, 0);
1311
        e= &st->index_entries[index];
1312

    
1313
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1314
            pos_min= e->pos;
1315
            ts_min= e->timestamp;
1316
#ifdef DEBUG_SEEK
1317
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1318
                   pos_min,ts_min);
1319
#endif
1320
        }else{
1321
            assert(index==0);
1322
        }
1323

    
1324
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1325
        assert(index < st->nb_index_entries);
1326
        if(index >= 0){
1327
            e= &st->index_entries[index];
1328
            assert(e->timestamp >= target_ts);
1329
            pos_max= e->pos;
1330
            ts_max= e->timestamp;
1331
            pos_limit= pos_max - e->min_distance;
1332
#ifdef DEBUG_SEEK
1333
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1334
                   pos_max,pos_limit, ts_max);
1335
#endif
1336
        }
1337
    }
1338

    
1339
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1340
    if(pos<0)
1341
        return -1;
1342

    
1343
    /* do the seek */
1344
    url_fseek(s->pb, pos, SEEK_SET);
1345

    
1346
    av_update_cur_dts(s, st, ts);
1347

    
1348
    return 0;
1349
}
1350

    
1351
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 )){
1352
    int64_t pos, ts;
1353
    int64_t start_pos, filesize;
1354
    int no_change;
1355

    
1356
#ifdef DEBUG_SEEK
1357
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1358
#endif
1359

    
1360
    if(ts_min == AV_NOPTS_VALUE){
1361
        pos_min = s->data_offset;
1362
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1363
        if (ts_min == AV_NOPTS_VALUE)
1364
            return -1;
1365
    }
1366

    
1367
    if(ts_max == AV_NOPTS_VALUE){
1368
        int step= 1024;
1369
        filesize = url_fsize(s->pb);
1370
        pos_max = filesize - 1;
1371
        do{
1372
            pos_max -= step;
1373
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1374
            step += step;
1375
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1376
        if (ts_max == AV_NOPTS_VALUE)
1377
            return -1;
1378

    
1379
        for(;;){
1380
            int64_t tmp_pos= pos_max + 1;
1381
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1382
            if(tmp_ts == AV_NOPTS_VALUE)
1383
                break;
1384
            ts_max= tmp_ts;
1385
            pos_max= tmp_pos;
1386
            if(tmp_pos >= filesize)
1387
                break;
1388
        }
1389
        pos_limit= pos_max;
1390
    }
1391

    
1392
    if(ts_min > ts_max){
1393
        return -1;
1394
    }else if(ts_min == ts_max){
1395
        pos_limit= pos_min;
1396
    }
1397

    
1398
    no_change=0;
1399
    while (pos_min < pos_limit) {
1400
#ifdef DEBUG_SEEK
1401
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1402
               pos_min, pos_max,
1403
               ts_min, ts_max);
1404
#endif
1405
        assert(pos_limit <= pos_max);
1406

    
1407
        if(no_change==0){
1408
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1409
            // interpolate position (better than dichotomy)
1410
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1411
                + pos_min - approximate_keyframe_distance;
1412
        }else if(no_change==1){
1413
            // bisection, if interpolation failed to change min or max pos last time
1414
            pos = (pos_min + pos_limit)>>1;
1415
        }else{
1416
            /* linear search if bisection failed, can only happen if there
1417
               are very few or no keyframes between min/max */
1418
            pos=pos_min;
1419
        }
1420
        if(pos <= pos_min)
1421
            pos= pos_min + 1;
1422
        else if(pos > pos_limit)
1423
            pos= pos_limit;
1424
        start_pos= pos;
1425

    
1426
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1427
        if(pos == pos_max)
1428
            no_change++;
1429
        else
1430
            no_change=0;
1431
#ifdef DEBUG_SEEK
1432
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1433
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1434
               start_pos, no_change);
1435
#endif
1436
        if(ts == AV_NOPTS_VALUE){
1437
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1438
            return -1;
1439
        }
1440
        assert(ts != AV_NOPTS_VALUE);
1441
        if (target_ts <= ts) {
1442
            pos_limit = start_pos - 1;
1443
            pos_max = pos;
1444
            ts_max = ts;
1445
        }
1446
        if (target_ts >= ts) {
1447
            pos_min = pos;
1448
            ts_min = ts;
1449
        }
1450
    }
1451

    
1452
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1453
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1454
#ifdef DEBUG_SEEK
1455
    pos_min = pos;
1456
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1457
    pos_min++;
1458
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1459
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1460
           pos, ts_min, target_ts, ts_max);
1461
#endif
1462
    *ts_ret= ts;
1463
    return pos;
1464
}
1465

    
1466
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1467
    int64_t pos_min, pos_max;
1468
#if 0
1469
    AVStream *st;
1470

1471
    if (stream_index < 0)
1472
        return -1;
1473

1474
    st= s->streams[stream_index];
1475
#endif
1476

    
1477
    pos_min = s->data_offset;
1478
    pos_max = url_fsize(s->pb) - 1;
1479

    
1480
    if     (pos < pos_min) pos= pos_min;
1481
    else if(pos > pos_max) pos= pos_max;
1482

    
1483
    url_fseek(s->pb, pos, SEEK_SET);
1484

    
1485
#if 0
1486
    av_update_cur_dts(s, st, ts);
1487
#endif
1488
    return 0;
1489
}
1490

    
1491
static int av_seek_frame_generic(AVFormatContext *s,
1492
                                 int stream_index, int64_t timestamp, int flags)
1493
{
1494
    int index, ret;
1495
    AVStream *st;
1496
    AVIndexEntry *ie;
1497

    
1498
    st = s->streams[stream_index];
1499

    
1500
    index = av_index_search_timestamp(st, timestamp, flags);
1501

    
1502
    if(index < 0 || index==st->nb_index_entries-1){
1503
        int i;
1504
        AVPacket pkt;
1505

    
1506
        if(st->nb_index_entries){
1507
            assert(st->index_entries);
1508
            ie= &st->index_entries[st->nb_index_entries-1];
1509
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1510
                return ret;
1511
            av_update_cur_dts(s, st, ie->timestamp);
1512
        }else{
1513
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1514
                return ret;
1515
        }
1516
        for(i=0;; i++) {
1517
            int ret;
1518
            do{
1519
                ret = av_read_frame(s, &pkt);
1520
            }while(ret == AVERROR(EAGAIN));
1521
            if(ret<0)
1522
                break;
1523
            av_free_packet(&pkt);
1524
            if(stream_index == pkt.stream_index){
1525
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1526
                    break;
1527
            }
1528
        }
1529
        index = av_index_search_timestamp(st, timestamp, flags);
1530
    }
1531
    if (index < 0)
1532
        return -1;
1533

    
1534
    av_read_frame_flush(s);
1535
    if (s->iformat->read_seek){
1536
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1537
            return 0;
1538
    }
1539
    ie = &st->index_entries[index];
1540
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1541
        return ret;
1542
    av_update_cur_dts(s, st, ie->timestamp);
1543

    
1544
    return 0;
1545
}
1546

    
1547
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1548
{
1549
    int ret;
1550
    AVStream *st;
1551

    
1552
    av_read_frame_flush(s);
1553

    
1554
    if(flags & AVSEEK_FLAG_BYTE)
1555
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1556

    
1557
    if(stream_index < 0){
1558
        stream_index= av_find_default_stream_index(s);
1559
        if(stream_index < 0)
1560
            return -1;
1561

    
1562
        st= s->streams[stream_index];
1563
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1564
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1565
    }
1566

    
1567
    /* first, we try the format specific seek */
1568
    if (s->iformat->read_seek)
1569
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1570
    else
1571
        ret = -1;
1572
    if (ret >= 0) {
1573
        return 0;
1574
    }
1575

    
1576
    if(s->iformat->read_timestamp)
1577
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1578
    else
1579
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1580
}
1581

    
1582
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1583
{
1584
    if(min_ts > ts || max_ts < ts)
1585
        return -1;
1586

    
1587
    av_read_frame_flush(s);
1588

    
1589
    if (s->iformat->read_seek2)
1590
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1591

    
1592
    if(s->iformat->read_timestamp){
1593
        //try to seek via read_timestamp()
1594
    }
1595

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

    
1601
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1602
}
1603

    
1604
/*******************************************************/
1605

    
1606
/**
1607
 * Returns TRUE if the stream has accurate duration in any stream.
1608
 *
1609
 * @return TRUE if the stream has accurate duration for at least one component.
1610
 */
1611
static int av_has_duration(AVFormatContext *ic)
1612
{
1613
    int i;
1614
    AVStream *st;
1615

    
1616
    for(i = 0;i < ic->nb_streams; i++) {
1617
        st = ic->streams[i];
1618
        if (st->duration != AV_NOPTS_VALUE)
1619
            return 1;
1620
    }
1621
    return 0;
1622
}
1623

    
1624
/**
1625
 * Estimate the stream timings from the one of each components.
1626
 *
1627
 * Also computes the global bitrate if possible.
1628
 */
1629
static void av_update_stream_timings(AVFormatContext *ic)
1630
{
1631
    int64_t start_time, start_time1, end_time, end_time1;
1632
    int64_t duration, duration1;
1633
    int i;
1634
    AVStream *st;
1635

    
1636
    start_time = INT64_MAX;
1637
    end_time = INT64_MIN;
1638
    duration = INT64_MIN;
1639
    for(i = 0;i < ic->nb_streams; i++) {
1640
        st = ic->streams[i];
1641
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1642
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1643
            if (start_time1 < start_time)
1644
                start_time = start_time1;
1645
            if (st->duration != AV_NOPTS_VALUE) {
1646
                end_time1 = start_time1
1647
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1648
                if (end_time1 > end_time)
1649
                    end_time = end_time1;
1650
            }
1651
        }
1652
        if (st->duration != AV_NOPTS_VALUE) {
1653
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1654
            if (duration1 > duration)
1655
                duration = duration1;
1656
        }
1657
    }
1658
    if (start_time != INT64_MAX) {
1659
        ic->start_time = start_time;
1660
        if (end_time != INT64_MIN) {
1661
            if (end_time - start_time > duration)
1662
                duration = end_time - start_time;
1663
        }
1664
    }
1665
    if (duration != INT64_MIN) {
1666
        ic->duration = duration;
1667
        if (ic->file_size > 0) {
1668
            /* compute the bitrate */
1669
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1670
                (double)ic->duration;
1671
        }
1672
    }
1673
}
1674

    
1675
static void fill_all_stream_timings(AVFormatContext *ic)
1676
{
1677
    int i;
1678
    AVStream *st;
1679

    
1680
    av_update_stream_timings(ic);
1681
    for(i = 0;i < ic->nb_streams; i++) {
1682
        st = ic->streams[i];
1683
        if (st->start_time == AV_NOPTS_VALUE) {
1684
            if(ic->start_time != AV_NOPTS_VALUE)
1685
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1686
            if(ic->duration != AV_NOPTS_VALUE)
1687
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1688
        }
1689
    }
1690
}
1691

    
1692
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1693
{
1694
    int64_t filesize, duration;
1695
    int bit_rate, i;
1696
    AVStream *st;
1697

    
1698
    /* if bit_rate is already set, we believe it */
1699
    if (ic->bit_rate == 0) {
1700
        bit_rate = 0;
1701
        for(i=0;i<ic->nb_streams;i++) {
1702
            st = ic->streams[i];
1703
            bit_rate += st->codec->bit_rate;
1704
        }
1705
        ic->bit_rate = bit_rate;
1706
    }
1707

    
1708
    /* if duration is already set, we believe it */
1709
    if (ic->duration == AV_NOPTS_VALUE &&
1710
        ic->bit_rate != 0 &&
1711
        ic->file_size != 0)  {
1712
        filesize = ic->file_size;
1713
        if (filesize > 0) {
1714
            for(i = 0; i < ic->nb_streams; i++) {
1715
                st = ic->streams[i];
1716
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1717
                if (st->duration == AV_NOPTS_VALUE)
1718
                    st->duration = duration;
1719
            }
1720
        }
1721
    }
1722
}
1723

    
1724
#define DURATION_MAX_READ_SIZE 250000
1725

    
1726
/* only usable for MPEG-PS streams */
1727
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1728
{
1729
    AVPacket pkt1, *pkt = &pkt1;
1730
    AVStream *st;
1731
    int read_size, i, ret;
1732
    int64_t end_time;
1733
    int64_t filesize, offset, duration;
1734

    
1735
    ic->cur_st = NULL;
1736

    
1737
    /* flush packet queue */
1738
    flush_packet_queue(ic);
1739

    
1740
    for(i=0;i<ic->nb_streams;i++) {
1741
        st = ic->streams[i];
1742
        if (st->parser) {
1743
            av_parser_close(st->parser);
1744
            st->parser= NULL;
1745
            av_free_packet(&st->cur_pkt);
1746
        }
1747
    }
1748

    
1749
    /* we read the first packets to get the first PTS (not fully
1750
       accurate, but it is enough now) */
1751
    url_fseek(ic->pb, 0, SEEK_SET);
1752
    read_size = 0;
1753
    for(;;) {
1754
        if (read_size >= DURATION_MAX_READ_SIZE)
1755
            break;
1756
        /* if all info is available, we can stop */
1757
        for(i = 0;i < ic->nb_streams; i++) {
1758
            st = ic->streams[i];
1759
            if (st->start_time == AV_NOPTS_VALUE)
1760
                break;
1761
        }
1762
        if (i == ic->nb_streams)
1763
            break;
1764

    
1765
        do{
1766
            ret = av_read_packet(ic, pkt);
1767
        }while(ret == AVERROR(EAGAIN));
1768
        if (ret != 0)
1769
            break;
1770
        read_size += pkt->size;
1771
        st = ic->streams[pkt->stream_index];
1772
        if (pkt->pts != AV_NOPTS_VALUE) {
1773
            if (st->start_time == AV_NOPTS_VALUE)
1774
                st->start_time = pkt->pts;
1775
        }
1776
        av_free_packet(pkt);
1777
    }
1778

    
1779
    /* estimate the end time (duration) */
1780
    /* XXX: may need to support wrapping */
1781
    filesize = ic->file_size;
1782
    offset = filesize - DURATION_MAX_READ_SIZE;
1783
    if (offset < 0)
1784
        offset = 0;
1785

    
1786
    url_fseek(ic->pb, offset, SEEK_SET);
1787
    read_size = 0;
1788
    for(;;) {
1789
        if (read_size >= DURATION_MAX_READ_SIZE)
1790
            break;
1791

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

    
1812
    fill_all_stream_timings(ic);
1813

    
1814
    url_fseek(ic->pb, old_offset, SEEK_SET);
1815
    for(i=0; i<ic->nb_streams; i++){
1816
        st= ic->streams[i];
1817
        st->cur_dts= st->first_dts;
1818
        st->last_IP_pts = AV_NOPTS_VALUE;
1819
    }
1820
}
1821

    
1822
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1823
{
1824
    int64_t file_size;
1825

    
1826
    /* get the file size, if possible */
1827
    if (ic->iformat->flags & AVFMT_NOFILE) {
1828
        file_size = 0;
1829
    } else {
1830
        file_size = url_fsize(ic->pb);
1831
        if (file_size < 0)
1832
            file_size = 0;
1833
    }
1834
    ic->file_size = file_size;
1835

    
1836
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1837
         !strcmp(ic->iformat->name, "mpegts")) &&
1838
        file_size && !url_is_streamed(ic->pb)) {
1839
        /* get accurate estimate from the PTSes */
1840
        av_estimate_timings_from_pts(ic, old_offset);
1841
    } else if (av_has_duration(ic)) {
1842
        /* at least one component has timings - we use them for all
1843
           the components */
1844
        fill_all_stream_timings(ic);
1845
    } else {
1846
        /* less precise: use bitrate info */
1847
        av_estimate_timings_from_bit_rate(ic);
1848
    }
1849
    av_update_stream_timings(ic);
1850

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

    
1869
static int has_codec_parameters(AVCodecContext *enc)
1870
{
1871
    int val;
1872
    switch(enc->codec_type) {
1873
    case CODEC_TYPE_AUDIO:
1874
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1875
        if(!enc->frame_size &&
1876
           (enc->codec_id == CODEC_ID_VORBIS ||
1877
            enc->codec_id == CODEC_ID_AAC ||
1878
            enc->codec_id == CODEC_ID_SPEEX))
1879
            return 0;
1880
        break;
1881
    case CODEC_TYPE_VIDEO:
1882
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1883
        break;
1884
    default:
1885
        val = 1;
1886
        break;
1887
    }
1888
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1889
}
1890

    
1891
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1892
{
1893
    int16_t *samples;
1894
    AVCodec *codec;
1895
    int got_picture, data_size, ret=0;
1896
    AVFrame picture;
1897

    
1898
    if(!st->codec->codec){
1899
        codec = avcodec_find_decoder(st->codec->codec_id);
1900
        if (!codec)
1901
            return -1;
1902
        ret = avcodec_open(st->codec, codec);
1903
        if (ret < 0)
1904
            return ret;
1905
    }
1906

    
1907
    if(!has_codec_parameters(st->codec)){
1908
        switch(st->codec->codec_type) {
1909
        case CODEC_TYPE_VIDEO:
1910
            avcodec_get_frame_defaults(&picture);
1911
            ret = avcodec_decode_video2(st->codec, &picture,
1912
                                        &got_picture, avpkt);
1913
            break;
1914
        case CODEC_TYPE_AUDIO:
1915
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1916
            samples = av_malloc(data_size);
1917
            if (!samples)
1918
                goto fail;
1919
            ret = avcodec_decode_audio3(st->codec, samples,
1920
                                        &data_size, avpkt);
1921
            av_free(samples);
1922
            break;
1923
        default:
1924
            break;
1925
        }
1926
    }
1927
 fail:
1928
    return ret;
1929
}
1930

    
1931
unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
1932
{
1933
    while (tags->id != CODEC_ID_NONE) {
1934
        if (tags->id == id)
1935
            return tags->tag;
1936
        tags++;
1937
    }
1938
    return 0;
1939
}
1940

    
1941
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
1942
{
1943
    int i;
1944
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1945
        if(tag == tags[i].tag)
1946
            return tags[i].id;
1947
    }
1948
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1949
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1950
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1951
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1952
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1953
            return tags[i].id;
1954
    }
1955
    return CODEC_ID_NONE;
1956
}
1957

    
1958
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1959
{
1960
    int i;
1961
    for(i=0; tags && tags[i]; i++){
1962
        int tag= ff_codec_get_tag(tags[i], id);
1963
        if(tag) return tag;
1964
    }
1965
    return 0;
1966
}
1967

    
1968
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1969
{
1970
    int i;
1971
    for(i=0; tags && tags[i]; i++){
1972
        enum CodecID id= ff_codec_get_id(tags[i], tag);
1973
        if(id!=CODEC_ID_NONE) return id;
1974
    }
1975
    return CODEC_ID_NONE;
1976
}
1977

    
1978
static void compute_chapters_end(AVFormatContext *s)
1979
{
1980
    unsigned int i;
1981

    
1982
    for (i=0; i+1<s->nb_chapters; i++)
1983
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1984
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1985
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1986
            s->chapters[i]->end = s->chapters[i+1]->start;
1987
        }
1988

    
1989
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1990
        assert(s->start_time != AV_NOPTS_VALUE);
1991
        assert(s->duration > 0);
1992
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1993
                                           AV_TIME_BASE_Q,
1994
                                           s->chapters[i]->time_base);
1995
    }
1996
}
1997

    
1998
#define MAX_STD_TIMEBASES (60*12+5)
1999
static int get_std_framerate(int i){
2000
    if(i<60*12) return i*1001;
2001
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2002
}
2003

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

    
2024
int av_find_stream_info(AVFormatContext *ic)
2025
{
2026
    int i, count, ret, read_size, j;
2027
    AVStream *st;
2028
    AVPacket pkt1, *pkt;
2029
    int64_t last_dts[MAX_STREAMS];
2030
    int64_t duration_gcd[MAX_STREAMS]={0};
2031
    int duration_count[MAX_STREAMS]={0};
2032
    double (*duration_error)[MAX_STD_TIMEBASES];
2033
    int64_t old_offset = url_ftell(ic->pb);
2034
    int64_t codec_info_duration[MAX_STREAMS]={0};
2035
    int codec_info_nb_frames[MAX_STREAMS]={0};
2036

    
2037
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2038
    if (!duration_error) return AVERROR(ENOMEM);
2039

    
2040
    for(i=0;i<ic->nb_streams;i++) {
2041
        st = ic->streams[i];
2042
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2043
/*            if(!st->time_base.num)
2044
                st->time_base= */
2045
            if(!st->codec->time_base.num)
2046
                st->codec->time_base= st->time_base;
2047
        }
2048
        //only for the split stuff
2049
        if (!st->parser) {
2050
            st->parser = av_parser_init(st->codec->codec_id);
2051
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2052
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2053
            }
2054
        }
2055
    }
2056

    
2057
    for(i=0;i<MAX_STREAMS;i++){
2058
        last_dts[i]= AV_NOPTS_VALUE;
2059
    }
2060

    
2061
    count = 0;
2062
    read_size = 0;
2063
    for(;;) {
2064
        if(url_interrupt_cb()){
2065
            ret= AVERROR(EINTR);
2066
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2067
            break;
2068
        }
2069

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

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

    
2123
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2124
        if(av_dup_packet(pkt) < 0) {
2125
            av_free(duration_error);
2126
            return AVERROR(ENOMEM);
2127
        }
2128

    
2129
        read_size += pkt->size;
2130

    
2131
        st = ic->streams[pkt->stream_index];
2132
        if(codec_info_nb_frames[st->index]>1) {
2133
            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){
2134
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2135
                break;
2136
            }
2137
            codec_info_duration[st->index] += pkt->duration;
2138
        }
2139
        if (pkt->duration != 0)
2140
            codec_info_nb_frames[st->index]++;
2141

    
2142
        {
2143
            int index= pkt->stream_index;
2144
            int64_t last= last_dts[index];
2145
            int64_t duration= pkt->dts - last;
2146

    
2147
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2148
                double dur= duration * av_q2d(st->time_base);
2149

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

    
2178
        /* if still no information, we try to open the codec and to
2179
           decompress the frame. We try to avoid that in most cases as
2180
           it takes longer and uses more memory. For MPEG-4, we need to
2181
           decompress for QuickTime. */
2182
        if (!has_codec_parameters(st->codec) /*&&
2183
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2184
             st->codec->codec_id == CODEC_ID_H264 ||
2185
             st->codec->codec_id == CODEC_ID_H263 ||
2186
             st->codec->codec_id == CODEC_ID_H261 ||
2187
             st->codec->codec_id == CODEC_ID_VORBIS ||
2188
             st->codec->codec_id == CODEC_ID_MJPEG ||
2189
             st->codec->codec_id == CODEC_ID_PNG ||
2190
             st->codec->codec_id == CODEC_ID_PAM ||
2191
             st->codec->codec_id == CODEC_ID_PGM ||
2192
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2193
             st->codec->codec_id == CODEC_ID_PBM ||
2194
             st->codec->codec_id == CODEC_ID_PPM ||
2195
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2196
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2197
            try_decode_frame(st, pkt);
2198

    
2199
        count++;
2200
    }
2201

    
2202
    // close codecs which were opened in try_decode_frame()
2203
    for(i=0;i<ic->nb_streams;i++) {
2204
        st = ic->streams[i];
2205
        if(st->codec->codec)
2206
            avcodec_close(st->codec);
2207
    }
2208
    for(i=0;i<ic->nb_streams;i++) {
2209
        st = ic->streams[i];
2210
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2211
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2212
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2213

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

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

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

    
2257
    av_estimate_timings(ic, old_offset);
2258

    
2259
    compute_chapters_end(ic);
2260

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

    
2286
    av_free(duration_error);
2287

    
2288
    return ret;
2289
}
2290

    
2291
/*******************************************************/
2292

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

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

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

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

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

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

    
2372
    if (s->nb_streams >= MAX_STREAMS)
2373
        return NULL;
2374

    
2375
    st = av_mallocz(sizeof(AVStream));
2376
    if (!st)
2377
        return NULL;
2378

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

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

    
2403
    st->sample_aspect_ratio = (AVRational){0,1};
2404

    
2405
    s->streams[s->nb_streams++] = st;
2406
    return st;
2407
}
2408

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

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

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

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

    
2431
    return program;
2432
}
2433

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

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

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

    
2458
    return chapter;
2459
}
2460

    
2461
/************************************************************/
2462
/* output media file */
2463

    
2464
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2465
{
2466
    int ret;
2467

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

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

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

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

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

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

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

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

    
2540
#if LIBAVFORMAT_VERSION_MAJOR < 53
2541
    ff_metadata_mux_compat(s);
2542
#endif
2543

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

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

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

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

    
2579
//    av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2580

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

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

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

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

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

    
2610
        pkt->dts= st->pts_buffer[0];
2611
    }
2612

    
2613
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2614
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", 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(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2619
        return -1;
2620
    }
2621

    
2622
//    av_log(NULL, 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->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(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
    for(i=0; i<ac->nb_programs; i++){
2827
        if(ac->programs[i]->id != progid)
2828
            continue;
2829
        program = ac->programs[i];
2830
        for(j=0; j<program->nb_stream_indexes; j++)
2831
            if(program->stream_index[j] == idx)
2832
                return;
2833

    
2834
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2835
        if(!tmp)
2836
            return;
2837
        program->stream_index = tmp;
2838
        program->stream_index[program->nb_stream_indexes++] = idx;
2839
        return;
2840
    }
2841
}
2842

    
2843
static void print_fps(double d, const char *postfix){
2844
    uint64_t v= lrintf(d*100);
2845
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2846
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2847
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2848
}
2849

    
2850
/* "user interface" functions */
2851
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2852
{
2853
    char buf[256];
2854
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2855
    AVStream *st = ic->streams[i];
2856
    int g = av_gcd(st->time_base.num, st->time_base.den);
2857
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2858
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2859
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2860
    /* the pid is an important information, so we display it */
2861
    /* XXX: add a generic system */
2862
    if (flags & AVFMT_SHOW_IDS)
2863
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2864
    if (lang)
2865
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2866
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2867
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2868
    if (st->sample_aspect_ratio.num && // default
2869
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2870
        AVRational display_aspect_ratio;
2871
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2872
                  st->codec->width*st->sample_aspect_ratio.num,
2873
                  st->codec->height*st->sample_aspect_ratio.den,
2874
                  1024*1024);
2875
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2876
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2877
                 display_aspect_ratio.num, display_aspect_ratio.den);
2878
    }
2879
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2880
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2881
            print_fps(av_q2d(st->r_frame_rate), "tbr");
2882
        if(st->time_base.den && st->time_base.num)
2883
            print_fps(1/av_q2d(st->time_base), "tbn");
2884
        if(st->codec->time_base.den && st->codec->time_base.num)
2885
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
2886
    }
2887
    av_log(NULL, AV_LOG_INFO, "\n");
2888
}
2889

    
2890
void dump_format(AVFormatContext *ic,
2891
                 int index,
2892
                 const char *url,
2893
                 int is_output)
2894
{
2895
    int i;
2896

    
2897
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2898
            is_output ? "Output" : "Input",
2899
            index,
2900
            is_output ? ic->oformat->name : ic->iformat->name,
2901
            is_output ? "to" : "from", url);
2902
    if (!is_output) {
2903
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2904
        if (ic->duration != AV_NOPTS_VALUE) {
2905
            int hours, mins, secs, us;
2906
            secs = ic->duration / AV_TIME_BASE;
2907
            us = ic->duration % AV_TIME_BASE;
2908
            mins = secs / 60;
2909
            secs %= 60;
2910
            hours = mins / 60;
2911
            mins %= 60;
2912
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2913
                   (100 * us) / AV_TIME_BASE);
2914
        } else {
2915
            av_log(NULL, AV_LOG_INFO, "N/A");
2916
        }
2917
        if (ic->start_time != AV_NOPTS_VALUE) {
2918
            int secs, us;
2919
            av_log(NULL, AV_LOG_INFO, ", start: ");
2920
            secs = ic->start_time / AV_TIME_BASE;
2921
            us = ic->start_time % AV_TIME_BASE;
2922
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2923
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2924
        }
2925
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2926
        if (ic->bit_rate) {
2927
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2928
        } else {
2929
            av_log(NULL, AV_LOG_INFO, "N/A");
2930
        }
2931
        av_log(NULL, AV_LOG_INFO, "\n");
2932
    }
2933
    if(ic->nb_programs) {
2934
        int j, k;
2935
        for(j=0; j<ic->nb_programs; j++) {
2936
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
2937
                                                  "name", NULL, 0);
2938
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2939
                   name ? name->value : "");
2940
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2941
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2942
         }
2943
    } else
2944
    for(i=0;i<ic->nb_streams;i++)
2945
        dump_stream_format(ic, i, index, is_output);
2946
    if (ic->metadata) {
2947
        AVMetadataTag *tag=NULL;
2948
        av_log(NULL, AV_LOG_INFO, "  Metadata\n");
2949
        while((tag=av_metadata_get(ic->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2950
            av_log(NULL, AV_LOG_INFO, "    %-16s: %s\n", tag->key, tag->value);
2951
        }
2952
    }
2953

    
2954
}
2955

    
2956
#if LIBAVFORMAT_VERSION_MAJOR < 53
2957
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2958
{
2959
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2960
}
2961

    
2962
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2963
{
2964
    AVRational frame_rate;
2965
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2966
    *frame_rate_num= frame_rate.num;
2967
    *frame_rate_den= frame_rate.den;
2968
    return ret;
2969
}
2970
#endif
2971

    
2972
int64_t av_gettime(void)
2973
{
2974
    struct timeval tv;
2975
    gettimeofday(&tv,NULL);
2976
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2977
}
2978

    
2979
int64_t parse_date(const char *datestr, int duration)
2980
{
2981
    const char *p;
2982
    int64_t t;
2983
    struct tm dt;
2984
    int i;
2985
    static const char * const date_fmt[] = {
2986
        "%Y-%m-%d",
2987
        "%Y%m%d",
2988
    };
2989
    static const char * const time_fmt[] = {
2990
        "%H:%M:%S",
2991
        "%H%M%S",
2992
    };
2993
    const char *q;
2994
    int is_utc, len;
2995
    char lastch;
2996
    int negative = 0;
2997

    
2998
#undef time
2999
    time_t now = time(0);
3000

    
3001
    len = strlen(datestr);
3002
    if (len > 0)
3003
        lastch = datestr[len - 1];
3004
    else
3005
        lastch = '\0';
3006
    is_utc = (lastch == 'z' || lastch == 'Z');
3007

    
3008
    memset(&dt, 0, sizeof(dt));
3009

    
3010
    p = datestr;
3011
    q = NULL;
3012
    if (!duration) {
3013
        if (!strncasecmp(datestr, "now", len))
3014
            return (int64_t) now * 1000000;
3015

    
3016
        /* parse the year-month-day part */
3017
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3018
            q = small_strptime(p, date_fmt[i], &dt);
3019
            if (q) {
3020
                break;
3021
            }
3022
        }
3023

    
3024
        /* if the year-month-day part is missing, then take the
3025
         * current year-month-day time */
3026
        if (!q) {
3027
            if (is_utc) {
3028
                dt = *gmtime(&now);
3029
            } else {
3030
                dt = *localtime(&now);
3031
            }
3032
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3033
        } else {
3034
            p = q;
3035
        }
3036

    
3037
        if (*p == 'T' || *p == 't' || *p == ' ')
3038
            p++;
3039

    
3040
        /* parse the hour-minute-second part */
3041
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3042
            q = small_strptime(p, time_fmt[i], &dt);
3043
            if (q) {
3044
                break;
3045
            }
3046
        }
3047
    } else {
3048
        /* parse datestr as a duration */
3049
        if (p[0] == '-') {
3050
            negative = 1;
3051
            ++p;
3052
        }
3053
        /* parse datestr as HH:MM:SS */
3054
        q = small_strptime(p, time_fmt[0], &dt);
3055
        if (!q) {
3056
            /* parse datestr as S+ */
3057
            dt.tm_sec = strtol(p, (char **)&q, 10);
3058
            if (q == p)
3059
                /* the parsing didn't succeed */
3060
                return INT64_MIN;
3061
            dt.tm_min = 0;
3062
            dt.tm_hour = 0;
3063
        }
3064
    }
3065

    
3066
    /* Now we have all the fields that we can get */
3067
    if (!q) {
3068
        return INT64_MIN;
3069
    }
3070

    
3071
    if (duration) {
3072
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3073
    } else {
3074
        dt.tm_isdst = -1;       /* unknown */
3075
        if (is_utc) {
3076
            t = mktimegm(&dt);
3077
        } else {
3078
            t = mktime(&dt);
3079
        }
3080
    }
3081

    
3082
    t *= 1000000;
3083

    
3084
    /* parse the .m... part */
3085
    if (*q == '.') {
3086
        int val, n;
3087
        q++;
3088
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3089
            if (!isdigit(*q))
3090
                break;
3091
            val += n * (*q - '0');
3092
        }
3093
        t += val;
3094
    }
3095
    return negative ? -t : t;
3096
}
3097

    
3098
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3099
{
3100
    const char *p;
3101
    char tag[128], *q;
3102

    
3103
    p = info;
3104
    if (*p == '?')
3105
        p++;
3106
    for(;;) {
3107
        q = tag;
3108
        while (*p != '\0' && *p != '=' && *p != '&') {
3109
            if ((q - tag) < sizeof(tag) - 1)
3110
                *q++ = *p;
3111
            p++;
3112
        }
3113
        *q = '\0';
3114
        q = arg;
3115
        if (*p == '=') {
3116
            p++;
3117
            while (*p != '&' && *p != '\0') {
3118
                if ((q - arg) < arg_size - 1) {
3119
                    if (*p == '+')
3120
                        *q++ = ' ';
3121
                    else
3122
                        *q++ = *p;
3123
                }
3124
                p++;
3125
            }
3126
            *q = '\0';
3127
        }
3128
        if (!strcmp(tag, tag1))
3129
            return 1;
3130
        if (*p != '&')
3131
            break;
3132
        p++;
3133
    }
3134
    return 0;
3135
}
3136

    
3137
int av_get_frame_filename(char *buf, int buf_size,
3138
                          const char *path, int number)
3139
{
3140
    const char *p;
3141
    char *q, buf1[20], c;
3142
    int nd, len, percentd_found;
3143

    
3144
    q = buf;
3145
    p = path;
3146
    percentd_found = 0;
3147
    for(;;) {
3148
        c = *p++;
3149
        if (c == '\0')
3150
            break;
3151
        if (c == '%') {
3152
            do {
3153
                nd = 0;
3154
                while (isdigit(*p)) {
3155
                    nd = nd * 10 + *p++ - '0';
3156
                }
3157
                c = *p++;
3158
            } while (isdigit(c));
3159

    
3160
            switch(c) {
3161
            case '%':
3162
                goto addchar;
3163
            case 'd':
3164
                if (percentd_found)
3165
                    goto fail;
3166
                percentd_found = 1;
3167
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3168
                len = strlen(buf1);
3169
                if ((q - buf + len) > buf_size - 1)
3170
                    goto fail;
3171
                memcpy(q, buf1, len);
3172
                q += len;
3173
                break;
3174
            default:
3175
                goto fail;
3176
            }
3177
        } else {
3178
        addchar:
3179
            if ((q - buf) < buf_size - 1)
3180
                *q++ = c;
3181
        }
3182
    }
3183
    if (!percentd_found)
3184
        goto fail;
3185
    *q = '\0';
3186
    return 0;
3187
 fail:
3188
    *q = '\0';
3189
    return -1;
3190
}
3191

    
3192
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3193
{
3194
    int len, i, j, c;
3195
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3196

    
3197
    for(i=0;i<size;i+=16) {
3198
        len = size - i;
3199
        if (len > 16)
3200
            len = 16;
3201
        PRINT("%08x ", i);
3202
        for(j=0;j<16;j++) {
3203
            if (j < len)
3204
                PRINT(" %02x", buf[i+j]);
3205
            else
3206
                PRINT("   ");
3207
        }
3208
        PRINT(" ");
3209
        for(j=0;j<len;j++) {
3210
            c = buf[i+j];
3211
            if (c < ' ' || c > '~')
3212
                c = '.';
3213
            PRINT("%c", c);
3214
        }
3215
        PRINT("\n");
3216
    }
3217
#undef PRINT
3218
}
3219

    
3220
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3221
{
3222
    hex_dump_internal(NULL, f, 0, buf, size);
3223
}
3224

    
3225
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3226
{
3227
    hex_dump_internal(avcl, NULL, level, buf, size);
3228
}
3229

    
3230
 //FIXME needs to know the time_base
3231
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3232
{
3233
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3234
    PRINT("stream #%d:\n", pkt->stream_index);
3235
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3236
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3237
    /* DTS is _always_ valid after av_read_frame() */
3238
    PRINT("  dts=");
3239
    if (pkt->dts == AV_NOPTS_VALUE)
3240
        PRINT("N/A");
3241
    else
3242
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3243
    /* PTS may not be known if B-frames are present. */
3244
    PRINT("  pts=");
3245
    if (pkt->pts == AV_NOPTS_VALUE)
3246
        PRINT("N/A");
3247
    else
3248
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3249
    PRINT("\n");
3250
    PRINT("  size=%d\n", pkt->size);
3251
#undef PRINT
3252
    if (dump_payload)
3253
        av_hex_dump(f, pkt->data, pkt->size);
3254
}
3255

    
3256
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3257
{
3258
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3259
}
3260

    
3261
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3262
{
3263
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3264
}
3265

    
3266
void url_split(char *proto, int proto_size,
3267
               char *authorization, int authorization_size,
3268
               char *hostname, int hostname_size,
3269
               int *port_ptr,
3270
               char *path, int path_size,
3271
               const char *url)
3272
{
3273
    const char *p, *ls, *at, *col, *brk;
3274

    
3275
    if (port_ptr)               *port_ptr = -1;
3276
    if (proto_size > 0)         proto[0] = 0;
3277
    if (authorization_size > 0) authorization[0] = 0;
3278
    if (hostname_size > 0)      hostname[0] = 0;
3279
    if (path_size > 0)          path[0] = 0;
3280

    
3281
    /* parse protocol */
3282
    if ((p = strchr(url, ':'))) {
3283
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3284
        p++; /* skip ':' */
3285
        if (*p == '/') p++;
3286
        if (*p == '/') p++;
3287
    } else {
3288
        /* no protocol means plain filename */
3289
        av_strlcpy(path, url, path_size);
3290
        return;
3291
    }
3292

    
3293
    /* separate path from hostname */
3294
    ls = strchr(p, '/');
3295
    if(!ls)
3296
        ls = strchr(p, '?');
3297
    if(ls)
3298
        av_strlcpy(path, ls, path_size);
3299
    else
3300
        ls = &p[strlen(p)]; // XXX
3301

    
3302
    /* the rest is hostname, use that to parse auth/port */
3303
    if (ls != p) {
3304
        /* authorization (user[:pass]@hostname) */
3305
        if ((at = strchr(p, '@')) && at < ls) {
3306
            av_strlcpy(authorization, p,
3307
                       FFMIN(authorization_size, at + 1 - p));
3308
            p = at + 1; /* skip '@' */
3309
        }
3310

    
3311
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3312
            /* [host]:port */
3313
            av_strlcpy(hostname, p + 1,
3314
                       FFMIN(hostname_size, brk - p));
3315
            if (brk[1] == ':' && port_ptr)
3316
                *port_ptr = atoi(brk + 2);
3317
        } else if ((col = strchr(p, ':')) && col < ls) {
3318
            av_strlcpy(hostname, p,
3319
                       FFMIN(col + 1 - p, hostname_size));
3320
            if (port_ptr) *port_ptr = atoi(col + 1);
3321
        } else
3322
            av_strlcpy(hostname, p,
3323
                       FFMIN(ls + 1 - p, hostname_size));
3324
    }
3325
}
3326

    
3327
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3328
{
3329
    int i;
3330
    static const char hex_table[16] = { '0', '1', '2', '3',
3331
                                        '4', '5', '6', '7',
3332
                                        '8', '9', 'A', 'B',
3333
                                        'C', 'D', 'E', 'F' };
3334

    
3335
    for(i = 0; i < s; i++) {
3336
        buff[i * 2]     = hex_table[src[i] >> 4];
3337
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3338
    }
3339

    
3340
    return buff;
3341
}
3342

    
3343
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3344
                     unsigned int pts_num, unsigned int pts_den)
3345
{
3346
    s->pts_wrap_bits = pts_wrap_bits;
3347

    
3348
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3349
        if(s->time_base.num != pts_num)
3350
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3351
    }else
3352
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3353

    
3354
    if(!s->time_base.num || !s->time_base.den)
3355
        s->time_base.num= s->time_base.den= 0;
3356
}