Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ e1745e2f

History | View | Annotate | Download (113 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/internal.h"
24
#include "libavcodec/opt.h"
25
#include "metadata.h"
26
#include "libavutil/avstring.h"
27
#include "riff.h"
28
#include "audiointerleave.h"
29
#include <sys/time.h>
30
#include <time.h>
31
#include <strings.h>
32
#include <stdarg.h>
33
#if CONFIG_NETWORK
34
#include "network.h"
35
#endif
36

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

    
40
/**
41
 * @file
42
 * various utility functions for use within FFmpeg
43
 */
44

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

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

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

    
61
/* fraction handling */
62

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

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

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

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

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

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

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

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

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

    
151
    if(!filename)
152
        return 0;
153

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

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

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

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

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

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

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

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

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

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

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

    
253
    return fmt;
254
}
255
#endif
256

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

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

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

    
286
/* memory handling */
287

    
288

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

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

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

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

    
304
    return ret;
305
}
306

    
307

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

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

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

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

    
345
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
346
{
347
    static const struct {
348
        const char *name; enum CodecID id; enum AVMediaType type;
349
    } fmt_id_type[] = {
350
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
351
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
352
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
353
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
354
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
355
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
356
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
357
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
358
        { 0 }
359
    };
360
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
361

    
362
    if (fmt) {
363
        int i;
364
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
365
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
366
        for (i = 0; fmt_id_type[i].name; i++) {
367
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
368
                st->codec->codec_id   = fmt_id_type[i].id;
369
                st->codec->codec_type = fmt_id_type[i].type;
370
                break;
371
            }
372
        }
373
    }
374
    return !!fmt;
375
}
376

    
377
/************************************************************/
378
/* input media file */
379

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

    
391
    if(!ap){
392
        ap=&default_ap;
393
        memset(ap, 0, sizeof(default_ap));
394
    }
395

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

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

    
421
    if (ic->iformat->read_header) {
422
        err = ic->iformat->read_header(ic, ap);
423
        if (err < 0)
424
            goto fail;
425
    }
426

    
427
    if (pb && !ic->data_offset)
428
        ic->data_offset = url_ftell(ic->pb);
429

    
430
#if LIBAVFORMAT_VERSION_MAJOR < 53
431
    ff_metadata_demux_compat(ic);
432
#endif
433

    
434
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
435

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

    
456
/** size of probe buffer, for guessing file type from file contents */
457
#define PROBE_BUF_MIN 2048
458
#define PROBE_BUF_MAX (1<<20)
459

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

    
468
    if (!max_probe_size) {
469
        max_probe_size = PROBE_BUF_MAX;
470
    } else if (max_probe_size > PROBE_BUF_MAX) {
471
        max_probe_size = PROBE_BUF_MAX;
472
    } else if (max_probe_size < PROBE_BUF_MIN) {
473
        return AVERROR(EINVAL);
474
    }
475

    
476
    if (offset >= max_probe_size) {
477
        return AVERROR(EINVAL);
478
    }
479

    
480
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
481
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
482
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
483
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
484

    
485
        if (probe_size < offset) {
486
            continue;
487
        }
488

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

    
503
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
504

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

    
515
    if (!*fmt) {
516
        av_free(buf);
517
        return AVERROR_INVALIDDATA;
518
    }
519

    
520
    /* rewind. reuse probe buffer to avoid seeking */
521
    if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
522
        av_free(buf);
523

    
524
    return ret;
525
}
526

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

    
537
    pd->filename = "";
538
    if (filename)
539
        pd->filename = filename;
540
    pd->buf = NULL;
541
    pd->buf_size = 0;
542

    
543
    if (!fmt) {
544
        /* guess format if no file can be opened */
545
        fmt = av_probe_input_format(pd, 0);
546
    }
547

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

    
563
    /* if still no format found, error */
564
    if (!fmt) {
565
        err = AVERROR_INVALIDDATA;
566
        goto fail;
567
    }
568

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

    
589
}
590

    
591
/*******************************************************/
592

    
593
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
594
                               AVPacketList **plast_pktl){
595
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
596
    if (!pktl)
597
        return NULL;
598

    
599
    if (*packet_buffer)
600
        (*plast_pktl)->next = pktl;
601
    else
602
        *packet_buffer = pktl;
603

    
604
    /* add the packet in the buffered packet list */
605
    *plast_pktl = pktl;
606
    pktl->pkt= *pkt;
607
    return &pktl->pkt;
608
}
609

    
610
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
611
{
612
    int ret, i;
613
    AVStream *st;
614

    
615
    for(;;){
616
        AVPacketList *pktl = s->raw_packet_buffer;
617

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

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

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

    
656
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
657
                     !st->probe_packets))
658
            return ret;
659

    
660
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
661
        s->raw_packet_buffer_remaining_size -= pkt->size;
662

    
663
        if(st->codec->codec_id == CODEC_ID_PROBE){
664
            AVProbeData *pd = &st->probe_data;
665
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
666
            --st->probe_packets;
667

    
668
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
669
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
670
            pd->buf_size += pkt->size;
671
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
672

    
673
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
674
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
675
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
676
                if(st->codec->codec_id != CODEC_ID_PROBE){
677
                    pd->buf_size=0;
678
                    av_freep(&pd->buf);
679
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
680
                }
681
            }
