Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 01d91b9b

History | View | Annotate | Download (112 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 "audiointerleave.h"
28
#include <sys/time.h>
29
#include <time.h>
30
#include <strings.h>
31
#include <stdarg.h>
32
#if CONFIG_NETWORK
33
#include "network.h"
34
#endif
35

    
36
#undef NDEBUG
37
#include <assert.h>
38

    
39
/**
40
 * @file libavformat/utils.c
41
 * various utility functions for use within FFmpeg
42
 */
43

    
44
unsigned avformat_version(void)
45
{
46
    return LIBAVFORMAT_VERSION_INT;
47
}
48

    
49
const char *avformat_configuration(void)
50
{
51
    return FFMPEG_CONFIGURATION;
52
}
53

    
54
const char *avformat_license(void)
55
{
56
#define LICENSE_PREFIX "libavformat license: "
57
    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
58
}
59

    
60
/* fraction handling */
61

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

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

    
94
    num = f->num + incr;
95
    den = f->den;
96
    if (num < 0) {
97
        f->val += num / den;
98
        num = num % den;
99
        if (num < 0) {
100
            num += den;
101
            f->val--;
102
        }
103
    } else if (num >= den) {
104
        f->val += num / den;
105
        num = num % den;
106
    }
107
    f->num = num;
108
}
109

    
110
/** head of registered input format linked list */
111
AVInputFormat *first_iformat = NULL;
112
/** head of registered output format linked list */
113
AVOutputFormat *first_oformat = NULL;
114

    
115
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
116
{
117
    if(f) return f->next;
118
    else  return first_iformat;
119
}
120

    
121
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
122
{
123
    if(f) return f->next;
124
    else  return first_oformat;
125
}
126

    
127
void av_register_input_format(AVInputFormat *format)
128
{
129
    AVInputFormat **p;
130
    p = &first_iformat;
131
    while (*p != NULL) p = &(*p)->next;
132
    *p = format;
133
    format->next = NULL;
134
}
135

    
136
void av_register_output_format(AVOutputFormat *format)
137
{
138
    AVOutputFormat **p;
139
    p = &first_oformat;
140
    while (*p != NULL) p = &(*p)->next;
141
    *p = format;
142
    format->next = NULL;
143
}
144

    
145
int av_match_ext(const char *filename, const char *extensions)
146
{
147
    const char *ext, *p;
148
    char ext1[32], *q;
149

    
150
    if(!filename)
151
        return 0;
152

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

    
172
static int match_format(const char *name, const char *names)
173
{
174
    const char *p;
175
    int len, namelen;
176

    
177
    if (!name || !names)
178
        return 0;
179

    
180
    namelen = strlen(name);
181
    while ((p = strchr(names, ','))) {
182
        len = FFMAX(p - names, namelen);
183
        if (!strncasecmp(name, names, len))
184
            return 1;
185
        names = p+1;
186
    }
187
    return !strcasecmp(name, names);
188
}
189

    
190
#if LIBAVFORMAT_VERSION_MAJOR < 53
191
AVOutputFormat *guess_format(const char *short_name, const char *filename,
192
                             const char *mime_type)
193
{
194
    return av_guess_format(short_name, filename, mime_type);
195
}
196
#endif
197

    
198
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
199
                                const char *mime_type)
200
{
201
    AVOutputFormat *fmt, *fmt_found;
202
    int score_max, score;
203

    
204
    /* specific test for image sequences */
205
#if CONFIG_IMAGE2_MUXER
206
    if (!short_name && filename &&
207
        av_filename_number_test(filename) &&
208
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
209
        return av_guess_format("image2", NULL, NULL);
210
    }
211
#endif
212
    /* Find the proper file type. */
213
    fmt_found = NULL;
214
    score_max = 0;
215
    fmt = first_oformat;
216
    while (fmt != NULL) {
217
        score = 0;
218
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
219
            score += 100;
220
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
221
            score += 10;
222
        if (filename && fmt->extensions &&
223
            av_match_ext(filename, fmt->extensions)) {
224
            score += 5;
225
        }
226
        if (score > score_max) {
227
            score_max = score;
228
            fmt_found = fmt;
229
        }
230
        fmt = fmt->next;
231
    }
232
    return fmt_found;
233
}
234

    
235
#if LIBAVFORMAT_VERSION_MAJOR < 53
236
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
237
                             const char *mime_type)
238
{
239
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
240

    
241
    if (fmt) {
242
        AVOutputFormat *stream_fmt;
243
        char stream_format_name[64];
244

    
245
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
246
        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
247

    
248
        if (stream_fmt)
249
            fmt = stream_fmt;
250
    }
251

    
252
    return fmt;
253
}
254
#endif
255

    
256
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
257
                            const char *filename, const char *mime_type, enum AVMediaType type){
258
    if(type == AVMEDIA_TYPE_VIDEO){
259
        enum CodecID codec_id= CODEC_ID_NONE;
260

    
261
#if CONFIG_IMAGE2_MUXER
262
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
263
            codec_id= av_guess_image2_codec(filename);
264
        }
265
#endif
266
        if(codec_id == CODEC_ID_NONE)
267
            codec_id= fmt->video_codec;
268
        return codec_id;
269
    }else if(type == AVMEDIA_TYPE_AUDIO)
270
        return fmt->audio_codec;
271
    else
272
        return CODEC_ID_NONE;
273
}
274

    
275
AVInputFormat *av_find_input_format(const char *short_name)
276
{
277
    AVInputFormat *fmt;
278
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
279
        if (match_format(short_name, fmt->name))
280
            return fmt;
281
    }
282
    return NULL;
283
}
284

    
285
/* memory handling */
286

    
287

    
288
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
289
{
290
    int ret= av_new_packet(pkt, size);
291

    
292
    if(ret<0)
293
        return ret;
294

    
295
    pkt->pos= url_ftell(s);
296

    
297
    ret= get_buffer(s, pkt->data, size);
298
    if(ret<=0)
299
        av_free_packet(pkt);
300
    else
301
        av_shrink_packet(pkt, ret);
302

    
303
    return ret;
304
}
305

    
306

    
307
int av_filename_number_test(const char *filename)
308
{
309
    char buf[1024];
310
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
311
}
312

    
313
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
314
{
315
    AVInputFormat *fmt1, *fmt;
316
    int score;
317

    
318
    fmt = NULL;
319
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
320
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
321
            continue;
322
        score = 0;
323
        if (fmt1->read_probe) {
324
            score = fmt1->read_probe(pd);
325
        } else if (fmt1->extensions) {
326
            if (av_match_ext(pd->filename, fmt1->extensions)) {
327
                score = 50;
328
            }
329
        }
330
        if (score > *score_max) {
331
            *score_max = score;
332
            fmt = fmt1;
333
        }else if (score == *score_max)
334
            fmt = NULL;
335
    }
336
    return fmt;
337
}
338

    
339
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
340
    int score=0;
341
    return av_probe_input_format2(pd, is_opened, &score);
342
}
343

    
344
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
345
{
346
    AVInputFormat *fmt;
347
    fmt = av_probe_input_format2(pd, 1, &score);
348

    
349
    if (fmt) {
350
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
351
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
352
        if (!strcmp(fmt->name, "mp3")) {
353
            st->codec->codec_id = CODEC_ID_MP3;
354
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
355
        } else if (!strcmp(fmt->name, "ac3")) {
356
            st->codec->codec_id = CODEC_ID_AC3;
357
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
358
        } else if (!strcmp(fmt->name, "eac3")) {
359
            st->codec->codec_id = CODEC_ID_EAC3;
360
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
361
        } else if (!strcmp(fmt->name, "mpegvideo")) {
362
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
363
            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
364
        } else if (!strcmp(fmt->name, "m4v")) {
365
            st->codec->codec_id = CODEC_ID_MPEG4;
366
            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
367
        } else if (!strcmp(fmt->name, "h264")) {
368
            st->codec->codec_id = CODEC_ID_H264;
369
            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
370
        } else if (!strcmp(fmt->name, "dts")) {
371
            st->codec->codec_id = CODEC_ID_DTS;
372
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
373
        } else if (!strcmp(fmt->name, "aac")) {
374
            st->codec->codec_id = CODEC_ID_AAC;
375
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
376
        }
377
    }
378
    return !!fmt;
379
}
380

    
381
/************************************************************/
382
/* input media file */
383

    
384
/**
385
 * Open a media file from an IO stream. 'fmt' must be specified.
386
 */
387
int av_open_input_stream(AVFormatContext **ic_ptr,
388
                         ByteIOContext *pb, const char *filename,
389
                         AVInputFormat *fmt, AVFormatParameters *ap)
390
{
391
    int err;
392
    AVFormatContext *ic;
393
    AVFormatParameters default_ap;
394

    
395
    if(!ap){
396
        ap=&default_ap;
397
        memset(ap, 0, sizeof(default_ap));
398
    }
399

    
400
    if(!ap->prealloced_context)
401
        ic = avformat_alloc_context();
402
    else
403
        ic = *ic_ptr;
404
    if (!ic) {
405
        err = AVERROR(ENOMEM);
406
        goto fail;
407
    }
408
    ic->iformat = fmt;
409
    ic->pb = pb;
410
    ic->duration = AV_NOPTS_VALUE;
411
    ic->start_time = AV_NOPTS_VALUE;
412
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
413

    
414
    /* allocate private data */
415
    if (fmt->priv_data_size > 0) {
416
        ic->priv_data = av_mallocz(fmt->priv_data_size);
417
        if (!ic->priv_data) {
418
            err = AVERROR(ENOMEM);
419
            goto fail;
420
        }
421
    } else {
422
        ic->priv_data = NULL;
423
    }
424

    
425
    if (ic->iformat->read_header) {
426
        err = ic->iformat->read_header(ic, ap);
427
        if (err < 0)
428
            goto fail;
429
    }
430

    
431
    if (pb && !ic->data_offset)
432
        ic->data_offset = url_ftell(ic->pb);
433

    
434
#if LIBAVFORMAT_VERSION_MAJOR < 53
435
    ff_metadata_demux_compat(ic);
436
#endif
437

    
438
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
439

    
440
    *ic_ptr = ic;
441
    return 0;
442
 fail:
443
    if (ic) {
444
        int i;
445
        av_freep(&ic->priv_data);
446
        for(i=0;i<ic->nb_streams;i++) {
447
            AVStream *st = ic->streams[i];
448
            if (st) {
449
                av_free(st->priv_data);
450
                av_free(st->codec->extradata);
451
            }
452
            av_free(st);
453
        }
454
    }
455
    av_free(ic);
456
    *ic_ptr = NULL;
457
    return err;
458
}
459

    
460
/** size of probe buffer, for guessing file type from file contents */
461
#define PROBE_BUF_MIN 2048
462
#define PROBE_BUF_MAX (1<<20)
463

    
464
int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
465
                          const char *filename, void *logctx,
466
                          unsigned int offset, unsigned int max_probe_size)
467
{
468
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
469
    unsigned char *buf = NULL;
470
    int ret = 0, probe_size;
471

    
472
    if (!max_probe_size) {
473
        max_probe_size = PROBE_BUF_MAX;
474
    } else if (max_probe_size > PROBE_BUF_MAX) {
475
        max_probe_size = PROBE_BUF_MAX;
476
    } else if (max_probe_size < PROBE_BUF_MIN) {
477
        return AVERROR(EINVAL);
478
    }
479

    
480
    if (offset >= max_probe_size) {
481
        return AVERROR(EINVAL);
482
    }
483

    
484
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
485
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
486
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
487
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
488

    
489
        if (probe_size < offset) {
490
            continue;
491
        }
492

    
493
        /* read probe data */
494
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
495
        if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
496
            /* fail if error was not end of file, otherwise, lower score */
497
            if (ret != AVERROR_EOF) {
498
                av_free(buf);
499
                return ret;
500
            }
501
            score = 0;
502
            ret = 0;            /* error was end of file, nothing read */
503
        }
504
        pd.buf_size += ret;
505
        pd.buf = &buf[offset];
506

    
507
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
508

    
509
        /* guess file format */
510
        *fmt = av_probe_input_format2(&pd, 1, &score);
511
        if(*fmt){
512
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
513
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
514
            }else
515
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
516
        }
517
    }
518

    
519
    if (!*fmt) {
520
        av_free(buf);
521
        return AVERROR_INVALIDDATA;
522
    }
523

    
524
    /* rewind. reuse probe buffer to avoid seeking */
525
    if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
526
        av_free(buf);
527

    
528
    return ret;
529
}
530

    
531
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
532
                       AVInputFormat *fmt,
533
                       int buf_size,
534
                       AVFormatParameters *ap)
