Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ f9c399c4

History | View | Annotate | Download (118 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 FF_API_OLD_METADATA
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
                av_free(st->codec);
478
            }
479
            av_free(st);
480
        }
481
    }
482
    av_free(ic);
483
    *ic_ptr = NULL;
484
    return err;
485
}
486

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

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

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

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

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

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

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

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

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

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

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

    
555
    return ret;
556
}
557

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

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

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

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

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

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

    
620
}
621

    
622
/*******************************************************/
623

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

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

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

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

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

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

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

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

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

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

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

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

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

    
717
/**********************************************************/
718

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

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

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

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

    
748

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1035

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

    
1041
    av_init_packet(pkt);
1042

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

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

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

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

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

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

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

    
1178
    return 0;
1179
}
1180

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

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

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

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

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

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

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

    
1259
/*******************************************************/
1260
/* seek support */
1261

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

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

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

    
1289
    flush_packet_queue(s);
1290

    
1291
    s->cur_st = NULL;
1292

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

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

    
1309
        st->probe_packets = MAX_PROBE_PACKETS;
1310

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

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

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

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

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

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

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

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

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

    
1357
    st->index_entries= entries;
1358

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

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

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

    
1382
    return index;
1383
}
1384

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

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

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

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

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

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

    
1421
#define DEBUG_SEEK
1422

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

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

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

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

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

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

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

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

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

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

    
1484
    av_update_cur_dts(s, st, ts);
1485

    
1486
    return 0;
1487
}
1488

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1686
    return 0;
1687
}
1688

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

    
1694
    ff_read_frame_flush(s);
1695

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

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

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

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

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

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

    
1729
    ff_read_frame_flush(s);
1730

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

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

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

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

    
1746
/*******************************************************/
1747

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

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

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

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

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

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

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

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

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

    
1866
#define DURATION_MAX_READ_SIZE 250000
1867
#define DURATION_MAX_RETRY 3
1868

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

    
1879
    ic->cur_st = NULL;
1880

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

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

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

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

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

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

    
1940
    fill_all_stream_timings(ic);
1941

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

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

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

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

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

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

    
2023
static int has_decode_delay_been_guessed(AVStream *st)
2024
{
2025
    return st->codec->codec_id != CODEC_ID_H264 ||
2026
        st->codec_info_nb_frames >= 4 + st->codec->has_b_frames;
2027
}
2028

    
2029
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2030
{
2031
    int16_t *samples;
2032
    AVCodec *codec;
2033
    int got_picture, data_size, ret=0;
2034
    AVFrame picture;
2035

    
2036
    if(!st->codec->codec){
2037
        codec = avcodec_find_decoder(st->codec->codec_id);
2038
        if (!codec)
2039
            return -1;
2040
        ret = avcodec_open(st->codec, codec);
2041
        if (ret < 0)
2042
            return ret;
2043
    }
2044

    
2045
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2046
        switch(st->codec->codec_type) {
2047
        case AVMEDIA_TYPE_VIDEO:
2048
            avcodec_get_frame_defaults(&picture);
2049
            ret = avcodec_decode_video2(st->codec, &picture,
2050
                                        &got_picture, avpkt);
2051
            break;
2052
        case AVMEDIA_TYPE_AUDIO:
2053
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2054
            samples = av_malloc(data_size);
2055
            if (!samples)
2056
                goto fail;
2057
            ret = avcodec_decode_audio3(st->codec, samples,
2058
                                        &data_size, avpkt);
2059
            av_free(samples);
2060
            break;
2061
        default:
2062
            break;
2063
        }
2064
    }
2065
 fail:
2066
    return ret;
2067
}
2068

    
2069
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2070
{
2071
    while (tags->id != CODEC_ID_NONE) {
2072
        if (tags->id == id)
2073
            return tags->tag;
2074
        tags++;
2075
    }
2076
    return 0;
2077
}
2078

    
2079
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2080
{
2081
    int i;
2082
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2083
        if(tag == tags[i].tag)
2084
            return tags[i].id;
2085
    }
2086
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2087
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2088
            return tags[i].id;
2089
    }
2090
    return CODEC_ID_NONE;
2091
}
2092

    
2093
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2094
{
2095
    int i;
2096
    for(i=0; tags && tags[i]; i++){
2097
        int tag= ff_codec_get_tag(tags[i], id);
2098
        if(tag) return tag;
2099
    }
2100
    return 0;
2101
}
2102

    
2103
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2104
{
2105
    int i;
2106
    for(i=0; tags && tags[i]; i++){
2107
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2108
        if(id!=CODEC_ID_NONE) return id;
2109
    }
2110
    return CODEC_ID_NONE;
2111
}
2112

    
2113
static void compute_chapters_end(AVFormatContext *s)
2114
{
2115
    unsigned int i;
2116

    
2117
    for (i=0; i+1<s->nb_chapters; i++)
2118
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2119
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2120
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2121
            s->chapters[i]->end = s->chapters[i+1]->start;
2122
        }
