Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ f3bfe388

History | View | Annotate | Download (116 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
#if LIBAVFORMAT_VERSION_MAJOR < 53 && CONFIG_SHARED && HAVE_SYMVER
287
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
288
{
289
    av_destruct_packet_nofree(pkt);
290
}
291

    
292
FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
293
{
294
    av_destruct_packet(pkt);
295
}
296

    
297
FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
298
{
299
    return av_new_packet(pkt, size);
300
}
301

    
302
FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
303
{
304
    return av_dup_packet(pkt);
305
}
306

    
307
FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
308
{
309
    av_free_packet(pkt);
310
}
311

    
312
FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
313
{
314
    av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
315
    av_init_packet(pkt);
316
}
317
#endif
318

    
319
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
320
{
321
    int ret= av_new_packet(pkt, size);
322

    
323
    if(ret<0)
324
        return ret;
325

    
326
    pkt->pos= url_ftell(s);
327

    
328
    ret= get_buffer(s, pkt->data, size);
329
    if(ret<=0)
330
        av_free_packet(pkt);
331
    else
332
        av_shrink_packet(pkt, ret);
333

    
334
    return ret;
335
}
336

    
337

    
338
int av_filename_number_test(const char *filename)
339
{
340
    char buf[1024];
341
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
342
}
343

    
344
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
345
{
346
    AVInputFormat *fmt1, *fmt;
347
    int score;
348

    
349
    fmt = NULL;
350
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
351
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
352
            continue;
353
        score = 0;
354
        if (fmt1->read_probe) {
355
            score = fmt1->read_probe(pd);
356
        } else if (fmt1->extensions) {
357
            if (av_match_ext(pd->filename, fmt1->extensions)) {
358
                score = 50;
359
            }
360
        }
361
        if (score > *score_max) {
362
            *score_max = score;
363
            fmt = fmt1;
364
        }else if (score == *score_max)
365
            fmt = NULL;
366
    }
367
    return fmt;
368
}
369

    
370
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
371
    int score=0;
372
    return av_probe_input_format2(pd, is_opened, &score);
373
}
374

    
375
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
376
{
377
    static const struct {
378
        const char *name; enum CodecID id; enum AVMediaType type;
379
    } fmt_id_type[] = {
380
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
381
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
382
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
383
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
384
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
385
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
386
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
387
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
388
        { 0 }
389
    };
390
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
391

    
392
    if (fmt) {
393
        int i;
394
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
395
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
396
        for (i = 0; fmt_id_type[i].name; i++) {
397
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
398
                st->codec->codec_id   = fmt_id_type[i].id;
399
                st->codec->codec_type = fmt_id_type[i].type;
400
                break;
401
            }
402
        }
403
    }
404
    return !!fmt;
405
}
406

    
407
/************************************************************/
408
/* input media file */
409

    
410
/**
411
 * Open a media file from an IO stream. 'fmt' must be specified.
412
 */
413
int av_open_input_stream(AVFormatContext **ic_ptr,
414
                         ByteIOContext *pb, const char *filename,
415
                         AVInputFormat *fmt, AVFormatParameters *ap)
416
{
417
    int err;
418
    AVFormatContext *ic;
419
    AVFormatParameters default_ap;
420

    
421
    if(!ap){
422
        ap=&default_ap;
423
        memset(ap, 0, sizeof(default_ap));
424
    }
425

    
426
    if(!ap->prealloced_context)
427
        ic = avformat_alloc_context();
428
    else
429
        ic = *ic_ptr;
430
    if (!ic) {
431
        err = AVERROR(ENOMEM);
432
        goto fail;
433
    }
434
    ic->iformat = fmt;
435
    ic->pb = pb;
436
    ic->duration = AV_NOPTS_VALUE;
437
    ic->start_time = AV_NOPTS_VALUE;
438
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
439

    
440
    /* allocate private data */
441
    if (fmt->priv_data_size > 0) {
442
        ic->priv_data = av_mallocz(fmt->priv_data_size);
443
        if (!ic->priv_data) {
444
            err = AVERROR(ENOMEM);
445
            goto fail;
446
        }
447
    } else {
448
        ic->priv_data = NULL;
449
    }
450

    
451
    if (ic->iformat->read_header) {
452
        err = ic->iformat->read_header(ic, ap);
453
        if (err < 0)
454
            goto fail;
455
    }
456

    
457
    if (pb && !ic->data_offset)
458
        ic->data_offset = url_ftell(ic->pb);
459

    
460
#if LIBAVFORMAT_VERSION_MAJOR < 53
461
    ff_metadata_demux_compat(ic);
462
#endif
463

    
464
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
465

    
466
    *ic_ptr = ic;
467
    return 0;
468
 fail:
469
    if (ic) {
470
        int i;
471
        av_freep(&ic->priv_data);
472
        for(i=0;i<ic->nb_streams;i++) {
473
            AVStream *st = ic->streams[i];
474
            if (st) {
475
                av_free(st->priv_data);
476
                av_free(st->codec->extradata);
477
            }
478
            av_free(st);
479
        }
480
    }
481
    av_free(ic);
482
    *ic_ptr = NULL;
483
    return err;
484
}
485

    
486
/** size of probe buffer, for guessing file type from file contents */
487
#define PROBE_BUF_MIN 2048
488
#define PROBE_BUF_MAX (1<<20)
489

    
490
int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
491
                          const char *filename, void *logctx,
492
                          unsigned int offset, unsigned int max_probe_size)
493
{
494
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
495
    unsigned char *buf = NULL;
496
    int ret = 0, probe_size;
497

    
498
    if (!max_probe_size) {
499
        max_probe_size = PROBE_BUF_MAX;
500
    } else if (max_probe_size > PROBE_BUF_MAX) {
501
        max_probe_size = PROBE_BUF_MAX;
502
    } else if (max_probe_size < PROBE_BUF_MIN) {
503
        return AVERROR(EINVAL);
504
    }
505

    
506
    if (offset >= max_probe_size) {
507
        return AVERROR(EINVAL);
508
    }
509

    
510
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
511
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
512
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
513
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
514

    
515
        if (probe_size < offset) {
516
            continue;
517
        }
518

    
519
        /* read probe data */
520
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
521
        if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
522
            /* fail if error was not end of file, otherwise, lower score */
523
            if (ret != AVERROR_EOF) {
524
                av_free(buf);
525
                return ret;
526
            }
527
            score = 0;
528
            ret = 0;            /* error was end of file, nothing read */
529
        }
530
        pd.buf_size += ret;
531
        pd.buf = &buf[offset];
532

    
533
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
534

    
535
        /* guess file format */
536
        *fmt = av_probe_input_format2(&pd, 1, &score);
537
        if(*fmt){
538
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
539
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
540
            }else
541
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
542
        }
543
    }
544

    
545
    if (!*fmt) {
546
        av_free(buf);
547
        return AVERROR_INVALIDDATA;
548
    }
549

    
550
    /* rewind. reuse probe buffer to avoid seeking */
551
    if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
552
        av_free(buf);
553

    
554
    return ret;
555
}
556

    
557
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
558
                       AVInputFormat *fmt,
559
                       int buf_size,
560
                       AVFormatParameters *ap)
561
{
562
    int err;
563
    AVProbeData probe_data, *pd = &probe_data;
564
    ByteIOContext *pb = NULL;
565
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
566

    
567
    pd->filename = "";
568
    if (filename)
569
        pd->filename = filename;
570
    pd->buf = NULL;
571
    pd->buf_size = 0;
572

    
573
    if (!fmt) {
574
        /* guess format if no file can be opened */
575
        fmt = av_probe_input_format(pd, 0);
576
    }
577

    
578
    /* Do not open file if the format does not need it. XXX: specific
579
       hack needed to handle RTSP/TCP */
580
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
581
        /* if no file needed do not try to open one */
582
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
583
            goto fail;
584
        }
585
        if (buf_size > 0) {
586
            url_setbufsize(pb, buf_size);
587
        }
588
        if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
589
            goto fail;
590
        }
591
    }
592

    
593
    /* if still no format found, error */
594
    if (!fmt) {
595
        err = AVERROR_INVALIDDATA;
596
        goto fail;
597
    }
598

    
599
    /* check filename in case an image number is expected */
600
    if (fmt->flags & AVFMT_NEEDNUMBER) {
601
        if (!av_filename_number_test(filename)) {
602
            err = AVERROR_NUMEXPECTED;
603
            goto fail;
604
        }
605
    }
606
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
607
    if (err)
608
        goto fail;
609
    return 0;
610
 fail:
611
    av_freep(&pd->buf);
612
    if (pb)
613
        url_fclose(pb);
614
    if (ap && ap->prealloced_context)
615
        av_free(*ic_ptr);
616
    *ic_ptr = NULL;
617
    return err;
618

    
619
}
620

    
621
/*******************************************************/
622

    
623
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
624
                               AVPacketList **plast_pktl){
625
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
626
    if (!pktl)
627
        return NULL;
628

    
629
    if (*packet_buffer)
630
        (*plast_pktl)->next = pktl;
631
    else
632
        *packet_buffer = pktl;
633

    
634
    /* add the packet in the buffered packet list */
635
    *plast_pktl = pktl;
636
    pktl->pkt= *pkt;
637
    return &pktl->pkt;
638
}
639

    
640
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
641
{
642
    int ret, i;
643
    AVStream *st;
644

    
645
    for(;;){
646
        AVPacketList *pktl = s->raw_packet_buffer;
647

    
648
        if (pktl) {
649
            *pkt = pktl->pkt;
650
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
651
               !s->streams[pkt->stream_index]->probe_packets ||
652
               s->raw_packet_buffer_remaining_size < pkt->size){
653
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
654
                av_freep(&pd->buf);
655
                pd->buf_size = 0;
656
                s->raw_packet_buffer = pktl->next;
657
                s->raw_packet_buffer_remaining_size += pkt->size;
658
                av_free(pktl);
659
                return 0;
660
            }
661
        }
662

    
663
        av_init_packet(pkt);
664
        ret= s->iformat->read_packet(s, pkt);
665
        if (ret < 0) {
666
            if (!pktl || ret == AVERROR(EAGAIN))
667
                return ret;
668
            for (i = 0; i < s->nb_streams; i++)
669
                s->streams[i]->probe_packets = 0;
670
            continue;
671
        }
672
        st= s->streams[pkt->stream_index];
673

    
674
        switch(st->codec->codec_type){
675
        case AVMEDIA_TYPE_VIDEO:
676
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
677
            break;
678
        case AVMEDIA_TYPE_AUDIO:
679
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
680
            break;
681
        case AVMEDIA_TYPE_SUBTITLE:
682
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
683
            break;
684
        }
685

    
686
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
687
                     !st->probe_packets))
688
            return ret;
689

    
690
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
691
        s->raw_packet_buffer_remaining_size -= pkt->size;
692

    
693
        if(st->codec->codec_id == CODEC_ID_PROBE){
694
            AVProbeData *pd = &st->probe_data;
695
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
696
            --st->probe_packets;
697

    
698
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
699
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
700
            pd->buf_size += pkt->size;
701
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
702

    
703
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
704
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
705
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
706
                if(st->codec->codec_id != CODEC_ID_PROBE){
707
                    pd->buf_size=0;
708
                    av_freep(&pd->buf);
709
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
710
                }
711
            }
712
        }
713
    }
714
}
715

    
716
/**********************************************************/
717

    
718
/**
719
 * Get the number of samples of an audio frame. Return -1 on error.
720
 */
721
static int get_audio_frame_size(AVCodecContext *enc, int size)
722
{
723
    int frame_size;
724

    
725
    if(enc->codec_id == CODEC_ID_VORBIS)
726
        return -1;
727

    
728
    if (enc->frame_size <= 1) {
729
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
730

    
731
        if (bits_per_sample) {
732
            if (enc->channels == 0)
733
                return -1;
734
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
735
        } else {
736
            /* used for example by ADPCM codecs */
737
            if (enc->bit_rate == 0)
738
                return -1;
739
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
740
        }
741
    } else {
742
        frame_size = enc->frame_size;
743
    }
744
    return frame_size;
745
}
746

    
747

    
748
/**
749
 * Return the frame duration in seconds. Return 0 if not available.
750
 */
751
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
752
                                   AVCodecParserContext *pc, AVPacket *pkt)
