Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 58edb075

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
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
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 (!fmt && (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
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
679
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
680
                if(st->codec->codec_id != CODEC_ID_PROBE){
681
                    pd->buf_size=0;
682
                    av_freep(&pd->buf);
683
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
684
                }
685
            }
686
        }
687
    }
688
}
689

    
690
/**********************************************************/
691

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

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

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

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

    
721

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

    
730
    *pnum = 0;
731
    *pden = 0;
732
    switch(st->codec->codec_type) {
733
    case AVMEDIA_TYPE_VIDEO:
734
        if(st->time_base.num*1000LL > st->time_base.den){
735
            *pnum = st->time_base.num;
736
            *pden = st->time_base.den;
737
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
738
            *pnum = st->codec->time_base.num;
739
            *pden = st->codec->time_base.den;
740
            if (pc && pc->repeat_pict) {
741
                *pnum = (*pnum) * (1 + pc->repeat_pict);
742
            }
743
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
744
            //Thus if we have no parser in such case leave duration undefined.
745
            if(st->codec->ticks_per_frame>1 && !pc){
746
                *pnum = *pden = 0;
747
            }
748
        }
749
        break;
750
    case AVMEDIA_TYPE_AUDIO:
751
        frame_size = get_audio_frame_size(st->codec, pkt->size);
752
        if (frame_size < 0)
753
            break;
754
        *pnum = frame_size;
755
        *pden = st->codec->sample_rate;
756
        break;
757
    default:
758
        break;
759
    }
760
}
761

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

    
786
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
787
                                      int64_t dts, int64_t pts)
788
{
789
    AVStream *st= s->streams[stream_index];
790
    AVPacketList *pktl= s->packet_buffer;
791

    
792
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
793
        return;
794

    
795
    st->first_dts= dts - st->cur_dts;
796
    st->cur_dts= dts;
797

    
798
    for(; pktl; pktl= pktl->next){
799
        if(pktl->pkt.stream_index != stream_index)
800
            continue;
801
        //FIXME think more about this check
802
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
803
            pktl->pkt.pts += st->first_dts;
804

    
805
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
806
            pktl->pkt.dts += st->first_dts;
807

    
808
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
809
            st->start_time= pktl->pkt.pts;
810
    }
811
    if (st->start_time == AV_NOPTS_VALUE)
812
        st->start_time = pts;
813
}
814

    
815
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
816
{
817
    AVPacketList *pktl= s->packet_buffer;
818
    int64_t cur_dts= 0;
819

    
820
    if(st->first_dts != AV_NOPTS_VALUE){
821
        cur_dts= st->first_dts;
822
        for(; pktl; pktl= pktl->next){
823
            if(pktl->pkt.stream_index == pkt->stream_index){
824
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
825
                    break;
826
                cur_dts -= pkt->duration;
827
            }
828
        }
829
        pktl= s->packet_buffer;
830
        st->first_dts = cur_dts;
831
    }else if(st->cur_dts)
832
        return;
833

    
834
    for(; pktl; pktl= pktl->next){
835
        if(pktl->pkt.stream_index != pkt->stream_index)
836
            continue;
837
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
838
           && !pktl->pkt.duration){
839
            pktl->pkt.dts= cur_dts;
840
            if(!st->codec->has_b_frames)
841
                pktl->pkt.pts= cur_dts;
842
            cur_dts += pkt->duration;
843
            pktl->pkt.duration= pkt->duration;
844
        }else
845
            break;
846
    }
847
    if(st->first_dts == AV_NOPTS_VALUE)
848
        st->cur_dts= cur_dts;
849
}
850

    
851
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
852
                               AVCodecParserContext *pc, AVPacket *pkt)
853
{
854
    int num, den, presentation_delayed, delay, i;
855
    int64_t offset;
856

    
857
    if (s->flags & AVFMT_FLAG_NOFILLIN)
858
        return;
859

    
860
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
861
        pkt->dts= AV_NOPTS_VALUE;
862

    
863
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
864
        //FIXME Set low_delay = 0 when has_b_frames = 1
865
        st->codec->has_b_frames = 1;
866

    
867
    /* do we have a video B-frame ? */
868
    delay= st->codec->has_b_frames;
869
    presentation_delayed = 0;
870
    /* XXX: need has_b_frame, but cannot get it if the codec is
871
        not initialized */
872
    if (delay &&
873
        pc && pc->pict_type != FF_B_TYPE)
874
        presentation_delayed = 1;
875

    
876
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
877
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
878
        pkt->dts -= 1LL<<st->pts_wrap_bits;
879
    }
880

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

    
889
    if (pkt->duration == 0) {
890
        compute_frame_duration(&num, &den, st, pc, pkt);
891
        if (den && num) {
892
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
893

    
894
            if(pkt->duration != 0 && s->packet_buffer)
895
                update_initial_durations(s, st, pkt);
896
        }
897
    }
898

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

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

    
929
    /* This may be redundant, but it should not hurt. */
930
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
931
        presentation_delayed = 1;
932

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

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

    
966
            /* presentation is not delayed : PTS and DTS are the same */
967
            if(pkt->pts == AV_NOPTS_VALUE)
968
                pkt->pts = pkt->dts;
969
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
970
            if(pkt->pts == AV_NOPTS_VALUE)
971
                pkt->pts = st->cur_dts;
972
            pkt->dts = pkt->pts;
973
            if(pkt->pts != AV_NOPTS_VALUE)
974
                st->cur_dts = pkt->pts + pkt->duration;
975
        }
976
    }
977

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

    
991
//    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);
992

    
993
    /* update flags */
994
    if(is_intra_only(st->codec))
995
        pkt->flags |= AV_PKT_FLAG_KEY;
996
    else if (pc) {
997
        pkt->flags = 0;
998
        /* keyframe computation */
999
        if (pc->key_frame == 1)
1000
            pkt->flags |= AV_PKT_FLAG_KEY;
1001
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1002
            pkt->flags |= AV_PKT_FLAG_KEY;
1003
    }
1004
    if (pc)
1005
        pkt->convergence_duration = pc->convergence_duration;