535
{
536
    int err;
537
    AVProbeData probe_data, *pd = &probe_data;
538
    ByteIOContext *pb = NULL;
539
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
540

    
541
    pd->filename = "";
542
    if (filename)
543
        pd->filename = filename;
544
    pd->buf = NULL;
545
    pd->buf_size = 0;
546

    
547
    if (!fmt) {
548
        /* guess format if no file can be opened */
549
        fmt = av_probe_input_format(pd, 0);
550
    }
551

    
552
    /* Do not open file if the format does not need it. XXX: specific
553
       hack needed to handle RTSP/TCP */
554
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
555
        /* if no file needed do not try to open one */
556
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
557
            goto fail;
558
        }
559
        if (buf_size > 0) {
560
            url_setbufsize(pb, buf_size);
561
        }
562
        if ((err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
563
            goto fail;
564
        }
565
    }
566

    
567
    /* if still no format found, error */
568
    if (!fmt) {
569
        err = AVERROR_INVALIDDATA;
570
        goto fail;
571
    }
572

    
573
    /* check filename in case an image number is expected */
574
    if (fmt->flags & AVFMT_NEEDNUMBER) {
575
        if (!av_filename_number_test(filename)) {
576
            err = AVERROR_NUMEXPECTED;
577
            goto fail;
578
        }
579
    }
580
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
581
    if (err)
582
        goto fail;
583
    return 0;
584
 fail:
585
    av_freep(&pd->buf);
586
    if (pb)
587
        url_fclose(pb);
588
    if (ap && ap->prealloced_context)
589
        av_free(*ic_ptr);
590
    *ic_ptr = NULL;
591
    return err;
592

    
593
}
594

    
595
/*******************************************************/
596

    
597
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
598
                               AVPacketList **plast_pktl){
599
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
600
    if (!pktl)
601
        return NULL;
602

    
603
    if (*packet_buffer)
604
        (*plast_pktl)->next = pktl;
605
    else
606
        *packet_buffer = pktl;
607

    
608
    /* add the packet in the buffered packet list */
609
    *plast_pktl = pktl;
610
    pktl->pkt= *pkt;
611
    return &pktl->pkt;
612
}
613

    
614
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
615
{
616
    int ret, i;
617
    AVStream *st;
618

    
619
    for(;;){
620
        AVPacketList *pktl = s->raw_packet_buffer;
621

    
622
        if (pktl) {
623
            *pkt = pktl->pkt;
624
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
625
               !s->streams[pkt->stream_index]->probe_packets ||
626
               s->raw_packet_buffer_remaining_size < pkt->size){
627
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
628
                av_freep(&pd->buf);
629
                pd->buf_size = 0;
630
                s->raw_packet_buffer = pktl->next;
631
                s->raw_packet_buffer_remaining_size += pkt->size;
632
                av_free(pktl);
633
                return 0;
634
            }
635
        }
636

    
637
        av_init_packet(pkt);
638
        ret= s->iformat->read_packet(s, pkt);
639
        if (ret < 0) {
640
            if (!pktl || ret == AVERROR(EAGAIN))
641
                return ret;
642
            for (i = 0; i < s->nb_streams; i++)
643
                s->streams[i]->probe_packets = 0;
644
            continue;
645
        }
646
        st= s->streams[pkt->stream_index];
647

    
648
        switch(st->codec->codec_type){
649
        case AVMEDIA_TYPE_VIDEO:
650
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
651
            break;
652
        case AVMEDIA_TYPE_AUDIO:
653
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
654
            break;
655
        case AVMEDIA_TYPE_SUBTITLE:
656
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
657
            break;
658
        }
659

    
660
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
661
                     !st->probe_packets))
662
            return ret;
663

    
664
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
665
        s->raw_packet_buffer_remaining_size -= pkt->size;
666

    
667
        if(st->codec->codec_id == CODEC_ID_PROBE){
668
            AVProbeData *pd = &st->probe_data;
669
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
670
            --st->probe_packets;
671

    
672
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
673
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
674
            pd->buf_size += pkt->size;
675
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
676

    
677
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
678
                set_codec_from_probe_data(s, st, pd, 1);
679
                if(st->codec->codec_id != CODEC_ID_PROBE){
680
                    pd->buf_size=0;
681
                    av_freep(&pd->buf);
682
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
683
                }
684
            }
685
        }
686
    }
687
}
688

    
689
/**********************************************************/
690

    
691
/**
692
 * Get the number of samples of an audio frame. Return -1 on error.
693
 */
694
static int get_audio_frame_size(AVCodecContext *enc, int size)
695
{
696
    int frame_size;
697

    
698
    if(enc->codec_id == CODEC_ID_VORBIS)
699
        return -1;
700

    
701
    if (enc->frame_size <= 1) {
702
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
703

    
704
        if (bits_per_sample) {
705
            if (enc->channels == 0)
706
                return -1;
707
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
708
        } else {
709
            /* used for example by ADPCM codecs */
710
            if (enc->bit_rate == 0)
711
                return -1;
712
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
713
        }
714
    } else {
715
        frame_size = enc->frame_size;
716
    }
717
    return frame_size;
718
}
719

    
720

    
721
/**
722
 * Return the frame duration in seconds. Return 0 if not available.
723
 */
724
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
725
                                   AVCodecParserContext *pc, AVPacket *pkt)
726
{
727
    int frame_size;
728

    
729
    *pnum = 0;
730
    *pden = 0;
731
    switch(st->codec->codec_type) {
732
    case AVMEDIA_TYPE_VIDEO:
733
        if(st->time_base.num*1000LL > st->time_base.den){
734
            *pnum = st->time_base.num;
735
            *pden = st->time_base.den;
736
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
737
            *pnum = st->codec->time_base.num;
738
            *pden = st->codec->time_base.den;
739
            if (pc && pc->repeat_pict) {
740
                *pnum = (*pnum) * (1 + pc->repeat_pict);
741
            }
742
        }
743
        break;
744
    case AVMEDIA_TYPE_AUDIO:
745
        frame_size = get_audio_frame_size(st->codec, pkt->size);
746
        if (frame_size < 0)
747
            break;
748
        *pnum = frame_size;
749
        *pden = st->codec->sample_rate;
750
        break;
751
    default:
752
        break;
753
    }
754
}
755

    
756
static int is_intra_only(AVCodecContext *enc){
757
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
758
        return 1;
759
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
760
        switch(enc->codec_id){
761
        case CODEC_ID_MJPEG:
762
        case CODEC_ID_MJPEGB:
763
        case CODEC_ID_LJPEG:
764
        case CODEC_ID_RAWVIDEO:
765
        case CODEC_ID_DVVIDEO:
766
        case CODEC_ID_HUFFYUV:
767
        case CODEC_ID_FFVHUFF:
768
        case CODEC_ID_ASV1:
769
        case CODEC_ID_ASV2:
770
        case CODEC_ID_VCR1:
771
        case CODEC_ID_DNXHD:
772
        case CODEC_ID_JPEG2000:
773
            return 1;
774
        default: break;
775
        }
776
    }
777
    return 0;
778
}
779

    
780
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
781
                                      int64_t dts, int64_t pts)
782
{
783
    AVStream *st= s->streams[stream_index];
784
    AVPacketList *pktl= s->packet_buffer;
785

    
786
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
787
        return;
788

    
789
    st->first_dts= dts - st->cur_dts;
790
    st->cur_dts= dts;
791

    
792
    for(; pktl; pktl= pktl->next){
793
        if(pktl->pkt.stream_index != stream_index)
794
            continue;
795
        //FIXME think more about this check
796
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
797
            pktl->pkt.pts += st->first_dts;
798

    
799
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
800
            pktl->pkt.dts += st->first_dts;
801

    
802
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
803
            st->start_time= pktl->pkt.pts;
804
    }
805
    if (st->start_time == AV_NOPTS_VALUE)
806
        st->start_time = pts;
807
}
808

    
809
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
810
{
811
    AVPacketList *pktl= s->packet_buffer;
812
    int64_t cur_dts= 0;
813

    
814
    if(st->first_dts != AV_NOPTS_VALUE){
815
        cur_dts= st->first_dts;
816
        for(; pktl; pktl= pktl->next){
817
            if(pktl->pkt.stream_index == pkt->stream_index){
818
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
819
                    break;
820
                cur_dts -= pkt->duration;
821
            }
822
        }
823
        pktl= s->packet_buffer;
824
        st->first_dts = cur_dts;
825
    }else if(st->cur_dts)
826
        return;
827

    
828
    for(; pktl; pktl= pktl->next){
829
        if(pktl->pkt.stream_index != pkt->stream_index)
830
            continue;
831
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
832
           && !pktl->pkt.duration){
833
            pktl->pkt.dts= cur_dts;
834
            if(!st->codec->has_b_frames)
835
                pktl->pkt.pts= cur_dts;
836
            cur_dts += pkt->duration;
837
            pktl->pkt.duration= pkt->duration;
838
        }else
839
            break;
840
    }
841
    if(st->first_dts == AV_NOPTS_VALUE)
842
        st->cur_dts= cur_dts;
843
}
844

    
845
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
846
                               AVCodecParserContext *pc, AVPacket *pkt)
847
{
848
    int num, den, presentation_delayed, delay, i;
849
    int64_t offset;
850

    
851
    if (s->flags & AVFMT_FLAG_NOFILLIN)
852
        return;
853

    
854
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
855
        pkt->dts= AV_NOPTS_VALUE;
856

    
857
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
858
        //FIXME Set low_delay = 0 when has_b_frames = 1
859
        st->codec->has_b_frames = 1;
860

    
861
    /* do we have a video B-frame ? */
862
    delay= st->codec->has_b_frames;
863
    presentation_delayed = 0;
864
    /* XXX: need has_b_frame, but cannot get it if the codec is
865
        not initialized */
866
    if (delay &&
867
        pc && pc->pict_type != FF_B_TYPE)
868
        presentation_delayed = 1;
869

    
870
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
871
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
872
        pkt->dts -= 1LL<<st->pts_wrap_bits;
873
    }
874

    
875
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
876
    // we take the conservative approach and discard both
877
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
878
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
879
        av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
880
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
881
    }
882

    
883
    if (pkt->duration == 0) {
884
        compute_frame_duration(&num, &den, st, pc, pkt);
885
        if (den && num) {
886
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
887

    
888
            if(pkt->duration != 0 && s->packet_buffer)
889
                update_initial_durations(s, st, pkt);
890
        }
891
    }
892

    
893
    /* correct timestamps with byte offset if demuxers only have timestamps
894
       on packet boundaries */
895
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
896
        /* this will estimate bitrate based on this frame's duration and size */
897
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
898
        if(pkt->pts != AV_NOPTS_VALUE)
899
            pkt->pts += offset;
900
        if(pkt->dts != AV_NOPTS_VALUE)
901
            pkt->dts += offset;
902
    }
903

    
904
    if (pc && pc->dts_sync_point >= 0) {
905
        // we have synchronization info from the parser
906
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
907
        if (den > 0) {
908
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
909
            if (pkt->dts != AV_NOPTS_VALUE) {
910
                // got DTS from the stream, update reference timestamp
911
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
912
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
913
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
914
                // compute DTS based on reference timestamp
915
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
916
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
917
            }
918
            if (pc->dts_sync_point > 0)
919
                st->reference_dts = pkt->dts; // new reference
920
        }
921
    }
922

    
923
    /* This may be redundant, but it should not hurt. */
924
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
925
        presentation_delayed = 1;
926

    
927
//    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);
928
    /* interpolate PTS and DTS if they are not present */
929
    //We skip H264 currently because delay and has_b_frames are not reliably set
930
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
931
        if (presentation_delayed) {
932
            /* DTS = decompression timestamp */
933
            /* PTS = presentation timestamp */
934
            if (pkt->dts == AV_NOPTS_VALUE)
935
                pkt->dts = st->last_IP_pts;
936
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
937
            if (pkt->dts == AV_NOPTS_VALUE)
938
                pkt->dts = st->cur_dts;
939

    
940
            /* this is tricky: the dts must be incremented by the duration
941
            of the frame we are displaying, i.e. the last I- or P-frame */
942
            if (st->last_IP_duration == 0)
943
                st->last_IP_duration = pkt->duration;
944
            if(pkt->dts != AV_NOPTS_VALUE)
945
                st->cur_dts = pkt->dts + st->last_IP_duration;
946
            st->last_IP_duration  = pkt->duration;
947
            st->last_IP_pts= pkt->pts;
948
            /* cannot compute PTS if not present (we can compute it only
949
            by knowing the future */
950
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
951
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
952
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
953
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
954
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
955
                    pkt->pts += pkt->duration;
956
    //                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);
957
                }
958
            }
959

    
960
            /* presentation is not delayed : PTS and DTS are the same */
961
            if(pkt->pts == AV_NOPTS_VALUE)
962
                pkt->pts = pkt->dts;
963
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
964
            if(pkt->pts == AV_NOPTS_VALUE)
965
                pkt->pts = st->cur_dts;
966
            pkt->dts = pkt->pts;
967
            if(pkt->pts != AV_NOPTS_VALUE)
968
                st->cur_dts = pkt->pts + pkt->duration;
