Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ c1736936

History | View | Annotate | Download (106 KB)

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

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

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

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

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

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

    
55
/* fraction handling */
56

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

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

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

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

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

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

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

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

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

    
145
    if(!filename)
146
        return 0;
147

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

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

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

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

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

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

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

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

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

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

    
238
    return fmt;
239
}
240

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

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

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

    
270
/* memory handling */
271

    
272

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

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

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

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

    
288
    return ret;
289
}
290

    
291

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
420
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
421

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

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

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

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

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

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

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

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

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

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

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

    
536
}
537

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

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

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

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

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

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

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

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

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

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

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

    
610
        if(st->codec->codec_id == CODEC_ID_PROBE){
611
            AVProbeData *pd = &st->probe_data;
612

    
613
            --st->probe_packets;
614

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

    
620
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
621
                set_codec_from_probe_data(s, st, pd, 1);
622
                if(st->codec->codec_id != CODEC_ID_PROBE){
623
                    pd->buf_size=0;
624
                    av_freep(&pd->buf);
625
                }
626
            }
627
        }
628
    }
629
}
630

    
631
/**********************************************************/
632

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

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

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

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

    
662

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
938

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

    
944
    av_init_packet(pkt);
945

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

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

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

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

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

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

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

    
1071
    return 0;
1072
}
1073

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

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

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

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

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

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

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

    
1152
/*******************************************************/
1153
/* seek support */
1154

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

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

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

    
1182
    flush_packet_queue(s);
1183

    
1184
    s->cur_st = NULL;
1185

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

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

    
1202
        st->probe_packets = MAX_PROBE_PACKETS;
1203
    }
1204
}
1205

    
1206
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1207
    int i;
1208

    
1209
    for(i = 0; i < s->nb_streams; i++) {
1210
        AVStream *st = s->streams[i];
1211

    
1212
        st->cur_dts = av_rescale(timestamp,
1213
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1214
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1215
    }
1216
}
1217

    
1218
void ff_reduce_index(AVFormatContext *s, int stream_index)
1219
{
1220
    AVStream *st= s->streams[stream_index];
1221
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1222

    
1223
    if((unsigned)st->nb_index_entries >= max_entries){
1224
        int i;
1225
        for(i=0; 2*i<st->nb_index_entries; i++)
1226
            st->index_entries[i]= st->index_entries[2*i];
1227
        st->nb_index_entries= i;
1228
    }
1229
}
1230

    
1231
int av_add_index_entry(AVStream *st,
1232
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1233
{
1234
    AVIndexEntry *entries, *ie;
1235
    int index;
1236

    
1237
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1238
        return -1;
1239

    
1240
    entries = av_fast_realloc(st->index_entries,
1241
                              &st->index_entries_allocated_size,
1242
                              (st->nb_index_entries + 1) *
1243
                              sizeof(AVIndexEntry));
1244
    if(!entries)
1245
        return -1;
1246

    
1247
    st->index_entries= entries;
1248

    
1249
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1250

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

    
1266
    ie->pos = pos;
1267
    ie->timestamp = timestamp;
1268
    ie->min_distance= distance;
1269
    ie->size= size;
1270
    ie->flags = flags;
1271

    
1272
    return index;
1273
}
1274

    
1275
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1276
                              int flags)
1277
{
1278
    AVIndexEntry *entries= st->index_entries;
1279
    int nb_entries= st->nb_index_entries;
1280
    int a, b, m;
1281
    int64_t timestamp;
1282

    
1283
    a = - 1;
1284
    b = nb_entries;
1285

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

    
1296
    if(!(flags & AVSEEK_FLAG_ANY)){
1297
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1298
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1299
        }
1300
    }
1301

    
1302
    if(m == nb_entries)
1303
        return -1;
1304
    return  m;
1305
}
1306

    
1307
#define DEBUG_SEEK
1308

    
1309
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1310
    AVInputFormat *avif= s->iformat;
1311
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1312
    int64_t ts_min, ts_max, ts;
1313
    int index;
1314
    AVStream *st;
1315

    
1316
    if (stream_index < 0)
1317
        return -1;
1318

    
1319
#ifdef DEBUG_SEEK
1320
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1321
#endif
1322

    
1323
    ts_max=
1324
    ts_min= AV_NOPTS_VALUE;
1325
    pos_limit= -1; //gcc falsely says it may be uninitialized
1326

    
1327
    st= s->streams[stream_index];