2123

    
2124
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2125
        assert(s->start_time != AV_NOPTS_VALUE);
2126
        assert(s->duration > 0);
2127
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2128
                                           AV_TIME_BASE_Q,
2129
                                           s->chapters[i]->time_base);
2130
    }
2131
}
2132

    
2133
#define MAX_STD_TIMEBASES (60*12+5)
2134
static int get_std_framerate(int i){
2135
    if(i<60*12) return i*1001;
2136
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2137
}
2138

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

    
2159
int av_find_stream_info(AVFormatContext *ic)
2160
{
2161
    int i, count, ret, read_size, j;
2162
    AVStream *st;
2163
    AVPacket pkt1, *pkt;
2164
    int64_t last_dts[MAX_STREAMS];
2165
    int64_t duration_gcd[MAX_STREAMS]={0};
2166
    int duration_count[MAX_STREAMS]={0};
2167
    double (*duration_error)[MAX_STD_TIMEBASES];
2168
    int64_t old_offset = url_ftell(ic->pb);
2169
    int64_t codec_info_duration[MAX_STREAMS]={0};
2170

    
2171
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2172
    if (!duration_error) return AVERROR(ENOMEM);
2173

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

    
2203
    for(i=0;i<MAX_STREAMS;i++){
2204
        last_dts[i]= AV_NOPTS_VALUE;
2205
    }
2206

    
2207
    count = 0;
2208
    read_size = 0;
2209
    for(;;) {
2210
        if(url_interrupt_cb()){
2211
            ret= AVERROR(EINTR);
2212
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2213
            break;
2214
        }
2215

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

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

    
2269
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2270
        if(av_dup_packet(pkt) < 0) {
2271
            av_free(duration_error);
2272
            return AVERROR(ENOMEM);
2273
        }
2274

    
2275
        read_size += pkt->size;
2276

    
2277
        st = ic->streams[pkt->stream_index];
2278
        if(st->codec_info_nb_frames>1) {
2279
            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){
2280
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2281
                break;
2282
            }
2283
            codec_info_duration[st->index] += pkt->duration;
2284
        }
2285
        {
2286
            int index= pkt->stream_index;
2287
            int64_t last= last_dts[index];
2288
            int64_t duration= pkt->dts - last;
2289

    
2290
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2291
                double dur= duration * av_q2d(st->time_base);
2292

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

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

    
2328
        st->codec_info_nb_frames++;
2329
        count++;
2330
    }
2331

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

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

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

    
2375
            if (!st->r_frame_rate.num){
2376
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2377
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2378
                    st->r_frame_rate.num = st->codec->time_base.den;
2379
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2380
                }else{
2381
                    st->r_frame_rate.num = st->time_base.den;
2382
                    st->r_frame_rate.den = st->time_base.num;
2383
                }
2384
            }
2385
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2386
            if(!st->codec->bits_per_coded_sample)
2387
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2388
        }
2389
    }
2390

    
2391
    av_estimate_timings(ic, old_offset);
2392

    
2393
    compute_chapters_end(ic);
2394

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

    
2420
    av_free(duration_error);
2421

    
2422
    return ret;