682
        }
683
    }
684
}
685

    
686
/**********************************************************/
687

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

    
695
    if(enc->codec_id == CODEC_ID_VORBIS)
696
        return -1;
697

    
698
    if (enc->frame_size <= 1) {
699
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
700

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

    
717

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

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

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

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

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

    
791
    st->first_dts= dts - st->cur_dts;
792
    st->cur_dts= dts;
793

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

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

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

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

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

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

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

    
853
    if (s->flags & AVFMT_FLAG_NOFILLIN)
854
        return;
855

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
987
//    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);
988

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

    
1004

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

    
1010
    av_init_packet(pkt);
1011

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

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

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

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

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

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

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

    
1137
    return 0;
1138
}
1139

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

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

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

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

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

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

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

    
1218
/*******************************************************/
1219
/* seek support */
1220

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

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

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

    
1248
    flush_packet_queue(s);
1249

    
1250
    s->cur_st = NULL;
1251

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

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

    
1268
        st->probe_packets = MAX_PROBE_PACKETS;
1269

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

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

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

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

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

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

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

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

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

    
1316
    st->index_entries= entries;
1317

    
1318
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1319

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

    
1335
    ie->pos = pos;
1336
    ie->timestamp = timestamp;
1337
    ie->min_distance= distance;
1338
    ie->size= size;
1339
    ie->flags = flags;
1340

    
1341
    return index;
1342
}
1343

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

    
1352
    a = - 1;
1353
    b = nb_entries;
1354

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

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

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

    
1375
    if(m == nb_entries)
1376
        return -1;
1377
    return  m;
1378
}
1379

    
1380
#define DEBUG_SEEK
1381

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

    
1390
    if (stream_index < 0)
1391
        return -1;
1392

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

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

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

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

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

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

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

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

    
1443
    av_update_cur_dts(s, st, ts);
1444

    
1445
    return 0;
1446
}
1447

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

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

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

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

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

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

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

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

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

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

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

1568
    if (stream_index < 0)
1569
        return -1;
1570

1571
    st= s->streams[stream_index];
1572
#endif
1573

    
1574
    pos_min = s->data_offset;
1575
    pos_max = url_fsize(s->pb) - 1;
1576

    
1577
    if     (pos < pos_min) pos= pos_min;
1578
    else if(pos > pos_max) pos= pos_max;
1579

    
1580
    url_fseek(s->pb, pos, SEEK_SET);
1581

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

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

    
1596
    st = s->streams[stream_index];
1597

    
1598
    index = av_index_search_timestamp(st, timestamp, flags);
1599

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

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

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

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

    
1645
    return 0;
1646
}
1647

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

    
1653
    ff_read_frame_flush(s);
1654

    
1655
    if(flags & AVSEEK_FLAG_BYTE)
1656
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1657

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

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

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

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

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

    
1688
    ff_read_frame_flush(s);
1689

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

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

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

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

    
1705
/*******************************************************/
1706

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

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

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

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

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

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

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

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

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

    
1825
#define DURATION_MAX_READ_SIZE 250000
1826
#define DURATION_MAX_RETRY 3
1827

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

    
1838
    ic->cur_st = NULL;
1839

    
1840
    /* flush packet queue */
1841
    flush_packet_queue(ic);
1842

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

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

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

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

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

    
1899
    fill_all_stream_timings(ic);
1900

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

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

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

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

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

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

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

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

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

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

    
2032
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2033
{
2034
    int i;
2035
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2036
        if(tag == tags[i].tag)
2037
            return tags[i].id;
2038
    }
2039
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2040
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2041
            return tags[i].id;
2042
    }
2043
    return CODEC_ID_NONE;
2044
}
2045

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2228
        read_size += pkt->size;
2229

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

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

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

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

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

    
2283
        count++;
2284
    }
2285

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

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

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

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

    
2345
    av_estimate_timings(ic, old_offset);
2346

    
2347
    compute_chapters_end(ic);
2348

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

    
2374
    av_free(duration_error);
2375

    
2376
    return ret;
2377
}
2378

    
2379
/*******************************************************/
2380

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2519
    return program;
2520
}
2521

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

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

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

    
2546
    return chapter;
2547
}
2548

    
2549
/************************************************************/
2550
/* output media file */
2551

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

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

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

    
2571
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2572
{
2573
    const AVCodecTag *avctag;
2574
    int n;
2575
    enum CodecID id = CODEC_ID_NONE;
2576
    unsigned int tag = 0;
2577

    
2578
    /**
2579
     * Check that tag + id is in the table
2580
     * If neither is in the table -> OK
2581
     * If tag is in the table with another id -> FAIL
2582
     * If id is in the table with another tag -> FAIL unless strict < normal
2583
     */
2584
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2585
        avctag = s->oformat->codec_tag[n];
2586
        while (avctag->id != CODEC_ID_NONE) {
2587
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2588
                id = avctag->id;
2589
                if (id == st->codec->codec_id)
2590
                    return 1;
2591
            }
2592
            if (avctag->id == st->codec->codec_id)
2593
                tag = avctag->tag;
2594
            avctag++;
2595
        }