1006
}
1007

    
1008

    
1009
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1010
{
1011
    AVStream *st;
1012
    int len, ret, i;
1013

    
1014
    av_init_packet(pkt);
1015

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

    
1043
                /* return packet if any */
1044
                if (pkt->size) {
1045
                got_packet:
1046
                    pkt->duration = 0;
1047
                    pkt->stream_index = st->index;
1048
                    pkt->pts = st->parser->pts;
1049
                    pkt->dts = st->parser->dts;
1050
                    pkt->pos = st->parser->pos;
1051
                    pkt->destruct = NULL;
1052
                    compute_pkt_fields(s, st, st->parser, pkt);
1053

    
1054
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1055
                        ff_reduce_index(s, st->index);
1056
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1057
                                           0, 0, AVINDEX_KEYFRAME);
1058
                    }
1059

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

    
1093
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1094
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1095
               st->cur_pkt.pts < st->cur_pkt.dts){
1096
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1097
                    st->cur_pkt.stream_index,
1098
                    st->cur_pkt.pts,
1099
                    st->cur_pkt.dts,
1100
                    st->cur_pkt.size);
1101
//                av_free_packet(&st->cur_pkt);
1102
//                return -1;
1103
            }
1104

    
1105
            if(s->debug & FF_FDEBUG_TS)
1106
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1107
                    st->cur_pkt.stream_index,
1108
                    st->cur_pkt.pts,
1109
                    st->cur_pkt.dts,
1110
                    st->cur_pkt.size,
1111
                    st->cur_pkt.duration,
1112
                    st->cur_pkt.flags);
1113

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

    
1141
    return 0;
1142
}
1143

    
1144
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1145
{
1146
    AVPacketList *pktl;
1147
    int eof=0;
1148
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1149

    
1150
    for(;;){
1151
        pktl = s->packet_buffer;
1152
        if (pktl) {
1153
            AVPacket *next_pkt= &pktl->pkt;
1154

    
1155
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1156
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1157
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1158
                       && next_pkt->dts < pktl->pkt.dts
1159
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1160
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1161
                        next_pkt->pts= pktl->pkt.dts;
1162
                    }
1163
                    pktl= pktl->next;
1164
                }
1165
                pktl = s->packet_buffer;
1166
            }
1167

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

    
1188
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1189
                                           &s->packet_buffer_end)) < 0)
1190
                return AVERROR(ENOMEM);
1191
        }else{
1192
            assert(!s->packet_buffer);
1193
            return av_read_frame_internal(s, pkt);
1194
        }
1195
    }
1196
}
1197

    
1198
/* XXX: suppress the packet queue */
1199
static void flush_packet_queue(AVFormatContext *s)
1200
{
1201
    AVPacketList *pktl;
1202

    
1203
    for(;;) {
1204
        pktl = s->packet_buffer;
1205
        if (!pktl)
1206
            break;
1207
        s->packet_buffer = pktl->next;
1208
        av_free_packet(&pktl->pkt);
1209
        av_free(pktl);
1210
    }
1211
    while(s->raw_packet_buffer){
1212
        pktl = s->raw_packet_buffer;
1213
        s->raw_packet_buffer = pktl->next;
1214
        av_free_packet(&pktl->pkt);
1215
        av_free(pktl);
1216
    }
1217
    s->packet_buffer_end=
1218
    s->raw_packet_buffer_end= NULL;
1219
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1220
}
1221

    
1222
/*******************************************************/
1223
/* seek support */
1224

    
1225
int av_find_default_stream_index(AVFormatContext *s)
1226
{
1227
    int first_audio_index = -1;
1228
    int i;
1229
    AVStream *st;
1230

    
1231
    if (s->nb_streams <= 0)
1232
        return -1;
1233
    for(i = 0; i < s->nb_streams; i++) {
1234
        st = s->streams[i];
1235
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1236
            return i;
1237
        }
1238
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1239
            first_audio_index = i;
1240
    }
1241
    return first_audio_index >= 0 ? first_audio_index : 0;
1242
}
1243

    
1244
/**
1245
 * Flush the frame reader.
1246
 */
1247
void ff_read_frame_flush(AVFormatContext *s)
1248
{
1249
    AVStream *st;
1250
    int i, j;
1251

    
1252
    flush_packet_queue(s);
1253

    
1254
    s->cur_st = NULL;
1255

    
1256
    /* for each stream, reset read state */
1257
    for(i = 0; i < s->nb_streams; i++) {
1258
        st = s->streams[i];
1259

    
1260
        if (st->parser) {
1261
            av_parser_close(st->parser);
1262
            st->parser = NULL;
1263
            av_free_packet(&st->cur_pkt);
1264
        }
1265
        st->last_IP_pts = AV_NOPTS_VALUE;
1266
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1267
        st->reference_dts = AV_NOPTS_VALUE;
1268
        /* fail safe */
1269
        st->cur_ptr = NULL;
1270
        st->cur_len = 0;
1271

    
1272
        st->probe_packets = MAX_PROBE_PACKETS;
1273

    
1274
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1275
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1276
    }
1277
}
1278

    
1279
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1280
    int i;
1281

    
1282
    for(i = 0; i < s->nb_streams; i++) {
1283
        AVStream *st = s->streams[i];
1284

    
1285
        st->cur_dts = av_rescale(timestamp,
1286
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1287
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1288
    }
1289
}
1290

    
1291
void ff_reduce_index(AVFormatContext *s, int stream_index)
1292
{
1293
    AVStream *st= s->streams[stream_index];
1294
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1295

    
1296
    if((unsigned)st->nb_index_entries >= max_entries){
1297
        int i;
1298
        for(i=0; 2*i<st->nb_index_entries; i++)
1299
            st->index_entries[i]= st->index_entries[2*i];
1300
        st->nb_index_entries= i;
1301
    }
1302
}
1303

    
1304
int av_add_index_entry(AVStream *st,
1305
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1306
{
1307
    AVIndexEntry *entries, *ie;
1308
    int index;
1309

    
1310
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1311
        return -1;
1312

    
1313
    entries = av_fast_realloc(st->index_entries,
1314
                              &st->index_entries_allocated_size,
1315
                              (st->nb_index_entries + 1) *
1316
                              sizeof(AVIndexEntry));
1317
    if(!entries)
1318
        return -1;
1319

    
1320
    st->index_entries= entries;
1321

    
1322
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1323

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

    
1339
    ie->pos = pos;
1340
    ie->timestamp = timestamp;
1341
    ie->min_distance= distance;
1342
    ie->size= size;
1343
    ie->flags = flags;
1344

    
1345
    return index;
1346
}
1347

    
1348
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1349
                              int flags)