1328
    if(st->index_entries){
1329
        AVIndexEntry *e;
1330

    
1331
        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()
1332
        index= FFMAX(index, 0);
1333
        e= &st->index_entries[index];
1334

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

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

    
1361
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1362
    if(pos<0)
1363
        return -1;
1364

    
1365
    /* do the seek */
1366
    url_fseek(s->pb, pos, SEEK_SET);
1367

    
1368
    av_update_cur_dts(s, st, ts);
1369

    
1370
    return 0;
1371
}
1372

    
1373
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 )){
1374
    int64_t pos, ts;
1375
    int64_t start_pos, filesize;
1376
    int no_change;
1377

    
1378
#ifdef DEBUG_SEEK
1379
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1380
#endif
1381

    
1382
    if(ts_min == AV_NOPTS_VALUE){
1383
        pos_min = s->data_offset;
1384
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1385
        if (ts_min == AV_NOPTS_VALUE)
1386
            return -1;
1387
    }
1388

    
1389
    if(ts_max == AV_NOPTS_VALUE){
1390
        int step= 1024;
1391
        filesize = url_fsize(s->pb);
1392
        pos_max = filesize - 1;
1393
        do{
1394
            pos_max -= step;
1395
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1396
            step += step;
1397
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1398
        if (ts_max == AV_NOPTS_VALUE)
1399
            return -1;
1400

    
1401
        for(;;){
1402
            int64_t tmp_pos= pos_max + 1;
1403
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1404
            if(tmp_ts == AV_NOPTS_VALUE)
1405
                break;
1406
            ts_max= tmp_ts;
1407
            pos_max= tmp_pos;
1408
            if(tmp_pos >= filesize)
1409
                break;
1410
        }
1411
        pos_limit= pos_max;
1412
    }
1413

    
1414
    if(ts_min > ts_max){
1415
        return -1;
1416
    }else if(ts_min == ts_max){
1417
        pos_limit= pos_min;
1418
    }
1419

    
1420
    no_change=0;
1421
    while (pos_min < pos_limit) {
1422
#ifdef DEBUG_SEEK
1423
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1424
               pos_min, pos_max,
1425
               ts_min, ts_max);
1426
#endif
1427
        assert(pos_limit <= pos_max);
1428

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

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

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

    
1488
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1489
    int64_t pos_min, pos_max;
1490
#if 0
1491
    AVStream *st;
1492

1493
    if (stream_index < 0)
1494
        return -1;
1495

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

    
1499
    pos_min = s->data_offset;
1500
    pos_max = url_fsize(s->pb) - 1;
1501

    
1502
    if     (pos < pos_min) pos= pos_min;
1503
    else if(pos > pos_max) pos= pos_max;
1504

    
1505
    url_fseek(s->pb, pos, SEEK_SET);
1506

    
1507
#if 0
1508
    av_update_cur_dts(s, st, ts);
1509
#endif
1510
    return 0;
1511
}
1512

    
1513
static int av_seek_frame_generic(AVFormatContext *s,
1514
                                 int stream_index, int64_t timestamp, int flags)
1515
{
1516
    int index, ret;
1517
    AVStream *st;
1518
    AVIndexEntry *ie;
1519

    
1520
    st = s->streams[stream_index];
1521

    
1522
    index = av_index_search_timestamp(st, timestamp, flags);
1523

    
1524
    if(index < 0 || index==st->nb_index_entries-1){
1525
        int i;
1526
        AVPacket pkt;
1527

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

    
1556
    av_read_frame_flush(s);
1557
    if (s->iformat->read_seek){
1558
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1559
            return 0;
1560
    }
1561
    ie = &st->index_entries[index];
1562
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1563
        return ret;
1564
    av_update_cur_dts(s, st, ie->timestamp);
1565

    
1566
    return 0;
1567
}
1568

    
1569
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1570
{
1571
    int ret;
1572
    AVStream *st;
1573

    
1574
    av_read_frame_flush(s);
1575

    
1576
    if(flags & AVSEEK_FLAG_BYTE)
1577
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1578

    
1579
    if(stream_index < 0){
1580
        stream_index= av_find_default_stream_index(s);
1581
        if(stream_index < 0)
1582
            return -1;
1583

    
1584
        st= s->streams[stream_index];
1585
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1586
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1587
    }
1588

    
1589
    /* first, we try the format specific seek */
1590
    if (s->iformat->read_seek)
1591
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1592
    else
1593
        ret = -1;
1594
    if (ret >= 0) {
1595
        return 0;
1596
    }
1597

    
1598
    if(s->iformat->read_timestamp)
1599
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1600
    else
1601
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1602
}
1603

    
1604
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1605
{
1606
    if(min_ts > ts || max_ts < ts)
1607
        return -1;
1608

    
1609
    av_read_frame_flush(s);
1610

    
1611
    if (s->iformat->read_seek2)
1612
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1613

    
1614
    if(s->iformat->read_timestamp){
1615
        //try to seek via read_timestamp()
1616
    }
1617

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

    
1623
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1624
}
1625

    
1626
/*******************************************************/
1627

    
1628
/**
1629
 * Returns TRUE if the stream has accurate duration in any stream.
1630
 *
1631
 * @return TRUE if the stream has accurate duration for at least one component.
1632
 */
1633
static int av_has_duration(AVFormatContext *ic)
1634
{
1635
    int i;
1636
    AVStream *st;
1637

    
1638
    for(i = 0;i < ic->nb_streams; i++) {
1639
        st = ic->streams[i];
1640
        if (st->duration != AV_NOPTS_VALUE)
1641
            return 1;
1642
    }
1643
    return 0;
1644
}
1645

    
1646
/**
1647
 * Estimate the stream timings from the one of each components.
1648
 *
1649
 * Also computes the global bitrate if possible.
1650
 */
1651
static void av_update_stream_timings(AVFormatContext *ic)
1652
{
1653
    int64_t start_time, start_time1, end_time, end_time1;
1654
    int64_t duration, duration1;
1655
    int i;
1656
    AVStream *st;
1657

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

    
1697
static void fill_all_stream_timings(AVFormatContext *ic)
1698
{
1699
    int i;
1700
    AVStream *st;
1701

    
1702
    av_update_stream_timings(ic);
1703
    for(i = 0;i < ic->nb_streams; i++) {
1704
        st = ic->streams[i];
1705
        if (st->start_time == AV_NOPTS_VALUE) {
1706
            if(ic->start_time != AV_NOPTS_VALUE)
1707
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1708
            if(ic->duration != AV_NOPTS_VALUE)
1709
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1710
        }
1711
    }
1712
}
1713

    
1714
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1715
{
1716
    int64_t filesize, duration;
1717
    int bit_rate, i;
1718
    AVStream *st;
1719

    
1720
    /* if bit_rate is already set, we believe it */
1721
    if (ic->bit_rate == 0) {
1722
        bit_rate = 0;
1723
        for(i=0;i<ic->nb_streams;i++) {
1724
            st = ic->streams[i];
1725
            bit_rate += st->codec->bit_rate;
1726
        }
1727
        ic->bit_rate = bit_rate;
1728
    }
1729

    
1730
    /* if duration is already set, we believe it */
1731
    if (ic->duration == AV_NOPTS_VALUE &&
1732
        ic->bit_rate != 0 &&
1733
        ic->file_size != 0)  {
1734
        filesize = ic->file_size;
1735
        if (filesize > 0) {
1736
            for(i = 0; i < ic->nb_streams; i++) {
1737
                st = ic->streams[i];
1738
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1739
                if (st->duration == AV_NOPTS_VALUE)
1740
                    st->duration = duration;
1741
            }
1742
        }
1743
    }
1744
}
1745

    
1746
#define DURATION_MAX_READ_SIZE 250000
1747

    
1748
/* only usable for MPEG-PS streams */
1749
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1750
{
1751
    AVPacket pkt1, *pkt = &pkt1;
1752
    AVStream *st;
1753
    int read_size, i, ret;
1754
    int64_t end_time;
1755
    int64_t filesize, offset, duration;
1756

    
1757
    ic->cur_st = NULL;
1758

    
1759
    /* flush packet queue */
1760
    flush_packet_queue(ic);
1761

    
1762
    for(i=0;i<ic->nb_streams;i++) {
1763
        st = ic->streams[i];
1764
        if (st->parser) {
1765
            av_parser_close(st->parser);
1766
            st->parser= NULL;
1767
            av_free_packet(&st->cur_pkt);
1768
        }
1769
    }
1770

    
1771
    /* we read the first packets to get the first PTS (not fully
1772
       accurate, but it is enough now) */
1773
    url_fseek(ic->pb, 0, SEEK_SET);
1774
    read_size = 0;
1775
    for(;;) {
1776
        if (read_size >= DURATION_MAX_READ_SIZE)
1777
            break;
1778
        /* if all info is available, we can stop */
1779
        for(i = 0;i < ic->nb_streams; i++) {
1780
            st = ic->streams[i];
1781
            if (st->start_time == AV_NOPTS_VALUE)
1782
                break;
1783
        }
1784
        if (i == ic->nb_streams)
1785
            break;
1786

    
1787
        do{
1788
            ret = av_read_packet(ic, pkt);
1789
        }while(ret == AVERROR(EAGAIN));
1790
        if (ret != 0)
1791
            break;
1792
        read_size += pkt->size;
1793
        st = ic->streams[pkt->stream_index];
1794
        if (pkt->pts != AV_NOPTS_VALUE) {
1795
            if (st->start_time == AV_NOPTS_VALUE)
1796
                st->start_time = pkt->pts;
1797
        }
1798
        av_free_packet(pkt);
1799
    }
1800

    
1801
    /* estimate the end time (duration) */
1802
    /* XXX: may need to support wrapping */
1803
    filesize = ic->file_size;
1804
    offset = filesize - DURATION_MAX_READ_SIZE;
1805
    if (offset < 0)
1806
        offset = 0;
1807

    
1808
    url_fseek(ic->pb, offset, SEEK_SET);
1809
    read_size = 0;
1810
    for(;;) {
1811
        if (read_size >= DURATION_MAX_READ_SIZE)
1812
            break;
1813

    
1814
        do{
1815
            ret = av_read_packet(ic, pkt);
1816
        }while(ret == AVERROR(EAGAIN));
1817
        if (ret != 0)
1818
            break;
1819
        read_size += pkt->size;
1820
        st = ic->streams[pkt->stream_index];
1821
        if (pkt->pts != AV_NOPTS_VALUE &&
1822
            st->start_time != AV_NOPTS_VALUE) {
1823
            end_time = pkt->pts;
1824
            duration = end_time - st->start_time;
1825
            if (duration > 0) {
1826
                if (st->duration == AV_NOPTS_VALUE ||
1827
                    st->duration < duration)
1828
                    st->duration = duration;
1829
            }
1830
        }
1831
        av_free_packet(pkt);
1832
    }
1833

    
1834
    fill_all_stream_timings(ic);
1835

    
1836
    url_fseek(ic->pb, old_offset, SEEK_SET);
1837
    for(i=0; i<ic->nb_streams; i++){
1838
        st= ic->streams[i];
1839
        st->cur_dts= st->first_dts;
1840
        st->last_IP_pts = AV_NOPTS_VALUE;
1841
    }
1842
}
1843

    
1844
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1845
{
1846
    int64_t file_size;
1847

    
1848
    /* get the file size, if possible */
1849
    if (ic->iformat->flags & AVFMT_NOFILE) {
1850
        file_size = 0;
1851
    } else {
1852
        file_size = url_fsize(ic->pb);
1853
        if (file_size < 0)
1854
            file_size = 0;
1855
    }
1856
    ic->file_size = file_size;
1857

    
1858
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1859
         !strcmp(ic->iformat->name, "mpegts")) &&
1860
        file_size && !url_is_streamed(ic->pb)) {
1861
        /* get accurate estimate from the PTSes */
1862
        av_estimate_timings_from_pts(ic, old_offset);
1863
    } else if (av_has_duration(ic)) {
1864
        /* at least one component has timings - we use them for all
1865
           the components */
1866
        fill_all_stream_timings(ic);
1867
    } else {
1868
        /* less precise: use bitrate info */
1869
        av_estimate_timings_from_bit_rate(ic);
1870
    }
1871
    av_update_stream_timings(ic);
1872

    
1873
#if 0
1874
    {
1875
        int i;
1876
        AVStream *st;
1877
        for(i = 0;i < ic->nb_streams; i++) {
1878
            st = ic->streams[i];
1879
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1880
               i, (double)st->start_time / AV_TIME_BASE,
1881
               (double)st->duration / AV_TIME_BASE);
1882
        }
1883
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1884
               (double)ic->start_time / AV_TIME_BASE,
1885
               (double)ic->duration / AV_TIME_BASE,
1886
               ic->bit_rate / 1000);
1887
    }