2596
    }
2597
    if (id != CODEC_ID_NONE)
2598
        return 0;
2599
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2600
        return 0;
2601
    return 1;
2602
}
2603

    
2604
int av_write_header(AVFormatContext *s)
2605
{
2606
    int ret, i;
2607
    AVStream *st;
2608

    
2609
    // some sanity checks
2610
    if (s->nb_streams == 0) {
2611
        av_log(s, AV_LOG_ERROR, "no streams\n");
2612
        return AVERROR(EINVAL);
2613
    }
2614

    
2615
    for(i=0;i<s->nb_streams;i++) {
2616
        st = s->streams[i];
2617

    
2618
        switch (st->codec->codec_type) {
2619
        case AVMEDIA_TYPE_AUDIO:
2620
            if(st->codec->sample_rate<=0){
2621
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2622
                return AVERROR(EINVAL);
2623
            }
2624
            if(!st->codec->block_align)
2625
                st->codec->block_align = st->codec->channels *
2626
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2627
            break;
2628
        case AVMEDIA_TYPE_VIDEO:
2629
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2630
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2631
                return AVERROR(EINVAL);
2632
            }
2633
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2634
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2635
                return AVERROR(EINVAL);
2636
            }
2637
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2638
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2639
                return AVERROR(EINVAL);
2640
            }
2641
            break;
2642
        }
2643

    
2644
        if(s->oformat->codec_tag){
2645
            if(st->codec->codec_tag){
2646
                if (!validate_codec_tag(s, st)) {
2647
                    av_log(s, AV_LOG_ERROR,
2648
                           "Tag 0x%08x incompatible with output codec\n",
2649
                           st->codec->codec_tag);
2650
                    return AVERROR_INVALIDDATA;
2651
                }
2652
            }else
2653
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2654
        }
2655

    
2656
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2657
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2658
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2659
    }
2660

    
2661
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2662
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2663
        if (!s->priv_data)
2664
            return AVERROR(ENOMEM);
2665
    }
2666

    
2667
#if LIBAVFORMAT_VERSION_MAJOR < 53
2668
    ff_metadata_mux_compat(s);
2669
#endif
2670

    
2671
    /* set muxer identification string */
2672
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2673
        AVMetadata *m;
2674
        AVMetadataTag *t;
2675

    
2676
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2677
            return AVERROR(ENOMEM);
2678
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2679
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2680
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2681
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2682
        av_metadata_free(&m);
2683
    }
2684

    
2685
    if(s->oformat->write_header){
2686
        ret = s->oformat->write_header(s);
2687
        if (ret < 0)
2688
            return ret;
2689
    }
2690

    
2691
    /* init PTS generation */
2692
    for(i=0;i<s->nb_streams;i++) {
2693
        int64_t den = AV_NOPTS_VALUE;
2694
        st = s->streams[i];
2695

    
2696
        switch (st->codec->codec_type) {
2697
        case AVMEDIA_TYPE_AUDIO:
2698
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2699
            break;
2700
        case AVMEDIA_TYPE_VIDEO:
2701
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2702
            break;
2703
        default:
2704
            break;
2705
        }
2706
        if (den != AV_NOPTS_VALUE) {
2707
            if (den <= 0)
2708
                return AVERROR_INVALIDDATA;
2709
            av_frac_init(&st->pts, 0, 0, den);
2710
        }
2711
    }
2712
    return 0;
2713
}
2714

    
2715
//FIXME merge with compute_pkt_fields
2716
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2717
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2718
    int num, den, frame_size, i;
2719

    
2720
//    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);
2721

    
2722
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2723
        return -1;*/
2724

    
2725
    /* duration field */
2726
    if (pkt->duration == 0) {
2727
        compute_frame_duration(&num, &den, st, NULL, pkt);
2728
        if (den && num) {
2729
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2730
        }
2731
    }
2732

    
2733
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2734
        pkt->pts= pkt->dts;
2735

    
2736
    //XXX/FIXME this is a temporary hack until all encoders output pts
2737
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2738
        pkt->dts=
2739
//        pkt->pts= st->cur_dts;
2740
        pkt->pts= st->pts.val;
2741
    }
2742

    
2743
    //calculate dts from pts
2744
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2745
        st->pts_buffer[0]= pkt->pts;
2746
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2747
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2748
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2749
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2750

    
2751
        pkt->dts= st->pts_buffer[0];
2752
    }
2753

    
2754
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2755
        av_log(s, AV_LOG_ERROR,
2756
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2757
               st->index, st->cur_dts, pkt->dts);
2758
        return -1;
2759
    }
2760
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2761
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2762
        return -1;
2763
    }
2764

    
2765
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2766
    st->cur_dts= pkt->dts;
2767
    st->pts.val= pkt->dts;
2768

    
2769
    /* update pts */