1350
{
1351
    AVIndexEntry *entries= st->index_entries;
1352
    int nb_entries= st->nb_index_entries;
1353
    int a, b, m;
1354
    int64_t timestamp;
1355

    
1356
    a = - 1;
1357
    b = nb_entries;
1358

    
1359
    //optimize appending index entries at the end
1360
    if(b && entries[b-1].timestamp < wanted_timestamp)
1361
        a= b-1;
1362

    
1363
    while (b - a > 1) {
1364
        m = (a + b) >> 1;
1365
        timestamp = entries[m].timestamp;
1366
        if(timestamp >= wanted_timestamp)
1367
            b = m;
1368
        if(timestamp <= wanted_timestamp)
1369
            a = m;
1370
    }
1371
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1372

    
1373
    if(!(flags & AVSEEK_FLAG_ANY)){
1374
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1375
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1376
        }
1377
    }
1378

    
1379
    if(m == nb_entries)
1380
        return -1;
1381
    return  m;
1382
}
1383

    
1384
#define DEBUG_SEEK
1385

    
1386
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1387
    AVInputFormat *avif= s->iformat;
1388
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1389
    int64_t ts_min, ts_max, ts;
1390
    int index;
1391
    int64_t ret;
1392
    AVStream *st;
1393

    
1394
    if (stream_index < 0)
1395
        return -1;
1396

    
1397
#ifdef DEBUG_SEEK
1398
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1399
#endif
1400

    
1401
    ts_max=
1402
    ts_min= AV_NOPTS_VALUE;
1403
    pos_limit= -1; //gcc falsely says it may be uninitialized
1404

    
1405
    st= s->streams[stream_index];
1406
    if(st->index_entries){
1407
        AVIndexEntry *e;
1408

    
1409
        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()
1410
        index= FFMAX(index, 0);
1411
        e= &st->index_entries[index];
1412

    
1413
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1414
            pos_min= e->pos;
1415
            ts_min= e->timestamp;
1416
#ifdef DEBUG_SEEK
1417
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1418
                   pos_min,ts_min);
1419
#endif
1420
        }else{
1421
            assert(index==0);
1422
        }
1423

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

    
1439
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1440
    if(pos<0)
1441
        return -1;
1442

    
1443
    /* do the seek */
1444
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1445
        return ret;
1446

    
1447
    av_update_cur_dts(s, st, ts);
1448

    
1449
    return 0;