2423
}
2424

    
2425
/*******************************************************/
2426

    
2427
int av_read_play(AVFormatContext *s)
2428
{
2429
    if (s->iformat->read_play)
2430
        return s->iformat->read_play(s);
2431
    if (s->pb)
2432
        return av_url_read_fpause(s->pb, 0);
2433
    return AVERROR(ENOSYS);
2434
}
2435

    
2436
int av_read_pause(AVFormatContext *s)
2437
{
2438
    if (s->iformat->read_pause)
2439
        return s->iformat->read_pause(s);
2440
    if (s->pb)
2441
        return av_url_read_fpause(s->pb, 1);
2442
    return AVERROR(ENOSYS);
2443
}
2444

    
2445
void av_close_input_stream(AVFormatContext *s)
2446
{
2447
    int i;
2448
    AVStream *st;
2449

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

    
2493
void av_close_input_file(AVFormatContext *s)
2494
{
2495
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2496
    av_close_input_stream(s);
2497
    if (pb)
2498
        url_fclose(pb);
2499
}
2500

    
2501
AVStream *av_new_stream(AVFormatContext *s, int id)
2502
{
2503
    AVStream *st;
2504
    int i;
2505

    
2506
    if (s->nb_streams >= MAX_STREAMS){
2507
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2508
        return NULL;
2509
    }
2510

    
2511
    st = av_mallocz(sizeof(AVStream));
2512
    if (!st)
2513
        return NULL;
2514

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

    
2532
    /* default pts setting is MPEG-like */
2533
    av_set_pts_info(st, 33, 1, 90000);
2534
    st->last_IP_pts = AV_NOPTS_VALUE;
2535
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2536
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2537
    st->reference_dts = AV_NOPTS_VALUE;
2538

    
2539
    st->sample_aspect_ratio = (AVRational){0,1};
2540

    
2541
    s->streams[s->nb_streams++] = st;
2542
    return st;
2543
}
2544

    
2545
AVProgram *av_new_program(AVFormatContext *ac, int id)
2546
{
2547
    AVProgram *program=NULL;
2548
    int i;
2549

    
2550
#ifdef DEBUG_SI
2551
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2552
#endif
2553

    
2554
    for(i=0; i<ac->nb_programs; i++)
2555
        if(ac->programs[i]->id == id)
2556
            program = ac->programs[i];
2557

    
2558
    if(!program){
2559
        program = av_mallocz(sizeof(AVProgram));
2560
        if (!program)
2561
            return NULL;
2562
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2563
        program->discard = AVDISCARD_NONE;
2564
    }
2565
    program->id = id;
2566

    
2567
    return program;
2568
}
2569

    
2570
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2571
{
2572
    AVChapter *chapter = NULL;
2573
    int i;
2574

    
2575
    for(i=0; i<s->nb_chapters; i++)
2576
        if(s->chapters[i]->id == id)
2577
            chapter = s->chapters[i];
2578

    
2579
    if(!chapter){
2580
        chapter= av_mallocz(sizeof(AVChapter));
2581
        if(!chapter)
2582
            return NULL;
2583
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2584
    }
2585
#if FF_API_OLD_METADATA
2586
    av_free(chapter->title);
2587
#endif
2588
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2589
    chapter->id    = id;
2590
    chapter->time_base= time_base;
2591
    chapter->start = start;
2592
    chapter->end   = end;
2593

    
2594
    return chapter;
2595
}
2596

    
2597
/************************************************************/
2598
/* output media file */
2599

    
2600
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2601
{
2602
    int ret;
2603

    
2604
    if (s->oformat->priv_data_size > 0) {
2605
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2606
        if (!s->priv_data)
2607
            return AVERROR(ENOMEM);
2608
    } else
2609
        s->priv_data = NULL;
2610

    
2611
    if (s->oformat->set_parameters) {
2612
        ret = s->oformat->set_parameters(s, ap);
2613
        if (ret < 0)
2614
            return ret;
2615
    }
2616
    return 0;
2617
}
2618

    
2619
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2620
{
2621
    const AVCodecTag *avctag;
2622
    int n;
2623
    enum CodecID id = CODEC_ID_NONE;
2624
    unsigned int tag = 0;
2625

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

    
2652
int av_write_header(AVFormatContext *s)
2653
{
2654
    int ret, i;
2655
    AVStream *st;
2656

    
2657
    // some sanity checks
2658
    if (s->nb_streams == 0) {
2659
        av_log(s, AV_LOG_ERROR, "no streams\n");
2660
        return AVERROR(EINVAL);
2661
    }
2662

    
2663
    for(i=0;i<s->nb_streams;i++) {
2664
        st = s->streams[i];
2665

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

    
2692
        if(s->oformat->codec_tag){
2693
            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)){
2694
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2695
                st->codec->codec_tag= 0;
2696
            }
2697
            if(st->codec->codec_tag){
2698
                if (!validate_codec_tag(s, st)) {
2699
                    char tagbuf[32];
2700
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2701
                    av_log(s, AV_LOG_ERROR,
2702
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2703
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2704
                    return AVERROR_INVALIDDATA;
2705
                }
2706
            }else
2707
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2708
        }
2709

    
2710
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2711
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2712
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2713
    }
2714

    
2715
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2716
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2717
        if (!s->priv_data)
2718
            return AVERROR(ENOMEM);
2719
    }
2720

    
2721
#if FF_API_OLD_METADATA
2722
    ff_metadata_mux_compat(s);
2723
#endif
2724

    
2725
    /* set muxer identification string */
2726
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2727
        AVMetadata *m;
2728
        AVMetadataTag *t;
2729

    
2730
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2731
            return AVERROR(ENOMEM);
2732
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2733
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2734
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2735
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2736
        av_metadata_free(&m);
2737
    }