2770
    switch (st->codec->codec_type) {
2771
    case AVMEDIA_TYPE_AUDIO:
2772
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2773

    
2774
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2775
           likely equal to the encoder delay, but it would be better if we
2776
           had the real timestamps from the encoder */
2777
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2778
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2779
        }
2780
        break;
2781
    case AVMEDIA_TYPE_VIDEO:
2782
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2783
        break;
2784
    default:
2785
        break;
2786
    }
2787
    return 0;
2788
}
2789

    
2790
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2791
{
2792
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2793

    
2794
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2795
        return ret;
2796

    
2797
    ret= s->oformat->write_packet(s, pkt);
2798
    if(!ret)
2799
        ret= url_ferror(s->pb);
2800
    return ret;
2801
}
2802

    
2803
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2804
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2805
{
2806
    AVPacketList **next_point, *this_pktl;
2807

    
2808
    this_pktl = av_mallocz(sizeof(AVPacketList));
2809
    this_pktl->pkt= *pkt;
2810
    pkt->destruct= NULL;             // do not free original but only the copy
2811
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2812

    
2813
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2814
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2815
    }else
2816
        next_point = &s->packet_buffer;
2817

    
2818
    if(*next_point){
2819
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2820
            while(!compare(s, &(*next_point)->pkt, pkt)){
2821
                next_point= &(*next_point)->next;
2822
            }
2823
            goto next_non_null;
2824
        }else{
2825
            next_point = &(s->packet_buffer_end->next);
2826
        }
2827
    }
2828
    assert(!*next_point);
2829

    
2830
    s->packet_buffer_end= this_pktl;
2831
next_non_null:
2832

    
2833
    this_pktl->next= *next_point;
2834

    
2835
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2836
    *next_point= this_pktl;
2837
}
2838

    
2839
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2840
{
2841
    AVStream *st = s->streams[ pkt ->stream_index];
2842
    AVStream *st2= s->streams[ next->stream_index];
2843
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2844
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2845
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2846
}
2847

    
2848
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2849
    AVPacketList *pktl;
2850
    int stream_count=0;
2851
    int i;
2852

    
2853
    if(pkt){
2854
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2855
    }
2856

    
2857
    for(i=0; i < s->nb_streams; i++)
2858
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2859

    
2860
    if(stream_count && (s->nb_streams == stream_count || flush)){
2861
        pktl= s->packet_buffer;
2862
        *out= pktl->pkt;
2863

    
2864
        s->packet_buffer= pktl->next;
2865
        if(!s->packet_buffer)
2866
            s->packet_buffer_end= NULL;
2867

    
2868
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2869
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2870
        av_freep(&pktl);
2871
        return 1;
2872
    }else{
2873
        av_init_packet(out);
2874
        return 0;
2875
    }
2876
}
2877

    
2878
/**
2879
 * Interleaves an AVPacket correctly so it can be muxed.
2880
 * @param out the interleaved packet will be output here
2881
 * @param in the input packet
2882
 * @param flush 1 if no further packets are available as input and all
2883
 *              remaining packets should be output
2884
 * @return 1 if a packet was output, 0 if no packet could be output,
2885
 *         < 0 if an error occurred
2886
 */
2887
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2888
    if(s->oformat->interleave_packet)
2889
        return s->oformat->interleave_packet(s, out, in, flush);
2890
    else
2891
        return av_interleave_packet_per_dts(s, out, in, flush);
2892
}
2893

    
2894
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2895
    AVStream *st= s->streams[ pkt->stream_index];
2896

    
2897
    //FIXME/XXX/HACK drop zero sized packets
2898
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2899
        return 0;
2900

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

    
2905
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2906
        return -1;
2907

    
2908
    for(;;){
2909
        AVPacket opkt;
2910
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2911
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2912
            return ret;
2913

    
2914
        ret= s->oformat->write_packet(s, &opkt);
2915

    
2916
        av_free_packet(&opkt);
2917
        pkt= NULL;
2918

    
2919
        if(ret<0)
2920
            return ret;
2921
        if(url_ferror(s->pb))
2922
            return url_ferror(s->pb);
2923
    }