753
{
754
    int frame_size;
755

    
756
    *pnum = 0;
757
    *pden = 0;
758
    switch(st->codec->codec_type) {
759
    case AVMEDIA_TYPE_VIDEO:
760
        if(st->time_base.num*1000LL > st->time_base.den){
761
            *pnum = st->time_base.num;
762
            *pden = st->time_base.den;
763
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
764
            *pnum = st->codec->time_base.num;
765
            *pden = st->codec->time_base.den;
766
            if (pc && pc->repeat_pict) {
767
                *pnum = (*pnum) * (1 + pc->repeat_pict);
768
            }
769
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
770
            //Thus if we have no parser in such case leave duration undefined.
771
            if(st->codec->ticks_per_frame>1 && !pc){
772
                *pnum = *pden = 0;
773
            }
774
        }
775
        break;
776
    case AVMEDIA_TYPE_AUDIO:
777
        frame_size = get_audio_frame_size(st->codec, pkt->size);
778
        if (frame_size < 0)
779
            break;
780
        *pnum = frame_size;
781
        *pden = st->codec->sample_rate;
782
        break;
783
    default:
784
        break;
785
    }
786
}
787

    
788
static int is_intra_only(AVCodecContext *enc){
789
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
790
        return 1;
791
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
792
        switch(enc->codec_id){
793
        case CODEC_ID_MJPEG:
794
        case CODEC_ID_MJPEGB:
795
        case CODEC_ID_LJPEG:
796
        case CODEC_ID_RAWVIDEO:
797
        case CODEC_ID_DVVIDEO:
798
        case CODEC_ID_HUFFYUV:
799
        case CODEC_ID_FFVHUFF:
800
        case CODEC_ID_ASV1:
801
        case CODEC_ID_ASV2:
802
        case CODEC_ID_VCR1:
803
        case CODEC_ID_DNXHD:
804
        case CODEC_ID_JPEG2000:
805
            return 1;
806
        default: break;
807
        }
808
    }
809
    return 0;
810
}
811

    
812
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
813
                                      int64_t dts, int64_t pts)
814
{
815
    AVStream *st= s->streams[stream_index];
816
    AVPacketList *pktl= s->packet_buffer;
817

    
818
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
819
        return;
820

    
821
    st->first_dts= dts - st->cur_dts;
822
    st->cur_dts= dts;
823

    
824
    for(; pktl; pktl= pktl->next){
825
        if(pktl->pkt.stream_index != stream_index)
826
            continue;
827
        //FIXME think more about this check
828
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
829
            pktl->pkt.pts += st->first_dts;
830

    
831
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
832
            pktl->pkt.dts += st->first_dts;
833

    
834
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
835
            st->start_time= pktl->pkt.pts;
836
    }
837
    if (st->start_time == AV_NOPTS_VALUE)
838
        st->start_time = pts;
839
}
840

    
841
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
842
{
843
    AVPacketList *pktl= s->packet_buffer;
844
    int64_t cur_dts= 0;
845

    
846
    if(st->first_dts != AV_NOPTS_VALUE){
847
        cur_dts= st->first_dts;
848
        for(; pktl; pktl= pktl->next){
849
            if(pktl->pkt.stream_index == pkt->stream_index){
850
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
851
                    break;
852
                cur_dts -= pkt->duration;
853
            }
854
        }
855
        pktl= s->packet_buffer;
856
        st->first_dts = cur_dts;
857
    }else if(st->cur_dts)
858
        return;
859

    
860
    for(; pktl; pktl= pktl->next){
861
        if(pktl->pkt.stream_index != pkt->stream_index)
862
            continue;
863
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
864
           && !pktl->pkt.duration){
865
            pktl->pkt.dts= cur_dts;
866
            if(!st->codec->has_b_frames)
867
                pktl->pkt.pts= cur_dts;
868
            cur_dts += pkt->duration;
869
            pktl->pkt.duration= pkt->duration;
870
        }else
871
            break;
872
    }
873
    if(st->first_dts == AV_NOPTS_VALUE)
874
        st->cur_dts= cur_dts;
875
}
876

    
877
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
878
                               AVCodecParserContext *pc, AVPacket *pkt)
879
{
880
    int num, den, presentation_delayed, delay, i;
881
    int64_t offset;
882

    
883
    if (s->flags & AVFMT_FLAG_NOFILLIN)
884
        return;
885

    
886
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
887
        pkt->dts= AV_NOPTS_VALUE;
888

    
889
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
890
        //FIXME Set low_delay = 0 when has_b_frames = 1
891
        st->codec->has_b_frames = 1;
892

    
893
    /* do we have a video B-frame ? */
894
    delay= st->codec->has_b_frames;
895
    presentation_delayed = 0;
896
    /* XXX: need has_b_frame, but cannot get it if the codec is
897
        not initialized */
898
    if (delay &&
899
        pc && pc->pict_type != FF_B_TYPE)
900
        presentation_delayed = 1;
901

    
902
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
903
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
904
        pkt->dts -= 1LL<<st->pts_wrap_bits;
905
    }
906

    
907
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
908
    // we take the conservative approach and discard both
909
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
910
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
911
        av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
912
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
913
    }
914

    
915
    if (pkt->duration == 0) {
916
        compute_frame_duration(&num, &den, st, pc, pkt);
917
        if (den && num) {
918
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
919

    
920
            if(pkt->duration != 0 && s->packet_buffer)
921
                update_initial_durations(s, st, pkt);
922
        }
923
    }
924

    
925
    /* correct timestamps with byte offset if demuxers only have timestamps
926
       on packet boundaries */
927
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
928
        /* this will estimate bitrate based on this frame's duration and size */
929
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
930
        if(pkt->pts != AV_NOPTS_VALUE)
931
            pkt->pts += offset;
932
        if(pkt->dts != AV_NOPTS_VALUE)
933
            pkt->dts += offset;
934
    }
935

    
936
    if (pc && pc->dts_sync_point >= 0) {
937
        // we have synchronization info from the parser
938
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
939
        if (den > 0) {
940
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
941
            if (pkt->dts != AV_NOPTS_VALUE) {
942
                // got DTS from the stream, update reference timestamp
943
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
944
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
945
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
946
                // compute DTS based on reference timestamp
947
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
948
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
949
            }
950
            if (pc->dts_sync_point > 0)
951
                st->reference_dts = pkt->dts; // new reference
952
        }
953
    }
954

    
955
    /* This may be redundant, but it should not hurt. */
956
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
957
        presentation_delayed = 1;
958

    
959
//    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);
960
    /* interpolate PTS and DTS if they are not present */
961
    //We skip H264 currently because delay and has_b_frames are not reliably set
962
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
963
        if (presentation_delayed) {
964
            /* DTS = decompression timestamp */
965
            /* PTS = presentation timestamp */
966
            if (pkt->dts == AV_NOPTS_VALUE)
967
                pkt->dts = st->last_IP_pts;
968
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
969
            if (pkt->dts == AV_NOPTS_VALUE)
970
                pkt->dts = st->cur_dts;
971

    
972
            /* this is tricky: the dts must be incremented by the duration
973
            of the frame we are displaying, i.e. the last I- or P-frame */
974
            if (st->last_IP_duration == 0)
975
                st->last_IP_duration = pkt->duration;
976
            if(pkt->dts != AV_NOPTS_VALUE)
977
                st->cur_dts = pkt->dts + st->last_IP_duration;
978
            st->last_IP_duration  = pkt->duration;
979
            st->last_IP_pts= pkt->pts;
980
            /* cannot compute PTS if not present (we can compute it only
981
            by knowing the future */
982
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
983
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
984
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
985
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
986
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
987
                    pkt->pts += pkt->duration;
988
    //                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);
989
                }
990
            }
991

    
992
            /* presentation is not delayed : PTS and DTS are the same */
993
            if(pkt->pts == AV_NOPTS_VALUE)
994
                pkt->pts = pkt->dts;
995
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
996
            if(pkt->pts == AV_NOPTS_VALUE)
997
                pkt->pts = st->cur_dts;
998
            pkt->dts = pkt->pts;
999
            if(pkt->pts != AV_NOPTS_VALUE)
1000
                st->cur_dts = pkt->pts + pkt->duration;
1001
        }
1002
    }
1003

    
1004
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1005
        st->pts_buffer[0]= pkt->pts;
1006
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1007
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1008
        if(pkt->dts == AV_NOPTS_VALUE)
1009
            pkt->dts= st->pts_buffer[0];
1010
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1011
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1012
        }
1013
        if(pkt->dts > st->cur_dts)
1014
            st->cur_dts = pkt->dts;
1015
    }
1016

    
1017
//    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);
1018

    
1019
    /* update flags */
1020
    if(is_intra_only(st->codec))
1021
        pkt->flags |= AV_PKT_FLAG_KEY;
1022
    else if (pc) {
1023
        pkt->flags = 0;
1024
        /* keyframe computation */
1025
        if (pc->key_frame == 1)
1026
            pkt->flags |= AV_PKT_FLAG_KEY;
1027
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1028
            pkt->flags |= AV_PKT_FLAG_KEY;
1029
    }
1030
    if (pc)
1031
        pkt->convergence_duration = pc->convergence_duration;
1032
}
1033

    
1034

    
1035
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1036
{
1037
    AVStream *st;
1038
    int len, ret, i;
1039

    
1040
    av_init_packet(pkt);
1041

    
1042
    for(;;) {
1043
        /* select current input stream component */
1044
        st = s->cur_st;
1045
        if (st) {
1046
            if (!st->need_parsing || !st->parser) {
1047
                /* no parsing needed: we just output the packet as is */
1048
                /* raw data support */
1049
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1050
                compute_pkt_fields(s, st, NULL, pkt);
1051
                s->cur_st = NULL;
1052
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1053
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1054
                    ff_reduce_index(s, st->index);
1055
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1056
                }
1057
                break;
1058
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1059
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1060
                                       st->cur_ptr, st->cur_len,
1061
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1062
                                       st->cur_pkt.pos);
1063
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1064
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1065
                /* increment read pointer */
1066
                st->cur_ptr += len;
1067
                st->cur_len -= len;
1068

    
1069
                /* return packet if any */
1070
                if (pkt->size) {
1071
                got_packet:
1072
                    pkt->duration = 0;
1073
                    pkt->stream_index = st->index;
1074
                    pkt->pts = st->parser->pts;
1075
                    pkt->dts = st->parser->dts;
1076
                    pkt->pos = st->parser->pos;
1077
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1078
                        s->cur_st = NULL;
1079
                        pkt->destruct= st->cur_pkt.destruct;
1080
                        st->cur_pkt.destruct=
1081
                        st->cur_pkt.data    = NULL;
1082
                        assert(st->cur_len == 0);
1083
                    }else{
1084
                    pkt->destruct = NULL;
1085
                    }
1086
                    compute_pkt_fields(s, st, st->parser, pkt);
1087

    
1088
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1089
                        ff_reduce_index(s, st->index);
1090
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1091
                                           0, 0, AVINDEX_KEYFRAME);
1092
                    }
1093

    
1094
                    break;
1095
                }
1096
            } else {
1097
                /* free packet */
1098
                av_free_packet(&st->cur_pkt);
1099
                s->cur_st = NULL;
1100
            }
1101
        } else {
1102
            AVPacket cur_pkt;
1103
            /* read next packet */
1104
            ret = av_read_packet(s, &cur_pkt);
1105
            if (ret < 0) {
1106
                if (ret == AVERROR(EAGAIN))
1107
                    return ret;
1108
                /* return the last frames, if any */
1109
                for(i = 0; i < s->nb_streams; i++) {
1110
                    st = s->streams[i];
1111
                    if (st->parser && st->need_parsing) {
1112
                        av_parser_parse2(st->parser, st->codec,
1113
                                        &pkt->data, &pkt->size,
1114
                                        NULL, 0,
1115
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1116
                                        AV_NOPTS_VALUE);
1117
                        if (pkt->size)
1118
                            goto got_packet;
1119
                    }
1120
                }
1121
                /* no more packets: really terminate parsing */
1122
                return ret;
1123
            }
1124
            st = s->streams[cur_pkt.stream_index];
1125
            st->cur_pkt= cur_pkt;
1126

    
1127
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1128
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1129
               st->cur_pkt.pts < st->cur_pkt.dts){
1130
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1131
                    st->cur_pkt.stream_index,
1132
                    st->cur_pkt.pts,
1133
                    st->cur_pkt.dts,
1134
                    st->cur_pkt.size);
1135
//                av_free_packet(&st->cur_pkt);
1136
//                return -1;
1137
            }
1138

    
1139
            if(s->debug & FF_FDEBUG_TS)
1140
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1141
                    st->cur_pkt.stream_index,
1142
                    st->cur_pkt.pts,
1143
                    st->cur_pkt.dts,
1144
                    st->cur_pkt.size,
1145
                    st->cur_pkt.duration,
1146
                    st->cur_pkt.flags);
1147

    
1148
            s->cur_st = st;