1888
#endif
1889
}
1890

    
1891
static int has_codec_parameters(AVCodecContext *enc)
1892
{
1893
    int val;
1894
    switch(enc->codec_type) {
1895
    case CODEC_TYPE_AUDIO:
1896
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1897
        if(!enc->frame_size &&
1898
           (enc->codec_id == CODEC_ID_VORBIS ||
1899
            enc->codec_id == CODEC_ID_AAC ||
1900
            enc->codec_id == CODEC_ID_MP3 ||
1901
            enc->codec_id == CODEC_ID_SPEEX))
1902
            return 0;
1903
        break;
1904
    case CODEC_TYPE_VIDEO:
1905
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1906
        break;
1907
    default:
1908
        val = 1;
1909
        break;
1910
    }
1911
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1912
}
1913

    
1914
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1915
{
1916
    int16_t *samples;
1917
    AVCodec *codec;
1918
    int got_picture, data_size, ret=0;
1919
    AVFrame picture;
1920

    
1921
    if(!st->codec->codec){
1922
        codec = avcodec_find_decoder(st->codec->codec_id);
1923
        if (!codec)
1924
            return -1;
1925
        ret = avcodec_open(st->codec, codec);
1926
        if (ret < 0)
1927
            return ret;
1928
    }
1929

    
1930
    if(!has_codec_parameters(st->codec)){
1931
        switch(st->codec->codec_type) {
1932
        case CODEC_TYPE_VIDEO:
1933
            avcodec_get_frame_defaults(&picture);
1934
            ret = avcodec_decode_video2(st->codec, &picture,
1935
                                        &got_picture, avpkt);
1936
            break;
1937
        case CODEC_TYPE_AUDIO:
1938
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1939
            samples = av_malloc(data_size);
1940
            if (!samples)
1941
                goto fail;
1942
            ret = avcodec_decode_audio3(st->codec, samples,
1943
                                        &data_size, avpkt);
1944
            av_free(samples);
1945
            break;
1946
        default:
1947
            break;
1948
        }
1949
    }
1950
 fail:
1951
    return ret;
1952
}
1953

    
1954
unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
1955
{
1956
    while (tags->id != CODEC_ID_NONE) {
1957
        if (tags->id == id)
1958
            return tags->tag;
1959
        tags++;
1960
    }
1961
    return 0;
1962
}
1963

    
1964
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
1965
{
1966
    int i;
1967
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1968
        if(tag == tags[i].tag)
1969
            return tags[i].id;
1970
    }
1971
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1972
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1973
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1974
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1975
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1976
            return tags[i].id;
1977
    }
1978
    return CODEC_ID_NONE;
1979
}
1980

    
1981
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1982
{
1983
    int i;
1984
    for(i=0; tags && tags[i]; i++){
1985
        int tag= ff_codec_get_tag(tags[i], id);
1986
        if(tag) return tag;
1987
    }
1988
    return 0;
1989
}
1990

    
1991
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1992
{
1993
    int i;
1994
    for(i=0; tags && tags[i]; i++){
1995
        enum CodecID id= ff_codec_get_id(tags[i], tag);
1996
        if(id!=CODEC_ID_NONE) return id;
1997
    }
1998
    return CODEC_ID_NONE;
1999
}
2000

    
2001
static void compute_chapters_end(AVFormatContext *s)
2002
{
2003
    unsigned int i;
2004

    
2005
    for (i=0; i+1<s->nb_chapters; i++)
2006
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2007
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2008
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2009
            s->chapters[i]->end = s->chapters[i+1]->start;
2010
        }
2011

    
2012
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2013
        assert(s->start_time != AV_NOPTS_VALUE);
2014
        assert(s->duration > 0);
2015
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2016
                                           AV_TIME_BASE_Q,
2017
                                           s->chapters[i]->time_base);
2018
    }
2019
}
2020

    
2021
#define MAX_STD_TIMEBASES (60*12+5)
2022
static int get_std_framerate(int i){
2023
    if(i<60*12) return i*1001;
2024
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2025
}
2026

    
2027
/*
2028
 * Is the time base unreliable.
2029
 * This is a heuristic to balance between quick acceptance of the values in
2030
 * the headers vs. some extra checks.
2031
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2032
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2033
 * And there are "variable" fps files this needs to detect as well.
2034
 */