2924
}
2925

    
2926
int av_write_trailer(AVFormatContext *s)
2927
{
2928
    int ret, i;
2929

    
2930
    for(;;){
2931
        AVPacket pkt;
2932
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2933
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2934
            goto fail;
2935
        if(!ret)
2936
            break;
2937

    
2938
        ret= s->oformat->write_packet(s, &pkt);
2939

    
2940
        av_free_packet(&pkt);
2941

    
2942
        if(ret<0)
2943
            goto fail;
2944
        if(url_ferror(s->pb))
2945
            goto fail;
2946
    }
2947

    
2948
    if(s->oformat->write_trailer)
2949
        ret = s->oformat->write_trailer(s);
2950
fail:
2951
    if(ret == 0)
2952
       ret=url_ferror(s->pb);
2953
    for(i=0;i<s->nb_streams;i++) {
2954
        av_freep(&s->streams[i]->priv_data);
2955
        av_freep(&s->streams[i]->index_entries);
2956
    }
2957
    av_freep(&s->priv_data);
2958
    return ret;
2959
}
2960

    
2961
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2962
{
2963
    int i, j;
2964
    AVProgram *program=NULL;
2965
    void *tmp;
2966

    
2967
    if (idx >= ac->nb_streams) {
2968
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2969
        return;
2970
    }
2971

    
2972
    for(i=0; i<ac->nb_programs; i++){
2973
        if(ac->programs[i]->id != progid)
2974
            continue;
2975
        program = ac->programs[i];
2976
        for(j=0; j<program->nb_stream_indexes; j++)
2977
            if(program->stream_index[j] == idx)
2978
                return;
2979

    
2980
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2981
        if(!tmp)
2982
            return;
2983
        program->stream_index = tmp;
2984
        program->stream_index[program->nb_stream_indexes++] = idx;
2985
        return;
2986
    }
2987
}
2988

    
2989
static void print_fps(double d, const char *postfix){
2990
    uint64_t v= lrintf(d*100);
2991
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2992
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2993
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2994
}
2995

    
2996
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2997
{
2998
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2999
        AVMetadataTag *tag=NULL;
3000

    
3001
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3002
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3003
            if(strcmp("language", tag->key))
3004
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3005
        }
3006
    }
3007
}
3008

    
3009
/* "user interface" functions */
3010
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3011
{
3012
    char buf[256];
3013
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3014
    AVStream *st = ic->streams[i];
3015
    int g = av_gcd(st->time_base.num, st->time_base.den);
3016
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3017
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3018
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3019
    /* the pid is an important information, so we display it */
3020
    /* XXX: add a generic system */
3021
    if (flags & AVFMT_SHOW_IDS)
3022
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3023
    if (lang)
3024
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3025
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3026
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3027
    if (st->sample_aspect_ratio.num && // default
3028
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3029
        AVRational display_aspect_ratio;
3030
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3031
                  st->codec->width*st->sample_aspect_ratio.num,
3032
                  st->codec->height*st->sample_aspect_ratio.den,
3033
                  1024*1024);
3034
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3035
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3036
                 display_aspect_ratio.num, display_aspect_ratio.den);
3037
    }
3038
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3039
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3040
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3041
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3042
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3043
        if(st->time_base.den && st->time_base.num)
3044
            print_fps(1/av_q2d(st->time_base), "tbn");
3045
        if(st->codec->time_base.den && st->codec->time_base.num)
3046
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3047
    }
3048
    av_log(NULL, AV_LOG_INFO, "\n");
3049
    dump_metadata(NULL, st->metadata, "    ");
3050
}
3051

    
3052
void dump_format(AVFormatContext *ic,
3053
                 int index,
3054
                 const char *url,
3055
                 int is_output)
3056
{
3057
    int i;
3058
    uint8_t *printed = av_mallocz(ic->nb_streams);
3059
    if (ic->nb_streams && !printed)
3060
        return;
3061

    
3062
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3063
            is_output ? "Output" : "Input",
3064
            index,
3065
            is_output ? ic->oformat->name : ic->iformat->name,
3066
            is_output ? "to" : "from", url);
3067
    dump_metadata(NULL, ic->metadata, "  ");
3068
    if (!is_output) {
3069
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3070
        if (ic->duration != AV_NOPTS_VALUE) {
3071
            int hours, mins, secs, us;
3072
            secs = ic->duration / AV_TIME_BASE;
3073
            us = ic->duration % AV_TIME_BASE;
3074
            mins = secs / 60;
3075
            secs %= 60;
3076
            hours = mins / 60;
3077
            mins %= 60;
3078
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3079
                   (100 * us) / AV_TIME_BASE);
3080
        } else {
3081
            av_log(NULL, AV_LOG_INFO, "N/A");
3082
        }
3083
        if (ic->start_time != AV_NOPTS_VALUE) {
3084
            int secs, us;
3085
            av_log(NULL, AV_LOG_INFO, ", start: ");
3086
            secs = ic->start_time / AV_TIME_BASE;
3087
            us = ic->start_time % AV_TIME_BASE;
3088
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3089
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3090
        }
3091
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3092
        if (ic->bit_rate) {
3093
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3094
        } else {
3095
            av_log(NULL, AV_LOG_INFO, "N/A");
3096
        }
3097
        av_log(NULL, AV_LOG_INFO, "\n");
3098
    }
3099
    for (i = 0; i < ic->nb_chapters; i++) {
3100
        AVChapter *ch = ic->chapters[i];
3101
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3102
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3103
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3104

    
3105
        dump_metadata(NULL, ch->metadata, "    ");
3106
    }
3107
    if(ic->nb_programs) {
3108
        int j, k, total = 0;
3109
        for(j=0; j<ic->nb_programs; j++) {
3110
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3111
                                                  "name", NULL, 0);
3112
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3113
                   name ? name->value : "");
3114
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3115
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3116
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3117
                printed[ic->programs[j]->stream_index[k]] = 1;
3118
            }
3119
            total += ic->programs[j]->nb_stream_indexes;