969
        }
970
    }
971

    
972
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
973
        st->pts_buffer[0]= pkt->pts;
974
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
975
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
976
        if(pkt->dts == AV_NOPTS_VALUE)
977
            pkt->dts= st->pts_buffer[0];
978
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
979
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
980
        }
981
        if(pkt->dts > st->cur_dts)
982
            st->cur_dts = pkt->dts;
983
    }
984

    
985
//    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);
986

    
987
    /* update flags */
988
    if(is_intra_only(st->codec))
989
        pkt->flags |= AV_PKT_FLAG_KEY;
990
    else if (pc) {
991
        pkt->flags = 0;
992
        /* keyframe computation */
993
        if (pc->key_frame == 1)
994
            pkt->flags |= AV_PKT_FLAG_KEY;
995
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
996
            pkt->flags |= AV_PKT_FLAG_KEY;
997
    }
998
    if (pc)
999
        pkt->convergence_duration = pc->convergence_duration;
1000
}
1001

    
1002

    
1003
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1004
{
1005
    AVStream *st;
1006
    int len, ret, i;
1007

    
1008
    av_init_packet(pkt);
1009

    
1010
    for(;;) {
1011
        /* select current input stream component */
1012
        st = s->cur_st;
1013
        if (st) {
1014
            if (!st->need_parsing || !st->parser) {
1015
                /* no parsing needed: we just output the packet as is */
1016
                /* raw data support */
1017
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1018
                compute_pkt_fields(s, st, NULL, pkt);
1019
                s->cur_st = NULL;
1020
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1021
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1022
                    ff_reduce_index(s, st->index);
1023
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1024
                }
1025
                break;
1026
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1027
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1028
                                       st->cur_ptr, st->cur_len,
1029
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1030
                                       st->cur_pkt.pos);
1031
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1032
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1033
                /* increment read pointer */
1034
                st->cur_ptr += len;
1035
                st->cur_len -= len;
1036

    
1037
                /* return packet if any */
1038
                if (pkt->size) {
1039
                got_packet:
1040
                    pkt->duration = 0;
1041
                    pkt->stream_index = st->index;
1042
                    pkt->pts = st->parser->pts;
1043
                    pkt->dts = st->parser->dts;
1044
                    pkt->pos = st->parser->pos;
1045
                    pkt->destruct = NULL;
1046
                    compute_pkt_fields(s, st, st->parser, pkt);
1047

    
1048
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1049
                        ff_reduce_index(s, st->index);
1050
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1051
                                           0, 0, AVINDEX_KEYFRAME);
1052
                    }
1053

    
1054
                    break;
1055
                }
1056
            } else {
1057
                /* free packet */
1058
                av_free_packet(&st->cur_pkt);
1059
                s->cur_st = NULL;
1060
            }
1061
        } else {
1062
            AVPacket cur_pkt;
1063
            /* read next packet */
1064
            ret = av_read_packet(s, &cur_pkt);
1065
            if (ret < 0) {
1066
                if (ret == AVERROR(EAGAIN))
1067
                    return ret;
1068
                /* return the last frames, if any */
1069
                for(i = 0; i < s->nb_streams; i++) {
1070
                    st = s->streams[i];
1071
                    if (st->parser && st->need_parsing) {
1072
                        av_parser_parse2(st->parser, st->codec,
1073
                                        &pkt->data, &pkt->size,
1074
                                        NULL, 0,
1075
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1076
                                        AV_NOPTS_VALUE);
1077
                        if (pkt->size)
1078
                            goto got_packet;
1079
                    }
1080
                }
1081
                /* no more packets: really terminate parsing */
1082
                return ret;
1083
            }
1084
            st = s->streams[cur_pkt.stream_index];
1085
            st->cur_pkt= cur_pkt;
1086

    
1087
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1088
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1089
               st->cur_pkt.pts < st->cur_pkt.dts){
1090
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1091
                    st->cur_pkt.stream_index,
1092
                    st->cur_pkt.pts,
1093
                    st->cur_pkt.dts,
1094
                    st->cur_pkt.size);
1095
//                av_free_packet(&st->cur_pkt);
1096
//                return -1;
1097
            }
1098

    
1099
            if(s->debug & FF_FDEBUG_TS)
1100
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1101
                    st->cur_pkt.stream_index,
1102
                    st->cur_pkt.pts,
1103
                    st->cur_pkt.dts,
1104
                    st->cur_pkt.size,
1105
                    st->cur_pkt.duration,
1106
                    st->cur_pkt.flags);
1107

    
1108
            s->cur_st = st;
1109
            st->cur_ptr = st->cur_pkt.data;
1110
            st->cur_len = st->cur_pkt.size;
1111
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1112
                st->parser = av_parser_init(st->codec->codec_id);
1113
                if (!st->parser) {
1114
                    /* no parser available: just output the raw packets */
1115
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1116
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1117
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1118
                }
1119
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1120
                    st->parser->next_frame_offset=
1121
                    st->parser->cur_offset= st->cur_pkt.pos;
1122
                }
1123
            }
1124
        }
1125
    }
1126
    if(s->debug & FF_FDEBUG_TS)
1127
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1128
            pkt->stream_index,
1129
            pkt->pts,
1130
            pkt->dts,
1131
            pkt->size,
1132
            pkt->duration,
1133
            pkt->flags);
1134

    
1135
    return 0;
1136
}
1137

    
1138
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1139
{
1140
    AVPacketList *pktl;
1141
    int eof=0;
1142
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1143

    
1144
    for(;;){
1145
        pktl = s->packet_buffer;
1146
        if (pktl) {
1147
            AVPacket *next_pkt= &pktl->pkt;
1148

    
1149
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1150
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1151
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1152
                       && next_pkt->dts < pktl->pkt.dts
1153
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1154
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1155
                        next_pkt->pts= pktl->pkt.dts;
1156
                    }
1157
                    pktl= pktl->next;
1158
                }
1159
                pktl = s->packet_buffer;
1160
            }
1161

    
1162
            if(   next_pkt->pts != AV_NOPTS_VALUE
1163
               || next_pkt->dts == AV_NOPTS_VALUE
1164
               || !genpts || eof){
1165
                /* read packet from packet buffer, if there is data */
1166
                *pkt = *next_pkt;
1167
                s->packet_buffer = pktl->next;
1168
                av_free(pktl);
1169
                return 0;
1170
            }
1171
        }
1172
        if(genpts){
1173
            int ret= av_read_frame_internal(s, pkt);
1174
            if(ret<0){
1175
                if(pktl && ret != AVERROR(EAGAIN)){
1176
                    eof=1;
1177
                    continue;
1178
                }else
1179
                    return ret;
1180
            }
1181

    
1182
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1183
                                           &s->packet_buffer_end)) < 0)
1184
                return AVERROR(ENOMEM);
1185
        }else{
1186
            assert(!s->packet_buffer);
1187
            return av_read_frame_internal(s, pkt);
1188
        }
1189
    }
1190
}
1191

    
1192
/* XXX: suppress the packet queue */
1193
static void flush_packet_queue(AVFormatContext *s)
1194
{
1195
    AVPacketList *pktl;
1196

    
1197
    for(;;) {
1198
        pktl = s->packet_buffer;
1199
        if (!pktl)
1200
            break;
1201
        s->packet_buffer = pktl->next;
1202
        av_free_packet(&pktl->pkt);
1203
        av_free(pktl);
1204
    }
1205
    while(s->raw_packet_buffer){
1206
        pktl = s->raw_packet_buffer;
1207
        s->raw_packet_buffer = pktl->next;
1208
        av_free_packet(&pktl->pkt);
1209
        av_free(pktl);
1210
    }
1211
    s->packet_buffer_end=
1212
    s->raw_packet_buffer_end= NULL;
1213
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1214
}
1215

    
1216
/*******************************************************/
1217
/* seek support */
1218

    
1219
int av_find_default_stream_index(AVFormatContext *s)
1220
{
1221
    int first_audio_index = -1;
1222
    int i;
1223
    AVStream *st;
1224

    
1225
    if (s->nb_streams <= 0)
1226
        return -1;
1227
    for(i = 0; i < s->nb_streams; i++) {
1228
        st = s->streams[i];
1229
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1230
            return i;
1231
        }
1232
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1233
            first_audio_index = i;
1234
    }
1235
    return first_audio_index >= 0 ? first_audio_index : 0;
1236
}
1237

    
1238
/**
1239
 * Flush the frame reader.
1240
 */
1241
void ff_read_frame_flush(AVFormatContext *s)
1242
{
1243
    AVStream *st;
1244
    int i, j;
1245

    
1246
    flush_packet_queue(s);
1247

    
1248
    s->cur_st = NULL;
1249

    
1250
    /* for each stream, reset read state */
1251
    for(i = 0; i < s->nb_streams; i++) {
1252
        st = s->streams[i];
1253

    
1254
        if (st->parser) {
1255
            av_parser_close(st->parser);
1256
            st->parser = NULL;
1257
            av_free_packet(&st->cur_pkt);
1258
        }
1259
        st->last_IP_pts = AV_NOPTS_VALUE;
1260
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1261
        st->reference_dts = AV_NOPTS_VALUE;
1262
        /* fail safe */
1263
        st->cur_ptr = NULL;
1264
        st->cur_len = 0;
1265

    
1266
        st->probe_packets = MAX_PROBE_PACKETS;
1267

    
1268
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1269
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1270
    }
1271
}
1272

    
1273
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1274
    int i;
1275

    
1276
    for(i = 0; i < s->nb_streams; i++) {
1277
        AVStream *st = s->streams[i];
1278

    
1279
        st->cur_dts = av_rescale(timestamp,
1280
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1281
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1282
    }
1283
}
1284

    
1285
void ff_reduce_index(AVFormatContext *s, int stream_index)
1286
{
1287
    AVStream *st= s->streams[stream_index];
1288
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1289

    
1290
    if((unsigned)st->nb_index_entries >= max_entries){
1291
        int i;
1292
        for(i=0; 2*i<st->nb_index_entries; i++)
1293
            st->index_entries[i]= st->index_entries[2*i];
1294
        st->nb_index_entries= i;
1295
    }
1296
}
1297

    
1298
int av_add_index_entry(AVStream *st,
1299
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1300
{
1301
    AVIndexEntry *entries, *ie;
1302
    int index;
1303

    
1304
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1305
        return -1;
1306

    
1307
    entries = av_fast_realloc(st->index_entries,
1308
                              &st->index_entries_allocated_size,
1309
                              (st->nb_index_entries + 1) *
1310
                              sizeof(AVIndexEntry));
1311
    if(!entries)
1312
        return -1;
1313

    
1314
    st->index_entries= entries;
1315

    
1316
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1317

    
1318
    if(index<0){
1319
        index= st->nb_index_entries++;
1320
        ie= &entries[index];
1321
        assert(index==0 || ie[-1].timestamp < timestamp);
1322
    }else{
1323
        ie= &entries[index];
1324
        if(ie->timestamp != timestamp){
1325
            if(ie->timestamp <= timestamp)
1326
                return -1;
1327
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1328
            st->nb_index_entries++;
1329
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1330
            distance= ie->min_distance;
1331
    }
1332

    
1333
    ie->pos = pos;
1334
    ie->timestamp = timestamp;
1335
    ie->min_distance= distance;
1336
    ie->size= size;
1337
    ie->flags = flags;
1338

    
1339
    return index;
1340
}
1341

    
1342
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1343
                              int flags)
1344
{
1345
    AVIndexEntry *entries= st->index_entries;
1346
    int nb_entries= st->nb_index_entries;
1347
    int a, b, m;
1348
    int64_t timestamp;
1349

    
1350
    a = - 1;
1351
    b = nb_entries;
1352

    
1353
    //optimize appending index entries at the end
1354
    if(b && entries[b-1].timestamp < wanted_timestamp)
1355
        a= b-1;
1356

    
1357
    while (b - a > 1) {
1358
        m = (a + b) >> 1;
1359
        timestamp = entries[m].timestamp;
1360
        if(timestamp >= wanted_timestamp)
1361
            b = m;
1362
        if(timestamp <= wanted_timestamp)
1363
            a = m;
1364
    }
1365
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1366

    
1367
    if(!(flags & AVSEEK_FLAG_ANY)){
1368
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1369
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1370
        }
1371
    }
1372

    
1373
    if(m == nb_entries)
1374
        return -1;
1375
    return  m;
1376
}
1377

    
1378
#define DEBUG_SEEK
1379

    
1380
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1381
    AVInputFormat *avif= s->iformat;
1382
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1383
    int64_t ts_min, ts_max, ts;
1384
    int index;
1385
    int64_t ret;
1386
    AVStream *st;
1387

    
1388
    if (stream_index < 0)
1389
        return -1;
1390

    
1391
#ifdef DEBUG_SEEK
1392
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1393
#endif
1394

    
1395
    ts_max=