2035
static int tb_unreliable(AVCodecContext *c){
2036
    if(   c->time_base.den >= 101L*c->time_base.num
2037
       || c->time_base.den <    5L*c->time_base.num
2038
/*       || c->codec_tag == AV_RL32("DIVX")
2039
       || c->codec_tag == AV_RL32("XVID")*/
2040
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2041
       || c->codec_id == CODEC_ID_H264
2042
       )
2043
        return 1;
2044
    return 0;
2045
}
2046

    
2047
int av_find_stream_info(AVFormatContext *ic)
2048
{
2049
    int i, count, ret, read_size, j;
2050
    AVStream *st;
2051
    AVPacket pkt1, *pkt;
2052
    int64_t last_dts[MAX_STREAMS];
2053
    int64_t duration_gcd[MAX_STREAMS]={0};
2054
    int duration_count[MAX_STREAMS]={0};
2055
    double (*duration_error)[MAX_STD_TIMEBASES];
2056
    int64_t old_offset = url_ftell(ic->pb);
2057
    int64_t codec_info_duration[MAX_STREAMS]={0};
2058
    int codec_info_nb_frames[MAX_STREAMS]={0};
2059

    
2060
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2061
    if (!duration_error) return AVERROR(ENOMEM);
2062

    
2063
    for(i=0;i<ic->nb_streams;i++) {
2064
        st = ic->streams[i];
2065
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2066
/*            if(!st->time_base.num)
2067
                st->time_base= */
2068
            if(!st->codec->time_base.num)
2069
                st->codec->time_base= st->time_base;
2070
        }
2071
        //only for the split stuff
2072
        if (!st->parser) {
2073
            st->parser = av_parser_init(st->codec->codec_id);
2074
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2075
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2076
            }
2077
        }
2078
    }
2079

    
2080
    for(i=0;i<MAX_STREAMS;i++){
2081
        last_dts[i]= AV_NOPTS_VALUE;
2082
    }
2083

    
2084
    count = 0;
2085
    read_size = 0;
2086
    for(;;) {
2087
        if(url_interrupt_cb()){
2088
            ret= AVERROR(EINTR);
2089
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2090
            break;
2091
        }
2092

    
2093
        /* check if one codec still needs to be handled */
2094
        for(i=0;i<ic->nb_streams;i++) {
2095
            st = ic->streams[i];
2096
            if (!has_codec_parameters(st->codec))
2097
                break;
2098
            /* variable fps and no guess at the real fps */
2099
            if(   tb_unreliable(st->codec)
2100
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2101
                break;
2102
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2103
                break;
2104
            if(st->first_dts == AV_NOPTS_VALUE)
2105
                break;
2106
        }
2107
        if (i == ic->nb_streams) {
2108
            /* NOTE: if the format has no header, then we need to read
2109
               some packets to get most of the streams, so we cannot
2110
               stop here */
2111
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2112
                /* if we found the info for all the codecs, we can stop */
2113
                ret = count;
2114
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2115
                break;
2116
            }
2117
        }
2118
        /* we did not get all the codec info, but we read too much data */
2119
        if (read_size >= ic->probesize) {
2120
            ret = count;
2121
            av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2122
            break;
2123
        }
2124

    
2125
        /* NOTE: a new stream can be added there if no header in file
2126
           (AVFMTCTX_NOHEADER) */
2127
        ret = av_read_frame_internal(ic, &pkt1);
2128
        if(ret == AVERROR(EAGAIN))
2129
            continue;
2130
        if (ret < 0) {
2131
            /* EOF or error */
2132
            ret = -1; /* we could not have all the codec parameters before EOF */
2133
            for(i=0;i<ic->nb_streams;i++) {
2134
                st = ic->streams[i];
2135
                if (!has_codec_parameters(st->codec)){
2136
                    char buf[256];
2137
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2138
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2139
                } else {
2140
                    ret = 0;
2141
                }
2142
            }
2143
            break;
2144
        }
2145

    
2146
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2147
        if(av_dup_packet(pkt) < 0) {
2148
            av_free(duration_error);
2149
            return AVERROR(ENOMEM);
2150
        }
2151

    
2152
        read_size += pkt->size;
2153

    
2154
        st = ic->streams[pkt->stream_index];
2155
        if(codec_info_nb_frames[st->index]>1) {
2156
            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){
2157
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2158
                break;
2159
            }
2160
            codec_info_duration[st->index] += pkt->duration;
2161
        }
2162
        if (pkt->duration != 0)
2163
            codec_info_nb_frames[st->index]++;
2164

    
2165
        {
2166
            int index= pkt->stream_index;
2167
            int64_t last= last_dts[index];
2168
            int64_t duration= pkt->dts - last;
2169

    
2170
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2171
                double dur= duration * av_q2d(st->time_base);
2172

    
2173
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2174
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2175
                if(duration_count[index] < 2)
2176
                    memset(duration_error[index], 0, sizeof(*duration_error));
2177
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2178
                    int framerate= get_std_framerate(i);
2179
                    int ticks= lrintf(dur*framerate/(1001*12));
2180
                    double error= dur - ticks*1001*12/(double)framerate;
2181
                    duration_error[index][i] += error*error;
2182
                }
2183
                duration_count[index]++;
2184
                // ignore the first 4 values, they might have some random jitter
2185
                if (duration_count[index] > 3)
2186
                    duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2187
            }
2188
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2189
                last_dts[pkt->stream_index]= pkt->dts;
2190
        }
2191
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2192
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2193
            if(i){
2194
                st->codec->extradata_size= i;
2195
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2196
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2197
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2198
            }
2199
        }
2200

    
2201
        /* if still no information, we try to open the codec and to
2202
           decompress the frame. We try to avoid that in most cases as
2203
           it takes longer and uses more memory. For MPEG-4, we need to
2204
           decompress for QuickTime. */
2205
        if (!has_codec_parameters(st->codec) /*&&
2206
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2207
             st->codec->codec_id == CODEC_ID_H264 ||
2208
             st->codec->codec_id == CODEC_ID_H263 ||
2209
             st->codec->codec_id == CODEC_ID_H261 ||
2210
             st->codec->codec_id == CODEC_ID_VORBIS ||
2211
             st->codec->codec_id == CODEC_ID_MJPEG ||
2212
             st->codec->codec_id == CODEC_ID_PNG ||
2213
             st->codec->codec_id == CODEC_ID_PAM ||
2214
             st->codec->codec_id == CODEC_ID_PGM ||
2215
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2216
             st->codec->codec_id == CODEC_ID_PBM ||
2217
             st->codec->codec_id == CODEC_ID_PPM ||
2218
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2219
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2220
            try_decode_frame(st, pkt);
2221

    
2222
        count++;
2223
    }
2224

    
2225
    // close codecs which were opened in try_decode_frame()
2226
    for(i=0;i<ic->nb_streams;i++) {
2227
        st = ic->streams[i];
2228
        if(st->codec->codec)
2229
            avcodec_close(st->codec);
2230
    }
2231
    for(i=0;i<ic->nb_streams;i++) {
2232
        st = ic->streams[i];
2233
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2234
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2235
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2236

    
2237
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2238
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2239
            // ipmovie.c produces.
2240
            if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
2241
                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);
2242
            if(duration_count[i]
2243
               && tb_unreliable(st->codec) /*&&
2244
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2245
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2246
                int num = 0;
2247
                double best_error= 2*av_q2d(st->time_base);
2248
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2249

    
2250
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2251
                    double error= duration_error[i][j] * get_std_framerate(j);
2252
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2253
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2254
                    if(error < best_error){
2255
                        best_error= error;
2256
                        num = get_std_framerate(j);
2257
                    }
2258
                }
2259
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2260
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2261
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2262
            }
2263

    
2264
            if (!st->r_frame_rate.num){
2265
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2266
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2267
                    st->r_frame_rate.num = st->codec->time_base.den;
2268
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2269
                }else{
2270
                    st->r_frame_rate.num = st->time_base.den;
2271
                    st->r_frame_rate.den = st->time_base.num;
2272
                }
2273
            }
2274
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2275
            if(!st->codec->bits_per_coded_sample)
2276
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2277
        }
2278
    }
2279

    
2280
    av_estimate_timings(ic, old_offset);
2281

    
2282
    compute_chapters_end(ic);
2283

    
2284
#if 0
2285
    /* correct DTS for B-frame streams with no timestamps */
2286
    for(i=0;i<ic->nb_streams;i++) {
2287
        st = ic->streams[i];
2288
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2289
            if(b-frames){
2290
                ppktl = &ic->packet_buffer;
2291
                while(ppkt1){
2292
                    if(ppkt1->stream_index != i)
2293
                        continue;
2294
                    if(ppkt1->pkt->dts < 0)
2295
                        break;
2296
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2297
                        break;
2298
                    ppkt1->pkt->dts -= delta;
2299
                    ppkt1= ppkt1->next;
2300
                }
2301
                if(ppkt1)
2302
                    continue;
2303
                st->cur_dts -= delta;
2304
            }
2305
        }
2306
    }