1149
            st->cur_ptr = st->cur_pkt.data;
1150
            st->cur_len = st->cur_pkt.size;
1151
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1152
                st->parser = av_parser_init(st->codec->codec_id);
1153
                if (!st->parser) {
1154
                    /* no parser available: just output the raw packets */
1155
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1156
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1157
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1158
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1159
                    st->parser->flags |= PARSER_FLAG_ONCE;
1160
                }
1161
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1162
                    st->parser->next_frame_offset=
1163
                    st->parser->cur_offset= st->cur_pkt.pos;
1164
                }
1165
            }
1166
        }
1167
    }
1168
    if(s->debug & FF_FDEBUG_TS)
1169
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1170
            pkt->stream_index,
1171
            pkt->pts,
1172
            pkt->dts,
1173
            pkt->size,
1174
            pkt->duration,
1175
            pkt->flags);
1176

    
1177
    return 0;
1178
}
1179

    
1180
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1181
{
1182
    AVPacketList *pktl;
1183
    int eof=0;
1184
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1185

    
1186
    for(;;){
1187
        pktl = s->packet_buffer;
1188
        if (pktl) {
1189
            AVPacket *next_pkt= &pktl->pkt;
1190

    
1191
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1192
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1193
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1194
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1195
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1196
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1197
                        next_pkt->pts= pktl->pkt.dts;
1198
                    }
1199
                    pktl= pktl->next;
1200
                }
1201
                pktl = s->packet_buffer;
1202
            }
1203

    
1204
            if(   next_pkt->pts != AV_NOPTS_VALUE
1205
               || next_pkt->dts == AV_NOPTS_VALUE
1206
               || !genpts || eof){
1207
                /* read packet from packet buffer, if there is data */
1208
                *pkt = *next_pkt;
1209
                s->packet_buffer = pktl->next;
1210
                av_free(pktl);
1211
                return 0;
1212
            }
1213
        }
1214
        if(genpts){
1215
            int ret= av_read_frame_internal(s, pkt);
1216
            if(ret<0){
1217
                if(pktl && ret != AVERROR(EAGAIN)){
1218
                    eof=1;
1219
                    continue;
1220
                }else
1221
                    return ret;
1222
            }
1223

    
1224
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1225
                                           &s->packet_buffer_end)) < 0)
1226
                return AVERROR(ENOMEM);
1227
        }else{
1228
            assert(!s->packet_buffer);
1229
            return av_read_frame_internal(s, pkt);
1230
        }
1231
    }
1232
}
1233

    
1234
/* XXX: suppress the packet queue */
1235
static void flush_packet_queue(AVFormatContext *s)
1236
{
1237
    AVPacketList *pktl;
1238

    
1239
    for(;;) {
1240
        pktl = s->packet_buffer;
1241
        if (!pktl)
1242
            break;
1243
        s->packet_buffer = pktl->next;
1244
        av_free_packet(&pktl->pkt);
1245
        av_free(pktl);
1246
    }
1247
    while(s->raw_packet_buffer){
1248
        pktl = s->raw_packet_buffer;
1249
        s->raw_packet_buffer = pktl->next;
1250
        av_free_packet(&pktl->pkt);
1251
        av_free(pktl);
1252
    }
1253
    s->packet_buffer_end=
1254
    s->raw_packet_buffer_end= NULL;
1255
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1256
}
1257

    
1258
/*******************************************************/
1259
/* seek support */
1260

    
1261
int av_find_default_stream_index(AVFormatContext *s)
1262
{
1263
    int first_audio_index = -1;
1264
    int i;
1265
    AVStream *st;
1266

    
1267
    if (s->nb_streams <= 0)
1268
        return -1;
1269
    for(i = 0; i < s->nb_streams; i++) {
1270
        st = s->streams[i];
1271
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1272
            return i;
1273
        }
1274
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1275
            first_audio_index = i;
1276
    }
1277
    return first_audio_index >= 0 ? first_audio_index : 0;
1278
}
1279

    
1280
/**
1281
 * Flush the frame reader.
1282
 */
1283
void ff_read_frame_flush(AVFormatContext *s)
1284
{
1285
    AVStream *st;
1286
    int i, j;
1287

    
1288
    flush_packet_queue(s);
1289

    
1290
    s->cur_st = NULL;
1291

    
1292
    /* for each stream, reset read state */
1293
    for(i = 0; i < s->nb_streams; i++) {
1294
        st = s->streams[i];
1295

    
1296
        if (st->parser) {
1297
            av_parser_close(st->parser);
1298
            st->parser = NULL;
1299
            av_free_packet(&st->cur_pkt);
1300
        }
1301
        st->last_IP_pts = AV_NOPTS_VALUE;
1302
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1303
        st->reference_dts = AV_NOPTS_VALUE;
1304
        /* fail safe */
1305
        st->cur_ptr = NULL;
1306
        st->cur_len = 0;
1307

    
1308
        st->probe_packets = MAX_PROBE_PACKETS;
1309

    
1310
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1311
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1312
    }
1313
}
1314

    
1315
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1316
    int i;
1317

    
1318
    for(i = 0; i < s->nb_streams; i++) {
1319
        AVStream *st = s->streams[i];
1320

    
1321
        st->cur_dts = av_rescale(timestamp,
1322
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1323
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1324
    }
1325
}
1326

    
1327
void ff_reduce_index(AVFormatContext *s, int stream_index)
1328
{
1329
    AVStream *st= s->streams[stream_index];
1330
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1331

    
1332
    if((unsigned)st->nb_index_entries >= max_entries){
1333
        int i;
1334
        for(i=0; 2*i<st->nb_index_entries; i++)
1335
            st->index_entries[i]= st->index_entries[2*i];
1336
        st->nb_index_entries= i;
1337
    }
1338
}
1339

    
1340
int av_add_index_entry(AVStream *st,
1341
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1342
{
1343
    AVIndexEntry *entries, *ie;
1344
    int index;
1345

    
1346
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1347
        return -1;
1348

    
1349
    entries = av_fast_realloc(st->index_entries,
1350
                              &st->index_entries_allocated_size,
1351
                              (st->nb_index_entries + 1) *
1352
                              sizeof(AVIndexEntry));
1353
    if(!entries)
1354
        return -1;
1355

    
1356
    st->index_entries= entries;
1357

    
1358
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1359

    
1360
    if(index<0){
1361
        index= st->nb_index_entries++;
1362
        ie= &entries[index];
1363
        assert(index==0 || ie[-1].timestamp < timestamp);
1364
    }else{
1365
        ie= &entries[index];
1366
        if(ie->timestamp != timestamp){
1367
            if(ie->timestamp <= timestamp)
1368
                return -1;
1369
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1370
            st->nb_index_entries++;
1371
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1372
            distance= ie->min_distance;
1373
    }
1374

    
1375
    ie->pos = pos;
1376
    ie->timestamp = timestamp;
1377
    ie->min_distance= distance;
1378
    ie->size= size;
1379
    ie->flags = flags;
1380

    
1381
    return index;
1382
}
1383

    
1384
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1385
                              int flags)
1386
{
1387
    AVIndexEntry *entries= st->index_entries;
1388
    int nb_entries= st->nb_index_entries;
1389
    int a, b, m;
1390
    int64_t timestamp;
1391

    
1392
    a = - 1;
1393
    b = nb_entries;
1394

    
1395
    //optimize appending index entries at the end
1396
    if(b && entries[b-1].timestamp < wanted_timestamp)
1397
        a= b-1;
1398

    
1399
    while (b - a > 1) {
1400
        m = (a + b) >> 1;
1401
        timestamp = entries[m].timestamp;
1402
        if(timestamp >= wanted_timestamp)
1403
            b = m;
1404
        if(timestamp <= wanted_timestamp)
1405
            a = m;
1406
    }
1407
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1408

    
1409
    if(!(flags & AVSEEK_FLAG_ANY)){
1410
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1411
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1412
        }
1413
    }
1414

    
1415
    if(m == nb_entries)
1416
        return -1;
1417
    return  m;
1418
}
1419

    
1420
#define DEBUG_SEEK
1421

    
1422
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1423
    AVInputFormat *avif= s->iformat;
1424
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1425
    int64_t ts_min, ts_max, ts;
1426
    int index;
1427
    int64_t ret;
1428
    AVStream *st;
1429

    
1430
    if (stream_index < 0)
1431
        return -1;
1432

    
1433
#ifdef DEBUG_SEEK
1434
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1435
#endif
1436

    
1437
    ts_max=
1438
    ts_min= AV_NOPTS_VALUE;
1439
    pos_limit= -1; //gcc falsely says it may be uninitialized
1440

    
1441
    st= s->streams[stream_index];
1442
    if(st->index_entries){
1443
        AVIndexEntry *e;
1444

    
1445
        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()
1446
        index= FFMAX(index, 0);
1447
        e= &st->index_entries[index];
1448

    
1449
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1450
            pos_min= e->pos;
1451
            ts_min= e->timestamp;
1452
#ifdef DEBUG_SEEK
1453
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1454
                   pos_min,ts_min);
1455
#endif
1456
        }else{
1457
            assert(index==0);
1458
        }
1459

    
1460
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1461
        assert(index < st->nb_index_entries);
1462
        if(index >= 0){
1463
            e= &st->index_entries[index];
1464
            assert(e->timestamp >= target_ts);
1465
            pos_max= e->pos;
1466
            ts_max= e->timestamp;
1467
            pos_limit= pos_max - e->min_distance;
1468
#ifdef DEBUG_SEEK
1469
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1470
                   pos_max,pos_limit, ts_max);
1471
#endif
1472
        }
1473
    }
1474

    
1475
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1476
    if(pos<0)
1477
        return -1;
1478

    
1479
    /* do the seek */
1480
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1481
        return ret;
1482

    
1483
    av_update_cur_dts(s, st, ts);
1484

    
1485
    return 0;
1486
}
1487

    
1488
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 )){
1489
    int64_t pos, ts;
1490
    int64_t start_pos, filesize;
1491
    int no_change;
1492

    
1493
#ifdef DEBUG_SEEK
1494
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1495
#endif
1496

    
1497
    if(ts_min == AV_NOPTS_VALUE){
1498
        pos_min = s->data_offset;
1499
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1500
        if (ts_min == AV_NOPTS_VALUE)
1501
            return -1;
1502
    }
1503

    
1504
    if(ts_max == AV_NOPTS_VALUE){
1505
        int step= 1024;
1506
        filesize = url_fsize(s->pb);
1507
        pos_max = filesize - 1;
1508
        do{
1509
            pos_max -= step;
1510
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1511
            step += step;
1512
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1513
        if (ts_max == AV_NOPTS_VALUE)
1514
            return -1;
1515

    
1516
        for(;;){
1517
            int64_t tmp_pos= pos_max + 1;
1518
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1519
            if(tmp_ts == AV_NOPTS_VALUE)
1520
                break;
1521
            ts_max= tmp_ts;
1522
            pos_max= tmp_pos;
1523
            if(tmp_pos >= filesize)
1524
                break;
1525
        }
1526
        pos_limit= pos_max;
1527
    }
1528

    
1529
    if(ts_min > ts_max){
1530
        return -1;
1531
    }else if(ts_min == ts_max){
1532
        pos_limit= pos_min;
1533
    }
1534

    
1535
    no_change=0;
1536
    while (pos_min < pos_limit) {
1537
#ifdef DEBUG_SEEK
1538
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1539
               pos_min, pos_max,
1540
               ts_min, ts_max);
1541
#endif
1542
        assert(pos_limit <= pos_max);
1543

    
1544
        if(no_change==0){
1545
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1546
            // interpolate position (better than dichotomy)
1547
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1548
                + pos_min - approximate_keyframe_distance;
1549
        }else if(no_change==1){
1550
            // bisection, if interpolation failed to change min or max pos last time
1551
            pos = (pos_min + pos_limit)>>1;
1552
        }else{
1553
            /* linear search if bisection failed, can only happen if there
1554
               are very few or no keyframes between min/max */
1555
            pos=pos_min;
1556
        }
1557
        if(pos <= pos_min)
1558
            pos= pos_min + 1;
1559
        else if(pos > pos_limit)
1560
            pos= pos_limit;
1561
        start_pos= pos;
1562

    
1563
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1564
        if(pos == pos_max)
1565
            no_change++;
1566
        else
1567
            no_change=0;
1568
#ifdef DEBUG_SEEK
1569
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1570
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1571
               start_pos, no_change);
1572
#endif
1573
        if(ts == AV_NOPTS_VALUE){
1574
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1575
            return -1;
1576
        }
1577
        assert(ts != AV_NOPTS_VALUE);
1578
        if (target_ts <= ts) {
1579
            pos_limit = start_pos - 1;
1580
            pos_max = pos;
1581
            ts_max = ts;
1582
        }
1583
        if (target_ts >= ts) {
1584
            pos_min = pos;
1585
            ts_min = ts;
1586
        }
1587
    }