1396
    ts_min= AV_NOPTS_VALUE;
1397
    pos_limit= -1; //gcc falsely says it may be uninitialized
1398

    
1399
    st= s->streams[stream_index];
1400
    if(st->index_entries){
1401
        AVIndexEntry *e;
1402

    
1403
        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()
1404
        index= FFMAX(index, 0);
1405
        e= &st->index_entries[index];
1406

    
1407
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1408
            pos_min= e->pos;
1409
            ts_min= e->timestamp;
1410
#ifdef DEBUG_SEEK
1411
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1412
                   pos_min,ts_min);
1413
#endif
1414
        }else{
1415
            assert(index==0);
1416
        }
1417

    
1418
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1419
        assert(index < st->nb_index_entries);
1420
        if(index >= 0){
1421
            e= &st->index_entries[index];
1422
            assert(e->timestamp >= target_ts);
1423
            pos_max= e->pos;
1424
            ts_max= e->timestamp;
1425
            pos_limit= pos_max - e->min_distance;
1426
#ifdef DEBUG_SEEK
1427
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1428
                   pos_max,pos_limit, ts_max);
1429
#endif
1430
        }
1431
    }
1432

    
1433
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1434
    if(pos<0)
1435
        return -1;
1436

    
1437
    /* do the seek */
1438
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1439
        return ret;
1440

    
1441
    av_update_cur_dts(s, st, ts);
1442

    
1443
    return 0;
1444
}
1445

    
1446
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 )){
1447
    int64_t pos, ts;
1448
    int64_t start_pos, filesize;
1449
    int no_change;
1450

    
1451
#ifdef DEBUG_SEEK
1452
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1453
#endif
1454

    
1455
    if(ts_min == AV_NOPTS_VALUE){
1456
        pos_min = s->data_offset;
1457
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1458
        if (ts_min == AV_NOPTS_VALUE)
1459
            return -1;
1460
    }
1461

    
1462
    if(ts_max == AV_NOPTS_VALUE){
1463
        int step= 1024;
1464
        filesize = url_fsize(s->pb);
1465
        pos_max = filesize - 1;
1466
        do{
1467
            pos_max -= step;
1468
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1469
            step += step;
1470
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1471
        if (ts_max == AV_NOPTS_VALUE)
1472
            return -1;
1473

    
1474
        for(;;){
1475
            int64_t tmp_pos= pos_max + 1;
1476
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1477
            if(tmp_ts == AV_NOPTS_VALUE)
1478
                break;
1479
            ts_max= tmp_ts;
1480
            pos_max= tmp_pos;
1481
            if(tmp_pos >= filesize)
1482
                break;
1483
        }
1484
        pos_limit= pos_max;
1485
    }
1486

    
1487
    if(ts_min > ts_max){
1488
        return -1;
1489
    }else if(ts_min == ts_max){
1490
        pos_limit= pos_min;
1491
    }
1492

    
1493
    no_change=0;
1494
    while (pos_min < pos_limit) {
1495
#ifdef DEBUG_SEEK
1496
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1497
               pos_min, pos_max,
1498
               ts_min, ts_max);
1499
#endif
1500
        assert(pos_limit <= pos_max);
1501

    
1502
        if(no_change==0){
1503
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1504
            // interpolate position (better than dichotomy)
1505
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1506
                + pos_min - approximate_keyframe_distance;
1507
        }else if(no_change==1){
1508
            // bisection, if interpolation failed to change min or max pos last time
1509
            pos = (pos_min + pos_limit)>>1;
1510
        }else{
1511
            /* linear search if bisection failed, can only happen if there
1512
               are very few or no keyframes between min/max */
1513
            pos=pos_min;
1514
        }
1515
        if(pos <= pos_min)
1516
            pos= pos_min + 1;
1517
        else if(pos > pos_limit)
1518
            pos= pos_limit;
1519
        start_pos= pos;
1520

    
1521
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1522
        if(pos == pos_max)
1523
            no_change++;
1524
        else
1525
            no_change=0;
1526
#ifdef DEBUG_SEEK
1527
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1528
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1529
               start_pos, no_change);
1530
#endif
1531
        if(ts == AV_NOPTS_VALUE){
1532
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1533
            return -1;
1534
        }
1535
        assert(ts != AV_NOPTS_VALUE);
1536
        if (target_ts <= ts) {
1537
            pos_limit = start_pos - 1;
1538
            pos_max = pos;
1539
            ts_max = ts;
1540
        }
1541
        if (target_ts >= ts) {
1542
            pos_min = pos;
1543
            ts_min = ts;
1544
        }
1545
    }
1546

    
1547
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1548
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1549
#ifdef DEBUG_SEEK
1550
    pos_min = pos;
1551
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1552
    pos_min++;
1553
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1554
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1555
           pos, ts_min, target_ts, ts_max);
1556
#endif
1557
    *ts_ret= ts;
1558
    return pos;
1559
}
1560

    
1561
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1562
    int64_t pos_min, pos_max;
1563
#if 0
1564
    AVStream *st;
1565

1566
    if (stream_index < 0)
1567
        return -1;
1568

1569
    st= s->streams[stream_index];
1570
#endif
1571

    
1572
    pos_min = s->data_offset;
1573
    pos_max = url_fsize(s->pb) - 1;
1574

    
1575
    if     (pos < pos_min) pos= pos_min;
1576
    else if(pos > pos_max) pos= pos_max;
1577

    
1578
    url_fseek(s->pb, pos, SEEK_SET);
1579

    
1580
#if 0
1581
    av_update_cur_dts(s, st, ts);
1582
#endif
1583
    return 0;
1584
}
1585

    
1586
static int av_seek_frame_generic(AVFormatContext *s,
1587
                                 int stream_index, int64_t timestamp, int flags)
1588
{
1589
    int index;
1590
    int64_t ret;
1591
    AVStream *st;
1592
    AVIndexEntry *ie;
1593

    
1594
    st = s->streams[stream_index];
1595

    
1596
    index = av_index_search_timestamp(st, timestamp, flags);
1597

    
1598
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1599
        return -1;
1600

    
1601
    if(index < 0 || index==st->nb_index_entries-1){
1602
        int i;
1603
        AVPacket pkt;
1604

    
1605
        if(st->nb_index_entries){
1606
            assert(st->index_entries);
1607
            ie= &st->index_entries[st->nb_index_entries-1];
1608
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1609
                return ret;
1610
            av_update_cur_dts(s, st, ie->timestamp);
1611
        }else{
1612
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1613
                return ret;
1614
        }
1615
        for(i=0;; i++) {
1616
            int ret;
1617
            do{
1618
                ret = av_read_frame(s, &pkt);
1619
            }while(ret == AVERROR(EAGAIN));
1620
            if(ret<0)
1621
                break;
1622
            av_free_packet(&pkt);
1623
            if(stream_index == pkt.stream_index){
1624
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1625
                    break;
1626
            }
1627
        }
1628
        index = av_index_search_timestamp(st, timestamp, flags);
1629
    }
1630
    if (index < 0)
1631
        return -1;
1632

    
1633
    ff_read_frame_flush(s);
1634
    if (s->iformat->read_seek){
1635
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1636
            return 0;
1637
    }
1638
    ie = &st->index_entries[index];
1639
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1640
        return ret;
1641
    av_update_cur_dts(s, st, ie->timestamp);
1642

    
1643
    return 0;
1644
}
1645

    
1646
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1647
{
1648
    int ret;
1649
    AVStream *st;
1650

    
1651
    ff_read_frame_flush(s);
1652

    
1653
    if(flags & AVSEEK_FLAG_BYTE)
1654
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1655

    
1656
    if(stream_index < 0){
1657
        stream_index= av_find_default_stream_index(s);
1658
        if(stream_index < 0)
1659
            return -1;
1660

    
1661
        st= s->streams[stream_index];
1662
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1663
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1664
    }
1665

    
1666
    /* first, we try the format specific seek */
1667
    if (s->iformat->read_seek)
1668
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1669
    else
1670
        ret = -1;
1671
    if (ret >= 0) {
1672
        return 0;
1673
    }
1674

    
1675
    if(s->iformat->read_timestamp)
1676
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1677
    else
1678
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1679
}
1680

    
1681
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1682
{
1683
    if(min_ts > ts || max_ts < ts)
1684
        return -1;
1685

    
1686
    ff_read_frame_flush(s);
1687

    
1688
    if (s->iformat->read_seek2)
1689
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1690

    
1691
    if(s->iformat->read_timestamp){
1692
        //try to seek via read_timestamp()
1693
    }
1694

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

    
1700
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1701
}
1702

    
1703
/*******************************************************/
1704

    
1705
/**
1706
 * Returns TRUE if the stream has accurate duration in any stream.
1707
 *
1708
 * @return TRUE if the stream has accurate duration for at least one component.
1709
 */
1710
static int av_has_duration(AVFormatContext *ic)
1711
{
1712
    int i;
1713
    AVStream *st;
1714

    
1715
    for(i = 0;i < ic->nb_streams; i++) {
1716
        st = ic->streams[i];
1717
        if (st->duration != AV_NOPTS_VALUE)
1718
            return 1;
1719
    }
1720
    return 0;
1721
}
1722

    
1723
/**
1724
 * Estimate the stream timings from the one of each components.
1725
 *
1726
 * Also computes the global bitrate if possible.
1727
 */
1728
static void av_update_stream_timings(AVFormatContext *ic)
1729
{
1730
    int64_t start_time, start_time1, end_time, end_time1;
1731
    int64_t duration, duration1;
1732
    int i;
1733
    AVStream *st;
1734

    
1735
    start_time = INT64_MAX;
1736
    end_time = INT64_MIN;
1737
    duration = INT64_MIN;
1738
    for(i = 0;i < ic->nb_streams; i++) {
1739
        st = ic->streams[i];
1740
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1741
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1742
            if (start_time1 < start_time)
1743
                start_time = start_time1;
1744
            if (st->duration != AV_NOPTS_VALUE) {
1745
                end_time1 = start_time1
1746
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1747
                if (end_time1 > end_time)
1748
                    end_time = end_time1;
1749
            }
1750
        }
1751
        if (st->duration != AV_NOPTS_VALUE) {
1752
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1753
            if (duration1 > duration)
1754
                duration = duration1;
1755
        }
1756
    }
1757
    if (start_time != INT64_MAX) {
1758
        ic->start_time = start_time;
1759
        if (end_time != INT64_MIN) {
1760
            if (end_time - start_time > duration)
1761
                duration = end_time - start_time;
1762
        }
1763
    }
1764
    if (duration != INT64_MIN) {
1765
        ic->duration = duration;
1766
        if (ic->file_size > 0) {
1767
            /* compute the bitrate */
1768
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1769
                (double)ic->duration;
1770
        }
1771
    }