2307
#endif
2308

    
2309
    av_free(duration_error);
2310

    
2311
    return ret;
2312
}
2313

    
2314
/*******************************************************/
2315

    
2316
int av_read_play(AVFormatContext *s)
2317
{
2318
    if (s->iformat->read_play)
2319
        return s->iformat->read_play(s);
2320
    if (s->pb)
2321
        return av_url_read_fpause(s->pb, 0);
2322
    return AVERROR(ENOSYS);
2323
}
2324

    
2325
int av_read_pause(AVFormatContext *s)
2326
{
2327
    if (s->iformat->read_pause)
2328
        return s->iformat->read_pause(s);
2329
    if (s->pb)
2330
        return av_url_read_fpause(s->pb, 1);
2331
    return AVERROR(ENOSYS);
2332
}
2333

    
2334
void av_close_input_stream(AVFormatContext *s)
2335
{
2336
    int i;
2337
    AVStream *st;
2338

    
2339
    if (s->iformat->read_close)
2340
        s->iformat->read_close(s);
2341
    for(i=0;i<s->nb_streams;i++) {
2342
        /* free all data in a stream component */
2343
        st = s->streams[i];
2344
        if (st->parser) {
2345
            av_parser_close(st->parser);
2346
            av_free_packet(&st->cur_pkt);
2347
        }
2348
        av_metadata_free(&st->metadata);
2349
        av_free(st->index_entries);
2350
        av_free(st->codec->extradata);
2351
        av_free(st->codec);
2352
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2353
        av_free(st->filename);
2354
#endif
2355
        av_free(st->priv_data);
2356
        av_free(st);
2357
    }
2358
    for(i=s->nb_programs-1; i>=0; i--) {
2359
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2360
        av_freep(&s->programs[i]->provider_name);
2361
        av_freep(&s->programs[i]->name);
2362
#endif
2363
        av_metadata_free(&s->programs[i]->metadata);
2364
        av_freep(&s->programs[i]->stream_index);
2365
        av_freep(&s->programs[i]);
2366
    }
2367
    av_freep(&s->programs);
2368
    flush_packet_queue(s);
2369
    av_freep(&s->priv_data);
2370
    while(s->nb_chapters--) {
2371
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2372
        av_free(s->chapters[s->nb_chapters]->title);
2373
#endif
2374
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2375
        av_free(s->chapters[s->nb_chapters]);
2376
    }
2377
    av_freep(&s->chapters);
2378
    av_metadata_free(&s->metadata);
2379
    av_free(s);
2380
}
2381

    
2382
void av_close_input_file(AVFormatContext *s)
2383
{
2384
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2385
    av_close_input_stream(s);
2386
    if (pb)
2387
        url_fclose(pb);
2388
}
2389

    
2390
AVStream *av_new_stream(AVFormatContext *s, int id)
2391
{
2392
    AVStream *st;
2393
    int i;
2394

    
2395
    if (s->nb_streams >= MAX_STREAMS)
2396
        return NULL;
2397

    
2398
    st = av_mallocz(sizeof(AVStream));
2399
    if (!st)
2400
        return NULL;
2401

    
2402
    st->codec= avcodec_alloc_context();
2403
    if (s->iformat) {
2404
        /* no default bitrate if decoding */
2405
        st->codec->bit_rate = 0;
2406
    }
2407
    st->index = s->nb_streams;
2408
    st->id = id;
2409
    st->start_time = AV_NOPTS_VALUE;
2410
    st->duration = AV_NOPTS_VALUE;
2411
        /* we set the current DTS to 0 so that formats without any timestamps
2412
           but durations get some timestamps, formats with some unknown
2413
           timestamps have their first few packets buffered and the
2414
           timestamps corrected before they are returned to the user */
2415
    st->cur_dts = 0;
2416
    st->first_dts = AV_NOPTS_VALUE;
2417
    st->probe_packets = MAX_PROBE_PACKETS;
2418

    
2419
    /* default pts setting is MPEG-like */
2420
    av_set_pts_info(st, 33, 1, 90000);
2421
    st->last_IP_pts = AV_NOPTS_VALUE;
2422
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2423
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2424
    st->reference_dts = AV_NOPTS_VALUE;
2425

    
2426
    st->sample_aspect_ratio = (AVRational){0,1};
2427

    
2428
    s->streams[s->nb_streams++] = st;
2429
    return st;
2430
}
2431

    
2432
AVProgram *av_new_program(AVFormatContext *ac, int id)
2433
{
2434
    AVProgram *program=NULL;
2435
    int i;
2436

    
2437
#ifdef DEBUG_SI
2438
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2439
#endif
2440

    
2441
    for(i=0; i<ac->nb_programs; i++)
2442
        if(ac->programs[i]->id == id)
2443
            program = ac->programs[i];
2444

    
2445
    if(!program){
2446
        program = av_mallocz(sizeof(AVProgram));
2447
        if (!program)
2448
            return NULL;
2449
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2450
        program->discard = AVDISCARD_NONE;
2451
    }
2452
    program->id = id;
2453

    
2454
    return program;
2455
}
2456

    
2457
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2458
{
2459
    AVChapter *chapter = NULL;
2460
    int i;
2461

    
2462
    for(i=0; i<s->nb_chapters; i++)
2463
        if(s->chapters[i]->id == id)
2464
            chapter = s->chapters[i];
2465

    
2466
    if(!chapter){
2467
        chapter= av_mallocz(sizeof(AVChapter));
2468
        if(!chapter)
2469
            return NULL;
2470
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2471
    }
2472
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2473
    av_free(chapter->title);
2474
#endif
2475
    av_metadata_set(&chapter->metadata, "title", title);
2476
    chapter->id    = id;
2477
    chapter->time_base= time_base;
2478
    chapter->start = start;
2479
    chapter->end   = end;
2480

    
2481
    return chapter;
2482
}
2483

    
2484
/************************************************************/
2485
/* output media file */
2486

    
2487
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2488
{
2489
    int ret;
2490

    
2491
    if (s->oformat->priv_data_size > 0) {
2492
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2493
        if (!s->priv_data)
2494
            return AVERROR(ENOMEM);
2495
    } else
2496
        s->priv_data = NULL;
2497

    
2498
    if (s->oformat->set_parameters) {
2499
        ret = s->oformat->set_parameters(s, ap);
2500
        if (ret < 0)
2501
            return ret;
2502
    }
2503
    return 0;
2504
}
2505

    
2506
int av_write_header(AVFormatContext *s)
2507
{
2508
    int ret, i;
2509
    AVStream *st;
2510

    
2511
    // some sanity checks
2512
    for(i=0;i<s->nb_streams;i++) {
2513
        st = s->streams[i];
2514

    
2515
        switch (st->codec->codec_type) {
2516
        case CODEC_TYPE_AUDIO:
2517
            if(st->codec->sample_rate<=0){
2518
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2519
                return -1;
2520
            }
2521
            if(!st->codec->block_align)
2522
                st->codec->block_align = st->codec->channels *
2523
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2524
            break;
2525
        case CODEC_TYPE_VIDEO:
2526
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2527
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2528
                return -1;
2529
            }
2530
            if(st->codec->width<=0 || st->codec->height<=0){
2531
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2532
                return -1;
2533
            }
2534
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2535
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2536
                return -1;
2537
            }
2538
            break;
2539
        }