1588

    
1589
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1590
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1591
#ifdef DEBUG_SEEK
1592
    pos_min = pos;
1593
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1594
    pos_min++;
1595
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1596
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1597
           pos, ts_min, target_ts, ts_max);
1598
#endif
1599
    *ts_ret= ts;
1600
    return pos;
1601
}
1602

    
1603
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1604
    int64_t pos_min, pos_max;
1605
#if 0
1606
    AVStream *st;
1607

1608
    if (stream_index < 0)
1609
        return -1;
1610

1611
    st= s->streams[stream_index];
1612
#endif
1613

    
1614
    pos_min = s->data_offset;
1615
    pos_max = url_fsize(s->pb) - 1;
1616

    
1617
    if     (pos < pos_min) pos= pos_min;
1618
    else if(pos > pos_max) pos= pos_max;
1619

    
1620
    url_fseek(s->pb, pos, SEEK_SET);
1621

    
1622
#if 0
1623
    av_update_cur_dts(s, st, ts);
1624
#endif
1625
    return 0;
1626
}
1627

    
1628
static int av_seek_frame_generic(AVFormatContext *s,
1629
                                 int stream_index, int64_t timestamp, int flags)
1630
{
1631
    int index;
1632
    int64_t ret;
1633
    AVStream *st;
1634
    AVIndexEntry *ie;
1635

    
1636
    st = s->streams[stream_index];
1637

    
1638
    index = av_index_search_timestamp(st, timestamp, flags);
1639

    
1640
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1641
        return -1;
1642

    
1643
    if(index < 0 || index==st->nb_index_entries-1){
1644
        int i;
1645
        AVPacket pkt;
1646

    
1647
        if(st->nb_index_entries){
1648
            assert(st->index_entries);
1649
            ie= &st->index_entries[st->nb_index_entries-1];
1650
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1651
                return ret;
1652
            av_update_cur_dts(s, st, ie->timestamp);
1653
        }else{
1654
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1655
                return ret;
1656
        }
1657
        for(i=0;; i++) {
1658
            int ret;
1659
            do{
1660
                ret = av_read_frame(s, &pkt);
1661
            }while(ret == AVERROR(EAGAIN));
1662
            if(ret<0)
1663
                break;
1664
            av_free_packet(&pkt);
1665
            if(stream_index == pkt.stream_index){
1666
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1667
                    break;
1668
            }
1669
        }
1670
        index = av_index_search_timestamp(st, timestamp, flags);
1671
    }
1672
    if (index < 0)
1673
        return -1;
1674

    
1675
    ff_read_frame_flush(s);
1676
    if (s->iformat->read_seek){
1677
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1678
            return 0;
1679
    }
1680
    ie = &st->index_entries[index];
1681
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1682
        return ret;
1683
    av_update_cur_dts(s, st, ie->timestamp);
1684

    
1685
    return 0;
1686
}
1687

    
1688
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1689
{
1690
    int ret;
1691
    AVStream *st;
1692

    
1693
    ff_read_frame_flush(s);
1694

    
1695
    if(flags & AVSEEK_FLAG_BYTE)
1696
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1697

    
1698
    if(stream_index < 0){
1699
        stream_index= av_find_default_stream_index(s);
1700
        if(stream_index < 0)
1701
            return -1;
1702

    
1703
        st= s->streams[stream_index];
1704
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1705
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1706
    }
1707

    
1708
    /* first, we try the format specific seek */
1709
    if (s->iformat->read_seek)
1710
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1711
    else
1712
        ret = -1;
1713
    if (ret >= 0) {
1714
        return 0;
1715
    }
1716

    
1717
    if(s->iformat->read_timestamp)
1718
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1719
    else
1720
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1721
}
1722

    
1723
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1724
{
1725
    if(min_ts > ts || max_ts < ts)
1726
        return -1;
1727

    
1728
    ff_read_frame_flush(s);
1729

    
1730
    if (s->iformat->read_seek2)
1731
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1732

    
1733
    if(s->iformat->read_timestamp){
1734
        //try to seek via read_timestamp()
1735
    }
1736

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

    
1742
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1743
}
1744

    
1745
/*******************************************************/
1746

    
1747
/**
1748
 * Returns TRUE if the stream has accurate duration in any stream.
1749
 *
1750
 * @return TRUE if the stream has accurate duration for at least one component.
1751
 */
1752
static int av_has_duration(AVFormatContext *ic)
1753
{
1754
    int i;
1755
    AVStream *st;
1756

    
1757
    for(i = 0;i < ic->nb_streams; i++) {
1758
        st = ic->streams[i];
1759
        if (st->duration != AV_NOPTS_VALUE)
1760
            return 1;
1761
    }
1762
    return 0;
1763
}
1764

    
1765
/**
1766
 * Estimate the stream timings from the one of each components.
1767
 *
1768
 * Also computes the global bitrate if possible.
1769
 */
1770
static void av_update_stream_timings(AVFormatContext *ic)
1771
{
1772
    int64_t start_time, start_time1, end_time, end_time1;
1773
    int64_t duration, duration1;
1774
    int i;
1775
    AVStream *st;
1776

    
1777
    start_time = INT64_MAX;
1778
    end_time = INT64_MIN;
1779
    duration = INT64_MIN;
1780
    for(i = 0;i < ic->nb_streams; i++) {
1781
        st = ic->streams[i];
1782
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1783
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1784
            if (start_time1 < start_time)
1785
                start_time = start_time1;
1786
            if (st->duration != AV_NOPTS_VALUE) {
1787
                end_time1 = start_time1
1788
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1789
                if (end_time1 > end_time)
1790
                    end_time = end_time1;
1791
            }
1792
        }
1793
        if (st->duration != AV_NOPTS_VALUE) {
1794
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1795
            if (duration1 > duration)
1796
                duration = duration1;
1797
        }
1798
    }
1799
    if (start_time != INT64_MAX) {
1800
        ic->start_time = start_time;
1801
        if (end_time != INT64_MIN) {
1802
            if (end_time - start_time > duration)
1803
                duration = end_time - start_time;
1804
        }
1805
    }
1806
    if (duration != INT64_MIN) {
1807
        ic->duration = duration;
1808
        if (ic->file_size > 0) {
1809
            /* compute the bitrate */
1810
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1811
                (double)ic->duration;
1812
        }
1813
    }
1814
}
1815

    
1816
static void fill_all_stream_timings(AVFormatContext *ic)
1817
{
1818
    int i;
1819
    AVStream *st;
1820

    
1821
    av_update_stream_timings(ic);
1822
    for(i = 0;i < ic->nb_streams; i++) {
1823
        st = ic->streams[i];
1824
        if (st->start_time == AV_NOPTS_VALUE) {
1825
            if(ic->start_time != AV_NOPTS_VALUE)
1826
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1827
            if(ic->duration != AV_NOPTS_VALUE)
1828
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1829
        }
1830
    }
1831
}
1832

    
1833
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1834
{
1835
    int64_t filesize, duration;
1836
    int bit_rate, i;
1837
    AVStream *st;
1838

    
1839
    /* if bit_rate is already set, we believe it */
1840
    if (ic->bit_rate == 0) {
1841
        bit_rate = 0;
1842
        for(i=0;i<ic->nb_streams;i++) {
1843
            st = ic->streams[i];
1844
            bit_rate += st->codec->bit_rate;
1845
        }
1846
        ic->bit_rate = bit_rate;
1847
    }
1848

    
1849
    /* if duration is already set, we believe it */
1850
    if (ic->duration == AV_NOPTS_VALUE &&
1851
        ic->bit_rate != 0 &&
1852
        ic->file_size != 0)  {
1853
        filesize = ic->file_size;
1854
        if (filesize > 0) {
1855
            for(i = 0; i < ic->nb_streams; i++) {
1856
                st = ic->streams[i];
1857
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1858
                if (st->duration == AV_NOPTS_VALUE)
1859
                    st->duration = duration;
1860
            }
1861
        }
1862
    }
1863
}
1864

    
1865
#define DURATION_MAX_READ_SIZE 250000
1866
#define DURATION_MAX_RETRY 3
1867

    
1868
/* only usable for MPEG-PS streams */
1869
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1870
{
1871
    AVPacket pkt1, *pkt = &pkt1;
1872
    AVStream *st;
1873
    int read_size, i, ret;
1874
    int64_t end_time, start_time[MAX_STREAMS];
1875
    int64_t filesize, offset, duration;
1876
    int retry=0;
1877

    
1878
    ic->cur_st = NULL;
1879

    
1880
    /* flush packet queue */
1881
    flush_packet_queue(ic);
1882

    
1883
    for(i=0;i<ic->nb_streams;i++) {
1884
        st = ic->streams[i];
1885
        if(st->start_time != AV_NOPTS_VALUE){
1886
            start_time[i]= st->start_time;
1887
        }else if(st->first_dts != AV_NOPTS_VALUE){
1888
            start_time[i]= st->first_dts;
1889
        }else
1890
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1891

    
1892
        if (st->parser) {
1893
            av_parser_close(st->parser);
1894
            st->parser= NULL;
1895
            av_free_packet(&st->cur_pkt);
1896
        }
1897
    }
1898

    
1899
    /* estimate the end time (duration) */
1900
    /* XXX: may need to support wrapping */
1901
    filesize = ic->file_size;
1902
    end_time = AV_NOPTS_VALUE;
1903
    do{
1904
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1905
    if (offset < 0)
1906
        offset = 0;
1907

    
1908
    url_fseek(ic->pb, offset, SEEK_SET);
1909
    read_size = 0;
1910
    for(;;) {
1911
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1912
            break;
1913

    
1914
        do{
1915
            ret = av_read_packet(ic, pkt);
1916
        }while(ret == AVERROR(EAGAIN));
1917
        if (ret != 0)
1918
            break;
1919
        read_size += pkt->size;
1920
        st = ic->streams[pkt->stream_index];
1921
        if (pkt->pts != AV_NOPTS_VALUE &&
1922
            start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1923
            end_time = pkt->pts;
1924
            duration = end_time - start_time[pkt->stream_index];
1925
            if (duration < 0)
1926
                duration += 1LL<<st->pts_wrap_bits;
1927
            if (duration > 0) {
1928
                if (st->duration == AV_NOPTS_VALUE ||
1929
                    st->duration < duration)
1930
                    st->duration = duration;
1931
            }
1932
        }
1933
        av_free_packet(pkt);
1934
    }
1935
    }while(   end_time==AV_NOPTS_VALUE
1936
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1937
           && ++retry <= DURATION_MAX_RETRY);
1938

    
1939
    fill_all_stream_timings(ic);
1940

    
1941
    url_fseek(ic->pb, old_offset, SEEK_SET);
1942
    for(i=0; i<ic->nb_streams; i++){
1943
        st= ic->streams[i];
1944
        st->cur_dts= st->first_dts;
1945
        st->last_IP_pts = AV_NOPTS_VALUE;
1946
    }
1947
}
1948

    
1949
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1950
{
1951
    int64_t file_size;
1952

    
1953
    /* get the file size, if possible */
1954
    if (ic->iformat->flags & AVFMT_NOFILE) {
1955
        file_size = 0;
1956
    } else {
1957
        file_size = url_fsize(ic->pb);
1958
        if (file_size < 0)
1959
            file_size = 0;
1960
    }
1961
    ic->file_size = file_size;
1962

    
1963
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1964
         !strcmp(ic->iformat->name, "mpegts")) &&
1965
        file_size && !url_is_streamed(ic->pb)) {
1966
        /* get accurate estimate from the PTSes */
1967
        av_estimate_timings_from_pts(ic, old_offset);
1968
    } else if (av_has_duration(ic)) {
1969
        /* at least one component has timings - we use them for all
1970
           the components */
1971
        fill_all_stream_timings(ic);
1972
    } else {
1973
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1974
        /* less precise: use bitrate info */
1975
        av_estimate_timings_from_bit_rate(ic);
1976
    }
1977
    av_update_stream_timings(ic);
1978

    
1979
#if 0
1980
    {
1981
        int i;
1982
        AVStream *st;
1983
        for(i = 0;i < ic->nb_streams; i++) {
1984
            st = ic->streams[i];
1985
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1986
               i, (double)st->start_time / AV_TIME_BASE,
1987
               (double)st->duration / AV_TIME_BASE);
1988
        }
1989
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1990
               (double)ic->start_time / AV_TIME_BASE,