1772
}
1773

    
1774
static void fill_all_stream_timings(AVFormatContext *ic)
1775
{
1776
    int i;
1777
    AVStream *st;
1778

    
1779
    av_update_stream_timings(ic);
1780
    for(i = 0;i < ic->nb_streams; i++) {
1781
        st = ic->streams[i];
1782
        if (st->start_time == AV_NOPTS_VALUE) {
1783
            if(ic->start_time != AV_NOPTS_VALUE)
1784
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1785
            if(ic->duration != AV_NOPTS_VALUE)
1786
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1787
        }
1788
    }
1789
}
1790

    
1791
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1792
{
1793
    int64_t filesize, duration;
1794
    int bit_rate, i;
1795
    AVStream *st;
1796

    
1797
    /* if bit_rate is already set, we believe it */
1798
    if (ic->bit_rate == 0) {
1799
        bit_rate = 0;
1800
        for(i=0;i<ic->nb_streams;i++) {
1801
            st = ic->streams[i];
1802
            bit_rate += st->codec->bit_rate;
1803
        }
1804
        ic->bit_rate = bit_rate;
1805
    }
1806

    
1807
    /* if duration is already set, we believe it */
1808
    if (ic->duration == AV_NOPTS_VALUE &&
1809
        ic->bit_rate != 0 &&
1810
        ic->file_size != 0)  {
1811
        filesize = ic->file_size;
1812
        if (filesize > 0) {
1813
            for(i = 0; i < ic->nb_streams; i++) {
1814
                st = ic->streams[i];
1815
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1816
                if (st->duration == AV_NOPTS_VALUE)
1817
                    st->duration = duration;
1818
            }
1819
        }
1820
    }
1821
}
1822

    
1823
#define DURATION_MAX_READ_SIZE 250000
1824
#define DURATION_MAX_RETRY 3
1825

    
1826
/* only usable for MPEG-PS streams */
1827
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1828
{
1829
    AVPacket pkt1, *pkt = &pkt1;
1830
    AVStream *st;
1831
    int read_size, i, ret;
1832
    int64_t end_time, start_time[MAX_STREAMS];
1833
    int64_t filesize, offset, duration;
1834
    int retry=0;
1835

    
1836
    ic->cur_st = NULL;
1837

    
1838
    /* flush packet queue */
1839
    flush_packet_queue(ic);
1840

    
1841
    for(i=0;i<ic->nb_streams;i++) {
1842
        st = ic->streams[i];
1843
        if(st->start_time != AV_NOPTS_VALUE){
1844
            start_time[i]= st->start_time;
1845
        }else if(st->first_dts != AV_NOPTS_VALUE){
1846
            start_time[i]= st->first_dts;
1847
        }else
1848
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1849

    
1850
        if (st->parser) {
1851
            av_parser_close(st->parser);
1852
            st->parser= NULL;
1853
            av_free_packet(&st->cur_pkt);
1854
        }
1855
    }
1856

    
1857
    /* estimate the end time (duration) */
1858
    /* XXX: may need to support wrapping */
1859
    filesize = ic->file_size;
1860
    end_time = AV_NOPTS_VALUE;
1861
    do{
1862
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1863
    if (offset < 0)
1864
        offset = 0;
1865

    
1866
    url_fseek(ic->pb, offset, SEEK_SET);
1867
    read_size = 0;
1868
    for(;;) {
1869
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1870
            break;
1871

    
1872
        do{
1873
            ret = av_read_packet(ic, pkt);
1874
        }while(ret == AVERROR(EAGAIN));
1875
        if (ret != 0)
1876
            break;
1877
        read_size += pkt->size;
1878
        st = ic->streams[pkt->stream_index];
1879
        if (pkt->pts != AV_NOPTS_VALUE &&
1880
            start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1881
            end_time = pkt->pts;
1882
            duration = end_time - start_time[pkt->stream_index];
1883
            if (duration < 0)
1884
                duration += 1LL<<st->pts_wrap_bits;
1885
            if (duration > 0) {
1886
                if (st->duration == AV_NOPTS_VALUE ||
1887
                    st->duration < duration)
1888
                    st->duration = duration;
1889
            }
1890
        }
1891
        av_free_packet(pkt);
1892
    }
1893
    }while(   end_time==AV_NOPTS_VALUE
1894
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1895
           && ++retry <= DURATION_MAX_RETRY);
1896

    
1897
    fill_all_stream_timings(ic);
1898

    
1899
    url_fseek(ic->pb, old_offset, SEEK_SET);
1900
    for(i=0; i<ic->nb_streams; i++){
1901
        st= ic->streams[i];
1902
        st->cur_dts= st->first_dts;
1903
        st->last_IP_pts = AV_NOPTS_VALUE;
1904
    }
1905
}
1906

    
1907
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1908
{
1909
    int64_t file_size;
1910

    
1911
    /* get the file size, if possible */
1912
    if (ic->iformat->flags & AVFMT_NOFILE) {
1913
        file_size = 0;
1914
    } else {
1915
        file_size = url_fsize(ic->pb);
1916
        if (file_size < 0)
1917
            file_size = 0;
1918
    }
1919
    ic->file_size = file_size;
1920

    
1921
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1922
         !strcmp(ic->iformat->name, "mpegts")) &&
1923
        file_size && !url_is_streamed(ic->pb)) {
1924
        /* get accurate estimate from the PTSes */
1925
        av_estimate_timings_from_pts(ic, old_offset);
1926
    } else if (av_has_duration(ic)) {
1927
        /* at least one component has timings - we use them for all
1928
           the components */
1929
        fill_all_stream_timings(ic);
1930
    } else {
1931
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1932
        /* less precise: use bitrate info */
1933
        av_estimate_timings_from_bit_rate(ic);
1934
    }
1935
    av_update_stream_timings(ic);
1936

    
1937
#if 0
1938
    {
1939
        int i;
1940
        AVStream *st;
1941
        for(i = 0;i < ic->nb_streams; i++) {
1942
            st = ic->streams[i];
1943
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1944
               i, (double)st->start_time / AV_TIME_BASE,
1945
               (double)st->duration / AV_TIME_BASE);
1946
        }
1947
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1948
               (double)ic->start_time / AV_TIME_BASE,
1949
               (double)ic->duration / AV_TIME_BASE,
1950
               ic->bit_rate / 1000);
1951
    }
1952
#endif
1953
}
1954

    
1955
static int has_codec_parameters(AVCodecContext *enc)
1956
{
1957
    int val;
1958
    switch(enc->codec_type) {
1959
    case AVMEDIA_TYPE_AUDIO:
1960
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1961
        if(!enc->frame_size &&
1962
           (enc->codec_id == CODEC_ID_VORBIS ||
1963
            enc->codec_id == CODEC_ID_AAC ||
1964
            enc->codec_id == CODEC_ID_MP1 ||
1965
            enc->codec_id == CODEC_ID_MP2 ||
1966
            enc->codec_id == CODEC_ID_MP3 ||
1967
            enc->codec_id == CODEC_ID_SPEEX))
1968
            return 0;
1969
        break;
1970
    case AVMEDIA_TYPE_VIDEO:
1971
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1972
        break;
1973
    default:
1974
        val = 1;
1975
        break;
1976
    }
1977
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1978
}
1979

    
1980
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1981
{
1982
    int16_t *samples;
1983
    AVCodec *codec;
1984
    int got_picture, data_size, ret=0;
1985
    AVFrame picture;
1986

    
1987
    if(!st->codec->codec){
1988
        codec = avcodec_find_decoder(st->codec->codec_id);
1989
        if (!codec)
1990
            return -1;
1991
        ret = avcodec_open(st->codec, codec);
1992
        if (ret < 0)
1993
            return ret;
1994
    }
1995

    
1996
    if(!has_codec_parameters(st->codec)){
1997
        switch(st->codec->codec_type) {
1998
        case AVMEDIA_TYPE_VIDEO:
1999
            avcodec_get_frame_defaults(&picture);
2000
            ret = avcodec_decode_video2(st->codec, &picture,
2001
                                        &got_picture, avpkt);
2002
            break;
2003
        case AVMEDIA_TYPE_AUDIO:
2004
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2005
            samples = av_malloc(data_size);
2006
            if (!samples)
2007
                goto fail;
2008
            ret = avcodec_decode_audio3(st->codec, samples,
2009
                                        &data_size, avpkt);
2010
            av_free(samples);
2011
            break;
2012
        default:
2013
            break;
2014
        }
2015
    }
2016
 fail:
2017
    return ret;
2018
}
2019

    
2020
unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
2021
{
2022
    while (tags->id != CODEC_ID_NONE) {
2023
        if (tags->id == id)
2024
            return tags->tag;
2025
        tags++;
2026
    }
2027
    return 0;
2028
}
2029

    
2030
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2031
{
2032
    int i;
2033
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2034
        if(tag == tags[i].tag)
2035
            return tags[i].id;
2036
    }
2037
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2038
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
2039
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
2040
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
2041
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
2042
            return tags[i].id;
2043
    }
2044
    return CODEC_ID_NONE;
2045
}
2046

    
2047
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2048
{
2049
    int i;
2050
    for(i=0; tags && tags[i]; i++){
2051
        int tag= ff_codec_get_tag(tags[i], id);
2052
        if(tag) return tag;
2053
    }
2054
    return 0;
2055
}
2056

    
2057
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2058
{
2059
    int i;
2060
    for(i=0; tags && tags[i]; i++){
2061
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2062
        if(id!=CODEC_ID_NONE) return id;
2063
    }
2064
    return CODEC_ID_NONE;
2065
}
2066

    
2067
static void compute_chapters_end(AVFormatContext *s)
2068
{
2069
    unsigned int i;
2070

    
2071
    for (i=0; i+1<s->nb_chapters; i++)
2072
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2073
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2074
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2075
            s->chapters[i]->end = s->chapters[i+1]->start;
2076
        }
2077

    
2078
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2079
        assert(s->start_time != AV_NOPTS_VALUE);
2080
        assert(s->duration > 0);
2081
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2082
                                           AV_TIME_BASE_Q,
2083
                                           s->chapters[i]->time_base);
2084
    }
2085
}
2086

    
2087
#define MAX_STD_TIMEBASES (60*12+5)
2088
static int get_std_framerate(int i){
2089
    if(i<60*12) return i*1001;
2090
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2091
}
2092

    
2093
/*
2094
 * Is the time base unreliable.
2095
 * This is a heuristic to balance between quick acceptance of the values in
2096
 * the headers vs. some extra checks.
2097
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2098
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2099
 * And there are "variable" fps files this needs to detect as well.
2100
 */
2101
static int tb_unreliable(AVCodecContext *c){
2102
    if(   c->time_base.den >= 101L*c->time_base.num
2103
       || c->time_base.den <    5L*c->time_base.num
2104
/*       || c->codec_tag == AV_RL32("DIVX")
2105
       || c->codec_tag == AV_RL32("XVID")*/
2106
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2107
       || c->codec_id == CODEC_ID_H264
2108
       )
2109
        return 1;
2110
    return 0;
2111
}
2112

    
2113
int av_find_stream_info(AVFormatContext *ic)
2114
{
2115
    int i, count, ret, read_size, j;
2116
    AVStream *st;
2117
    AVPacket pkt1, *pkt;
2118
    int64_t last_dts[MAX_STREAMS];
2119
    int64_t duration_gcd[MAX_STREAMS]={0};
2120
    int duration_count[MAX_STREAMS]={0};
2121
    double (*duration_error)[MAX_STD_TIMEBASES];
2122
    int64_t old_offset = url_ftell(ic->pb);
2123
    int64_t codec_info_duration[MAX_STREAMS]={0};
2124

    
2125
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2126
    if (!duration_error) return AVERROR(ENOMEM);
2127

    
2128
    for(i=0;i<ic->nb_streams;i++) {
2129
        st = ic->streams[i];
2130
        if (st->codec->codec_id == CODEC_ID_AAC) {
2131
            st->codec->sample_rate = 0;
2132
            st->codec->frame_size = 0;
2133
            st->codec->channels = 0;
2134
        }
2135
        if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2136
/*            if(!st->time_base.num)
2137
                st->time_base= */
2138
            if(!st->codec->time_base.num)
2139
                st->codec->time_base= st->time_base;
2140
        }
2141
        //only for the split stuff
2142
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2143
            st->parser = av_parser_init(st->codec->codec_id);
2144
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2145
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2146
            }
2147
        }
2148
        assert(!st->codec->codec);
2149
        //try to just open decoders, in case this is enough to get parameters
2150
        if(!has_codec_parameters(st->codec)){
2151
            AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
2152
            if (codec)
2153
                avcodec_open(st->codec, codec);
2154
        }
2155
    }
2156

    
2157
    for(i=0;i<MAX_STREAMS;i++){
2158
        last_dts[i]= AV_NOPTS_VALUE;
2159
    }
2160

    
2161
    count = 0;
2162
    read_size = 0;
2163
    for(;;) {
2164
        if(url_interrupt_cb()){
2165
            ret= AVERROR(EINTR);
2166
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2167
            break;
2168
        }
2169

    
2170
        /* check if one codec still needs to be handled */
2171
        for(i=0;i<ic->nb_streams;i++) {
2172
            st = ic->streams[i];
2173
            if (!has_codec_parameters(st->codec))
2174
                break;
2175
            /* variable fps and no guess at the real fps */
2176
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2177
               && duration_count[i]<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2178
                break;
2179
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2180
                break;
2181
            if(st->first_dts == AV_NOPTS_VALUE)
2182
                break;
2183
        }
2184
        if (i == ic->nb_streams) {
2185
            /* NOTE: if the format has no header, then we need to read
2186
               some packets to get most of the streams, so we cannot
2187
               stop here */
2188
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2189
                /* if we found the info for all the codecs, we can stop */
2190
                ret = count;
2191
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2192
                break;
2193
            }
2194
        }
2195
        /* we did not get all the codec info, but we read too much data */
2196
        if (read_size >= ic->probesize) {
2197
            ret = count;
2198
            av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2199
            break;
2200
        }
2201

    
2202
        /* NOTE: a new stream can be added there if no header in file
2203
           (AVFMTCTX_NOHEADER) */
2204
        ret = av_read_frame_internal(ic, &pkt1);
2205
        if(ret == AVERROR(EAGAIN))
2206
            continue;
2207
        if (ret < 0) {
2208
            /* EOF or error */
2209
            ret = -1; /* we could not have all the codec parameters before EOF */
2210
            for(i=0;i<ic->nb_streams;i++) {
2211
                st = ic->streams[i];
2212
                if (!has_codec_parameters(st->codec)){
2213
                    char buf[256];
2214
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2215
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2216
                } else {
2217
                    ret = 0;
2218
                }
2219
            }
2220
            break;
2221
        }
2222

    
2223
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2224
        if(av_dup_packet(pkt) < 0) {
2225
            av_free(duration_error);
2226
            return AVERROR(ENOMEM);
2227
        }
2228

    
2229
        read_size += pkt->size;
2230

    
2231
        st = ic->streams[pkt->stream_index];
