Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ db46c4e1

History | View | Annotate | Download (104 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

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

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

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

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

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

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

    
515
}
516

    
517
/*******************************************************/
518

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

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

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

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

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

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

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

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

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

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

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

    
592
            --st->probe_packets;
593

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

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

    
610
/**********************************************************/
611

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

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

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

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

    
641

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

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

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

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

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

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

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

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

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

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

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

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

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

    
772
    if (pc && pc->pict_type == FF_B_TYPE)
773
        st->codec->has_b_frames = 1;
774

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

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

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

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

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

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

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

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

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

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

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

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

    
899
//    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);
900

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

    
916

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

    
922
    av_init_packet(pkt);
923

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

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

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

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

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

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

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

    
1047
    return 0;
1048
}
1049

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

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

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

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

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

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

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

    
1128
/*******************************************************/
1129
/* seek support */
1130

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

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

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

    
1158
    flush_packet_queue(s);
1159

    
1160
    s->cur_st = NULL;
1161

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

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

    
1178
        st->probe_packets = MAX_PROBE_PACKETS;
1179
    }
1180
}
1181

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

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

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

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

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

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

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

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

    
1223
    st->index_entries= entries;
1224

    
1225
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1226

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

    
1242
    ie->pos = pos;
1243
    ie->timestamp = timestamp;
1244
    ie->min_distance= distance;
1245
    ie->size= size;
1246
    ie->flags = flags;
1247

    
1248
    return index;
1249
}
1250

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

    
1259
    a = - 1;
1260
    b = nb_entries;
1261

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

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

    
1278
    if(m == nb_entries)
1279
        return -1;
1280
    return  m;
1281
}
1282

    
1283
#define DEBUG_SEEK
1284

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

    
1292
    if (stream_index < 0)
1293
        return -1;
1294

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

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

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

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

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

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

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

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

    
1344
    av_update_cur_dts(s, st, ts);
1345

    
1346
    return 0;
1347
}
1348

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

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

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

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

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

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

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

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

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

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

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

1469
    if (stream_index < 0)
1470
        return -1;
1471

1472
    st= s->streams[stream_index];
1473
#endif
1474

    
1475
    pos_min = s->data_offset;
1476
    pos_max = url_fsize(s->pb) - 1;
1477

    
1478
    if     (pos < pos_min) pos= pos_min;
1479
    else if(pos > pos_max) pos= pos_max;
1480

    
1481
    url_fseek(s->pb, pos, SEEK_SET);
1482

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

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

    
1496
    st = s->streams[stream_index];
1497

    
1498
    index = av_index_search_timestamp(st, timestamp, flags);
1499

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

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

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

    
1542
    return 0;
1543
}
1544

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

    
1550
    av_read_frame_flush(s);
1551

    
1552
    if(flags & AVSEEK_FLAG_BYTE)
1553
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1554

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

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

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

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

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

    
1585
    av_read_frame_flush(s);
1586

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

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

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

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

    
1602
/*******************************************************/
1603

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

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

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

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

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

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

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

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

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

    
1722
#define DURATION_MAX_READ_SIZE 250000
1723

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

    
1733
    ic->cur_st = NULL;
1734

    
1735
    /* flush packet queue */
1736
    flush_packet_queue(ic);
1737

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

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

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

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

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

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

    
1810
    fill_all_stream_timings(ic);
1811

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1976
static void compute_chapters_end(AVFormatContext *s)
1977
{
1978
    unsigned int i;
1979

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

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

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

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

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

    
2035
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2036
    if (!duration_error) return AVERROR(ENOMEM);
2037

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

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

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

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

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

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

    
2127
        read_size += pkt->size;
2128

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

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

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

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

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

    
2197
        count++;
2198
    }
2199

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

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

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

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

    
2255
    av_estimate_timings(ic, old_offset);
2256

    
2257
    compute_chapters_end(ic);
2258

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

    
2284
    av_free(duration_error);
2285

    
2286
    return ret;
2287
}
2288

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2429
    return program;
2430
}
2431

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

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

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

    
2456
    return chapter;
2457
}
2458

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2685
    s->packet_buffer_end= this_pktl;
2686
next_non_null:
2687

    
2688
    this_pktl->next= *next_point;
2689

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

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

    
2701
    if (pkt->dts == AV_NOPTS_VALUE)
2702
        return 0;
2703

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

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

    
2712
    if(pkt){
2713
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2714
    }
2715

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

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

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

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

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

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

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

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

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

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

    
2773
        ret= s->oformat->write_packet(s, &opkt);
2774

    
2775
        av_free_packet(&opkt);
2776
        pkt= NULL;
2777

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

    
2785
int av_write_trailer(AVFormatContext *s)
2786
{
2787
    int ret, i;
2788

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

    
2797
        ret= s->oformat->write_packet(s, &pkt);
2798

    
2799
        av_free_packet(&pkt);
2800

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

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

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

    
2824
    for(i=0; i<ac->nb_programs; i++){
2825
        if(ac->programs[i]->id != progid)
2826
            continue;
2827
        program = ac->programs[i];
2828
        for(j=0; j<program->nb_stream_indexes; j++)
2829
            if(program->stream_index[j] == idx)
2830
                return;
2831

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

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

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

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

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

    
2952
}
2953

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

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

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

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

    
2996
#undef time
2997
    time_t now = time(0);
2998

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

    
3006
    memset(&dt, 0, sizeof(dt));
3007

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

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

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

    
3035
        if (*p == 'T' || *p == 't' || *p == ' ')
3036
            p++;
3037

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

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

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

    
3080
    t *= 1000000;
3081

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3338
    return buff;
3339
}
3340

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

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

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