3120
        }
3121
        if (total < ic->nb_streams)
3122
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3123
    }
3124
    for(i=0;i<ic->nb_streams;i++)
3125
        if (!printed[i])
3126
            dump_stream_format(ic, i, index, is_output);
3127

    
3128
    av_free(printed);
3129
}
3130

    
3131
#if LIBAVFORMAT_VERSION_MAJOR < 53
3132
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3133
{
3134
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
3135
}
3136

    
3137
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3138
{
3139
    AVRational frame_rate;
3140
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
3141
    *frame_rate_num= frame_rate.num;
3142
    *frame_rate_den= frame_rate.den;
3143
    return ret;
3144
}
3145
#endif
3146

    
3147
int64_t av_gettime(void)
3148
{
3149
    struct timeval tv;
3150
    gettimeofday(&tv,NULL);
3151
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3152
}
3153

    
3154
uint64_t ff_ntp_time(void)
3155
{
3156
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3157
}
3158

    
3159
int64_t parse_date(const char *datestr, int duration)
3160
{
3161
    const char *p;
3162
    int64_t t;
3163
    struct tm dt;
3164
    int i;
3165
    static const char * const date_fmt[] = {
3166
        "%Y-%m-%d",
3167
        "%Y%m%d",
3168
    };
3169
    static const char * const time_fmt[] = {
3170
        "%H:%M:%S",
3171
        "%H%M%S",
3172
    };
3173
    const char *q;
3174
    int is_utc, len;
3175
    char lastch;
3176
    int negative = 0;
3177

    
3178
#undef time
3179
    time_t now = time(0);
3180

    
3181
    len = strlen(datestr);
3182
    if (len > 0)
3183
        lastch = datestr[len - 1];
3184
    else
3185
        lastch = '\0';
3186
    is_utc = (lastch == 'z' || lastch == 'Z');
3187

    
3188
    memset(&dt, 0, sizeof(dt));
3189

    
3190
    p = datestr;
3191
    q = NULL;
3192
    if (!duration) {
3193
        if (!strncasecmp(datestr, "now", len))
3194
            return (int64_t) now * 1000000;
3195

    
3196
        /* parse the year-month-day part */
3197
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3198
            q = small_strptime(p, date_fmt[i], &dt);
3199
            if (q) {
3200
                break;
3201
            }
3202
        }
3203

    
3204
        /* if the year-month-day part is missing, then take the
3205
         * current year-month-day time */
3206
        if (!q) {
3207
            if (is_utc) {
3208
                dt = *gmtime(&now);
3209
            } else {
3210
                dt = *localtime(&now);
3211
            }
3212
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3213
        } else {
3214
            p = q;
3215
        }
3216

    
3217
        if (*p == 'T' || *p == 't' || *p == ' ')
3218
            p++;
3219

    
3220
        /* parse the hour-minute-second part */
3221
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3222
            q = small_strptime(p, time_fmt[i], &dt);
3223
            if (q) {
3224
                break;
3225
            }
3226
        }
3227
    } else {
3228
        /* parse datestr as a duration */
3229
        if (p[0] == '-') {
3230
            negative = 1;
3231
            ++p;
3232
        }
3233
        /* parse datestr as HH:MM:SS */
3234
        q = small_strptime(p, time_fmt[0], &dt);
3235
        if (!q) {
3236
            /* parse datestr as S+ */
3237
            dt.tm_sec = strtol(p, (char **)&q, 10);
3238
            if (q == p)
3239
                /* the parsing didn't succeed */
3240
                return INT64_MIN;
3241
            dt.tm_min = 0;
3242
            dt.tm_hour = 0;
3243
        }
3244
    }
3245

    
3246
    /* Now we have all the fields that we can get */
3247
    if (!q) {
3248
        return INT64_MIN;
3249
    }
3250

    
3251
    if (duration) {
3252
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3253
    } else {
3254
        dt.tm_isdst = -1;       /* unknown */
3255
        if (is_utc) {
3256
            t = mktimegm(&dt);
3257
        } else {
3258
            t = mktime(&dt);
3259
        }
3260
    }
3261

    
3262
    t *= 1000000;
3263

    
3264
    /* parse the .m... part */
3265
    if (*q == '.') {
3266
        int val, n;
3267
        q++;
3268
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3269
            if (!isdigit(*q))
3270
                break;
3271
            val += n * (*q - '0');
3272
        }
3273
        t += val;
3274
    }
3275
    return negative ? -t : t;