1450
}
1451

    
1452
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 )){
1453
    int64_t pos, ts;
1454
    int64_t start_pos, filesize;
1455
    int no_change;
1456

    
1457
#ifdef DEBUG_SEEK
1458
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1459
#endif
1460

    
1461
    if(ts_min == AV_NOPTS_VALUE){
1462
        pos_min = s->data_offset;
1463
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1464
        if (ts_min == AV_NOPTS_VALUE)
1465
            return -1;
1466
    }
1467

    
1468
    if(ts_max == AV_NOPTS_VALUE){
1469
        int step= 1024;
1470
        filesize = url_fsize(s->pb);
1471
        pos_max = filesize - 1;
1472
        do{
1473
            pos_max -= step;
1474
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1475
            step += step;
1476
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1477
        if (ts_max == AV_NOPTS_VALUE)
1478
            return -1;
1479

    
1480
        for(;;){
1481
            int64_t tmp_pos= pos_max + 1;
1482
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1483
            if(tmp_ts == AV_NOPTS_VALUE)
1484
                break;
1485
            ts_max= tmp_ts;
1486
            pos_max= tmp_pos;
1487
            if(tmp_pos >= filesize)
1488
                break;
1489
        }
1490
        pos_limit= pos_max;
1491
    }
1492

    
1493
    if(ts_min > ts_max){
1494
        return -1;
1495
    }else if(ts_min == ts_max){
1496
        pos_limit= pos_min;
1497
    }
1498

    
1499
    no_change=0;
1500
    while (pos_min < pos_limit) {
1501
#ifdef DEBUG_SEEK
1502
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1503
               pos_min, pos_max,
1504
               ts_min, ts_max);
1505
#endif
1506
        assert(pos_limit <= pos_max);
1507

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

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

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

    
1567
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1568
    int64_t pos_min, pos_max;
1569
#if 0
1570
    AVStream *st;
1571

1572
    if (stream_index < 0)
1573
        return -1;
1574

1575
    st= s->streams[stream_index];
1576
#endif
1577

    
1578
    pos_min = s->data_offset;
1579
    pos_max = url_fsize(s->pb) - 1;
1580

    
1581
    if     (pos < pos_min) pos= pos_min;
1582
    else if(pos > pos_max) pos= pos_max;
1583

    
1584
    url_fseek(s->pb, pos, SEEK_SET);
1585

    
1586
#if 0
1587
    av_update_cur_dts(s, st, ts);
1588
#endif
1589
    return 0;
1590
}
1591

    
1592
static int av_seek_frame_generic(AVFormatContext *s,
1593
                                 int stream_index, int64_t timestamp, int flags)
1594
{
1595
    int index;
1596
    int64_t ret;
1597
    AVStream *st;
1598
    AVIndexEntry *ie;
1599

    
1600
    st = s->streams[stream_index];
1601

    
1602
    index = av_index_search_timestamp(st, timestamp, flags);
1603

    
1604
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1605
        return -1;
1606

    
1607
    if(index < 0 || index==st->nb_index_entries-1){
1608
        int i;
1609
        AVPacket pkt;
1610

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

    
1639
    ff_read_frame_flush(s);
1640
    if (s->iformat->read_seek){
1641
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1642
            return 0;
1643
    }
1644
    ie = &st->index_entries[index];
1645
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1646
        return ret;
1647
    av_update_cur_dts(s, st, ie->timestamp);
1648

    
1649
    return 0;
1650
}
1651

    
1652
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1653
{
1654
    int ret;
1655
    AVStream *st;
1656

    
1657
    ff_read_frame_flush(s);
1658

    
1659
    if(flags & AVSEEK_FLAG_BYTE)
1660
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1661

    
1662
    if(stream_index < 0){
1663
        stream_index= av_find_default_stream_index(s);
1664
        if(stream_index < 0)
1665
            return -1;
1666

    
1667
        st= s->streams[stream_index];
1668
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1669
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1670
    }
1671

    
1672
    /* first, we try the format specific seek */
1673
    if (s->iformat->read_seek)
1674
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1675
    else
1676
        ret = -1;
1677
    if (ret >= 0) {
1678
        return 0;
1679
    }
1680

    
1681
    if(s->iformat->read_timestamp)
1682
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1683
    else
1684
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1685
}
1686

    
1687
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1688
{
1689
    if(min_ts > ts || max_ts < ts)
1690
        return -1;
1691

    
1692
    ff_read_frame_flush(s);
1693

    
1694
    if (s->iformat->read_seek2)
1695
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1696

    
1697
    if(s->iformat->read_timestamp){
1698
        //try to seek via read_timestamp()
1699
    }
1700

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

    
1706
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1707
}
1708

    
1709
/*******************************************************/
1710

    
1711
/**
1712
 * Returns TRUE if the stream has accurate duration in any stream.
1713
 *
1714
 * @return TRUE if the stream has accurate duration for at least one component.
1715
 */
1716
static int av_has_duration(AVFormatContext *ic)
1717
{
1718
    int i;
1719
    AVStream *st;
1720

    
1721
    for(i = 0;i < ic->nb_streams; i++) {
1722
        st = ic->streams[i];
1723
        if (st->duration != AV_NOPTS_VALUE)
1724
            return 1;
1725
    }
1726
    return 0;
1727
}
1728

    
1729
/**
1730
 * Estimate the stream timings from the one of each components.
1731
 *
1732
 * Also computes the global bitrate if possible.
1733
 */
1734
static void av_update_stream_timings(AVFormatContext *ic)
1735
{
1736
    int64_t start_time, start_time1, end_time, end_time1;
1737
    int64_t duration, duration1;
1738
    int i;
1739
    AVStream *st;
1740

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

    
1780
static void fill_all_stream_timings(AVFormatContext *ic)
1781
{
1782
    int i;
1783
    AVStream *st;
1784

    
1785
    av_update_stream_timings(ic);
1786
    for(i = 0;i < ic->nb_streams; i++) {
1787
        st = ic->streams[i];
1788
        if (st->start_time == AV_NOPTS_VALUE) {
1789
            if(ic->start_time != AV_NOPTS_VALUE)
1790
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1791
            if(ic->duration != AV_NOPTS_VALUE)
1792
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1793
        }
1794
    }
1795
}
1796

    
1797
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1798
{
1799
    int64_t filesize, duration;
1800
    int bit_rate, i;
1801
    AVStream *st;
1802

    
1803
    /* if bit_rate is already set, we believe it */
1804
    if (ic->bit_rate == 0) {
1805
        bit_rate = 0;
1806
        for(i=0;i<ic->nb_streams;i++) {
1807
            st = ic->streams[i];
1808
            bit_rate += st->codec->bit_rate;
1809
        }
1810
        ic->bit_rate = bit_rate;
1811
    }
1812

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

    
1829
#define DURATION_MAX_READ_SIZE 250000
1830
#define DURATION_MAX_RETRY 3
1831

    
1832
/* only usable for MPEG-PS streams */
1833
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1834
{
1835
    AVPacket pkt1, *pkt = &pkt1;
1836
    AVStream *st;
1837
    int read_size, i, ret;
1838
    int64_t end_time, start_time[MAX_STREAMS];
1839
    int64_t filesize, offset, duration;
1840
    int retry=0;
1841

    
1842
    ic->cur_st = NULL;
1843

    
1844
    /* flush packet queue */
1845
    flush_packet_queue(ic);
1846

    
1847
    for(i=0;i<ic->nb_streams;i++) {
1848
        st = ic->streams[i];
1849
        if(st->start_time != AV_NOPTS_VALUE){
1850
            start_time[i]= st->start_time;
1851
        }else if(st->first_dts != AV_NOPTS_VALUE){
1852
            start_time[i]= st->first_dts;
1853
        }else
1854
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1855

    
1856
        if (st->parser) {
1857
            av_parser_close(st->parser);
1858
            st->parser= NULL;
1859
            av_free_packet(&st->cur_pkt);
1860
        }
1861
    }
1862

    
1863
    /* estimate the end time (duration) */
1864
    /* XXX: may need to support wrapping */
1865
    filesize = ic->file_size;
1866
    end_time = AV_NOPTS_VALUE;
1867
    do{
1868
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1869
    if (offset < 0)
1870
        offset = 0;
1871

    
1872
    url_fseek(ic->pb, offset, SEEK_SET);
1873
    read_size = 0;
1874
    for(;;) {
1875
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1876
            break;
1877

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

    
1903
    fill_all_stream_timings(ic);
1904

    
1905
    url_fseek(ic->pb, old_offset, SEEK_SET);
1906
    for(i=0; i<ic->nb_streams; i++){
1907
        st= ic->streams[i];
1908
        st->cur_dts= st->first_dts;
1909
        st->last_IP_pts = AV_NOPTS_VALUE;
1910
    }
1911
}
1912

    
1913
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1914
{
1915
    int64_t file_size;
1916

    
1917
    /* get the file size, if possible */
1918
    if (ic->iformat->flags & AVFMT_NOFILE) {
1919
        file_size = 0;
1920
    } else {
1921
        file_size = url_fsize(ic->pb);
1922
        if (file_size < 0)
1923
            file_size = 0;
1924
    }
1925
    ic->file_size = file_size;
1926

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

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

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

    
1986
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1987
{
1988
    int16_t *samples;
1989
    AVCodec *codec;
1990
    int got_picture, data_size, ret=0;
1991
    AVFrame picture;
1992

    
1993
    if(!st->codec->codec){
1994
        codec = avcodec_find_decoder(st->codec->codec_id);
1995
        if (!codec)
1996
            return -1;
1997
        ret = avcodec_open(st->codec, codec);
1998
        if (ret < 0)
1999
            return ret;
2000
    }
2001

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

    
2026
unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
2027
{
2028
    while (tags->id != CODEC_ID_NONE) {
2029
        if (tags->id == id)
2030
            return tags->tag;
2031
        tags++;
2032
    }
2033
    return 0;
2034
}
2035

    
2036
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2037
{
2038
    int i;
2039
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2040
        if(tag == tags[i].tag)
2041
            return tags[i].id;
2042
    }
2043
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2044
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
2045
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
2046
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
2047
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
2048
            return tags[i].id;
2049
    }
2050
    return CODEC_ID_NONE;
2051
}
2052

    
2053
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2054
{
2055
    int i;
2056
    for(i=0; tags && tags[i]; i++){
2057
        int tag= ff_codec_get_tag(tags[i], id);
2058
        if(tag) return tag;
2059
    }
2060
    return 0;
2061
}
2062

    
2063
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2064
{
2065
    int i;
2066
    for(i=0; tags && tags[i]; i++){
2067
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2068
        if(id!=CODEC_ID_NONE) return id;
2069
    }
2070
    return CODEC_ID_NONE;
2071
}
2072

    
2073
static void compute_chapters_end(AVFormatContext *s)
2074
{
2075
    unsigned int i;
2076

    
2077
    for (i=0; i+1<s->nb_chapters; i++)
2078
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2079
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2080
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2081
            s->chapters[i]->end = s->chapters[i+1]->start;
2082
        }
2083

    
2084
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2085
        assert(s->start_time != AV_NOPTS_VALUE);
2086
        assert(s->duration > 0);
2087
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2088
                                           AV_TIME_BASE_Q,
2089
                                           s->chapters[i]->time_base);
2090
    }
2091
}
2092

    
2093
#define MAX_STD_TIMEBASES (60*12+5)
2094
static int get_std_framerate(int i){
2095
    if(i<60*12) return i*1001;
2096
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2097
}
2098

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

    
2119
int av_find_stream_info(AVFormatContext *ic)
2120
{
2121
    int i, count, ret, read_size, j;
2122
    AVStream *st;
2123
    AVPacket pkt1, *pkt;
2124
    int64_t last_dts[MAX_STREAMS];
2125
    int64_t duration_gcd[MAX_STREAMS]={0};
2126
    int duration_count[MAX_STREAMS]={0};
2127
    double (*duration_error)[MAX_STD_TIMEBASES];
2128
    int64_t old_offset = url_ftell(ic->pb);
2129
    int64_t codec_info_duration[MAX_STREAMS]={0};
2130

    
2131
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2132
    if (!duration_error) return AVERROR(ENOMEM);
2133

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

    
2163
    for(i=0;i<MAX_STREAMS;i++){
2164
        last_dts[i]= AV_NOPTS_VALUE;
2165
    }
2166

    
2167
    count = 0;
2168
    read_size = 0;
2169
    for(;;) {
2170
        if(url_interrupt_cb()){
2171
            ret= AVERROR(EINTR);
2172
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2173
            break;
2174
        }
2175

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

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

    
2229
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2230
        if(av_dup_packet(pkt) < 0) {
2231
            av_free(duration_error);
2232
            return AVERROR(ENOMEM);
2233
        }
2234

    
2235
        read_size += pkt->size;
2236

    
2237
        st = ic->streams[pkt->stream_index];
2238
        if(st->codec_info_nb_frames>1) {
2239
            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){
2240
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2241
                break;
2242
            }
2243
            codec_info_duration[st->index] += pkt->duration;
2244
        }
2245
            st->codec_info_nb_frames++;
2246

    
2247
        {
2248
            int index= pkt->stream_index;
2249
            int64_t last= last_dts[index];
2250
            int64_t duration= pkt->dts - last;
2251

    
2252
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2253
                double dur= duration * av_q2d(st->time_base);
2254

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

    
2283
        /* if still no information, we try to open the codec and to
2284
           decompress the frame. We try to avoid that in most cases as
2285
           it takes longer and uses more memory. For MPEG-4, we need to
2286
           decompress for QuickTime. */
2287
        if (!has_codec_parameters(st->codec))
2288
            try_decode_frame(st, pkt);
2289

    
2290
        count++;
2291
    }
2292

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

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

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

    
2336
            if (!st->r_frame_rate.num){
2337
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2338
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2339
                    st->r_frame_rate.num = st->codec->time_base.den;
2340
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2341
                }else{
2342
                    st->r_frame_rate.num = st->time_base.den;
2343
                    st->r_frame_rate.den = st->time_base.num;
2344
                }
2345
            }
2346
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2347
            if(!st->codec->bits_per_coded_sample)
2348
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2349
        }
2350
    }
2351

    
2352
    av_estimate_timings(ic, old_offset);
2353

    
2354
    compute_chapters_end(ic);
2355

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

    
2381
    av_free(duration_error);
2382

    
2383
    return ret;
2384
}
2385

    
2386
/*******************************************************/
2387

    
2388
int av_read_play(AVFormatContext *s)
2389
{
2390
    if (s->iformat->read_play)
2391
        return s->iformat->read_play(s);
2392
    if (s->pb)
2393
        return av_url_read_fpause(s->pb, 0);
2394
    return AVERROR(ENOSYS);
2395
}
2396

    
2397
int av_read_pause(AVFormatContext *s)
2398
{
2399
    if (s->iformat->read_pause)
2400
        return s->iformat->read_pause(s);
2401
    if (s->pb)
2402
        return av_url_read_fpause(s->pb, 1);
2403
    return AVERROR(ENOSYS);
2404
}
2405

    
2406
void av_close_input_stream(AVFormatContext *s)
2407
{
2408
    int i;
2409
    AVStream *st;
2410

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

    
2454
void av_close_input_file(AVFormatContext *s)
2455
{
2456
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2457
    av_close_input_stream(s);
2458
    if (pb)
2459
        url_fclose(pb);
2460
}
2461

    
2462
AVStream *av_new_stream(AVFormatContext *s, int id)
2463
{
2464
    AVStream *st;
2465
    int i;
2466

    
2467
    if (s->nb_streams >= MAX_STREAMS)
2468
        return NULL;
2469

    
2470
    st = av_mallocz(sizeof(AVStream));
2471
    if (!st)
2472
        return NULL;
2473

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

    
2491
    /* default pts setting is MPEG-like */
2492
    av_set_pts_info(st, 33, 1, 90000);
2493
    st->last_IP_pts = AV_NOPTS_VALUE;
2494
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2495
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2496
    st->reference_dts = AV_NOPTS_VALUE;
2497

    
2498
    st->sample_aspect_ratio = (AVRational){0,1};
2499

    
2500
    s->streams[s->nb_streams++] = st;
2501
    return st;
2502
}
2503

    
2504
AVProgram *av_new_program(AVFormatContext *ac, int id)
2505
{
2506
    AVProgram *program=NULL;
2507
    int i;
2508

    
2509
#ifdef DEBUG_SI
2510
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2511
#endif
2512

    
2513
    for(i=0; i<ac->nb_programs; i++)
2514
        if(ac->programs[i]->id == id)
2515
            program = ac->programs[i];
2516

    
2517
    if(!program){
2518
        program = av_mallocz(sizeof(AVProgram));
2519
        if (!program)
2520
            return NULL;
2521
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2522
        program->discard = AVDISCARD_NONE;
2523
    }
2524
    program->id = id;
2525

    
2526
    return program;
2527
}
2528

    
2529
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2530
{
2531
    AVChapter *chapter = NULL;
2532
    int i;
2533

    
2534
    for(i=0; i<s->nb_chapters; i++)
2535
        if(s->chapters[i]->id == id)
2536
            chapter = s->chapters[i];
2537

    
2538
    if(!chapter){
2539
        chapter= av_mallocz(sizeof(AVChapter));
2540
        if(!chapter)
2541
            return NULL;
2542
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2543
    }
2544
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2545
    av_free(chapter->title);
2546
#endif
2547
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2548
    chapter->id    = id;
2549
    chapter->time_base= time_base;
2550
    chapter->start = start;
2551
    chapter->end   = end;
2552

    
2553
    return chapter;
2554
}
2555

    
2556
/************************************************************/
2557
/* output media file */
2558

    
2559
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2560
{
2561
    int ret;
2562

    
2563
    if (s->oformat->priv_data_size > 0) {
2564
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2565
        if (!s->priv_data)
2566
            return AVERROR(ENOMEM);
2567
    } else
2568
        s->priv_data = NULL;
2569

    
2570
    if (s->oformat->set_parameters) {
2571
        ret = s->oformat->set_parameters(s, ap);
2572
        if (ret < 0)
2573
            return ret;
2574
    }
2575
    return 0;
2576
}
2577

    
2578
int av_write_header(AVFormatContext *s)
2579
{
2580
    int ret, i;
2581
    AVStream *st;
2582

    
2583
    // some sanity checks
2584
    if (s->nb_streams == 0) {
2585
        av_log(s, AV_LOG_ERROR, "no streams\n");
2586
        return -1;
2587
    }
2588

    
2589
    for(i=0;i<s->nb_streams;i++) {
2590
        st = s->streams[i];
2591

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

    
2618
        if(s->oformat->codec_tag){
2619
            if(st->codec->codec_tag){
2620
                //FIXME
2621
                //check that tag + id is in the table
2622
                //if neither is in the table -> OK
2623
                //if tag is in the table with another id -> FAIL
2624
                //if id is in the table with another tag -> FAIL unless strict < ?
2625
            }else
2626
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2627
        }
2628

    
2629
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2630
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2631
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2632
    }
2633

    
2634
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2635
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2636
        if (!s->priv_data)
2637
            return AVERROR(ENOMEM);
2638
    }
2639

    
2640
#if LIBAVFORMAT_VERSION_MAJOR < 53
2641
    ff_metadata_mux_compat(s);
2642
#endif
2643

    
2644
    /* set muxer identification string */
2645
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2646
        AVMetadata *m;
2647
        AVMetadataTag *t;
2648

    
2649
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2650
            return AVERROR(ENOMEM);
2651
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2652
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2653
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2654
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2655
        av_metadata_free(&m);
2656
    }