2738

    
2739
    if(s->oformat->write_header){
2740
        ret = s->oformat->write_header(s);
2741
        if (ret < 0)
2742
            return ret;
2743
    }
2744

    
2745
    /* init PTS generation */
2746
    for(i=0;i<s->nb_streams;i++) {
2747
        int64_t den = AV_NOPTS_VALUE;
2748
        st = s->streams[i];
2749

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

    
2769
//FIXME merge with compute_pkt_fields
2770
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2771
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2772
    int num, den, frame_size, i;
2773

    
2774
//    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);
2775

    
2776
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2777
        return -1;*/
2778

    
2779
    /* duration field */
2780
    if (pkt->duration == 0) {
2781
        compute_frame_duration(&num, &den, st, NULL, pkt);
2782
        if (den && num) {
2783
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2784
        }
2785
    }
2786

    
2787
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2788
        pkt->pts= pkt->dts;
2789

    
2790
    //XXX/FIXME this is a temporary hack until all encoders output pts
2791
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2792
        pkt->dts=
2793
//        pkt->pts= st->cur_dts;
2794
        pkt->pts= st->pts.val;
2795
    }
2796

    
2797
    //calculate dts from pts
2798
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2799
        st->pts_buffer[0]= pkt->pts;
2800
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2801
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2802
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2803
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2804

    
2805
        pkt->dts= st->pts_buffer[0];
2806
    }
2807

    
2808
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2809
        av_log(s, AV_LOG_ERROR,
2810
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2811
               st->index, st->cur_dts, pkt->dts);
2812
        return -1;
2813
    }
2814
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2815
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2816
        return -1;
2817
    }
2818

    
2819
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2820
    st->cur_dts= pkt->dts;
2821
    st->pts.val= pkt->dts;
2822

    
2823
    /* update pts */
2824
    switch (st->codec->codec_type) {
2825
    case AVMEDIA_TYPE_AUDIO:
2826
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2827

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

    
2844
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2845
{
2846
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2847

    
2848
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2849
        return ret;
2850

    
2851
    ret= s->oformat->write_packet(s, pkt);
2852
    if(!ret)
2853
        ret= url_ferror(s->pb);
2854
    return ret;
2855
}
2856

    
2857
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2858
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2859
{
2860
    AVPacketList **next_point, *this_pktl;
2861

    
2862
    this_pktl = av_mallocz(sizeof(AVPacketList));
2863
    this_pktl->pkt= *pkt;
2864
    pkt->destruct= NULL;             // do not free original but only the copy
2865
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2866

    
2867
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2868
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2869
    }else
2870
        next_point = &s->packet_buffer;
2871

    
2872
    if(*next_point){
2873
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2874
            while(!compare(s, &(*next_point)->pkt, pkt)){
2875
                next_point= &(*next_point)->next;
2876
            }
2877
            goto next_non_null;
2878
        }else{
2879
            next_point = &(s->packet_buffer_end->next);
2880
        }
2881
    }
2882
    assert(!*next_point);
2883

    
2884
    s->packet_buffer_end= this_pktl;
2885
next_non_null:
2886

    
2887
    this_pktl->next= *next_point;
2888

    
2889
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2890
    *next_point= this_pktl;
2891
}
2892

    
2893
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2894
{
2895
    AVStream *st = s->streams[ pkt ->stream_index];
2896
    AVStream *st2= s->streams[ next->stream_index];
2897
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2898
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2899
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2900
}
2901

    
2902
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2903
    AVPacketList *pktl;
2904
    int stream_count=0;
2905
    int i;
2906

    
2907
    if(pkt){
2908
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2909
    }
2910

    
2911
    for(i=0; i < s->nb_streams; i++)
2912
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2913

    
2914
    if(stream_count && (s->nb_streams == stream_count || flush)){
2915
        pktl= s->packet_buffer;
2916
        *out= pktl->pkt;
2917

    
2918
        s->packet_buffer= pktl->next;
2919
        if(!s->packet_buffer)
2920
            s->packet_buffer_end= NULL;
2921

    
2922
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2923
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2924
        av_freep(&pktl);
2925
        return 1;
2926
    }else{
2927
        av_init_packet(out);
2928
        return 0;
2929
    }
2930
}
2931

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

    
2948
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2949
    AVStream *st= s->streams[ pkt->stream_index];
2950

    
2951
    //FIXME/XXX/HACK drop zero sized packets
2952
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2953
        return 0;
2954

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

    
2959
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2960
        return -1;
