Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 6ed04040

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 "libavutil/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 old_offset = url_ftell(ic->pb);
2165
    struct {
2166
        int64_t last_dts;
2167
        int64_t duration_gcd;
2168
        int duration_count;
2169
        double duration_error[MAX_STD_TIMEBASES];
2170
        int64_t codec_info_duration;
2171
    } info[MAX_STREAMS] = {{0}};
2172

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

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

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

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

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

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

    
2273
        read_size += pkt->size;
2274

    
2275
        st = ic->streams[pkt->stream_index];
2276
        if(st->codec_info_nb_frames>1) {
2277
            if (st->time_base.den > 0 && av_rescale_q(info[st->index].codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
2278
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2279
                break;
2280
            }
2281
            info[st->index].codec_info_duration += pkt->duration;
2282
        }
2283
        {
2284
            int index= pkt->stream_index;
2285
            int64_t last= info[index].last_dts;
2286
            int64_t duration= pkt->dts - last;
2287

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

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

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

    
2326
        st->codec_info_nb_frames++;
2327
        count++;
2328
    }
2329

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

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

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

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

    
2389
    av_estimate_timings(ic, old_offset);
2390

    
2391
    compute_chapters_end(ic);
2392

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

    
2418
    return ret;
2419
}
2420

    
2421
/*******************************************************/
2422

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

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

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

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

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

    
2498
AVStream *av_new_stream(AVFormatContext *s, int id)
2499
{
2500
    AVStream *st;
2501
    int i;
2502

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

    
2508
    st = av_mallocz(sizeof(AVStream));
2509
    if (!st)
2510
        return NULL;
2511

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

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

    
2536
    st->sample_aspect_ratio = (AVRational){0,1};
2537

    
2538
    s->streams[s->nb_streams++] = st;
2539
    return st;
2540
}
2541

    
2542
AVProgram *av_new_program(AVFormatContext *ac, int id)
2543
{
2544
    AVProgram *program=NULL;
2545
    int i;
2546

    
2547
#ifdef DEBUG_SI
2548
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2549
#endif
2550

    
2551
    for(i=0; i<ac->nb_programs; i++)
2552
        if(ac->programs[i]->id == id)
2553
            program = ac->programs[i];
2554

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

    
2564
    return program;
2565
}
2566

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

    
2572
    for(i=0; i<s->nb_chapters; i++)
2573
        if(s->chapters[i]->id == id)
2574
            chapter = s->chapters[i];
2575

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

    
2591
    return chapter;
2592
}
2593

    
2594
/************************************************************/
2595
/* output media file */
2596

    
2597
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2598
{
2599
    int ret;
2600

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

    
2608
    if (s->oformat->set_parameters) {
2609
        ret = s->oformat->set_parameters(s, ap);
2610
        if (ret < 0)
2611
            return ret;
2612
    }
2613
    return 0;
2614
}
2615

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

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

    
2649
int av_write_header(AVFormatContext *s)
2650
{
2651
    int ret, i;
2652
    AVStream *st;
2653

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

    
2660
    for(i=0;i<s->nb_streams;i++) {
2661
        st = s->streams[i];
2662

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

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

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

    
2712
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2713
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2714
        if (!s->priv_data)
2715
            return AVERROR(ENOMEM);
2716
    }
2717

    
2718
#if FF_API_OLD_METADATA
2719
    ff_metadata_mux_compat(s);
2720
#endif
2721

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

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

    
2736
    if(s->oformat->write_header){
2737
        ret = s->oformat->write_header(s);
2738
        if (ret < 0)
2739
            return ret;
2740
    }
2741

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

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

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

    
2771
//    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);
2772

    
2773
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2774
        return -1;*/
2775

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

    
2784
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2785
        pkt->pts= pkt->dts;
2786

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

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

    
2802
        pkt->dts= st->pts_buffer[0];
2803
    }
2804

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

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

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

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

    
2841
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2842
{
2843
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2844

    
2845
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2846
        return ret;
2847

    
2848
    ret= s->oformat->write_packet(s, pkt);
2849
    if(!ret)
2850
        ret= url_ferror(s->pb);
2851
    return ret;
2852
}
2853

    
2854
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2855
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2856
{
2857
    AVPacketList **next_point, *this_pktl;
2858

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

    
2864
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2865
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2866
    }else