2657

    
2658
    if(s->oformat->write_header){
2659
        ret = s->oformat->write_header(s);
2660
        if (ret < 0)
2661
            return ret;
2662
    }
2663

    
2664
    /* init PTS generation */
2665
    for(i=0;i<s->nb_streams;i++) {
2666
        int64_t den = AV_NOPTS_VALUE;
2667
        st = s->streams[i];
2668

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

    
2688
//FIXME merge with compute_pkt_fields
2689
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2690
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2691
    int num, den, frame_size, i;
2692

    
2693
//    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);
2694

    
2695
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2696
        return -1;*/
2697

    
2698
    /* duration field */
2699
    if (pkt->duration == 0) {
2700
        compute_frame_duration(&num, &den, st, NULL, pkt);
2701
        if (den && num) {
2702
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2703
        }
2704
    }
2705

    
2706
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2707
        pkt->pts= pkt->dts;
2708

    
2709
    //XXX/FIXME this is a temporary hack until all encoders output pts
2710
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2711
        pkt->dts=
2712
//        pkt->pts= st->cur_dts;
2713
        pkt->pts= st->pts.val;
2714
    }
2715

    
2716
    //calculate dts from pts
2717
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2718
        st->pts_buffer[0]= pkt->pts;
2719
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2720
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2721
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2722
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2723

    
2724
        pkt->dts= st->pts_buffer[0];