2961

    
2962
    for(;;){
2963
        AVPacket opkt;
2964
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2965
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2966
            return ret;
2967

    
2968
        ret= s->oformat->write_packet(s, &opkt);
2969

    
2970
        av_free_packet(&opkt);
2971
        pkt= NULL;
2972

    
2973
        if(ret<0)
2974
            return ret;
2975
        if(url_ferror(s->pb))
2976
            return url_ferror(s->pb);
2977
    }
2978
}
2979

    
2980
int av_write_trailer(AVFormatContext *s)
2981
{
2982
    int ret, i;
2983

    
2984
    for(;;){
2985
        AVPacket pkt;
2986
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2987
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2988
            goto fail;
2989
        if(!ret)
2990
            break;
2991

    
2992
        ret= s->oformat->write_packet(s, &pkt);
2993

    
2994
        av_free_packet(&pkt);
2995

    
2996
        if(ret<0)
2997
            goto fail;
2998
        if(url_ferror(s->pb))
2999
            goto fail;
3000
    }
3001

    
3002
    if(s->oformat->write_trailer)
3003
        ret = s->oformat->write_trailer(s);
3004
fail:
3005
    if(ret == 0)
3006
       ret=url_ferror(s->pb);
3007
    for(i=0;i<s->nb_streams;i++) {
3008
        av_freep(&s->streams[i]->priv_data);
3009
        av_freep(&s->streams[i]->index_entries);
3010
    }
3011
    av_freep(&s->priv_data);
3012
    return ret;
3013
}
3014

    
3015
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3016
{
3017
    int i, j;
3018
    AVProgram *program=NULL;
3019
    void *tmp;
3020

    
3021
    if (idx >= ac->nb_streams) {
3022
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3023
        return;
3024
    }
3025

    
3026
    for(i=0; i<ac->nb_programs; i++){
3027
        if(ac->programs[i]->id != progid)
3028
            continue;
3029
        program = ac->programs[i];
3030
        for(j=0; j<program->nb_stream_indexes; j++)
3031
            if(program->stream_index[j] == idx)
3032
                return;
3033

    
3034
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3035
        if(!tmp)
3036
            return;
3037
        program->stream_index = tmp;
3038
        program->stream_index[program->nb_stream_indexes++] = idx;
3039
        return;
3040
    }
3041
}
3042

    
3043
static void print_fps(double d, const char *postfix){
3044
    uint64_t v= lrintf(d*100);
3045
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3046
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3047
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3048
}
3049

    
3050
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3051
{
3052
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3053
        AVMetadataTag *tag=NULL;
3054

    
3055
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3056
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3057
            if(strcmp("language", tag->key))
3058
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3059
        }
3060
    }
3061
}
3062

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

    
3106
void dump_format(AVFormatContext *ic,
3107
                 int index,
3108
                 const char *url,
3109
                 int is_output)
3110
{
3111
    int i;
3112
    uint8_t *printed = av_mallocz(ic->nb_streams);
3113
    if (ic->nb_streams && !printed)
3114
        return;
3115

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

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

    
3182
    av_free(printed);
3183
}
3184

    
3185
#if LIBAVFORMAT_VERSION_MAJOR < 53
3186
#include "libavcore/parseutils.h"
3187

    
3188
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3189
{
3190
    return av_parse_video_size(width_ptr, height_ptr, str);
3191
}
3192

    
3193
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3194
{
3195
    AVRational frame_rate;
3196
    int ret = av_parse_video_rate(&frame_rate, arg);
3197
    *frame_rate_num= frame_rate.num;
3198
    *frame_rate_den= frame_rate.den;
3199
    return ret;
3200
}
3201
#endif
3202

    
3203
int64_t av_gettime(void)
3204
{
3205
    struct timeval tv;
3206
    gettimeofday(&tv,NULL);
3207
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3208
}
3209

    
3210
uint64_t ff_ntp_time(void)
3211
{
3212
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3213
}
3214

    
3215
int64_t parse_date(const char *datestr, int duration)
3216
{
3217
    const char *p;
3218
    int64_t t;
3219
    struct tm dt;
3220
    int i;
3221
    static const char * const date_fmt[] = {
3222
        "%Y-%m-%d",
3223
        "%Y%m%d",
3224
    };
3225
    static const char * const time_fmt[] = {
3226
        "%H:%M:%S",
3227
        "%H%M%S",
3228
    };
3229
    const char *q;
3230
    int is_utc, len;
3231
    char lastch;
3232
    int negative = 0;
3233

    
3234
#undef time
3235
    time_t now = time(0);
3236

    
3237
    len = strlen(datestr);
3238
    if (len > 0)
3239
        lastch = datestr[len - 1];
3240
    else
3241
        lastch = '\0';
3242
    is_utc = (lastch == 'z' || lastch == 'Z');
3243

    
3244
    memset(&dt, 0, sizeof(dt));
3245

    
3246
    p = datestr;
3247
    q = NULL;
3248
    if (!duration) {
3249
        if (!strncasecmp(datestr, "now", len))
3250
            return (int64_t) now * 1000000;
3251

    
3252
        /* parse the year-month-day part */
3253
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3254
            q = small_strptime(p, date_fmt[i], &dt);
3255
            if (q) {
3256
                break;
3257
            }
3258
        }
3259

    
3260
        /* if the year-month-day part is missing, then take the
3261
         * current year-month-day time */
3262
        if (!q) {
3263
            if (is_utc) {
3264
                dt = *gmtime(&now);
3265
            } else {
3266
                dt = *localtime(&now);
3267
            }
3268
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3269
        } else {
3270
            p = q;
3271
        }
3272

    
3273
        if (*p == 'T' || *p == 't' || *p == ' ')
3274
            p++;
3275

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

    
3302
    /* Now we have all the fields that we can get */
3303
    if (!q) {
3304
        return INT64_MIN;
3305
    }
3306

    
3307
    if (duration) {
3308
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3309
    } else {
3310
        dt.tm_isdst = -1;       /* unknown */
3311
        if (is_utc) {
3312
            t = mktimegm(&dt);
3313
        } else {
3314
            t = mktime(&dt);
3315
        }
3316
    }
3317

    
3318
    t *= 1000000;
3319

    
3320
    /* parse the .m... part */
3321
    if (*q == '.') {
3322
        int val, n;
3323
        q++;
3324
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3325
            if (!isdigit(*q))
3326
                break;
3327
            val += n * (*q - '0');
3328
        }
3329
        t += val;
3330
    }