2232
        if(st->codec_info_nb_frames>1) {
2233
            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){
2234
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2235
                break;
2236
            }
2237
            codec_info_duration[st->index] += pkt->duration;
2238
        }
2239
            st->codec_info_nb_frames++;
2240

    
2241
        {
2242
            int index= pkt->stream_index;
2243
            int64_t last= last_dts[index];
2244
            int64_t duration= pkt->dts - last;
2245

    
2246
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2247
                double dur= duration * av_q2d(st->time_base);
2248

    
2249
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2250
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2251
                if(duration_count[index] < 2)
2252
                    memset(duration_error[index], 0, sizeof(*duration_error));
2253
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2254
                    int framerate= get_std_framerate(i);
2255
                    int ticks= lrintf(dur*framerate/(1001*12));
2256
                    double error= dur - ticks*1001*12/(double)framerate;
2257
                    duration_error[index][i] += error*error;
2258
                }
2259
                duration_count[index]++;
2260
                // ignore the first 4 values, they might have some random jitter
2261
                if (duration_count[index] > 3)
2262
                    duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2263
            }
2264
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2265
                last_dts[pkt->stream_index]= pkt->dts;
2266
        }
2267
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2268
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2269
            if(i){
2270
                st->codec->extradata_size= i;
2271
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2272
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2273
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2274
            }
2275
        }
2276

    
2277
        /* if still no information, we try to open the codec and to
2278
           decompress the frame. We try to avoid that in most cases as
2279
           it takes longer and uses more memory. For MPEG-4, we need to
2280
           decompress for QuickTime. */
2281
        if (!has_codec_parameters(st->codec))
2282
            try_decode_frame(st, pkt);
2283

    
2284
        count++;
2285
    }
2286

    
2287
    // close codecs which were opened in try_decode_frame()
2288
    for(i=0;i<ic->nb_streams;i++) {
2289
        st = ic->streams[i];
2290
        if(st->codec->codec)
2291
            avcodec_close(st->codec);
2292
    }
2293
    for(i=0;i<ic->nb_streams;i++) {
2294
        st = ic->streams[i];
2295
        if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
2296
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2297
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2298
                      codec_info_duration[i]    *(int64_t)st->time_base.num, 60000);
2299
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2300
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2301
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2302

    
2303
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2304
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2305
            // ipmovie.c produces.
2306
            if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
2307
                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);
2308
            if(duration_count[i] && !st->r_frame_rate.num
2309
               && tb_unreliable(st->codec) /*&&
2310
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2311
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2312
                int num = 0;
2313
                double best_error= 2*av_q2d(st->time_base);
2314
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2315

    
2316
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2317
                    double error= duration_error[i][j] * get_std_framerate(j);
2318
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2319
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2320
                    if(error < best_error){
2321
                        best_error= error;
2322
                        num = get_std_framerate(j);
2323
                    }
2324
                }
2325
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2326
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2327
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2328
            }
2329

    
2330
            if (!st->r_frame_rate.num){
2331
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2332
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2333
                    st->r_frame_rate.num = st->codec->time_base.den;
2334
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2335
                }else{
2336
                    st->r_frame_rate.num = st->time_base.den;
2337
                    st->r_frame_rate.den = st->time_base.num;
2338
                }
2339
            }
2340
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2341
            if(!st->codec->bits_per_coded_sample)
2342
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2343
        }
2344
    }
2345

    
2346
    av_estimate_timings(ic, old_offset);
2347

    
2348
    compute_chapters_end(ic);
2349

    
2350
#if 0
2351
    /* correct DTS for B-frame streams with no timestamps */
2352
    for(i=0;i<ic->nb_streams;i++) {
2353
        st = ic->streams[i];
2354
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2355
            if(b-frames){
2356
                ppktl = &ic->packet_buffer;
2357
                while(ppkt1){
2358
                    if(ppkt1->stream_index != i)
2359
                        continue;
2360
                    if(ppkt1->pkt->dts < 0)
2361
                        break;
2362
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2363
                        break;
2364
                    ppkt1->pkt->dts -= delta;
2365
                    ppkt1= ppkt1->next;
2366
                }
2367
                if(ppkt1)
2368
                    continue;
2369
                st->cur_dts -= delta;
2370
            }
2371
        }
2372
    }
2373
#endif
2374

    
2375
    av_free(duration_error);
2376

    
2377
    return ret;
2378
}
2379

    
2380
/*******************************************************/
2381

    
2382
int av_read_play(AVFormatContext *s)
2383
{
2384
    if (s->iformat->read_play)
2385
        return s->iformat->read_play(s);
2386
    if (s->pb)
2387
        return av_url_read_fpause(s->pb, 0);
2388
    return AVERROR(ENOSYS);
2389
}
2390

    
2391
int av_read_pause(AVFormatContext *s)
2392
{
2393
    if (s->iformat->read_pause)
2394
        return s->iformat->read_pause(s);
2395
    if (s->pb)
2396
        return av_url_read_fpause(s->pb, 1);
2397
    return AVERROR(ENOSYS);
2398
}
2399

    
2400
void av_close_input_stream(AVFormatContext *s)
2401
{
2402
    int i;
2403
    AVStream *st;
2404

    
2405
    if (s->iformat->read_close)
2406
        s->iformat->read_close(s);
2407
    for(i=0;i<s->nb_streams;i++) {
2408
        /* free all data in a stream component */
2409
        st = s->streams[i];
2410
        if (st->parser) {
2411
            av_parser_close(st->parser);
2412
            av_free_packet(&st->cur_pkt);
2413
        }
2414
        av_metadata_free(&st->metadata);
2415
        av_free(st->index_entries);
2416
        av_free(st->codec->extradata);
2417
        av_free(st->codec);
2418
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2419
        av_free(st->filename);
2420
#endif
2421
        av_free(st->priv_data);
2422
        av_free(st);
2423
    }
2424
    for(i=s->nb_programs-1; i>=0; i--) {
2425
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2426
        av_freep(&s->programs[i]->provider_name);
2427
        av_freep(&s->programs[i]->name);
2428
#endif
2429
        av_metadata_free(&s->programs[i]->metadata);
2430
        av_freep(&s->programs[i]->stream_index);
2431
        av_freep(&s->programs[i]);
2432
    }
2433
    av_freep(&s->programs);
2434
    flush_packet_queue(s);
2435
    av_freep(&s->priv_data);
2436
    while(s->nb_chapters--) {
2437
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2438
        av_free(s->chapters[s->nb_chapters]->title);
2439
#endif
2440
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2441
        av_free(s->chapters[s->nb_chapters]);
2442
    }
2443
    av_freep(&s->chapters);
2444
    av_metadata_free(&s->metadata);
2445
    av_free(s);
2446
}
2447

    
2448
void av_close_input_file(AVFormatContext *s)
2449
{
2450
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2451
    av_close_input_stream(s);
2452
    if (pb)
2453
        url_fclose(pb);
2454
}
2455

    
2456
AVStream *av_new_stream(AVFormatContext *s, int id)
2457
{
2458
    AVStream *st;
2459
    int i;
2460

    
2461
    if (s->nb_streams >= MAX_STREAMS)
2462
        return NULL;
2463

    
2464
    st = av_mallocz(sizeof(AVStream));
2465
    if (!st)
2466
        return NULL;
2467

    
2468
    st->codec= avcodec_alloc_context();
2469
    if (s->iformat) {
2470
        /* no default bitrate if decoding */
2471
        st->codec->bit_rate = 0;
2472
    }
2473
    st->index = s->nb_streams;
2474
    st->id = id;
2475
    st->start_time = AV_NOPTS_VALUE;
2476
    st->duration = AV_NOPTS_VALUE;
2477
        /* we set the current DTS to 0 so that formats without any timestamps
2478
           but durations get some timestamps, formats with some unknown
2479
           timestamps have their first few packets buffered and the
2480
           timestamps corrected before they are returned to the user */
2481
    st->cur_dts = 0;
2482
    st->first_dts = AV_NOPTS_VALUE;
2483
    st->probe_packets = MAX_PROBE_PACKETS;
2484

    
2485
    /* default pts setting is MPEG-like */
2486
    av_set_pts_info(st, 33, 1, 90000);
2487
    st->last_IP_pts = AV_NOPTS_VALUE;
2488
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2489
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2490
    st->reference_dts = AV_NOPTS_VALUE;
2491

    
2492
    st->sample_aspect_ratio = (AVRational){0,1};
2493

    
2494
    s->streams[s->nb_streams++] = st;
2495
    return st;
2496
}
2497

    
2498
AVProgram *av_new_program(AVFormatContext *ac, int id)
2499
{
2500
    AVProgram *program=NULL;
2501
    int i;
2502

    
2503
#ifdef DEBUG_SI
2504
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2505
#endif
2506

    
2507
    for(i=0; i<ac->nb_programs; i++)
2508
        if(ac->programs[i]->id == id)
2509
            program = ac->programs[i];
2510

    
2511
    if(!program){
2512
        program = av_mallocz(sizeof(AVProgram));
2513
        if (!program)
2514
            return NULL;
2515
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2516
        program->discard = AVDISCARD_NONE;
2517
    }
2518
    program->id = id;
2519

    
2520
    return program;
2521
}
2522

    
2523
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2524
{
2525
    AVChapter *chapter = NULL;
2526
    int i;
2527

    
2528
    for(i=0; i<s->nb_chapters; i++)
2529
        if(s->chapters[i]->id == id)
2530
            chapter = s->chapters[i];
2531

    
2532
    if(!chapter){
2533
        chapter= av_mallocz(sizeof(AVChapter));
2534
        if(!chapter)
2535
            return NULL;
2536
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2537
    }
2538
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2539
    av_free(chapter->title);
2540
#endif
2541
    av_metadata_set(&chapter->metadata, "title", title);
2542
    chapter->id    = id;
2543
    chapter->time_base= time_base;
2544
    chapter->start = start;
2545
    chapter->end   = end;
2546

    
2547
    return chapter;
2548
}
2549

    
2550
/************************************************************/
2551
/* output media file */
2552

    
2553
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2554
{
2555
    int ret;
2556

    
2557
    if (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
    } else
2562
        s->priv_data = NULL;
2563

    
2564
    if (s->oformat->set_parameters) {
2565
        ret = s->oformat->set_parameters(s, ap);
2566
        if (ret < 0)
2567
            return ret;
2568
    }
2569
    return 0;
2570
}
2571

    
2572
int av_write_header(AVFormatContext *s)
2573
{
2574
    int ret, i;
2575
    AVStream *st;
2576

    
2577
    // some sanity checks
2578
    if (s->nb_streams == 0) {
2579
        av_log(s, AV_LOG_ERROR, "no streams\n");
2580
        return -1;
2581
    }
2582

    
2583
    for(i=0;i<s->nb_streams;i++) {
2584
        st = s->streams[i];
2585

    
2586
        switch (st->codec->codec_type) {
2587
        case AVMEDIA_TYPE_AUDIO:
2588
            if(st->codec->sample_rate<=0){
2589
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2590
                return -1;
2591
            }
2592
            if(!st->codec->block_align)
2593
                st->codec->block_align = st->codec->channels *
2594
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2595
            break;
2596
        case AVMEDIA_TYPE_VIDEO:
2597
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2598
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2599
                return -1;
2600
            }
2601
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2602
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2603
                return -1;
2604
            }
2605
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2606
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2607
                return -1;
2608
            }
2609
            break;
2610
        }
2611

    
2612
        if(s->oformat->codec_tag){
2613
            if(st->codec->codec_tag){
2614
                //FIXME
2615
                //check that tag + id is in the table
2616
                //if neither is in the table -> OK
2617
                //if tag is in the table with another id -> FAIL
2618
                //if id is in the table with another tag -> FAIL unless strict < ?
2619
            }else
2620
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2621
        }
2622

    
2623
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2624
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2625
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2626
    }
2627

    
2628
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2629
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2630
        if (!s->priv_data)
2631
            return AVERROR(ENOMEM);
2632
    }
2633

    
2634
#if LIBAVFORMAT_VERSION_MAJOR < 53
2635
    ff_metadata_mux_compat(s);
2636
#endif
2637

    
2638
    /* set muxer identification string */
2639
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2640
        AVMetadata *m;
2641
        AVMetadataTag *t;
2642

    
2643
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2644
            return AVERROR(ENOMEM);
2645
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2646
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2647
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2648
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2649
        av_metadata_free(&m);
2650
    }
2651

    
2652
    if(s->oformat->write_header){
2653
        ret = s->oformat->write_header(s);
2654
        if (ret < 0)
2655
            return ret;
2656
    }
2657

    
2658
    /* init PTS generation */