2540

    
2541
        if(s->oformat->codec_tag){
2542
            if(st->codec->codec_tag){
2543
                //FIXME
2544
                //check that tag + id is in the table
2545
                //if neither is in the table -> OK
2546
                //if tag is in the table with another id -> FAIL
2547
                //if id is in the table with another tag -> FAIL unless strict < ?
2548
            }else
2549
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2550
        }
2551

    
2552
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2553
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2554
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2555
    }
2556

    
2557
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2558
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2559
        if (!s->priv_data)
2560
            return AVERROR(ENOMEM);
2561
    }
2562

    
2563
#if LIBAVFORMAT_VERSION_MAJOR < 53
2564
    ff_metadata_mux_compat(s);
2565
#endif
2566

    
2567
    if(s->oformat->write_header){
2568
        ret = s->oformat->write_header(s);
2569
        if (ret < 0)
2570
            return ret;
2571
    }
2572

    
2573
    /* init PTS generation */
2574
    for(i=0;i<s->nb_streams;i++) {
2575
        int64_t den = AV_NOPTS_VALUE;
2576
        st = s->streams[i];
2577

    
2578
        switch (st->codec->codec_type) {
2579
        case CODEC_TYPE_AUDIO:
2580
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2581
            break;
2582
        case CODEC_TYPE_VIDEO:
2583
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2584
            break;
2585
        default:
2586
            break;
2587
        }
2588
        if (den != AV_NOPTS_VALUE) {
2589
            if (den <= 0)
2590
                return AVERROR_INVALIDDATA;
2591
            av_frac_init(&st->pts, 0, 0, den);
2592
        }
2593
    }
2594
    return 0;
2595
}
2596

    
2597
//FIXME merge with compute_pkt_fields
2598
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2599
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2600
    int num, den, frame_size, i;
2601

    
2602
//    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);
2603

    
2604
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2605
        return -1;*/
2606

    
2607
    /* duration field */
2608
    if (pkt->duration == 0) {
2609
        compute_frame_duration(&num, &den, st, NULL, pkt);
2610
        if (den && num) {
2611
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2612
        }
2613
    }
2614

    
2615
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2616
        pkt->pts= pkt->dts;
2617

    
2618
    //XXX/FIXME this is a temporary hack until all encoders output pts
2619
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2620
        pkt->dts=
2621
//        pkt->pts= st->cur_dts;
2622
        pkt->pts= st->pts.val;
2623
    }
2624

    
2625
    //calculate dts from pts
2626
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2627
        st->pts_buffer[0]= pkt->pts;
2628
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2629
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2630
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2631
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2632

    
2633
        pkt->dts= st->pts_buffer[0];
2634
    }
2635

    
2636
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2637
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2638
        return -1;
2639
    }
2640
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2641
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2642
        return -1;
2643
    }
2644

    
2645
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2646
    st->cur_dts= pkt->dts;
2647
    st->pts.val= pkt->dts;
2648

    
2649
    /* update pts */
2650
    switch (st->codec->codec_type) {
2651
    case CODEC_TYPE_AUDIO:
2652
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2653

    
2654
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2655
           likely equal to the encoder delay, but it would be better if we
2656
           had the real timestamps from the encoder */
2657
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2658
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2659
        }
2660
        break;
2661
    case CODEC_TYPE_VIDEO:
2662
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2663
        break;
2664
    default:
2665
        break;
2666
    }
2667
    return 0;
2668
}
2669

    
2670
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2671
{
2672
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2673

    
2674
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2675
        return ret;
2676

    
2677
    ret= s->oformat->write_packet(s, pkt);
2678
    if(!ret)
2679
        ret= url_ferror(s->pb);
2680
    return ret;
2681
}
2682

    
2683
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2684
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2685
{
2686
    AVPacketList **next_point, *this_pktl;
2687

    
2688
    this_pktl = av_mallocz(sizeof(AVPacketList));
2689
    this_pktl->pkt= *pkt;
2690
    pkt->destruct= NULL;             // do not free original but only the copy
2691
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2692

    
2693
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2694
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2695
    }else
2696
        next_point = &s->packet_buffer;
2697

    
2698
    if(*next_point){
2699
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2700
            while(!compare(s, &(*next_point)->pkt, pkt)){
2701
                next_point= &(*next_point)->next;
2702
            }
2703
            goto next_non_null;
2704
        }else{
2705
            next_point = &(s->packet_buffer_end->next);
2706
        }
2707
    }
2708
    assert(!*next_point);
2709

    
2710
    s->packet_buffer_end= this_pktl;
2711
next_non_null:
2712

    
2713
    this_pktl->next= *next_point;
2714

    
2715
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2716
    *next_point= this_pktl;
2717
}
2718

    
2719
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2720
{
2721
    AVStream *st = s->streams[ pkt ->stream_index];
2722
    AVStream *st2= s->streams[ next->stream_index];
2723
    int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2724
    int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2725

    
2726
    if (pkt->dts == AV_NOPTS_VALUE)
2727
        return 0;
2728

    
2729
    return next->dts * left > pkt->dts * right; //FIXME this can overflow
2730
}
2731

    
2732
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2733
    AVPacketList *pktl;
2734
    int stream_count=0;
2735
    int i;
2736

    
2737
    if(pkt){
2738
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2739
    }
2740

    
2741
    for(i=0; i < s->nb_streams; i++)
2742
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2743

    
2744
    if(stream_count && (s->nb_streams == stream_count || flush)){
2745
        pktl= s->packet_buffer;
2746
        *out= pktl->pkt;
2747

    
2748
        s->packet_buffer= pktl->next;
2749
        if(!s->packet_buffer)
2750
            s->packet_buffer_end= NULL;
2751

    
2752
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2753
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2754
        av_freep(&pktl);
2755
        return 1;
2756
    }else{
2757
        av_init_packet(out);
2758
        return 0;
2759
    }
2760
}
2761

    
2762
/**
2763
 * Interleaves an AVPacket correctly so it can be muxed.
2764
 * @param out the interleaved packet will be output here
2765
 * @param in the input packet
2766
 * @param flush 1 if no further packets are available as input and all
2767
 *              remaining packets should be output
2768
 * @return 1 if a packet was output, 0 if no packet could be output,
2769
 *         < 0 if an error occurred
2770
 */