3276
}
3277

    
3278
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3279
{
3280
    const char *p;
3281
    char tag[128], *q;
3282

    
3283
    p = info;
3284
    if (*p == '?')
3285
        p++;
3286
    for(;;) {
3287
        q = tag;
3288
        while (*p != '\0' && *p != '=' && *p != '&') {
3289
            if ((q - tag) < sizeof(tag) - 1)
3290
                *q++ = *p;
3291
            p++;
3292
        }
3293
        *q = '\0';
3294
        q = arg;
3295
        if (*p == '=') {
3296
            p++;
3297
            while (*p != '&' && *p != '\0') {
3298
                if ((q - arg) < arg_size - 1) {
3299
                    if (*p == '+')
3300
                        *q++ = ' ';
3301
                    else
3302
                        *q++ = *p;
3303
                }
3304
                p++;
3305
            }
3306
            *q = '\0';
3307
        }
3308
        if (!strcmp(tag, tag1))
3309
            return 1;
3310
        if (*p != '&')
3311
            break;
3312
        p++;
3313
    }
3314
    return 0;
3315
}
3316

    
3317
int av_get_frame_filename(char *buf, int buf_size,
3318
                          const char *path, int number)
3319
{
3320
    const char *p;
3321
    char *q, buf1[20], c;
3322
    int nd, len, percentd_found;
3323

    
3324
    q = buf;
3325
    p = path;
3326
    percentd_found = 0;
3327
    for(;;) {
3328
        c = *p++;
3329
        if (c == '\0')
3330
            break;
3331
        if (c == '%') {
3332
            do {
3333
                nd = 0;
3334
                while (isdigit(*p)) {
3335
                    nd = nd * 10 + *p++ - '0';
3336
                }
3337
                c = *p++;
3338
            } while (isdigit(c));
3339

    
3340
            switch(c) {
3341
            case '%':
3342
                goto addchar;
3343
            case 'd':
3344
                if (percentd_found)
3345
                    goto fail;
3346
                percentd_found = 1;
3347
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3348
                len = strlen(buf1);
3349
                if ((q - buf + len) > buf_size - 1)
3350
                    goto fail;
3351
                memcpy(q, buf1, len);
3352
                q += len;
3353
                break;
3354
            default:
3355
                goto fail;
3356
            }
3357
        } else {
3358
        addchar:
3359
            if ((q - buf) < buf_size - 1)
3360
                *q++ = c;
3361
        }
3362
    }
3363
    if (!percentd_found)
3364
        goto fail;
3365
    *q = '\0';
3366
    return 0;
3367
 fail:
3368
    *q = '\0';
3369
    return -1;
3370
}
3371

    
3372
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3373
{
3374
    int len, i, j, c;
3375
#undef fprintf
3376
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3377

    
3378
    for(i=0;i<size;i+=16) {
3379
        len = size - i;
3380
        if (len > 16)
3381
            len = 16;
3382
        PRINT("%08x ", i);
3383
        for(j=0;j<16;j++) {
3384
            if (j < len)
3385
                PRINT(" %02x", buf[i+j]);
3386
            else
3387
                PRINT("   ");
3388
        }
3389
        PRINT(" ");
3390
        for(j=0;j<len;j++) {
3391
            c = buf[i+j];
3392
            if (c < ' ' || c > '~')
3393
                c = '.';
3394
            PRINT("%c", c);
3395
        }
3396
        PRINT("\n");
3397
    }
3398
#undef PRINT
3399
}
3400

    
3401
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3402
{
3403
    hex_dump_internal(NULL, f, 0, buf, size);
3404
}
3405

    
3406
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3407
{
3408
    hex_dump_internal(avcl, NULL, level, buf, size);
3409
}
3410

    
3411
 //FIXME needs to know the time_base
3412
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3413
{
3414
#undef fprintf
3415
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3416
    PRINT("stream #%d:\n", pkt->stream_index);
3417
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3418
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3419
    /* DTS is _always_ valid after av_read_frame() */
3420
    PRINT("  dts=");
3421
    if (pkt->dts == AV_NOPTS_VALUE)
3422
        PRINT("N/A");
3423
    else
3424
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3425
    /* PTS may not be known if B-frames are present. */
3426
    PRINT("  pts=");
3427
    if (pkt->pts == AV_NOPTS_VALUE)
3428
        PRINT("N/A");
3429
    else
3430
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3431
    PRINT("\n");
3432
    PRINT("  size=%d\n", pkt->size);
3433
#undef PRINT
3434
    if (dump_payload)
3435
        av_hex_dump(f, pkt->data, pkt->size);
3436
}
3437

    
3438
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3439
{
3440
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3441
}
3442

    
3443
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3444
{
3445
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3446
}
3447

    
3448
void ff_url_split(char *proto, int proto_size,
3449
                  char *authorization, int authorization_size,
3450
                  char *hostname, int hostname_size,
3451
                  int *port_ptr,
3452
                  char *path, int path_size,
3453
                  const char *url)