3331
    return negative ? -t : t;
3332
}
3333

    
3334
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3335
{
3336
    const char *p;
3337
    char tag[128], *q;
3338

    
3339
    p = info;
3340
    if (*p == '?')
3341
        p++;
3342
    for(;;) {
3343
        q = tag;
3344
        while (*p != '\0' && *p != '=' && *p != '&') {
3345
            if ((q - tag) < sizeof(tag) - 1)
3346
                *q++ = *p;
3347
            p++;
3348
        }
3349
        *q = '\0';
3350
        q = arg;
3351
        if (*p == '=') {
3352
            p++;
3353
            while (*p != '&' && *p != '\0') {
3354
                if ((q - arg) < arg_size - 1) {
3355
                    if (*p == '+')
3356
                        *q++ = ' ';
3357
                    else
3358
                        *q++ = *p;
3359
                }
3360
                p++;
3361
            }
3362
            *q = '\0';
3363
        }
3364
        if (!strcmp(tag, tag1))
3365
            return 1;
3366
        if (*p != '&')
3367
            break;
3368
        p++;
3369
    }
3370
    return 0;
3371
}
3372

    
3373
int av_get_frame_filename(char *buf, int buf_size,
3374
                          const char *path, int number)
3375
{
3376
    const char *p;
3377
    char *q, buf1[20], c;
3378
    int nd, len, percentd_found;
3379

    
3380
    q = buf;
3381
    p = path;
3382
    percentd_found = 0;
3383
    for(;;) {
3384
        c = *p++;
3385
        if (c == '\0')
3386
            break;
3387
        if (c == '%') {
3388
            do {
3389
                nd = 0;
3390
                while (isdigit(*p)) {
3391
                    nd = nd * 10 + *p++ - '0';
3392
                }
3393
                c = *p++;
3394
            } while (isdigit(c));
3395

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

    
3428
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3429
{
3430
    int len, i, j, c;
3431
#undef fprintf
3432
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3433

    
3434
    for(i=0;i<size;i+=16) {
3435
        len = size - i;
3436
        if (len > 16)
3437
            len = 16;
3438
        PRINT("%08x ", i);
3439
        for(j=0;j<16;j++) {
3440
            if (j < len)
3441
                PRINT(" %02x", buf[i+j]);
3442
            else
3443
                PRINT("   ");
3444
        }
3445
        PRINT(" ");
3446
        for(j=0;j<len;j++) {
3447
            c = buf[i+j];
3448
            if (c < ' ' || c > '~')
3449
                c = '.';
3450
            PRINT("%c", c);
3451
        }
3452
        PRINT("\n");
3453
    }
3454
#undef PRINT
3455
}
3456

    
3457
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3458
{
3459
    hex_dump_internal(NULL, f, 0, buf, size);
3460
}
3461

    
3462
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3463
{
3464
    hex_dump_internal(avcl, NULL, level, buf, size);
3465
}
3466

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

    
3494
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3495
{
3496
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3497
}
3498

    
3499
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3500
{
3501
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3502
}
3503

    
3504
#if LIBAVFORMAT_VERSION_MAJOR < 53
3505
attribute_deprecated
3506
void ff_url_split(char *proto, int proto_size,
3507
                  char *authorization, int authorization_size,
3508
                  char *hostname, int hostname_size,
3509
                  int *port_ptr,
3510
                  char *path, int path_size,
3511
                  const char *url)
3512
{
3513
    av_url_split(proto, proto_size,
3514
                 authorization, authorization_size,
3515
                 hostname, hostname_size,
3516
                 port_ptr,
3517
                 path, path_size,
3518
                 url);
3519
}
3520
#endif
3521

    
3522
void av_url_split(char *proto, int proto_size,
3523
                  char *authorization, int authorization_size,
3524
                  char *hostname, int hostname_size,
3525
                  int *port_ptr,
3526
                  char *path, int path_size,
3527
                  const char *url)
3528
{
3529
    const char *p, *ls, *at, *col, *brk;
3530

    
3531
    if (port_ptr)               *port_ptr = -1;
3532
    if (proto_size > 0)         proto[0] = 0;
3533
    if (authorization_size > 0) authorization[0] = 0;
3534
    if (hostname_size > 0)      hostname[0] = 0;
3535
    if (path_size > 0)          path[0] = 0;
3536

    
3537
    /* parse protocol */
3538
    if ((p = strchr(url, ':'))) {
3539
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3540
        p++; /* skip ':' */
3541
        if (*p == '/') p++;
3542
        if (*p == '/') p++;
3543
    } else {
3544
        /* no protocol means plain filename */
3545
        av_strlcpy(path, url, path_size);
3546
        return;
3547
    }
3548

    
3549
    /* separate path from hostname */
3550
    ls = strchr(p, '/');
3551
    if(!ls)
3552
        ls = strchr(p, '?');
3553
    if(ls)
3554
        av_strlcpy(path, ls, path_size);
3555
    else
3556
        ls = &p[strlen(p)]; // XXX
3557

    
3558
    /* the rest is hostname, use that to parse auth/port */
3559
    if (ls != p) {
3560
        /* authorization (user[:pass]@hostname) */
3561
        if ((at = strchr(p, '@')) && at < ls) {
3562
            av_strlcpy(authorization, p,
3563
                       FFMIN(authorization_size, at + 1 - p));
3564
            p = at + 1; /* skip '@' */
3565
        }
3566

    
3567
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3568
            /* [host]:port */
3569
            av_strlcpy(hostname, p + 1,
3570
                       FFMIN(hostname_size, brk - p));
3571
            if (brk[1] == ':' && port_ptr)
3572
                *port_ptr = atoi(brk + 2);
3573
        } else if ((col = strchr(p, ':')) && col < ls) {
3574
            av_strlcpy(hostname, p,
3575
                       FFMIN(col + 1 - p, hostname_size));
3576
            if (port_ptr) *port_ptr = atoi(col + 1);
3577
        } else
3578
            av_strlcpy(hostname, p,
3579
                       FFMIN(ls + 1 - p, hostname_size));
3580
    }
3581
}
3582

    
3583
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3584
{
3585
    int i;
3586
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3587
                                           '4', '5', '6', '7',
3588
                                           '8', '9', 'A', 'B',
3589
                                           'C', 'D', 'E', 'F' };
3590
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3591
                                           '4', '5', '6', '7',
3592
                                           '8', '9', 'a', 'b',
3593
                                           'c', 'd', 'e', 'f' };
3594
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3595

    
3596
    for(i = 0; i < s; i++) {
3597
        buff[i * 2]     = hex_table[src[i] >> 4];
3598
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3599
    }
3600

    
3601
    return buff;
3602
}
3603

    
3604
int ff_hex_to_data(uint8_t *data, const char *p)
3605
{
3606
    int c, len, v;
3607

    
3608
    len = 0;
3609
    v = 1;
3610
    for (;;) {
3611
        p += strspn(p, SPACE_CHARS);
3612
        if (*p == '\0')
3613
            break;
3614
        c = toupper((unsigned char) *p++);
3615
        if (c >= '0' && c <= '9')
3616
            c = c - '0';
3617
        else if (c >= 'A' && c <= 'F')
3618
            c = c - 'A' + 10;
3619
        else
3620
            break;
3621
        v = (v << 4) | c;
3622
        if (v & 0x100) {
3623
            if (data)
3624
                data[len] = v;
3625
            len++;
3626
            v = 1;
3627
        }
3628
    }
3629
    return len;
3630
}
3631

    
3632
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3633
                     unsigned int pts_num, unsigned int pts_den)