1991
               (double)ic->duration / AV_TIME_BASE,
1992
               ic->bit_rate / 1000);
1993
    }
1994
#endif
1995
}
1996

    
1997
static int has_codec_parameters(AVCodecContext *enc)
1998
{
1999
    int val;
2000
    switch(enc->codec_type) {
2001
    case AVMEDIA_TYPE_AUDIO:
2002
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
2003
        if(!enc->frame_size &&
2004
           (enc->codec_id == CODEC_ID_VORBIS ||
2005
            enc->codec_id == CODEC_ID_AAC ||
2006
            enc->codec_id == CODEC_ID_MP1 ||
2007
            enc->codec_id == CODEC_ID_MP2 ||
2008
            enc->codec_id == CODEC_ID_MP3 ||
2009
            enc->codec_id == CODEC_ID_SPEEX))
2010
            return 0;
2011
        break;
2012
    case AVMEDIA_TYPE_VIDEO:
2013
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2014
        break;
2015
    default:
2016
        val = 1;
2017
        break;
2018
    }
2019
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2020
}
2021

    
2022
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2023
{
2024
    int16_t *samples;
2025
    AVCodec *codec;
2026
    int got_picture, data_size, ret=0;
2027
    AVFrame picture;
2028

    
2029
    if(!st->codec->codec){
2030
        codec = avcodec_find_decoder(st->codec->codec_id);
2031
        if (!codec)
2032
            return -1;
2033
        ret = avcodec_open(st->codec, codec);
2034
        if (ret < 0)
2035
            return ret;
2036
    }
2037

    
2038
    if(!has_codec_parameters(st->codec)){
2039
        switch(st->codec->codec_type) {
2040
        case AVMEDIA_TYPE_VIDEO:
2041
            avcodec_get_frame_defaults(&picture);
2042
            ret = avcodec_decode_video2(st->codec, &picture,
2043
                                        &got_picture, avpkt);
2044
            break;
2045
        case AVMEDIA_TYPE_AUDIO:
2046
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2047
            samples = av_malloc(data_size);
2048
            if (!samples)
2049
                goto fail;
2050
            ret = avcodec_decode_audio3(st->codec, samples,
2051
                                        &data_size, avpkt);
2052
            av_free(samples);
2053
            break;
2054
        default:
2055
            break;
2056
        }
2057
    }
2058
 fail:
2059
    return ret;
2060
}
2061

    
2062
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2063
{
2064
    while (tags->id != CODEC_ID_NONE) {
2065
        if (tags->id == id)
2066
            return tags->tag;
2067
        tags++;
2068
    }
2069
    return 0;
2070
}
2071

    
2072
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2073
{
2074
    int i;
2075
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2076
        if(tag == tags[i].tag)
2077
            return tags[i].id;
2078
    }
2079
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2080
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2081
            return tags[i].id;
2082
    }
2083
    return CODEC_ID_NONE;
2084
}
2085

    
2086
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2087
{
2088
    int i;
2089
    for(i=0; tags && tags[i]; i++){
2090
        int tag= ff_codec_get_tag(tags[i], id);
2091
        if(tag) return tag;
2092
    }
2093
    return 0;
2094
}
2095

    
2096
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2097
{
2098
    int i;
2099
    for(i=0; tags && tags[i]; i++){
2100
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2101
        if(id!=CODEC_ID_NONE) return id;
2102
    }
2103
    return CODEC_ID_NONE;
2104
}
2105

    
2106
static void compute_chapters_end(AVFormatContext *s)
2107
{
2108
    unsigned int i;
2109

    
2110
    for (i=0; i+1<s->nb_chapters; i++)
2111
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2112
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2113
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2114
            s->chapters[i]->end = s->chapters[i+1]->start;
2115
        }
2116

    
2117
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2118
        assert(s->start_time != AV_NOPTS_VALUE);
2119
        assert(s->duration > 0);
2120
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2121
                                           AV_TIME_BASE_Q,
2122
                                           s->chapters[i]->time_base);
2123
    }
2124
}
2125

    
2126
#define MAX_STD_TIMEBASES (60*12+5)
2127
static int get_std_framerate(int i){
2128
    if(i<60*12) return i*1001;
2129
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2130
}
2131

    
2132
/*
2133
 * Is the time base unreliable.
2134
 * This is a heuristic to balance between quick acceptance of the values in
2135
 * the headers vs. some extra checks.
2136
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2137
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2138
 * And there are "variable" fps files this needs to detect as well.
2139
 */
2140
static int tb_unreliable(AVCodecContext *c){
2141
    if(   c->time_base.den >= 101L*c->time_base.num
2142
       || c->time_base.den <    5L*c->time_base.num
2143
/*       || c->codec_tag == AV_RL32("DIVX")
2144
       || c->codec_tag == AV_RL32("XVID")*/
2145
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2146
       || c->codec_id == CODEC_ID_H264
2147
       )
2148
        return 1;
2149
    return 0;
2150
}
2151

    
2152
int av_find_stream_info(AVFormatContext *ic)
2153
{
2154
    int i, count, ret, read_size, j;
2155
    AVStream *st;
2156
    AVPacket pkt1, *pkt;
2157
    int64_t last_dts[MAX_STREAMS];
2158
    int64_t duration_gcd[MAX_STREAMS]={0};
2159
    int duration_count[MAX_STREAMS]={0};
2160
    double (*duration_error)[MAX_STD_TIMEBASES];
2161
    int64_t old_offset = url_ftell(ic->pb);
2162
    int64_t codec_info_duration[MAX_STREAMS]={0};
2163

    
2164
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2165
    if (!duration_error) return AVERROR(ENOMEM);
2166

    
2167
    for(i=0;i<ic->nb_streams;i++) {
2168
        st = ic->streams[i];
2169
        if (st->codec->codec_id == CODEC_ID_AAC) {
2170
            st->codec->sample_rate = 0;
2171
            st->codec->frame_size = 0;
2172
            st->codec->channels = 0;
2173
        }
2174
        if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2175
/*            if(!st->time_base.num)
2176
                st->time_base= */
2177
            if(!st->codec->time_base.num)
2178
                st->codec->time_base= st->time_base;
2179
        }
2180
        //only for the split stuff
2181
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2182
            st->parser = av_parser_init(st->codec->codec_id);
2183
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2184
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2185
            }
2186
        }
2187
        assert(!st->codec->codec);
2188
        //try to just open decoders, in case this is enough to get parameters
2189
        if(!has_codec_parameters(st->codec)){
2190
            AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
2191
            if (codec)
2192
                avcodec_open(st->codec, codec);
2193
        }
2194
    }
2195

    
2196
    for(i=0;i<MAX_STREAMS;i++){
2197
        last_dts[i]= AV_NOPTS_VALUE;
2198
    }
2199

    
2200
    count = 0;
2201
    read_size = 0;
2202
    for(;;) {
2203
        if(url_interrupt_cb()){
2204
            ret= AVERROR(EINTR);
2205
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2206
            break;
2207
        }
2208

    
2209
        /* check if one codec still needs to be handled */
2210
        for(i=0;i<ic->nb_streams;i++) {
2211
            st = ic->streams[i];
2212
            if (!has_codec_parameters(st->codec))
2213
                break;
2214
            /* variable fps and no guess at the real fps */
2215
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2216
               && duration_count[i]<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2217
                break;
2218
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2219
                break;
2220
            if(st->first_dts == AV_NOPTS_VALUE)
2221
                break;
2222
        }
2223
        if (i == ic->nb_streams) {
2224
            /* NOTE: if the format has no header, then we need to read
2225
               some packets to get most of the streams, so we cannot
2226
               stop here */
2227
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2228
                /* if we found the info for all the codecs, we can stop */
2229
                ret = count;
2230
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2231
                break;
2232
            }
2233
        }
2234
        /* we did not get all the codec info, but we read too much data */
2235
        if (read_size >= ic->probesize) {
2236
            ret = count;
2237
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2238
            break;
2239
        }
2240

    
2241
        /* NOTE: a new stream can be added there if no header in file
2242
           (AVFMTCTX_NOHEADER) */
2243
        ret = av_read_frame_internal(ic, &pkt1);
2244
        if(ret == AVERROR(EAGAIN))
2245
            continue;
2246
        if (ret < 0) {
2247
            /* EOF or error */
2248
            ret = -1; /* we could not have all the codec parameters before EOF */
2249
            for(i=0;i<ic->nb_streams;i++) {
2250
                st = ic->streams[i];
2251
                if (!has_codec_parameters(st->codec)){
2252
                    char buf[256];
2253
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2254
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2255
                } else {
2256
                    ret = 0;
2257
                }
2258
            }
2259
            break;
2260
        }
2261

    
2262
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2263
        if(av_dup_packet(pkt) < 0) {
2264
            av_free(duration_error);
2265
            return AVERROR(ENOMEM);
2266
        }
2267

    
2268
        read_size += pkt->size;
2269

    
2270
        st = ic->streams[pkt->stream_index];
2271
        if(st->codec_info_nb_frames>1) {
2272
            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){
2273
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2274
                break;
2275
            }
2276
            codec_info_duration[st->index] += pkt->duration;
2277
        }
2278
            st->codec_info_nb_frames++;
2279

    
2280
        {
2281
            int index= pkt->stream_index;
2282
            int64_t last= last_dts[index];
2283
            int64_t duration= pkt->dts - last;
2284

    
2285
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2286
                double dur= duration * av_q2d(st->time_base);
2287

    
2288
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2289
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2290
                if(duration_count[index] < 2)
2291
                    memset(duration_error[index], 0, sizeof(*duration_error));
2292
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2293
                    int framerate= get_std_framerate(i);
2294
                    int ticks= lrintf(dur*framerate/(1001*12));
2295
                    double error= dur - ticks*1001*12/(double)framerate;
2296
                    duration_error[index][i] += error*error;
2297
                }
2298
                duration_count[index]++;
2299
                // ignore the first 4 values, they might have some random jitter
2300
                if (duration_count[index] > 3)
2301
                    duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2302
            }
2303
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2304
                last_dts[pkt->stream_index]= pkt->dts;
2305
        }
2306
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2307
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2308
            if(i){
2309
                st->codec->extradata_size= i;
2310
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2311
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2312
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2313
            }
2314
        }
2315

    
2316
        /* if still no information, we try to open the codec and to
2317
           decompress the frame. We try to avoid that in most cases as
2318
           it takes longer and uses more memory. For MPEG-4, we need to
2319
           decompress for QuickTime. */
2320
        if (!has_codec_parameters(st->codec))
2321
            try_decode_frame(st, pkt);
2322

    
2323
        count++;
2324
    }
2325

    
2326
    // close codecs which were opened in try_decode_frame()
2327
    for(i=0;i<ic->nb_streams;i++) {
2328
        st = ic->streams[i];
2329
        if(st->codec->codec)
2330
            avcodec_close(st->codec);
2331
    }
2332
    for(i=0;i<ic->nb_streams;i++) {
2333
        st = ic->streams[i];
2334
        if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
2335
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2336
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2337
                      codec_info_duration[i]    *(int64_t)st->time_base.num, 60000);
2338
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2339
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2340
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2341

    
2342
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2343
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2344
            // ipmovie.c produces.
2345
            if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
2346
                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);
2347
            if(duration_count[i] && !st->r_frame_rate.num
2348
               && tb_unreliable(st->codec) /*&&
2349
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2350
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2351
                int num = 0;
2352
                double best_error= 2*av_q2d(st->time_base);
2353
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2354

    
2355
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2356
                    double error= duration_error[i][j] * get_std_framerate(j);
2357
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2358
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2359
                    if(error < best_error){
2360
                        best_error= error;
2361
                        num = get_std_framerate(j);
2362
                    }
2363
                }
2364
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2365
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2366
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2367
            }
2368

    
2369
            if (!st->r_frame_rate.num){
2370
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2371
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2372
                    st->r_frame_rate.num = st->codec->time_base.den;
2373
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2374
                }else{
2375
                    st->r_frame_rate.num = st->time_base.den;
2376
                    st->r_frame_rate.den = st->time_base.num;
2377
                }
2378
            }
2379
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2380
            if(!st->codec->bits_per_coded_sample)
2381
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2382
        }
2383
    }
2384

    
2385
    av_estimate_timings(ic, old_offset);
2386

    
2387
    compute_chapters_end(ic);
2388

    
2389
#if 0
2390
    /* correct DTS for B-frame streams with no timestamps */
2391
    for(i=0;i<ic->nb_streams;i++) {
2392
        st = ic->streams[i];
2393
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2394
            if(b-frames){
2395
                ppktl = &ic->packet_buffer;
2396
                while(ppkt1){
2397
                    if(ppkt1->stream_index != i)
2398
                        continue;
2399
                    if(ppkt1->pkt->dts < 0)
2400
                        break;
2401
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2402
                        break;
2403
                    ppkt1->pkt->dts -= delta;
2404
                    ppkt1= ppkt1->next;
2405
                }
2406
                if(ppkt1)
2407
                    continue;
2408
                st->cur_dts -= delta;
2409
            }
2410
        }
2411
    }