2725
    }
2726

    
2727
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2728
        av_log(s, AV_LOG_ERROR,
2729
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2730
               st->index, st->cur_dts, pkt->dts);
2731
        return -1;
2732
    }
2733
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2734
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2735
        return -1;
2736
    }
2737

    
2738
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2739
    st->cur_dts= pkt->dts;
2740
    st->pts.val= pkt->dts;
2741

    
2742
    /* update pts */
2743
    switch (st->codec->codec_type) {
2744
    case AVMEDIA_TYPE_AUDIO:
2745
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2746

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

    
2763
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2764
{
2765
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2766

    
2767
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2768
        return ret;
2769

    
2770
    ret= s->oformat->write_packet(s, pkt);
2771
    if(!ret)
2772
        ret= url_ferror(s->pb);
2773
    return ret;
2774
}
2775

    
2776
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2777
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2778
{
2779
    AVPacketList **next_point, *this_pktl;
2780

    
2781
    this_pktl = av_mallocz(sizeof(AVPacketList));
2782
    this_pktl->pkt= *pkt;
2783
    pkt->destruct= NULL;             // do not free original but only the copy
2784
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2785

    
2786
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2787
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2788
    }else
2789
        next_point = &s->packet_buffer;
2790

    
2791
    if(*next_point){
2792
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2793
            while(!compare(s, &(*next_point)->pkt, pkt)){
2794
                next_point= &(*next_point)->next;
2795
            }
2796
            goto next_non_null;
2797
        }else{
2798
            next_point = &(s->packet_buffer_end->next);
2799
        }
2800
    }