3634
{
3635
    s->pts_wrap_bits = pts_wrap_bits;
3636

    
3637
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3638
        if(s->time_base.num != pts_num)
3639
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3640
    }else
3641
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3642

    
3643
    if(!s->time_base.num || !s->time_base.den)
3644
        s->time_base.num= s->time_base.den= 0;
3645
}
3646

    
3647
int ff_url_join(char *str, int size, const char *proto,
3648
                const char *authorization, const char *hostname,
3649
                int port, const char *fmt, ...)
3650
{
3651
#if CONFIG_NETWORK
3652
    struct addrinfo hints, *ai;
3653
#endif
3654

    
3655
    str[0] = '\0';
3656
    if (proto)
3657
        av_strlcatf(str, size, "%s://", proto);
3658
    if (authorization && authorization[0])
3659
        av_strlcatf(str, size, "%s@", authorization);
3660
#if CONFIG_NETWORK && defined(AF_INET6)
3661
    /* Determine if hostname is a numerical IPv6 address,
3662
     * properly escape it within [] in that case. */
3663
    memset(&hints, 0, sizeof(hints));
3664
    hints.ai_flags = AI_NUMERICHOST;
3665
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3666
        if (ai->ai_family == AF_INET6) {
3667
            av_strlcat(str, "[", size);
3668
            av_strlcat(str, hostname, size);
3669
            av_strlcat(str, "]", size);
3670
        } else {
3671
            av_strlcat(str, hostname, size);
3672
        }
3673
        freeaddrinfo(ai);
3674
    } else