2412
#endif
2413

    
2414
    av_free(duration_error);
2415

    
2416
    return ret;
2417
}
2418

    
2419
/*******************************************************/
2420

    
2421
int av_read_play(AVFormatContext *s)
2422
{
2423
    if (s->iformat->read_play)
2424
        return s->iformat->read_play(s);
2425
    if (s->pb)
2426
        return av_url_read_fpause(s->pb, 0);
2427
    return AVERROR(ENOSYS);
2428
}
2429

    
2430
int av_read_pause(AVFormatContext *s)
2431
{
2432
    if (s->iformat->read_pause)
2433
        return s->iformat->read_pause(s);
2434
    if (s->pb)
2435
        return av_url_read_fpause(s->pb, 1);
2436
    return AVERROR(ENOSYS);
2437
}
2438

    
2439
void av_close_input_stream(AVFormatContext *s)
2440
{
2441
    int i;
2442
    AVStream *st;
2443

    
2444
    if (s->iformat->read_close)
2445
        s->iformat->read_close(s);
2446
    for(i=0;i<s->nb_streams;i++) {
2447
        /* free all data in a stream component */
2448
        st = s->streams[i];
2449
        if (st->parser) {
2450
            av_parser_close(st->parser);
2451
            av_free_packet(&st->cur_pkt);
2452
        }
2453
        av_metadata_free(&st->metadata);
2454
        av_free(st->index_entries);
2455
        av_free(st->codec->extradata);
2456
        av_free(st->codec);
2457
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2458
        av_free(st->filename);
2459
#endif
2460
        av_free(st->priv_data);
2461
        av_free(st);
2462
    }
2463
    for(i=s->nb_programs-1; i>=0; i--) {
2464
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2465
        av_freep(&s->programs[i]->provider_name);
2466
        av_freep(&s->programs[i]->name);
2467
#endif
2468
        av_metadata_free(&s->programs[i]->metadata);
2469
        av_freep(&s->programs[i]->stream_index);
2470
        av_freep(&s->programs[i]);
2471
    }
2472
    av_freep(&s->programs);
2473
    flush_packet_queue(s);
2474
    av_freep(&s->priv_data);
2475
    while(s->nb_chapters--) {
2476
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2477
        av_free(s->chapters[s->nb_chapters]->title);
2478
#endif
2479
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2480
        av_free(s->chapters[s->nb_chapters]);
2481
    }
2482
    av_freep(&s->chapters);
2483
    av_metadata_free(&s->metadata);
2484
    av_free(s);
2485
}
2486

    
2487
void av_close_input_file(AVFormatContext *s)
2488
{
2489
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2490
    av_close_input_stream(s);
2491
    if (pb)
2492
        url_fclose(pb);
2493
}
2494

    
2495
AVStream *av_new_stream(AVFormatContext *s, int id)
2496
{
2497
    AVStream *st;
2498
    int i;
2499

    
2500
    if (s->nb_streams >= MAX_STREAMS){
2501
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2502
        return NULL;
2503
    }
2504

    
2505
    st = av_mallocz(sizeof(AVStream));
2506
    if (!st)
2507
        return NULL;
2508

    
2509
    st->codec= avcodec_alloc_context();
2510
    if (s->iformat) {
2511
        /* no default bitrate if decoding */
2512
        st->codec->bit_rate = 0;
2513
    }
2514
    st->index = s->nb_streams;
2515
    st->id = id;
2516
    st->start_time = AV_NOPTS_VALUE;
2517
    st->duration = AV_NOPTS_VALUE;
2518
        /* we set the current DTS to 0 so that formats without any timestamps
2519
           but durations get some timestamps, formats with some unknown
2520
           timestamps have their first few packets buffered and the
2521
           timestamps corrected before they are returned to the user */
2522
    st->cur_dts = 0;
2523
    st->first_dts = AV_NOPTS_VALUE;
2524
    st->probe_packets = MAX_PROBE_PACKETS;
2525

    
2526
    /* default pts setting is MPEG-like */
2527
    av_set_pts_info(st, 33, 1, 90000);
2528
    st->last_IP_pts = AV_NOPTS_VALUE;
2529
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2530
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2531
    st->reference_dts = AV_NOPTS_VALUE;
2532

    
2533
    st->sample_aspect_ratio = (AVRational){0,1};
2534

    
2535
    s->streams[s->nb_streams++] = st;
2536
    return st;
2537
}
2538

    
2539
AVProgram *av_new_program(AVFormatContext *ac, int id)
2540
{
2541
    AVProgram *program=NULL;
2542
    int i;
2543

    
2544
#ifdef DEBUG_SI
2545
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2546
#endif
2547

    
2548
    for(i=0; i<ac->nb_programs; i++)
2549
        if(ac->programs[i]->id == id)
2550
            program = ac->programs[i];
2551

    
2552
    if(!program){
2553
        program = av_mallocz(sizeof(AVProgram));
2554
        if (!program)
2555
            return NULL;
2556
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2557
        program->discard = AVDISCARD_NONE;
2558
    }
2559
    program->id = id;
2560

    
2561
    return program;
2562
}
2563

    
2564
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2565
{
2566
    AVChapter *chapter = NULL;
2567
    int i;
2568

    
2569
    for(i=0; i<s->nb_chapters; i++)
2570
        if(s->chapters[i]->id == id)
2571
            chapter = s->chapters[i];
2572

    
2573
    if(!chapter){
2574
        chapter= av_mallocz(sizeof(AVChapter));
2575
        if(!chapter)
2576
            return NULL;
2577
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2578
    }
2579
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2580
    av_free(chapter->title);
2581
#endif
2582
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2583
    chapter->id    = id;
2584
    chapter->time_base= time_base;
2585
    chapter->start = start;
2586
    chapter->end   = end;
2587

    
2588
    return chapter;
2589
}
2590

    
2591
/************************************************************/
2592
/* output media file */
2593

    
2594
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2595
{
2596
    int ret;
2597

    
2598
    if (s->oformat->priv_data_size > 0) {
2599
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2600
        if (!s->priv_data)
2601
            return AVERROR(ENOMEM);
2602
    } else
2603
        s->priv_data = NULL;
2604

    
2605
    if (s->oformat->set_parameters) {
2606
        ret = s->oformat->set_parameters(s, ap);
2607
        if (ret < 0)
2608
            return ret;
2609
    }
2610
    return 0;
2611
}
2612

    
2613
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2614
{
2615
    const AVCodecTag *avctag;
2616
    int n;
2617
    enum CodecID id = CODEC_ID_NONE;
2618
    unsigned int tag = 0;
2619

    
2620
    /**
2621
     * Check that tag + id is in the table
2622
     * If neither is in the table -> OK
2623
     * If tag is in the table with another id -> FAIL
2624
     * If id is in the table with another tag -> FAIL unless strict < normal
2625
     */
2626
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2627
        avctag = s->oformat->codec_tag[n];
2628
        while (avctag->id != CODEC_ID_NONE) {
2629
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2630
                id = avctag->id;
2631
                if (id == st->codec->codec_id)
2632
                    return 1;
2633
            }
2634
            if (avctag->id == st->codec->codec_id)
2635
                tag = avctag->tag;
2636
            avctag++;
2637
        }
2638
    }
2639
    if (id != CODEC_ID_NONE)
2640
        return 0;
2641
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2642
        return 0;
2643
    return 1;
2644
}
2645

    
2646
int av_write_header(AVFormatContext *s)
2647
{
2648
    int ret, i;
2649
    AVStream *st;
2650

    
2651
    // some sanity checks
2652
    if (s->nb_streams == 0) {
2653
        av_log(s, AV_LOG_ERROR, "no streams\n");
2654
        return AVERROR(EINVAL);
2655
    }
2656

    
2657
    for(i=0;i<s->nb_streams;i++) {
2658
        st = s->streams[i];
2659

    
2660
        switch (st->codec->codec_type) {
2661
        case AVMEDIA_TYPE_AUDIO:
2662
            if(st->codec->sample_rate<=0){
2663
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2664
                return AVERROR(EINVAL);
2665
            }
2666
            if(!st->codec->block_align)
2667
                st->codec->block_align = st->codec->channels *
2668
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2669
            break;
2670
        case AVMEDIA_TYPE_VIDEO:
2671
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2672
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2673
                return AVERROR(EINVAL);
2674
            }
2675
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2676
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2677
                return AVERROR(EINVAL);
2678
            }
2679
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2680
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2681
                return AVERROR(EINVAL);
2682
            }
2683
            break;
2684
        }
2685

    
2686
        if(s->oformat->codec_tag){
2687
            if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2688
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2689
                st->codec->codec_tag= 0;
2690
            }
2691
            if(st->codec->codec_tag){
2692
                if (!validate_codec_tag(s, st)) {
2693
                    char tagbuf[32];
2694
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2695
                    av_log(s, AV_LOG_ERROR,
2696
                           "Tag %s/0x%08x incompatible with output codec '%s'\n",
2697
                           tagbuf, st->codec->codec_tag, st->codec->codec->name);
2698
                    return AVERROR_INVALIDDATA;
2699
                }
2700
            }else
2701
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2702
        }
2703

    
2704
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2705
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2706
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2707
    }
2708

    
2709
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2710
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2711
        if (!s->priv_data)
2712
            return AVERROR(ENOMEM);
2713
    }
2714

    
2715
#if LIBAVFORMAT_VERSION_MAJOR < 53
2716
    ff_metadata_mux_compat(s);
2717
#endif
2718

    
2719
    /* set muxer identification string */
2720
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2721
        AVMetadata *m;
2722
        AVMetadataTag *t;
2723

    
2724
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2725
            return AVERROR(ENOMEM);
2726
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2727
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2728
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2729
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2730
        av_metadata_free(&m);
2731
    }
2732

    
2733
    if(s->oformat->write_header){
2734
        ret = s->oformat->write_header(s);
2735
        if (ret < 0)
2736
            return ret;
2737
    }
2738

    
2739
    /* init PTS generation */
2740
    for(i=0;i<s->nb_streams;i++) {
2741
        int64_t den = AV_NOPTS_VALUE;
2742
        st = s->streams[i];
2743

    
2744
        switch (st->codec->codec_type) {
2745
        case AVMEDIA_TYPE_AUDIO:
2746
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2747
            break;
2748
        case AVMEDIA_TYPE_VIDEO:
2749
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2750
            break;
2751
        default:
2752
            break;
2753
        }
2754
        if (den != AV_NOPTS_VALUE) {
2755
            if (den <= 0)
2756
                return AVERROR_INVALIDDATA;
2757
            av_frac_init(&st->pts, 0, 0, den);
2758
        }
2759
    }
2760
    return 0;
2761
}
2762

    
2763
//FIXME merge with compute_pkt_fields
2764
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2765
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2766
    int num, den, frame_size, i;
2767

    
2768
//    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);
2769

    
2770
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2771
        return -1;*/
2772

    
2773
    /* duration field */
2774
    if (pkt->duration == 0) {
2775
        compute_frame_duration(&num, &den, st, NULL, pkt);
2776
        if (den && num) {
2777
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2778
        }
2779
    }
2780

    
2781
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2782
        pkt->pts= pkt->dts;
2783

    
2784
    //XXX/FIXME this is a temporary hack until all encoders output pts
2785
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2786
        pkt->dts=
2787
//        pkt->pts= st->cur_dts;
2788
        pkt->pts= st->pts.val;
2789
    }
2790

    
2791
    //calculate dts from pts
2792
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2793
        st->pts_buffer[0]= pkt->pts;
2794
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2795
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2796
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2797
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2798

    
2799
        pkt->dts= st->pts_buffer[0];
2800
    }
2801

    
2802
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2803
        av_log(s, AV_LOG_ERROR,
2804
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2805
               st->index, st->cur_dts, pkt->dts);
2806
        return -1;
2807
    }
2808
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2809
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2810
        return -1;
2811
    }
2812

    
2813
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2814
    st->cur_dts= pkt->dts;
2815
    st->pts.val= pkt->dts;
2816

    
2817
    /* update pts */
2818
    switch (st->codec->codec_type) {
2819
    case AVMEDIA_TYPE_AUDIO:
2820
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2821

    
2822
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2823
           likely equal to the encoder delay, but it would be better if we
2824
           had the real timestamps from the encoder */
2825
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2826
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2827
        }