2801
    assert(!*next_point);
2802

    
2803
    s->packet_buffer_end= this_pktl;
2804
next_non_null:
2805

    
2806
    this_pktl->next= *next_point;
2807

    
2808
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2809
    *next_point= this_pktl;
2810
}
2811

    
2812
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2813
{
2814
    AVStream *st = s->streams[ pkt ->stream_index];
2815
    AVStream *st2= s->streams[ next->stream_index];
2816
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2817
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2818
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2819
}
2820

    
2821
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2822
    AVPacketList *pktl;
2823
    int stream_count=0;
2824
    int i;
2825

    
2826
    if(pkt){
2827
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2828
    }
2829

    
2830
    for(i=0; i < s->nb_streams; i++)
2831
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2832

    
2833
    if(stream_count && (s->nb_streams == stream_count || flush)){
2834
        pktl= s->packet_buffer;
2835
        *out= pktl->pkt;
2836

    
2837
        s->packet_buffer= pktl->next;
2838
        if(!s->packet_buffer)
2839
            s->packet_buffer_end= NULL;
2840

    
2841
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2842
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2843
        av_freep(&pktl);
2844
        return 1;
2845
    }else{
2846
        av_init_packet(out);
2847
        return 0;
2848
    }
2849
}
2850

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

    
2867
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2868
    AVStream *st= s->streams[ pkt->stream_index];
2869

    
2870
    //FIXME/XXX/HACK drop zero sized packets
2871
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2872
        return 0;
2873

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

    
2878
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2879
        return -1;
2880

    
2881
    for(;;){
2882
        AVPacket opkt;
2883
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2884
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2885
            return ret;
2886

    
2887
        ret= s->oformat->write_packet(s, &opkt);
2888

    
2889
        av_free_packet(&opkt);
2890
        pkt= NULL;
2891

    
2892
        if(ret<0)
2893
            return ret;
2894
        if(url_ferror(s->pb))
2895
            return url_ferror(s->pb);
2896
    }
2897
}
2898

    
2899
int av_write_trailer(AVFormatContext *s)
2900
{
2901
    int ret, i;
2902

    
2903
    for(;;){
2904
        AVPacket pkt;
2905
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2906
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2907
            goto fail;
2908
        if(!ret)
2909
            break;
2910

    
2911
        ret= s->oformat->write_packet(s, &pkt);
2912

    
2913
        av_free_packet(&pkt);
2914

    
2915
        if(ret<0)
2916
            goto fail;
2917
        if(url_ferror(s->pb))
2918
            goto fail;
2919
    }
2920

    
2921
    if(s->oformat->write_trailer)
2922
        ret = s->oformat->write_trailer(s);
2923
fail:
2924
    if(ret == 0)
2925
       ret=url_ferror(s->pb);
2926
    for(i=0;i<s->nb_streams;i++) {
2927
        av_freep(&s->streams[i]->priv_data);
2928
        av_freep(&s->streams[i]->index_entries);
2929
    }
2930
    av_freep(&s->priv_data);
2931
    return ret;
2932
}
2933

    
2934
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2935
{
2936
    int i, j;
2937
    AVProgram *program=NULL;
2938
    void *tmp;
2939

    
2940
    if (idx >= ac->nb_streams) {
2941
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2942
        return;
2943
    }
2944

    
2945
    for(i=0; i<ac->nb_programs; i++){
2946
        if(ac->programs[i]->id != progid)
2947
            continue;
2948
        program = ac->programs[i];
2949
        for(j=0; j<program->nb_stream_indexes; j++)
2950
            if(program->stream_index[j] == idx)
2951
                return;
2952

    
2953
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2954
        if(!tmp)
2955
            return;
2956
        program->stream_index = tmp;
2957
        program->stream_index[program->nb_stream_indexes++] = idx;
2958
        return;
2959
    }
2960
}
2961

    
2962
static void print_fps(double d, const char *postfix){
2963
    uint64_t v= lrintf(d*100);
2964
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2965
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2966
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2967
}
2968

    
2969
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2970
{
2971
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2972
        AVMetadataTag *tag=NULL;
2973

    
2974
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2975
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2976
            if(strcmp("language", tag->key))
2977
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
2978
        }
2979
    }
2980
}
2981

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

    
3025
void dump_format(AVFormatContext *ic,
3026
                 int index,
3027
                 const char *url,
3028
                 int is_output)
3029
{
3030
    int i;
3031
    uint8_t *printed = av_mallocz(ic->nb_streams);
3032
    if (ic->nb_streams && !printed)
3033
        return;
3034

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

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

    
3101
    av_free(printed);
3102
}
3103

    
3104
#if LIBAVFORMAT_VERSION_MAJOR < 53
3105
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3106
{
3107
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
3108
}
3109

    
3110
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3111
{
3112
    AVRational frame_rate;
3113
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
3114
    *frame_rate_num= frame_rate.num;
3115
    *frame_rate_den= frame_rate.den;
3116
    return ret;
3117
}
3118
#endif
3119

    
3120
int64_t av_gettime(void)
3121
{
3122
    struct timeval tv;
3123
    gettimeofday(&tv,NULL);
3124
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3125
}
3126

    
3127
uint64_t ff_ntp_time(void)
3128
{
3129
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3130
}
3131

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

    
3151
#undef time
3152
    time_t now = time(0);
3153

    
3154
    len = strlen(datestr);
3155
    if (len > 0)
3156
        lastch = datestr[len - 1];
3157
    else
3158
        lastch = '\0';
3159
    is_utc = (lastch == 'z' || lastch == 'Z');
3160

    
3161
    memset(&dt, 0, sizeof(dt));
3162

    
3163
    p = datestr;
3164
    q = NULL;
3165
    if (!duration) {
3166
        if (!strncasecmp(datestr, "now", len))
3167
            return (int64_t) now * 1000000;
3168

    
3169
        /* parse the year-month-day part */
3170
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3171
            q = small_strptime(p, date_fmt[i], &dt);
3172
            if (q) {
3173
                break;
3174
            }
3175
        }