3454
{
3455
    const char *p, *ls, *at, *col, *brk;
3456

    
3457
    if (port_ptr)               *port_ptr = -1;
3458
    if (proto_size > 0)         proto[0] = 0;
3459
    if (authorization_size > 0) authorization[0] = 0;
3460
    if (hostname_size > 0)      hostname[0] = 0;
3461
    if (path_size > 0)          path[0] = 0;
3462

    
3463
    /* parse protocol */
3464
    if ((p = strchr(url, ':'))) {
3465
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3466
        p++; /* skip ':' */
3467
        if (*p == '/') p++;
3468
        if (*p == '/') p++;
3469
    } else {
3470
        /* no protocol means plain filename */
3471
        av_strlcpy(path, url, path_size);
3472
        return;
3473
    }
3474

    
3475
    /* separate path from hostname */
3476
    ls = strchr(p, '/');
3477
    if(!ls)
3478
        ls = strchr(p, '?');
3479
    if(ls)
3480
        av_strlcpy(path, ls, path_size);
3481
    else
3482
        ls = &p[strlen(p)]; // XXX
3483

    
3484
    /* the rest is hostname, use that to parse auth/port */
3485
    if (ls != p) {
3486
        /* authorization (user[:pass]@hostname) */
3487
        if ((at = strchr(p, '@')) && at < ls) {
3488
            av_strlcpy(authorization, p,
3489
                       FFMIN(authorization_size, at + 1 - p));
3490
            p = at + 1; /* skip '@' */
3491
        }
3492

    
3493
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3494
            /* [host]:port */
3495
            av_strlcpy(hostname, p + 1,
3496
                       FFMIN(hostname_size, brk - p));
3497
            if (brk[1] == ':' && port_ptr)
3498
                *port_ptr = atoi(brk + 2);
3499
        } else if ((col = strchr(p, ':')) && col < ls) {
3500
            av_strlcpy(hostname, p,
3501
                       FFMIN(col + 1 - p, hostname_size));
3502
            if (port_ptr) *port_ptr = atoi(col + 1);
3503
        } else
3504
            av_strlcpy(hostname, p,
3505
                       FFMIN(ls + 1 - p, hostname_size));
3506
    }
3507
}
3508

    
3509
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3510
{
3511
    int i;
3512
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3513
                                           '4', '5', '6', '7',
3514
                                           '8', '9', 'A', 'B',
3515
                                           'C', 'D', 'E', 'F' };
3516
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3517
                                           '4', '5', '6', '7',
3518
                                           '8', '9', 'a', 'b',
3519
                                           'c', 'd', 'e', 'f' };
3520
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3521

    
3522
    for(i = 0; i < s; i++) {
3523
        buff[i * 2]     = hex_table[src[i] >> 4];
3524
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3525
    }
3526

    
3527
    return buff;
3528
}
3529

    
3530
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3531
                     unsigned int pts_num, unsigned int pts_den)
3532
{
3533
    s->pts_wrap_bits = pts_wrap_bits;
3534

    
3535
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3536
        if(s->time_base.num != pts_num)
3537
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3538
    }else
3539
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3540

    
3541
    if(!s->time_base.num || !s->time_base.den)
3542
        s->time_base.num= s->time_base.den= 0;
3543
}
3544

    
3545
int ff_url_join(char *str, int size, const char *proto,
3546
                const char *authorization, const char *hostname,
3547
                int port, const char *fmt, ...)
3548
{
3549
#if CONFIG_NETWORK
3550
    struct addrinfo hints, *ai;
3551
#endif
3552

    
3553
    str[0] = '\0';
3554
    if (proto)
3555
        av_strlcatf(str, size, "%s://", proto);
3556
    if (authorization)
3557
        av_strlcatf(str, size, "%s@", authorization);
3558
#if CONFIG_NETWORK && defined(AF_INET6)
3559
    /* Determine if hostname is a numerical IPv6 address,
3560
     * properly escape it within [] in that case. */
3561
    memset(&hints, 0, sizeof(hints));
3562
    hints.ai_flags = AI_NUMERICHOST;
3563
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3564
        if (ai->ai_family == AF_INET6) {
3565
            av_strlcat(str, "[", size);
3566
            av_strlcat(str, hostname, size);
3567
            av_strlcat(str, "]", size);
3568
        } else {
3569
            av_strlcat(str, hostname, size);
3570
        }
3571
        freeaddrinfo(ai);
3572
    } else
3573
#endif
3574
        /* Not an IPv6 address, just output the plain string. */
3575
        av_strlcat(str, hostname, size);
3576

    
3577
    if (port >= 0)
3578
        av_strlcatf(str, size, ":%d", port);
3579
    if (fmt) {
3580
        va_list vl;
3581
        int len = strlen(str);
3582

    
3583
        va_start(vl, fmt);
3584
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3585
        va_end(vl);
3586
    }
3587
    return strlen(str);
3588
}
3589

    
3590
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3591
                     AVFormatContext *src)
3592
{
3593
    AVPacket local_pkt;
3594

    
3595
    local_pkt = *pkt;
3596
    local_pkt.stream_index = dst_stream;
3597
    if (pkt->pts != AV_NOPTS_VALUE)
3598
        local_pkt.pts = av_rescale_q(pkt->pts,
3599
                                     src->streams[pkt->stream_index]->time_base,
3600
                                     dst->streams[dst_stream]->time_base);
3601
    if (pkt->dts != AV_NOPTS_VALUE)
3602
        local_pkt.dts = av_rescale_q(pkt->dts,
3603
                                     src->streams[pkt->stream_index]->time_base,
3604
                                     dst->streams[dst_stream]->time_base);
3605
    return av_write_frame(dst, &local_pkt);
3606
}
3607