2828
        break;
2829
    case AVMEDIA_TYPE_VIDEO:
2830
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2831
        break;
2832
    default:
2833
        break;
2834
    }
2835
    return 0;
2836
}
2837

    
2838
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2839
{
2840
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2841

    
2842
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2843
        return ret;
2844

    
2845
    ret= s->oformat->write_packet(s, pkt);
2846
    if(!ret)
2847
        ret= url_ferror(s->pb);
2848
    return ret;
2849
}
2850

    
2851
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2852
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2853
{
2854
    AVPacketList **next_point, *this_pktl;
2855

    
2856
    this_pktl = av_mallocz(sizeof(AVPacketList));
2857
    this_pktl->pkt= *pkt;
2858
    pkt->destruct= NULL;             // do not free original but only the copy
2859
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2860

    
2861
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2862
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2863
    }else
2864
        next_point = &s->packet_buffer;
2865

    
2866
    if(*next_point){
2867
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2868
            while(!compare(s, &(*next_point)->pkt, pkt)){
2869
                next_point= &(*next_point)->next;
2870
            }
2871
            goto next_non_null;
2872
        }else{
2873
            next_point = &(s->packet_buffer_end->next);
2874
        }
2875
    }
2876
    assert(!*next_point);
2877

    
2878
    s->packet_buffer_end= this_pktl;
2879
next_non_null:
2880

    
2881
    this_pktl->next= *next_point;
2882

    
2883
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2884
    *next_point= this_pktl;
2885
}
2886

    
2887
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2888
{
2889
    AVStream *st = s->streams[ pkt ->stream_index];
2890
    AVStream *st2= s->streams[ next->stream_index];
2891
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2892
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2893
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2894
}
2895

    
2896
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2897
    AVPacketList *pktl;
2898
    int stream_count=0;
2899
    int i;
2900

    
2901
    if(pkt){
2902
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2903
    }
2904

    
2905
    for(i=0; i < s->nb_streams; i++)
2906
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2907

    
2908
    if(stream_count && (s->nb_streams == stream_count || flush)){
2909
        pktl= s->packet_buffer;
2910
        *out= pktl->pkt;
2911

    
2912
        s->packet_buffer= pktl->next;
2913
        if(!s->packet_buffer)
2914
            s->packet_buffer_end= NULL;
2915

    
2916
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2917
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2918
        av_freep(&pktl);
2919
        return 1;
2920
    }else{
2921
        av_init_packet(out);
2922
        return 0;
2923
    }
2924
}
2925

    
2926
/**
2927
 * Interleaves an AVPacket correctly so it can be muxed.
2928
 * @param out the interleaved packet will be output here
2929
 * @param in the input packet
2930
 * @param flush 1 if no further packets are available as input and all
2931
 *              remaining packets should be output
2932
 * @return 1 if a packet was output, 0 if no packet could be output,
2933
 *         < 0 if an error occurred
2934
 */
2935
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2936
    if(s->oformat->interleave_packet)
2937
        return s->oformat->interleave_packet(s, out, in, flush);
2938
    else
2939
        return av_interleave_packet_per_dts(s, out, in, flush);
2940
}
2941

    
2942
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2943
    AVStream *st= s->streams[ pkt->stream_index];
2944

    
2945
    //FIXME/XXX/HACK drop zero sized packets
2946
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2947
        return 0;
2948

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

    
2953
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2954
        return -1;
2955

    
2956
    for(;;){
2957
        AVPacket opkt;
2958
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2959
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2960
            return ret;
2961

    
2962
        ret= s->oformat->write_packet(s, &opkt);
2963

    
2964
        av_free_packet(&opkt);
2965
        pkt= NULL;
2966

    
2967
        if(ret<0)
2968
            return ret;
2969
        if(url_ferror(s->pb))
2970
            return url_ferror(s->pb);
2971
    }
2972
}
2973

    
2974
int av_write_trailer(AVFormatContext *s)
2975
{
2976
    int ret, i;
2977

    
2978
    for(;;){
2979
        AVPacket pkt;
2980
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2981
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2982
            goto fail;
2983
        if(!ret)
2984
            break;
2985

    
2986
        ret= s->oformat->write_packet(s, &pkt);
2987

    
2988
        av_free_packet(&pkt);
2989

    
2990
        if(ret<0)
2991
            goto fail;
2992
        if(url_ferror(s->pb))
2993
            goto fail;
2994
    }
2995

    
2996
    if(s->oformat->write_trailer)
2997
        ret = s->oformat->write_trailer(s);
2998
fail:
2999
    if(ret == 0)
3000
       ret=url_ferror(s->pb);
3001
    for(i=0;i<s->nb_streams;i++) {
3002
        av_freep(&s->streams[i]->priv_data);
3003
        av_freep(&s->streams[i]->index_entries);
3004
    }
3005
    av_freep(&s->priv_data);
3006
    return ret;
3007
}
3008

    
3009
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3010
{
3011
    int i, j;
3012
    AVProgram *program=NULL;
3013
    void *tmp;
3014

    
3015
    if (idx >= ac->nb_streams) {
3016
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3017
        return;
3018
    }
3019

    
3020
    for(i=0; i<ac->nb_programs; i++){
3021
        if(ac->programs[i]->id != progid)
3022
            continue;
3023
        program = ac->programs[i];
3024
        for(j=0; j<program->nb_stream_indexes; j++)
3025
            if(program->stream_index[j] == idx)
3026
                return;
3027

    
3028
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3029
        if(!tmp)
3030
            return;
3031
        program->stream_index = tmp;
3032
        program->stream_index[program->nb_stream_indexes++] = idx;
3033
        return;
3034
    }
3035
}
3036

    
3037
static void print_fps(double d, const char *postfix){
3038
    uint64_t v= lrintf(d*100);
3039
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3040
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3041
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3042
}
3043

    
3044
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3045
{
3046
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3047
        AVMetadataTag *tag=NULL;
3048

    
3049
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3050
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3051
            if(strcmp("language", tag->key))
3052
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3053
        }
3054
    }
3055
}
3056

    
3057
/* "user interface" functions */
3058
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3059
{
3060
    char buf[256];
3061
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3062
    AVStream *st = ic->streams[i];
3063
    int g = av_gcd(st->time_base.num, st->time_base.den);
3064
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3065
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3066
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3067
    /* the pid is an important information, so we display it */
3068
    /* XXX: add a generic system */
3069
    if (flags & AVFMT_SHOW_IDS)
3070
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3071
    if (lang)
3072
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3073
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3074
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3075
    if (st->sample_aspect_ratio.num && // default
3076
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3077
        AVRational display_aspect_ratio;
3078
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3079
                  st->codec->width*st->sample_aspect_ratio.num,
3080
                  st->codec->height*st->sample_aspect_ratio.den,
3081
                  1024*1024);
3082
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3083
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3084
                 display_aspect_ratio.num, display_aspect_ratio.den);
3085
    }
3086
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3087
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3088
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3089
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3090
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3091
        if(st->time_base.den && st->time_base.num)
3092
            print_fps(1/av_q2d(st->time_base), "tbn");
3093
        if(st->codec->time_base.den && st->codec->time_base.num)
3094
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3095
    }
3096
    av_log(NULL, AV_LOG_INFO, "\n");
3097
    dump_metadata(NULL, st->metadata, "    ");
3098
}
3099

    
3100
void dump_format(AVFormatContext *ic,
3101
                 int index,
3102
                 const char *url,
3103
                 int is_output)
3104
{
3105
    int i;
3106
    uint8_t *printed = av_mallocz(ic->nb_streams);
3107
    if (ic->nb_streams && !printed)
3108
        return;
3109

    
3110
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3111
            is_output ? "Output" : "Input",
3112
            index,
3113
            is_output ? ic->oformat->name : ic->iformat->name,
3114
            is_output ? "to" : "from", url);
3115
    dump_metadata(NULL, ic->metadata, "  ");
3116
    if (!is_output) {
3117
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3118
        if (ic->duration != AV_NOPTS_VALUE) {
3119
            int hours, mins, secs, us;
3120
            secs = ic->duration / AV_TIME_BASE;
3121
            us = ic->duration % AV_TIME_BASE;
3122
            mins = secs / 60;
3123
            secs %= 60;
3124
            hours = mins / 60;
3125
            mins %= 60;
3126
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3127
                   (100 * us) / AV_TIME_BASE);
3128
        } else {
3129
            av_log(NULL, AV_LOG_INFO, "N/A");
3130
        }
3131
        if (ic->start_time != AV_NOPTS_VALUE) {
3132
            int secs, us;
3133
            av_log(NULL, AV_LOG_INFO, ", start: ");
3134
            secs = ic->start_time / AV_TIME_BASE;
3135
            us = ic->start_time % AV_TIME_BASE;
3136
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3137
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3138
        }
3139
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3140
        if (ic->bit_rate) {
3141
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3142
        } else {
3143
            av_log(NULL, AV_LOG_INFO, "N/A");
3144
        }
3145
        av_log(NULL, AV_LOG_INFO, "\n");
3146
    }
3147
    for (i = 0; i < ic->nb_chapters; i++) {
3148
        AVChapter *ch = ic->chapters[i];
3149
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3150
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3151
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3152

    
3153
        dump_metadata(NULL, ch->metadata, "    ");
3154
    }
3155
    if(ic->nb_programs) {
3156
        int j, k, total = 0;
3157
        for(j=0; j<ic->nb_programs; j++) {
3158
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3159
                                                  "name", NULL, 0);
3160
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3161
                   name ? name->value : "");
3162
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3163
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3164
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3165
                printed[ic->programs[j]->stream_index[k]] = 1;
3166
            }
3167
            total += ic->programs[j]->nb_stream_indexes;
3168
        }
3169
        if (total < ic->nb_streams)
3170
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3171
    }
3172
    for(i=0;i<ic->nb_streams;i++)
3173
        if (!printed[i])
3174
            dump_stream_format(ic, i, index, is_output);
3175

    
3176
    av_free(printed);
3177
}
3178

    
3179
#if LIBAVFORMAT_VERSION_MAJOR < 53
3180
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3181
{
3182
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
3183
}
3184

    
3185
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3186
{
3187
    AVRational frame_rate;
3188
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
3189
    *frame_rate_num= frame_rate.num;
3190
    *frame_rate_den= frame_rate.den;
3191
    return ret;
3192
}
3193
#endif
3194

    
3195
int64_t av_gettime(void)
3196
{
3197
    struct timeval tv;
3198
    gettimeofday(&tv,NULL);
3199
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3200
}
3201

    
3202
uint64_t ff_ntp_time(void)
3203
{
3204
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3205
}
3206

    
3207
int64_t parse_date(const char *datestr, int duration)
3208
{
3209
    const char *p;
3210
    int64_t t;
3211
    struct tm dt;
3212
    int i;
3213
    static const char * const date_fmt[] = {
3214
        "%Y-%m-%d",
3215
        "%Y%m%d",
3216
    };
3217
    static const char * const time_fmt[] = {
3218
        "%H:%M:%S",
3219
        "%H%M%S",
3220
    };
3221
    const char *q;
3222
    int is_utc, len;
3223
    char lastch;
3224
    int negative = 0;
3225

    
3226
#undef time
3227
    time_t now = time(0);
3228

    
3229
    len = strlen(datestr);
3230
    if (len > 0)
3231
        lastch = datestr[len - 1];
3232
    else
3233
        lastch = '\0';
3234
    is_utc = (lastch == 'z' || lastch == 'Z');
3235

    
3236
    memset(&dt, 0, sizeof(dt));
3237

    
3238
    p = datestr;
3239
    q = NULL;
3240
    if (!duration) {
3241
        if (!strncasecmp(datestr, "now", len))
3242
            return (int64_t) now * 1000000;
3243

    
3244
        /* parse the year-month-day part */
3245
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3246
            q = small_strptime(p, date_fmt[i], &dt);
3247
            if (q) {
3248
                break;
3249
            }
3250
        }
3251

    
3252
        /* if the year-month-day part is missing, then take the
3253
         * current year-month-day time */
3254
        if (!q) {
3255
            if (is_utc) {
3256
                dt = *gmtime(&now);
3257
            } else {
3258
                dt = *localtime(&now);
3259
            }
3260
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3261
        } else {
3262
            p = q;
3263
        }
3264

    
3265
        if (*p == 'T' || *p == 't' || *p == ' ')
3266
            p++;
3267

    
3268
        /* parse the hour-minute-second part */
3269
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3270
            q = small_strptime(p, time_fmt[i], &dt);
3271
            if (q) {
3272
                break;
3273
            }
3274
        }