3176

    
3177
        /* if the year-month-day part is missing, then take the
3178
         * current year-month-day time */
3179
        if (!q) {
3180
            if (is_utc) {
3181
                dt = *gmtime(&now);
3182
            } else {
3183
                dt = *localtime(&now);
3184
            }
3185
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3186
        } else {
3187
            p = q;
3188
        }
3189

    
3190
        if (*p == 'T' || *p == 't' || *p == ' ')
3191
            p++;
3192

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

    
3219
    /* Now we have all the fields that we can get */
3220
    if (!q) {
3221
        return INT64_MIN;
3222
    }
3223

    
3224
    if (duration) {
3225
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3226
    } else {
3227
        dt.tm_isdst = -1;       /* unknown */
3228
        if (is_utc) {
3229
            t = mktimegm(&dt);
3230
        } else {
3231
            t = mktime(&dt);
3232
        }
3233
    }
3234

    
3235
    t *= 1000000;
3236

    
3237
    /* parse the .m... part */
3238
    if (*q == '.') {
3239
        int val, n;
3240
        q++;
3241
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3242
            if (!isdigit(*q))
3243
                break;
3244
            val += n * (*q - '0');
3245
        }
3246
        t += val;
3247
    }
3248
    return negative ? -t : t;
3249
}
3250

    
3251
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3252
{
3253
    const char *p;
3254
    char tag[128], *q;
3255

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

    
3290
int av_get_frame_filename(char *buf, int buf_size,
3291
                          const char *path, int number)
3292
{
3293
    const char *p;
3294
    char *q, buf1[20], c;
3295
    int nd, len, percentd_found;
3296

    
3297
    q = buf;
3298
    p = path;
3299
    percentd_found = 0;
3300
    for(;;) {
3301
        c = *p++;
3302
        if (c == '\0')
3303
            break;
3304
        if (c == '%') {
3305
            do {
3306
                nd = 0;
3307
                while (isdigit(*p)) {
3308
                    nd = nd * 10 + *p++ - '0';
3309
                }
3310
                c = *p++;
3311
            } while (isdigit(c));
3312

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

    
3345
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3346
{
3347
    int len, i, j, c;
3348
#undef fprintf
3349
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3350

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

    
3374
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3375
{
3376
    hex_dump_internal(NULL, f, 0, buf, size);
3377
}
3378

    
3379
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3380
{
3381
    hex_dump_internal(avcl, NULL, level, buf, size);
3382
}
3383

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

    
3411
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3412
{
3413
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3414
}
3415

    
3416
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3417
{
3418
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3419
}
3420

    
3421
void ff_url_split(char *proto, int proto_size,
3422
                  char *authorization, int authorization_size,
3423
                  char *hostname, int hostname_size,
3424
                  int *port_ptr,
3425
                  char *path, int path_size,
3426
                  const char *url)
3427
{
3428
    const char *p, *ls, *at, *col, *brk;
3429

    
3430
    if (port_ptr)               *port_ptr = -1;
3431
    if (proto_size > 0)         proto[0] = 0;
3432
    if (authorization_size > 0) authorization[0] = 0;
3433
    if (hostname_size > 0)      hostname[0] = 0;
3434
    if (path_size > 0)          path[0] = 0;
3435

    
3436
    /* parse protocol */
3437
    if ((p = strchr(url, ':'))) {
3438
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3439
        p++; /* skip ':' */
3440
        if (*p == '/') p++;
3441
        if (*p == '/') p++;
3442
    } else {
3443
        /* no protocol means plain filename */
3444
        av_strlcpy(path, url, path_size);
3445
        return;
3446
    }
3447

    
3448
    /* separate path from hostname */
3449
    ls = strchr(p, '/');
3450
    if(!ls)
3451
        ls = strchr(p, '?');
3452
    if(ls)
3453
        av_strlcpy(path, ls, path_size);
3454
    else
3455
        ls = &p[strlen(p)]; // XXX
3456

    
3457
    /* the rest is hostname, use that to parse auth/port */
3458
    if (ls != p) {
3459
        /* authorization (user[:pass]@hostname) */
3460
        if ((at = strchr(p, '@')) && at < ls) {
3461
            av_strlcpy(authorization, p,
3462
                       FFMIN(authorization_size, at + 1 - p));
3463
            p = at + 1; /* skip '@' */
3464
        }
3465

    
3466
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3467
            /* [host]:port */
3468
            av_strlcpy(hostname, p + 1,
3469
                       FFMIN(hostname_size, brk - p));
3470
            if (brk[1] == ':' && port_ptr)
3471
                *port_ptr = atoi(brk + 2);
3472
        } else if ((col = strchr(p, ':')) && col < ls) {
3473
            av_strlcpy(hostname, p,
3474
                       FFMIN(col + 1 - p, hostname_size));
3475
            if (port_ptr) *port_ptr = atoi(col + 1);
3476
        } else
3477
            av_strlcpy(hostname, p,
3478
                       FFMIN(ls + 1 - p, hostname_size));
3479
    }
3480
}
3481

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

    
3495
    for(i = 0; i < s; i++) {
3496
        buff[i * 2]     = hex_table[src[i] >> 4];
3497
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3498
    }
3499

    
3500
    return buff;
3501
}
3502

    
3503
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3504
                     unsigned int pts_num, unsigned int pts_den)
3505
{
3506
    s->pts_wrap_bits = pts_wrap_bits;
3507

    
3508
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3509
        if(s->time_base.num != pts_num)
3510
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3511
    }else
3512
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3513

    
3514
    if(!s->time_base.num || !s->time_base.den)
3515
        s->time_base.num= s->time_base.den= 0;
3516
}
3517

    
3518
int ff_url_join(char *str, int size, const char *proto,
3519
                const char *authorization, const char *hostname,
3520
                int port, const char *fmt, ...)
3521
{
3522
#if CONFIG_NETWORK
3523
    struct addrinfo hints, *ai;
3524
#endif
3525

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

    
3550
    if (port >= 0)
3551
        av_strlcatf(str, size, ":%d", port);
3552
    if (fmt) {
3553
        va_list vl;
3554
        int len = strlen(str);
3555

    
3556
        va_start(vl, fmt);
3557
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3558
        va_end(vl);
3559
    }
3560
    return strlen(str);
3561
}