2867
        next_point = &s->packet_buffer;
2868

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

    
2881
    s->packet_buffer_end= this_pktl;
2882
next_non_null:
2883

    
2884
    this_pktl->next= *next_point;
2885

    
2886
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2887
    *next_point= this_pktl;
2888
}
2889

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

    
2899
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2900
    AVPacketList *pktl;
2901
    int stream_count=0;
2902
    int i;
2903

    
2904
    if(pkt){
2905
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2906
    }
2907

    
2908
    for(i=0; i < s->nb_streams; i++)
2909
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2910

    
2911
    if(stream_count && (s->nb_streams == stream_count || flush)){
2912
        pktl= s->packet_buffer;
2913
        *out= pktl->pkt;
2914

    
2915
        s->packet_buffer= pktl->next;
2916
        if(!s->packet_buffer)
2917
            s->packet_buffer_end= NULL;
2918

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

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

    
2945
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2946
    AVStream *st= s->streams[ pkt->stream_index];
2947

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

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

    
2956
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2957
        return -1;
2958

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

    
2965
        ret= s->oformat->write_packet(s, &opkt);
2966

    
2967
        av_free_packet(&opkt);
2968
        pkt= NULL;
2969

    
2970
        if(ret<0)
2971
            return ret;
2972
        if(url_ferror(s->pb))
2973
            return url_ferror(s->pb);
2974
    }
2975
}
2976

    
2977
int av_write_trailer(AVFormatContext *s)
2978
{
2979
    int ret, i;
2980

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

    
2989
        ret= s->oformat->write_packet(s, &pkt);
2990

    
2991
        av_free_packet(&pkt);
2992

    
2993
        if(ret<0)
2994
            goto fail;
2995
        if(url_ferror(s->pb))
2996
            goto fail;
2997
    }
2998

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

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

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

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

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

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

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

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

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

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

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

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

    
3179
    av_free(printed);
3180
}
3181

    
3182
#if LIBAVFORMAT_VERSION_MAJOR < 53
3183
#include "libavcore/parseutils.h"
3184

    
3185
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3186
{
3187
    return av_parse_video_size(width_ptr, height_ptr, str);
3188
}
3189

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

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

    
3207
uint64_t ff_ntp_time(void)
3208
{
3209
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3210
}
3211

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

    
3231
#undef time
3232
    time_t now = time(0);
3233

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

    
3241
    memset(&dt, 0, sizeof(dt));
3242

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

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

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

    
3270
        if (*p == 'T' || *p == 't' || *p == ' ')
3271
            p++;
3272

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

    
3299
    /* Now we have all the fields that we can get */
3300
    if (!q) {
3301
        return INT64_MIN;
3302
    }
3303

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

    
3315
    t *= 1000000;
3316

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

    
3331
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3332
{
3333
    const char *p;
3334
    char tag[128], *q;
3335

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

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

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

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

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

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

    
3454
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3455
{
3456
    hex_dump_internal(NULL, f, 0, buf, size);
3457
}
3458

    
3459
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3460
{
3461
    hex_dump_internal(avcl, NULL, level, buf, size);
3462
}
3463

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

    
3491
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3492
{
3493
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3494
}
3495

    
3496
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3497
{
3498
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3499
}
3500

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

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

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

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

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

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

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

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

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

    
3598
    return buff;
3599
}
3600

    
3601
int ff_hex_to_data(uint8_t *data, const char *p)
3602
{
3603
    int c, len, v;
3604

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

    
3629
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3630
                     unsigned int pts_num, unsigned int pts_den)
3631
{
3632
    s->pts_wrap_bits = pts_wrap_bits;
3633

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

    
3640
    if(!s->time_base.num || !s->time_base.den)
3641
        s->time_base.num= s->time_base.den= 0;
3642
}
3643

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

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

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

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

    
3689
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3690
                     AVFormatContext *src)
3691
{
3692
    AVPacket local_pkt;
3693

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

    
3707
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3708
                        void *context)
3709
{
3710
    const char *ptr = str;
3711

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

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

    
3724
        key = ptr;
3725

    
3726
        if (!(ptr = strchr(key, '=')))
3727
            break;
3728
        ptr++;
3729
        key_len = ptr - key;
3730

    
3731
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3732
        dest_end = dest + dest_len - 1;
3733

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