2659
    for(i=0;i<s->nb_streams;i++) {
2660
        int64_t den = AV_NOPTS_VALUE;
2661
        st = s->streams[i];
2662

    
2663
        switch (st->codec->codec_type) {
2664
        case AVMEDIA_TYPE_AUDIO:
2665
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2666
            break;
2667
        case AVMEDIA_TYPE_VIDEO:
2668
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2669
            break;
2670
        default:
2671
            break;
2672
        }
2673
        if (den != AV_NOPTS_VALUE) {
2674
            if (den <= 0)
2675
                return AVERROR_INVALIDDATA;
2676
            av_frac_init(&st->pts, 0, 0, den);
2677
        }
2678
    }
2679
    return 0;
2680
}
2681

    
2682
//FIXME merge with compute_pkt_fields
2683
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2684
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2685
    int num, den, frame_size, i;
2686

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

    
2689
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2690
        return -1;*/
2691

    
2692
    /* duration field */
2693
    if (pkt->duration == 0) {
2694
        compute_frame_duration(&num, &den, st, NULL, pkt);
2695
        if (den && num) {
2696
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2697
        }
2698
    }
2699

    
2700
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2701
        pkt->pts= pkt->dts;
2702

    
2703
    //XXX/FIXME this is a temporary hack until all encoders output pts
2704
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2705
        pkt->dts=
2706
//        pkt->pts= st->cur_dts;
2707
        pkt->pts= st->pts.val;
2708
    }
2709

    
2710
    //calculate dts from pts
2711
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2712
        st->pts_buffer[0]= pkt->pts;
2713
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2714
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2715
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2716
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2717

    
2718
        pkt->dts= st->pts_buffer[0];
2719
    }
2720

    
2721
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2722
        av_log(s, AV_LOG_ERROR,
2723
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2724
               st->index, st->cur_dts, pkt->dts);
2725
        return -1;
2726
    }
2727
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2728
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2729
        return -1;
2730
    }
2731

    
2732
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2733
    st->cur_dts= pkt->dts;
2734
    st->pts.val= pkt->dts;
2735

    
2736
    /* update pts */
2737
    switch (st->codec->codec_type) {
2738
    case AVMEDIA_TYPE_AUDIO:
2739
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2740

    
2741
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2742
           likely equal to the encoder delay, but it would be better if we
2743
           had the real timestamps from the encoder */
2744
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2745
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2746
        }
2747
        break;
2748
    case AVMEDIA_TYPE_VIDEO:
2749
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2750
        break;
2751
    default:
2752
        break;
2753
    }
2754
    return 0;
2755
}
2756

    
2757
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2758
{
2759
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2760

    
2761
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2762
        return ret;
2763

    
2764
    ret= s->oformat->write_packet(s, pkt);
2765
    if(!ret)
2766
        ret= url_ferror(s->pb);
2767
    return ret;
2768
}
2769

    
2770
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2771
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2772
{
2773
    AVPacketList **next_point, *this_pktl;
2774

    
2775
    this_pktl = av_mallocz(sizeof(AVPacketList));
2776
    this_pktl->pkt= *pkt;
2777
    pkt->destruct= NULL;             // do not free original but only the copy
2778
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2779

    
2780
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2781
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2782
    }else
2783
        next_point = &s->packet_buffer;
2784

    
2785
    if(*next_point){
2786
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2787
            while(!compare(s, &(*next_point)->pkt, pkt)){
2788
                next_point= &(*next_point)->next;
2789
            }
2790
            goto next_non_null;
2791
        }else{
2792
            next_point = &(s->packet_buffer_end->next);
2793
        }
2794
    }
2795
    assert(!*next_point);
2796

    
2797
    s->packet_buffer_end= this_pktl;
2798
next_non_null:
2799

    
2800
    this_pktl->next= *next_point;
2801

    
2802
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2803
    *next_point= this_pktl;
2804
}
2805

    
2806
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2807
{
2808
    AVStream *st = s->streams[ pkt ->stream_index];
2809
    AVStream *st2= s->streams[ next->stream_index];
2810
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2811
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2812
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2813
}
2814

    
2815
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2816
    AVPacketList *pktl;
2817
    int stream_count=0;
2818
    int i;
2819

    
2820
    if(pkt){
2821
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2822
    }
2823

    
2824
    for(i=0; i < s->nb_streams; i++)
2825
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2826

    
2827
    if(stream_count && (s->nb_streams == stream_count || flush)){
2828
        pktl= s->packet_buffer;
2829
        *out= pktl->pkt;
2830

    
2831
        s->packet_buffer= pktl->next;
2832
        if(!s->packet_buffer)
2833
            s->packet_buffer_end= NULL;
2834

    
2835
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2836
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2837
        av_freep(&pktl);
2838
        return 1;
2839
    }else{
2840
        av_init_packet(out);
2841
        return 0;
2842
    }
2843
}
2844

    
2845
/**
2846
 * Interleaves an AVPacket correctly so it can be muxed.
2847
 * @param out the interleaved packet will be output here
2848
 * @param in the input packet
2849
 * @param flush 1 if no further packets are available as input and all
2850
 *              remaining packets should be output
2851
 * @return 1 if a packet was output, 0 if no packet could be output,
2852
 *         < 0 if an error occurred
2853
 */
2854
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2855
    if(s->oformat->interleave_packet)
2856
        return s->oformat->interleave_packet(s, out, in, flush);
2857
    else
2858
        return av_interleave_packet_per_dts(s, out, in, flush);
2859
}
2860

    
2861
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2862
    AVStream *st= s->streams[ pkt->stream_index];
2863

    
2864
    //FIXME/XXX/HACK drop zero sized packets
2865
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2866
        return 0;
2867

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

    
2872
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2873
        return -1;
2874

    
2875
    for(;;){
2876
        AVPacket opkt;
2877
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2878
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2879
            return ret;
2880

    
2881
        ret= s->oformat->write_packet(s, &opkt);
2882

    
2883
        av_free_packet(&opkt);
2884
        pkt= NULL;
2885

    
2886
        if(ret<0)
2887
            return ret;
2888
        if(url_ferror(s->pb))
2889
            return url_ferror(s->pb);
2890
    }
2891
}
2892

    
2893
int av_write_trailer(AVFormatContext *s)
2894
{
2895
    int ret, i;
2896

    
2897
    for(;;){
2898
        AVPacket pkt;
2899
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2900
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2901
            goto fail;
2902
        if(!ret)
2903
            break;
2904

    
2905
        ret= s->oformat->write_packet(s, &pkt);
2906

    
2907
        av_free_packet(&pkt);
2908

    
2909
        if(ret<0)
2910
            goto fail;
2911
        if(url_ferror(s->pb))
2912
            goto fail;
2913
    }
2914

    
2915
    if(s->oformat->write_trailer)
2916
        ret = s->oformat->write_trailer(s);
2917
fail:
2918
    if(ret == 0)
2919
       ret=url_ferror(s->pb);
2920
    for(i=0;i<s->nb_streams;i++) {
2921
        av_freep(&s->streams[i]->priv_data);
2922
        av_freep(&s->streams[i]->index_entries);
2923
    }
2924
    av_freep(&s->priv_data);
2925
    return ret;
2926
}
2927

    
2928
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2929
{
2930
    int i, j;
2931
    AVProgram *program=NULL;
2932
    void *tmp;
2933

    
2934
    if (idx >= ac->nb_streams) {
2935
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2936
        return;
2937
    }
2938

    
2939
    for(i=0; i<ac->nb_programs; i++){
2940
        if(ac->programs[i]->id != progid)
2941
            continue;
2942
        program = ac->programs[i];
2943
        for(j=0; j<program->nb_stream_indexes; j++)
2944
            if(program->stream_index[j] == idx)
2945
                return;
2946

    
2947
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2948
        if(!tmp)
2949
            return;
2950
        program->stream_index = tmp;
2951
        program->stream_index[program->nb_stream_indexes++] = idx;
2952
        return;
2953
    }
2954
}
2955

    
2956
static void print_fps(double d, const char *postfix){
2957
    uint64_t v= lrintf(d*100);
2958
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2959
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2960
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2961
}
2962

    
2963
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2964
{
2965
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2966
        AVMetadataTag *tag=NULL;
2967

    
2968
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2969
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2970
            if(strcmp("language", tag->key))
2971
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
2972
        }
2973
    }
2974
}
2975

    
2976
/* "user interface" functions */
2977
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2978
{
2979
    char buf[256];
2980
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2981
    AVStream *st = ic->streams[i];
2982
    int g = av_gcd(st->time_base.num, st->time_base.den);
2983
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2984
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2985
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2986
    /* the pid is an important information, so we display it */
2987
    /* XXX: add a generic system */
2988
    if (flags & AVFMT_SHOW_IDS)
2989
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2990
    if (lang)
2991
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2992
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
2993
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2994
    if (st->sample_aspect_ratio.num && // default
2995
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2996
        AVRational display_aspect_ratio;
2997
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2998
                  st->codec->width*st->sample_aspect_ratio.num,
2999
                  st->codec->height*st->sample_aspect_ratio.den,
3000
                  1024*1024);
3001
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3002
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3003
                 display_aspect_ratio.num, display_aspect_ratio.den);
3004
    }
3005
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3006
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3007
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3008
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3009
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3010
        if(st->time_base.den && st->time_base.num)
3011
            print_fps(1/av_q2d(st->time_base), "tbn");
3012
        if(st->codec->time_base.den && st->codec->time_base.num)
3013
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3014
    }
3015
    av_log(NULL, AV_LOG_INFO, "\n");
3016
    dump_metadata(NULL, st->metadata, "    ");
3017
}
3018

    
3019
void dump_format(AVFormatContext *ic,
3020
                 int index,
3021
                 const char *url,
3022
                 int is_output)
3023
{
3024
    int i;
3025
    uint8_t *printed = av_mallocz(ic->nb_streams);
3026
    if (ic->nb_streams && !printed)
3027
        return;
3028

    
3029
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3030
            is_output ? "Output" : "Input",
3031
            index,
3032
            is_output ? ic->oformat->name : ic->iformat->name,
3033
            is_output ? "to" : "from", url);
3034
    dump_metadata(NULL, ic->metadata, "  ");
3035
    if (!is_output) {
3036
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3037
        if (ic->duration != AV_NOPTS_VALUE) {
3038
            int hours, mins, secs, us;
3039
            secs = ic->duration / AV_TIME_BASE;
3040
            us = ic->duration % AV_TIME_BASE;
3041
            mins = secs / 60;
3042
            secs %= 60;
3043
            hours = mins / 60;
3044
            mins %= 60;
3045
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3046
                   (100 * us) / AV_TIME_BASE);
3047
        } else {
3048
            av_log(NULL, AV_LOG_INFO, "N/A");
3049
        }
3050
        if (ic->start_time != AV_NOPTS_VALUE) {
3051
            int secs, us;
3052
            av_log(NULL, AV_LOG_INFO, ", start: ");
3053
            secs = ic->start_time / AV_TIME_BASE;
3054
            us = ic->start_time % AV_TIME_BASE;
3055
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3056
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3057
        }
3058
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3059
        if (ic->bit_rate) {
3060
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3061
        } else {
3062
            av_log(NULL, AV_LOG_INFO, "N/A");
3063
        }
3064
        av_log(NULL, AV_LOG_INFO, "\n");
3065
    }
3066
    for (i = 0; i < ic->nb_chapters; i++) {
3067
        AVChapter *ch = ic->chapters[i];
3068
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3069
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3070
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3071

    
3072
        dump_metadata(NULL, ch->metadata, "    ");
3073
    }
3074
    if(ic->nb_programs) {
3075
        int j, k, total = 0;
3076
        for(j=0; j<ic->nb_programs; j++) {
3077
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3078
                                                  "name", NULL, 0);
3079
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3080
                   name ? name->value : "");
3081
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3082
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3083
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3084
                printed[ic->programs[j]->stream_index[k]] = 1;
3085
            }
3086
            total += ic->programs[j]->nb_stream_indexes;
3087
        }
3088
        if (total < ic->nb_streams)
3089
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3090
    }
3091
    for(i=0;i<ic->nb_streams;i++)
3092
        if (!printed[i])
3093
            dump_stream_format(ic, i, index, is_output);
3094

    
3095
    av_free(printed);