3675
#endif
3676
        /* Not an IPv6 address, just output the plain string. */
3677
        av_strlcat(str, hostname, size);
3678

    
3679
    if (port >= 0)
3680
        av_strlcatf(str, size, ":%d", port);
3681
    if (fmt) {
3682
        va_list vl;
3683
        int len = strlen(str);
3684

    
3685
        va_start(vl, fmt);
3686
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3687
        va_end(vl);
3688
    }
3689
    return strlen(str);
3690
}
3691

    
3692
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3693
                     AVFormatContext *src)
3694
{
3695
    AVPacket local_pkt;
3696

    
3697
    local_pkt = *pkt;
3698
    local_pkt.stream_index = dst_stream;
3699
    if (pkt->pts != AV_NOPTS_VALUE)
3700
        local_pkt.pts = av_rescale_q(pkt->pts,
3701
                                     src->streams[pkt->stream_index]->time_base,
3702
                                     dst->streams[dst_stream]->time_base);
3703
    if (pkt->dts != AV_NOPTS_VALUE)
3704
        local_pkt.dts = av_rescale_q(pkt->dts,
3705
                                     src->streams[pkt->stream_index]->time_base,
3706
                                     dst->streams[dst_stream]->time_base);
3707
    return av_write_frame(dst, &local_pkt);
3708
}
3709

    
3710
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3711
                        void *context)
3712
{
3713
    const char *ptr = str;
3714

    
3715
    /* Parse key=value pairs. */
3716
    for (;;) {
3717
        const char *key;
3718
        char *dest = NULL, *dest_end;
3719
        int key_len, dest_len = 0;
3720

    
3721
        /* Skip whitespace and potential commas. */
3722
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3723
            ptr++;
3724
        if (!*ptr)
3725
            break;
3726

    
3727
        key = ptr;
3728

    
3729
        if (!(ptr = strchr(key, '=')))
3730
            break;
3731
        ptr++;
3732
        key_len = ptr - key;
3733

    
3734
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3735
        dest_end = dest + dest_len - 1;
3736

    
3737
        if (*ptr == '\"') {
3738
            ptr++;
3739
            while (*ptr && *ptr != '\"') {
3740
                if (*ptr == '\\') {
3741
                    if (!ptr[1])
3742
                        break;
3743
                    if (dest && dest < dest_end)
3744
                        *dest++ = ptr[1];
3745
                    ptr += 2;
3746
                } else {
3747
                    if (dest && dest < dest_end)
3748
                        *dest++ = *ptr;
3749
                    ptr++;
3750
                }
3751
            }
3752
            if (*ptr == '\"')
3753
                ptr++;
3754
        } else {
3755
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3756
                if (dest && dest < dest_end)
3757
                    *dest++ = *ptr;
3758
        }
3759
        if (dest)
3760
            *dest = 0;
3761
    }
3762
}
3763