2771
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2772
    if(s->oformat->interleave_packet)
2773
        return s->oformat->interleave_packet(s, out, in, flush);
2774
    else
2775
        return av_interleave_packet_per_dts(s, out, in, flush);
2776
}
2777

    
2778
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2779
    AVStream *st= s->streams[ pkt->stream_index];
2780

    
2781
    //FIXME/XXX/HACK drop zero sized packets
2782
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2783
        return 0;
2784

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

    
2789
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2790
        return -1;
2791

    
2792
    for(;;){
2793
        AVPacket opkt;
2794
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2795
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2796
            return ret;
2797

    
2798
        ret= s->oformat->write_packet(s, &opkt);
2799

    
2800
        av_free_packet(&opkt);
2801
        pkt= NULL;
2802

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

    
2810
int av_write_trailer(AVFormatContext *s)
2811
{
2812
    int ret, i;
2813

    
2814
    for(;;){
2815
        AVPacket pkt;
2816
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2817
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2818
            goto fail;
2819
        if(!ret)
2820
            break;
2821

    
2822
        ret= s->oformat->write_packet(s, &pkt);
2823

    
2824
        av_free_packet(&pkt);
2825

    
2826
        if(ret<0)
2827
            goto fail;
2828
        if(url_ferror(s->pb))
2829
            goto fail;
2830
    }
2831

    
2832
    if(s->oformat->write_trailer)
2833
        ret = s->oformat->write_trailer(s);
2834
fail:
2835
    if(ret == 0)
2836
       ret=url_ferror(s->pb);
2837
    for(i=0;i<s->nb_streams;i++)
2838
        av_freep(&s->streams[i]->priv_data);
2839
    av_freep(&s->priv_data);
2840
    return ret;
2841
}
2842

    
2843
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2844
{
2845
    int i, j;
2846
    AVProgram *program=NULL;
2847
    void *tmp;
2848

    
2849
    if (idx >= ac->nb_streams) {
2850
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2851
        return;
2852
    }
2853

    
2854
    for(i=0; i<ac->nb_programs; i++){
2855
        if(ac->programs[i]->id != progid)
2856
            continue;
2857
        program = ac->programs[i];
2858
        for(j=0; j<program->nb_stream_indexes; j++)
2859
            if(program->stream_index[j] == idx)
2860
                return;
2861

    
2862
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2863
        if(!tmp)
2864
            return;
2865
        program->stream_index = tmp;
2866
        program->stream_index[program->nb_stream_indexes++] = idx;
2867
        return;
2868
    }
2869
}
2870

    
2871
static void print_fps(double d, const char *postfix){
2872
    uint64_t v= lrintf(d*100);
2873
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2874
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2875
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2876
}
2877

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

    
2918
void dump_format(AVFormatContext *ic,
2919
                 int index,
2920
                 const char *url,
2921
                 int is_output)
2922
{
2923
    int i;
2924
    uint8_t *printed = av_mallocz(ic->nb_streams);
2925
    if (ic->nb_streams && !printed)
2926
        return;
2927

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

    
2984
    if (ic->metadata) {
2985
        AVMetadataTag *tag=NULL;
2986
        av_log(NULL, AV_LOG_INFO, "  Metadata\n");
2987
        while((tag=av_metadata_get(ic->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2988
            av_log(NULL, AV_LOG_INFO, "    %-16s: %s\n", tag->key, tag->value);
2989
        }
2990
    }
2991
    av_free(printed);
2992
}
2993

    
2994
#if LIBAVFORMAT_VERSION_MAJOR < 53
2995
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2996
{
2997
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2998
}
2999

    
3000
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3001
{
3002
    AVRational frame_rate;
3003
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
3004
    *frame_rate_num= frame_rate.num;
3005
    *frame_rate_den= frame_rate.den;
3006
    return ret;
3007
}
3008
#endif
3009

    
3010
int64_t av_gettime(void)
3011
{
3012
    struct timeval tv;
3013
    gettimeofday(&tv,NULL);
3014
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3015
}
3016

    
3017
int64_t parse_date(const char *datestr, int duration)
3018
{
3019
    const char *p;
3020
    int64_t t;
3021
    struct tm dt;
3022
    int i;
3023
    static const char * const date_fmt[] = {
3024
        "%Y-%m-%d",
3025
        "%Y%m%d",
3026
    };
3027
    static const char * const time_fmt[] = {
3028
        "%H:%M:%S",
3029
        "%H%M%S",
3030
    };
3031
    const char *q;
3032
    int is_utc, len;
3033
    char lastch;
3034
    int negative = 0;
3035

    
3036
#undef time
3037
    time_t now = time(0);
3038

    
3039
    len = strlen(datestr);
3040
    if (len > 0)
3041
        lastch = datestr[len - 1];
3042
    else
3043
        lastch = '\0';
3044
    is_utc = (lastch == 'z' || lastch == 'Z');
3045

    
3046
    memset(&dt, 0, sizeof(dt));
3047

    
3048
    p = datestr;
3049
    q = NULL;
3050
    if (!duration) {
3051
        if (!strncasecmp(datestr, "now", len))
3052
            return (int64_t) now * 1000000;
3053

    
3054
        /* parse the year-month-day part */
3055
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3056
            q = small_strptime(p, date_fmt[i], &dt);
3057
            if (q) {
3058
                break;
3059
            }
3060
        }
3061

    
3062
        /* if the year-month-day part is missing, then take the
3063
         * current year-month-day time */
3064
        if (!q) {
3065
            if (is_utc) {
3066
                dt = *gmtime(&now);
3067
            } else {
3068
                dt = *localtime(&now);
3069
            }
3070
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3071
        } else {
3072
            p = q;
3073
        }
3074

    
3075
        if (*p == 'T' || *p == 't' || *p == ' ')
3076
            p++;
3077

    
3078
        /* parse the hour-minute-second part */
3079
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3080
            q = small_strptime(p, time_fmt[i], &dt);
3081
            if (q) {
3082
                break;
3083
            }
3084
        }
3085
    } else {
3086
        /* parse datestr as a duration */
3087
        if (p[0] == '-') {
3088
            negative = 1;
3089
            ++p;
3090
        }
3091
        /* parse datestr as HH:MM:SS */
3092
        q = small_strptime(p, time_fmt[0], &dt);
3093
        if (!q) {
3094
            /* parse datestr as S+ */
3095
            dt.tm_sec = strtol(p, (char **)&q, 10);
3096
            if (q == p)
3097
                /* the parsing didn't succeed */
3098
                return INT64_MIN;
3099
            dt.tm_min = 0;
3100
            dt.tm_hour = 0;
3101
        }
3102
    }
3103

    
3104
    /* Now we have all the fields that we can get */
3105
    if (!q) {
3106
        return INT64_MIN;
3107
    }
3108

    
3109
    if (duration) {
3110
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3111
    } else {
3112
        dt.tm_isdst = -1;       /* unknown */
3113
        if (is_utc) {
3114
            t = mktimegm(&dt);
3115
        } else {
3116
            t = mktime(&dt);
3117
        }
3118
    }
3119

    
3120
    t *= 1000000;
3121

    
3122
    /* parse the .m... part */
3123
    if (*q == '.') {
3124
        int val, n;
3125
        q++;
3126
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3127
            if (!isdigit(*q))
3128
                break;
3129
            val += n * (*q - '0');
3130
        }
3131
        t += val;
3132
    }
3133
    return negative ? -t : t;
3134
}
3135

    
3136
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3137
{
3138
    const char *p;
3139
    char tag[128], *q;
3140

    
3141
    p = info;
3142
    if (*p == '?')
3143
        p++;
3144
    for(;;) {
3145
        q = tag;
3146
        while (*p != '\0' && *p != '=' && *p != '&') {
3147
            if ((q - tag) < sizeof(tag) - 1)
3148
                *q++ = *p;
3149
            p++;
3150
        }
3151
        *q = '\0';
3152
        q = arg;
3153
        if (*p == '=') {
3154
            p++;
3155
            while (*p != '&' && *p != '\0') {
3156
                if ((q - arg) < arg_size - 1) {
3157
                    if (*p == '+')
3158
                        *q++ = ' ';
3159
                    else
3160
                        *q++ = *p;
3161
                }
3162
                p++;
3163
            }
3164
            *q = '\0';
3165
        }
3166
        if (!strcmp(tag, tag1))
3167
            return 1;
3168
        if (*p != '&')
3169
            break;
3170
        p++;
3171
    }
3172
    return 0;
3173
}
3174

    
3175
int av_get_frame_filename(char *buf, int buf_size,
3176
                          const char *path, int number)