3275
    } else {
3276
        /* parse datestr as a duration */
3277
        if (p[0] == '-') {
3278
            negative = 1;
3279
            ++p;
3280
        }
3281
        /* parse datestr as HH:MM:SS */
3282
        q = small_strptime(p, time_fmt[0], &dt);
3283
        if (!q) {
3284
            /* parse datestr as S+ */
3285
            dt.tm_sec = strtol(p, (char **)&q, 10);
3286
            if (q == p)
3287
                /* the parsing didn't succeed */
3288
                return INT64_MIN;
3289
            dt.tm_min = 0;
3290
            dt.tm_hour = 0;
3291
        }
3292
    }
3293

    
3294
    /* Now we have all the fields that we can get */
3295
    if (!q) {
3296
        return INT64_MIN;
3297
    }
3298

    
3299
    if (duration) {
3300
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3301
    } else {
3302
        dt.tm_isdst = -1;       /* unknown */
3303
        if (is_utc) {
3304
            t = mktimegm(&dt);
3305
        } else {
3306
            t = mktime(&dt);
3307
        }
3308
    }
3309

    
3310
    t *= 1000000;
3311

    
3312
    /* parse the .m... part */
3313
    if (*q == '.') {
3314
        int val, n;
3315
        q++;
3316
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3317
            if (!isdigit(*q))
3318
                break;
3319
            val += n * (*q - '0');
3320
        }
3321
        t += val;
3322
    }
3323
    return negative ? -t : t;
3324
}
3325

    
3326
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3327
{
3328
    const char *p;
3329
    char tag[128], *q;
3330

    
3331
    p = info;
3332
    if (*p == '?')
3333
        p++;
3334
    for(;;) {
3335
        q = tag;
3336
        while (*p != '\0' && *p != '=' && *p != '&') {
3337
            if ((q - tag) < sizeof(tag) - 1)
3338
                *q++ = *p;
3339
            p++;
3340
        }
3341
        *q = '\0';
3342
        q = arg;
3343
        if (*p == '=') {
3344
            p++;
3345
            while (*p != '&' && *p != '\0') {
3346
                if ((q - arg) < arg_size - 1) {
3347
                    if (*p == '+')
3348
                        *q++ = ' ';
3349
                    else
3350
                        *q++ = *p;
3351
                }
3352
                p++;
3353
            }
3354
            *q = '\0';
3355
        }
3356
        if (!strcmp(tag, tag1))
3357
            return 1;
3358
        if (*p != '&')
3359
            break;
3360
        p++;
3361
    }
3362
    return 0;
3363
}
3364

    
3365
int av_get_frame_filename(char *buf, int buf_size,
3366
                          const char *path, int number)
3367
{
3368
    const char *p;
3369
    char *q, buf1[20], c;
3370
    int nd, len, percentd_found;
3371

    
3372
    q = buf;
3373
    p = path;
3374
    percentd_found = 0;
3375
    for(;;) {
3376
        c = *p++;
3377
        if (c == '\0')
3378
            break;
3379
        if (c == '%') {
3380
            do {
3381
                nd = 0;
3382
                while (isdigit(*p)) {
3383
                    nd = nd * 10 + *p++ - '0';
3384
                }
3385
                c = *p++;
3386
            } while (isdigit(c));
3387

    
3388
            switch(c) {
3389
            case '%':
3390
                goto addchar;
3391
            case 'd':
3392
                if (percentd_found)
3393
                    goto fail;
3394
                percentd_found = 1;
3395
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3396
                len = strlen(buf1);
3397
                if ((q - buf + len) > buf_size - 1)
3398
                    goto fail;
3399
                memcpy(q, buf1, len);
3400
                q += len;
3401
                break;
3402
            default:
3403
                goto fail;
3404
            }
3405
        } else {
3406
        addchar:
3407
            if ((q - buf) < buf_size - 1)
3408
                *q++ = c;
3409
        }
3410
    }
3411
    if (!percentd_found)
3412
        goto fail;
3413
    *q = '\0';
3414
    return 0;
3415
 fail:
3416
    *q = '\0';
3417
    return -1;
3418
}
3419

    
3420
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3421
{
3422
    int len, i, j, c;
3423
#undef fprintf
3424
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3425

    
3426
    for(i=0;i<size;i+=16) {
3427
        len = size - i;
3428
        if (len > 16)
3429
            len = 16;
3430
        PRINT("%08x ", i);
3431
        for(j=0;j<16;j++) {
3432
            if (j < len)
3433
                PRINT(" %02x", buf[i+j]);
3434
            else
3435
                PRINT("   ");
3436
        }
3437
        PRINT(" ");
3438
        for(j=0;j<len;j++) {
3439
            c = buf[i+j];
3440
            if (c < ' ' || c > '~')
3441
                c = '.';
3442
            PRINT("%c", c);
3443
        }
3444
        PRINT("\n");
3445
    }
3446
#undef PRINT
3447
}
3448

    
3449
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3450
{
3451
    hex_dump_internal(NULL, f, 0, buf, size);
3452
}
3453

    
3454
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3455
{
3456
    hex_dump_internal(avcl, NULL, level, buf, size);
3457
}
3458

    
3459
 //FIXME needs to know the time_base
3460
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3461
{
3462
#undef fprintf
3463
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3464
    PRINT("stream #%d:\n", pkt->stream_index);
3465
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3466
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3467
    /* DTS is _always_ valid after av_read_frame() */
3468
    PRINT("  dts=");
3469
    if (pkt->dts == AV_NOPTS_VALUE)
3470
        PRINT("N/A");
3471
    else
3472
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3473
    /* PTS may not be known if B-frames are present. */
3474
    PRINT("  pts=");
3475
    if (pkt->pts == AV_NOPTS_VALUE)
3476
        PRINT("N/A");
3477
    else
3478
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3479
    PRINT("\n");
3480
    PRINT("  size=%d\n", pkt->size);
3481
#undef PRINT
3482
    if (dump_payload)
3483
        av_hex_dump(f, pkt->data, pkt->size);
3484
}
3485

    
3486
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3487
{
3488
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3489
}
3490

    
3491
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3492
{
3493
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3494
}
3495

    
3496
#if LIBAVFORMAT_VERSION_MAJOR < 53
3497
attribute_deprecated
3498
void ff_url_split(char *proto, int proto_size,
3499
                  char *authorization, int authorization_size,
3500
                  char *hostname, int hostname_size,
3501
                  int *port_ptr,
3502
                  char *path, int path_size,
3503
                  const char *url)
3504
{
3505
    av_url_split(proto, proto_size,
3506
                 authorization, authorization_size,
3507
                 hostname, hostname_size,
3508
                 port_ptr,
3509
                 path, path_size,
3510
                 url);
3511
}
3512
#endif
3513

    
3514
void av_url_split(char *proto, int proto_size,
3515
                  char *authorization, int authorization_size,
3516
                  char *hostname, int hostname_size,
3517
                  int *port_ptr,
3518
                  char *path, int path_size,
3519
                  const char *url)
3520
{
3521
    const char *p, *ls, *at, *col, *brk;
3522

    
3523
    if (port_ptr)               *port_ptr = -1;
3524
    if (proto_size > 0)         proto[0] = 0;
3525
    if (authorization_size > 0) authorization[0] = 0;
3526
    if (hostname_size > 0)      hostname[0] = 0;
3527
    if (path_size > 0)          path[0] = 0;
3528

    
3529
    /* parse protocol */
3530
    if ((p = strchr(url, ':'))) {
3531
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3532
        p++; /* skip ':' */
3533
        if (*p == '/') p++;
3534
        if (*p == '/') p++;
3535
    } else {
3536
        /* no protocol means plain filename */
3537
        av_strlcpy(path, url, path_size);
3538
        return;
3539
    }
3540

    
3541
    /* separate path from hostname */
3542
    ls = strchr(p, '/');
3543
    if(!ls)
3544
        ls = strchr(p, '?');
3545
    if(ls)
3546
        av_strlcpy(path, ls, path_size);
3547
    else
3548
        ls = &p[strlen(p)]; // XXX
3549

    
3550
    /* the rest is hostname, use that to parse auth/port */
3551
    if (ls != p) {
3552
        /* authorization (user[:pass]@hostname) */
3553
        if ((at = strchr(p, '@')) && at < ls) {
3554
            av_strlcpy(authorization, p,
3555
                       FFMIN(authorization_size, at + 1 - p));
3556
            p = at + 1; /* skip '@' */
3557
        }
3558

    
3559
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3560
            /* [host]:port */
3561
            av_strlcpy(hostname, p + 1,
3562
                       FFMIN(hostname_size, brk - p));
3563
            if (brk[1] == ':' && port_ptr)
3564
                *port_ptr = atoi(brk + 2);
3565
        } else if ((col = strchr(p, ':')) && col < ls) {
3566
            av_strlcpy(hostname, p,
3567
                       FFMIN(col + 1 - p, hostname_size));
3568
            if (port_ptr) *port_ptr = atoi(col + 1);
3569
        } else
3570
            av_strlcpy(hostname, p,
3571
                       FFMIN(ls + 1 - p, hostname_size));
3572
    }
3573
}
3574

    
3575
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3576
{
3577
    int i;
3578
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3579
                                           '4', '5', '6', '7',
3580
                                           '8', '9', 'A', 'B',
3581
                                           'C', 'D', 'E', 'F' };
3582
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3583
                                           '4', '5', '6', '7',
3584
                                           '8', '9', 'a', 'b',
3585
                                           'c', 'd', 'e', 'f' };
3586
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3587

    
3588
    for(i = 0; i < s; i++) {
3589
        buff[i * 2]     = hex_table[src[i] >> 4];
3590
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3591
    }
3592

    
3593
    return buff;
3594
}
3595

    
3596
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3597
                     unsigned int pts_num, unsigned int pts_den)
3598
{
3599
    s->pts_wrap_bits = pts_wrap_bits;
3600

    
3601
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3602
        if(s->time_base.num != pts_num)
3603
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3604
    }else
3605
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3606

    
3607
    if(!s->time_base.num || !s->time_base.den)
3608
        s->time_base.num= s->time_base.den= 0;
3609
}
3610

    
3611
int ff_url_join(char *str, int size, const char *proto,
3612
                const char *authorization, const char *hostname,
3613
                int port, const char *fmt, ...)
3614
{
3615
#if CONFIG_NETWORK
3616
    struct addrinfo hints, *ai;
3617
#endif
3618

    
3619
    str[0] = '\0';
3620
    if (proto)
3621
        av_strlcatf(str, size, "%s://", proto);
3622
    if (authorization && authorization[0])
3623
        av_strlcatf(str, size, "%s@", authorization);
3624
#if CONFIG_NETWORK && defined(AF_INET6)
3625
    /* Determine if hostname is a numerical IPv6 address,
3626
     * properly escape it within [] in that case. */
3627
    memset(&hints, 0, sizeof(hints));
3628
    hints.ai_flags = AI_NUMERICHOST;
3629
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3630
        if (ai->ai_family == AF_INET6) {
3631
            av_strlcat(str, "[", size);
3632
            av_strlcat(str, hostname, size);
3633
            av_strlcat(str, "]", size);
3634
        } else {
3635
            av_strlcat(str, hostname, size);
3636
        }
3637
        freeaddrinfo(ai);
3638
    } else
3639
#endif
3640
        /* Not an IPv6 address, just output the plain string. */
3641
        av_strlcat(str, hostname, size);
3642

    
3643
    if (port >= 0)
3644
        av_strlcatf(str, size, ":%d", port);
3645
    if (fmt) {
3646
        va_list vl;
3647
        int len = strlen(str);
3648

    
3649
        va_start(vl, fmt);
3650
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3651
        va_end(vl);
3652
    }
3653
    return strlen(str);
3654
}
3655

    
3656
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3657
                     AVFormatContext *src)
3658
{
3659
    AVPacket local_pkt;
3660

    
3661
    local_pkt = *pkt;
3662
    local_pkt.stream_index = dst_stream;
3663
    if (pkt->pts != AV_NOPTS_VALUE)
3664
        local_pkt.pts = av_rescale_q(pkt->pts,
3665
                                     src->streams[pkt->stream_index]->time_base,
3666
                                     dst->streams[dst_stream]->time_base);
3667
    if (pkt->dts != AV_NOPTS_VALUE)
3668
        local_pkt.dts = av_rescale_q(pkt->dts,
3669
                                     src->streams[pkt->stream_index]->time_base,
3670
                                     dst->streams[dst_stream]->time_base);
3671
    return av_write_frame(dst, &local_pkt);
3672
}
3673