3096
}
3097

    
3098
#if LIBAVFORMAT_VERSION_MAJOR < 53
3099
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3100
{
3101
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
3102
}
3103

    
3104
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3105
{
3106
    AVRational frame_rate;
3107
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
3108
    *frame_rate_num= frame_rate.num;
3109
    *frame_rate_den= frame_rate.den;
3110
    return ret;
3111
}
3112
#endif
3113

    
3114
int64_t av_gettime(void)
3115
{
3116
    struct timeval tv;
3117
    gettimeofday(&tv,NULL);
3118
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3119
}
3120

    
3121
uint64_t ff_ntp_time(void)
3122
{
3123
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3124
}
3125

    
3126
int64_t parse_date(const char *datestr, int duration)
3127
{
3128
    const char *p;
3129
    int64_t t;
3130
    struct tm dt;
3131
    int i;
3132
    static const char * const date_fmt[] = {
3133
        "%Y-%m-%d",
3134
        "%Y%m%d",
3135
    };
3136
    static const char * const time_fmt[] = {
3137
        "%H:%M:%S",
3138
        "%H%M%S",
3139
    };
3140
    const char *q;
3141
    int is_utc, len;
3142
    char lastch;
3143
    int negative = 0;
3144

    
3145
#undef time
3146
    time_t now = time(0);
3147

    
3148
    len = strlen(datestr);
3149
    if (len > 0)
3150
        lastch = datestr[len - 1];
3151
    else
3152
        lastch = '\0';
3153
    is_utc = (lastch == 'z' || lastch == 'Z');
3154

    
3155
    memset(&dt, 0, sizeof(dt));
3156

    
3157
    p = datestr;
3158
    q = NULL;
3159
    if (!duration) {
3160
        if (!strncasecmp(datestr, "now", len))
3161
            return (int64_t) now * 1000000;
3162

    
3163
        /* parse the year-month-day part */
3164
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3165
            q = small_strptime(p, date_fmt[i], &dt);
3166
            if (q) {
3167
                break;
3168
            }
3169
        }
3170

    
3171
        /* if the year-month-day part is missing, then take the
3172
         * current year-month-day time */
3173
        if (!q) {
3174
            if (is_utc) {
3175
                dt = *gmtime(&now);
3176
            } else {
3177
                dt = *localtime(&now);
3178
            }
3179
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3180
        } else {
3181
            p = q;
3182
        }
3183

    
3184
        if (*p == 'T' || *p == 't' || *p == ' ')
3185
            p++;
3186

    
3187
        /* parse the hour-minute-second part */
3188
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3189
            q = small_strptime(p, time_fmt[i], &dt);
3190
            if (q) {
3191
                break;
3192
            }
3193
        }
3194
    } else {
3195
        /* parse datestr as a duration */
3196
        if (p[0] == '-') {
3197
            negative = 1;
3198
            ++p;
3199
        }
3200
        /* parse datestr as HH:MM:SS */
3201
        q = small_strptime(p, time_fmt[0], &dt);
3202
        if (!q) {
3203
            /* parse datestr as S+ */
3204
            dt.tm_sec = strtol(p, (char **)&q, 10);
3205
            if (q == p)
3206
                /* the parsing didn't succeed */
3207
                return INT64_MIN;
3208
            dt.tm_min = 0;
3209
            dt.tm_hour = 0;
3210
        }
3211
    }
3212

    
3213
    /* Now we have all the fields that we can get */
3214
    if (!q) {
3215
        return INT64_MIN;
3216
    }
3217

    
3218
    if (duration) {
3219
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3220
    } else {
3221
        dt.tm_isdst = -1;       /* unknown */
3222
        if (is_utc) {
3223
            t = mktimegm(&dt);
3224
        } else {
3225
            t = mktime(&dt);
3226
        }
3227
    }
3228

    
3229
    t *= 1000000;
3230

    
3231
    /* parse the .m... part */
3232
    if (*q == '.') {
3233
        int val, n;
3234
        q++;
3235
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3236
            if (!isdigit(*q))
3237
                break;
3238
            val += n * (*q - '0');
3239
        }
3240
        t += val;
3241
    }
3242
    return negative ? -t : t;
3243
}
3244

    
3245
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3246
{
3247
    const char *p;
3248
    char tag[128], *q;
3249

    
3250
    p = info;
3251
    if (*p == '?')
3252
        p++;
3253
    for(;;) {
3254
        q = tag;
3255
        while (*p != '\0' && *p != '=' && *p != '&') {
3256
            if ((q - tag) < sizeof(tag) - 1)
3257
                *q++ = *p;
3258
            p++;
3259
        }
3260
        *q = '\0';
3261
        q = arg;
3262
        if (*p == '=') {
3263
            p++;
3264
            while (*p != '&' && *p != '\0') {
3265
                if ((q - arg) < arg_size - 1) {
3266
                    if (*p == '+')
3267
                        *q++ = ' ';
3268
                    else
3269
                        *q++ = *p;
3270
                }
3271
                p++;
3272
            }
3273
            *q = '\0';
3274
        }
3275
        if (!strcmp(tag, tag1))
3276
            return 1;
3277
        if (*p != '&')
3278
            break;
3279
        p++;
3280
    }
3281
    return 0;
3282
}
3283

    
3284
int av_get_frame_filename(char *buf, int buf_size,
3285
                          const char *path, int number)
3286
{
3287
    const char *p;
3288
    char *q, buf1[20], c;
3289
    int nd, len, percentd_found;
3290

    
3291
    q = buf;
3292
    p = path;
3293
    percentd_found = 0;
3294
    for(;;) {
3295
        c = *p++;
3296
        if (c == '\0')
3297
            break;
3298
        if (c == '%') {
3299
            do {
3300
                nd = 0;
3301
                while (isdigit(*p)) {
3302
                    nd = nd * 10 + *p++ - '0';
3303
                }
3304
                c = *p++;
3305
            } while (isdigit(c));
3306

    
3307
            switch(c) {
3308
            case '%':
3309
                goto addchar;
3310
            case 'd':
3311
                if (percentd_found)
3312
                    goto fail;
3313
                percentd_found = 1;
3314
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3315
                len = strlen(buf1);
3316
                if ((q - buf + len) > buf_size - 1)
3317
                    goto fail;
3318
                memcpy(q, buf1, len);
3319
                q += len;
3320
                break;
3321
            default:
3322
                goto fail;
3323
            }
3324
        } else {
3325
        addchar:
3326
            if ((q - buf) < buf_size - 1)
3327
                *q++ = c;
3328
        }
3329
    }
3330
    if (!percentd_found)
3331
        goto fail;
3332
    *q = '\0';
3333
    return 0;
3334
 fail:
3335
    *q = '\0';
3336
    return -1;
3337
}
3338

    
3339
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3340
{
3341
    int len, i, j, c;
3342
#undef fprintf
3343
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3344

    
3345
    for(i=0;i<size;i+=16) {
3346
        len = size - i;
3347
        if (len > 16)
3348
            len = 16;
3349
        PRINT("%08x ", i);
3350
        for(j=0;j<16;j++) {
3351
            if (j < len)
3352
                PRINT(" %02x", buf[i+j]);
3353
            else
3354
                PRINT("   ");
3355
        }
3356
        PRINT(" ");
3357
        for(j=0;j<len;j++) {
3358
            c = buf[i+j];
3359
            if (c < ' ' || c > '~')
3360
                c = '.';
3361
            PRINT("%c", c);
3362
        }
3363
        PRINT("\n");
3364
    }
3365
#undef PRINT
3366
}
3367

    
3368
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3369
{
3370
    hex_dump_internal(NULL, f, 0, buf, size);
3371
}
3372

    
3373
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3374
{
3375
    hex_dump_internal(avcl, NULL, level, buf, size);
3376
}
3377

    
3378
 //FIXME needs to know the time_base
3379
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3380
{
3381
#undef fprintf
3382
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3383
    PRINT("stream #%d:\n", pkt->stream_index);
3384
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3385
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3386
    /* DTS is _always_ valid after av_read_frame() */
3387
    PRINT("  dts=");
3388
    if (pkt->dts == AV_NOPTS_VALUE)
3389
        PRINT("N/A");
3390
    else
3391
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3392
    /* PTS may not be known if B-frames are present. */
3393
    PRINT("  pts=");
3394
    if (pkt->pts == AV_NOPTS_VALUE)
3395
        PRINT("N/A");
3396
    else
3397
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3398
    PRINT("\n");
3399
    PRINT("  size=%d\n", pkt->size);
3400
#undef PRINT
3401
    if (dump_payload)
3402
        av_hex_dump(f, pkt->data, pkt->size);
3403
}
3404

    
3405
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3406
{
3407
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3408
}
3409

    
3410
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3411
{
3412
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3413
}
3414

    
3415
void ff_url_split(char *proto, int proto_size,
3416
                  char *authorization, int authorization_size,
3417
                  char *hostname, int hostname_size,
3418
                  int *port_ptr,
3419
                  char *path, int path_size,
3420
                  const char *url)
3421
{
3422
    const char *p, *ls, *at, *col, *brk;
3423

    
3424
    if (port_ptr)               *port_ptr = -1;
3425
    if (proto_size > 0)         proto[0] = 0;
3426
    if (authorization_size > 0) authorization[0] = 0;
3427
    if (hostname_size > 0)      hostname[0] = 0;
3428
    if (path_size > 0)          path[0] = 0;
3429

    
3430
    /* parse protocol */
3431
    if ((p = strchr(url, ':'))) {
3432
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3433
        p++; /* skip ':' */
3434
        if (*p == '/') p++;
3435
        if (*p == '/') p++;
3436
    } else {
3437
        /* no protocol means plain filename */
3438
        av_strlcpy(path, url, path_size);
3439
        return;
3440
    }
3441

    
3442
    /* separate path from hostname */
3443
    ls = strchr(p, '/');
3444
    if(!ls)
3445
        ls = strchr(p, '?');
3446
    if(ls)
3447
        av_strlcpy(path, ls, path_size);
3448
    else
3449
        ls = &p[strlen(p)]; // XXX
3450

    
3451
    /* the rest is hostname, use that to parse auth/port */
3452
    if (ls != p) {
3453
        /* authorization (user[:pass]@hostname) */
3454
        if ((at = strchr(p, '@')) && at < ls) {
3455
            av_strlcpy(authorization, p,
3456
                       FFMIN(authorization_size, at + 1 - p));
3457
            p = at + 1; /* skip '@' */
3458
        }
3459

    
3460
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3461
            /* [host]:port */
3462
            av_strlcpy(hostname, p + 1,
3463
                       FFMIN(hostname_size, brk - p));
3464
            if (brk[1] == ':' && port_ptr)
3465
                *port_ptr = atoi(brk + 2);
3466
        } else if ((col = strchr(p, ':')) && col < ls) {
3467
            av_strlcpy(hostname, p,
3468
                       FFMIN(col + 1 - p, hostname_size));
3469
            if (port_ptr) *port_ptr = atoi(col + 1);
3470
        } else
3471
            av_strlcpy(hostname, p,
3472
                       FFMIN(ls + 1 - p, hostname_size));
3473
    }
3474
}
3475

    
3476
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3477
{
3478
    int i;
3479
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3480
                                           '4', '5', '6', '7',
3481
                                           '8', '9', 'A', 'B',
3482
                                           'C', 'D', 'E', 'F' };
3483
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3484
                                           '4', '5', '6', '7',
3485
                                           '8', '9', 'a', 'b',
3486
                                           'c', 'd', 'e', 'f' };
3487
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3488

    
3489
    for(i = 0; i < s; i++) {
3490
        buff[i * 2]     = hex_table[src[i] >> 4];
3491
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3492
    }
3493

    
3494
    return buff;
3495
}
3496

    
3497
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3498
                     unsigned int pts_num, unsigned int pts_den)
3499
{
3500
    s->pts_wrap_bits = pts_wrap_bits;
3501

    
3502
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3503
        if(s->time_base.num != pts_num)
3504
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3505
    }else
3506
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3507

    
3508
    if(!s->time_base.num || !s->time_base.den)
3509
        s->time_base.num= s->time_base.den= 0;
3510
}
3511

    
3512
int ff_url_join(char *str, int size, const char *proto,
3513
                const char *authorization, const char *hostname,
3514
                int port, const char *fmt, ...)
3515
{
3516
#if CONFIG_NETWORK
3517
    struct addrinfo hints, *ai;
3518
#endif
3519

    
3520
    str[0] = '\0';
3521
    if (proto)
3522
        av_strlcatf(str, size, "%s://", proto);
3523
    if (authorization)
3524
        av_strlcatf(str, size, "%s@", authorization);
3525
#if CONFIG_NETWORK && defined(AF_INET6)
3526
    /* Determine if hostname is a numerical IPv6 address,
3527
     * properly escape it within [] in that case. */
3528
    memset(&hints, 0, sizeof(hints));
3529
    hints.ai_flags = AI_NUMERICHOST;
3530
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3531
        if (ai->ai_family == AF_INET6) {
3532
            av_strlcat(str, "[", size);
3533
            av_strlcat(str, hostname, size);
3534
            av_strlcat(str, "]", size);
3535
        } else {
3536
            av_strlcat(str, hostname, size);
3537
        }
3538
        freeaddrinfo(ai);
3539
    } else
3540
#endif
3541
        /* Not an IPv6 address, just output the plain string. */
3542
        av_strlcat(str, hostname, size);
3543

    
3544
    if (port >= 0)
3545
        av_strlcatf(str, size, ":%d", port);
3546
    if (fmt) {
3547
        va_list vl;
3548
        int len = strlen(str);
3549

    
3550
        va_start(vl, fmt);
3551
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3552
        va_end(vl);
3553
    }
3554
    return strlen(str);
3555
}