3177
{
3178
    const char *p;
3179
    char *q, buf1[20], c;
3180
    int nd, len, percentd_found;
3181

    
3182
    q = buf;
3183
    p = path;
3184
    percentd_found = 0;
3185
    for(;;) {
3186
        c = *p++;
3187
        if (c == '\0')
3188
            break;
3189
        if (c == '%') {
3190
            do {
3191
                nd = 0;
3192
                while (isdigit(*p)) {
3193
                    nd = nd * 10 + *p++ - '0';
3194
                }
3195
                c = *p++;
3196
            } while (isdigit(c));
3197

    
3198
            switch(c) {
3199
            case '%':
3200
                goto addchar;
3201
            case 'd':
3202
                if (percentd_found)
3203
                    goto fail;
3204
                percentd_found = 1;
3205
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3206
                len = strlen(buf1);
3207
                if ((q - buf + len) > buf_size - 1)
3208
                    goto fail;
3209
                memcpy(q, buf1, len);
3210
                q += len;
3211
                break;
3212
            default:
3213
                goto fail;
3214
            }
3215
        } else {
3216
        addchar:
3217
            if ((q - buf) < buf_size - 1)
3218
                *q++ = c;
3219
        }
3220
    }
3221
    if (!percentd_found)
3222
        goto fail;
3223
    *q = '\0';
3224
    return 0;
3225
 fail:
3226
    *q = '\0';
3227
    return -1;
3228
}
3229

    
3230
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3231
{
3232
    int len, i, j, c;
3233
#undef fprintf
3234
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3235

    
3236
    for(i=0;i<size;i+=16) {
3237
        len = size - i;
3238
        if (len > 16)
3239
            len = 16;
3240
        PRINT("%08x ", i);
3241
        for(j=0;j<16;j++) {
3242
            if (j < len)
3243
                PRINT(" %02x", buf[i+j]);
3244
            else
3245
                PRINT("   ");
3246
        }
3247
        PRINT(" ");
3248
        for(j=0;j<len;j++) {
3249
            c = buf[i+j];
3250
            if (c < ' ' || c > '~')
3251
                c = '.';
3252
            PRINT("%c", c);
3253
        }
3254
        PRINT("\n");
3255
    }
3256
#undef PRINT
3257
}
3258

    
3259
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3260
{
3261
    hex_dump_internal(NULL, f, 0, buf, size);
3262
}
3263

    
3264
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3265
{
3266
    hex_dump_internal(avcl, NULL, level, buf, size);
3267
}
3268

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

    
3296
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3297
{
3298
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3299
}
3300

    
3301
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3302
{
3303
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3304
}
3305

    
3306
void url_split(char *proto, int proto_size,
3307
               char *authorization, int authorization_size,
3308
               char *hostname, int hostname_size,
3309
               int *port_ptr,
3310
               char *path, int path_size,
3311
               const char *url)
3312
{
3313
    const char *p, *ls, *at, *col, *brk;
3314

    
3315
    if (port_ptr)               *port_ptr = -1;
3316
    if (proto_size > 0)         proto[0] = 0;
3317
    if (authorization_size > 0) authorization[0] = 0;
3318
    if (hostname_size > 0)      hostname[0] = 0;
3319
    if (path_size > 0)          path[0] = 0;
3320

    
3321
    /* parse protocol */
3322
    if ((p = strchr(url, ':'))) {
3323
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3324
        p++; /* skip ':' */
3325
        if (*p == '/') p++;
3326
        if (*p == '/') p++;
3327
    } else {
3328
        /* no protocol means plain filename */
3329
        av_strlcpy(path, url, path_size);
3330
        return;
3331
    }
3332

    
3333
    /* separate path from hostname */
3334
    ls = strchr(p, '/');
3335
    if(!ls)
3336
        ls = strchr(p, '?');
3337
    if(ls)
3338
        av_strlcpy(path, ls, path_size);
3339
    else
3340
        ls = &p[strlen(p)]; // XXX
3341

    
3342
    /* the rest is hostname, use that to parse auth/port */
3343
    if (ls != p) {
3344
        /* authorization (user[:pass]@hostname) */
3345
        if ((at = strchr(p, '@')) && at < ls) {
3346
            av_strlcpy(authorization, p,
3347
                       FFMIN(authorization_size, at + 1 - p));
3348
            p = at + 1; /* skip '@' */
3349
        }
3350

    
3351
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3352
            /* [host]:port */
3353
            av_strlcpy(hostname, p + 1,
3354
                       FFMIN(hostname_size, brk - p));
3355
            if (brk[1] == ':' && port_ptr)
3356
                *port_ptr = atoi(brk + 2);
3357
        } else if ((col = strchr(p, ':')) && col < ls) {
3358
            av_strlcpy(hostname, p,
3359
                       FFMIN(col + 1 - p, hostname_size));
3360
            if (port_ptr) *port_ptr = atoi(col + 1);
3361
        } else
3362
            av_strlcpy(hostname, p,
3363
                       FFMIN(ls + 1 - p, hostname_size));
3364
    }
3365
}
3366

    
3367
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3368
{
3369
    int i;
3370
    static const char hex_table[16] = { '0', '1', '2', '3',
3371
                                        '4', '5', '6', '7',
3372
                                        '8', '9', 'A', 'B',
3373
                                        'C', 'D', 'E', 'F' };
3374

    
3375
    for(i = 0; i < s; i++) {
3376
        buff[i * 2]     = hex_table[src[i] >> 4];
3377
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3378
    }
3379

    
3380
    return buff;
3381
}
3382

    
3383
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3384
                     unsigned int pts_num, unsigned int pts_den)
3385
{
3386
    s->pts_wrap_bits = pts_wrap_bits;
3387

    
3388
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3389
        if(s->time_base.num != pts_num)
3390
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3391
    }else
3392
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3393

    
3394
    if(!s->time_base.num || !s->time_base.den)
3395
        s->time_base.num= s->time_base.den= 0;
3396
}