Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 88e44314

History | View | Annotate | Download (119 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 "id3v2.h"
27
#include "libavutil/avstring.h"
28
#include "riff.h"
29
#include "audiointerleave.h"
30
#include <sys/time.h>
31
#include <time.h>
32
#include <strings.h>
33
#include <stdarg.h>
34
#if CONFIG_NETWORK
35
#include "network.h"
36
#endif
37

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

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

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

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

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

    
62
/* fraction handling */
63

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

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

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

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

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

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

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

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

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

    
152
    if(!filename)
153
        return 0;
154

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

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

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

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

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

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

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

    
237
#if FF_API_GUESS_FORMAT
238
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
239
                             const char *mime_type)
240
{
241
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
242

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

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

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

    
254
    return fmt;
255
}
256
#endif
257

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

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

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

    
287
#if LIBAVFORMAT_VERSION_MAJOR < 53 && CONFIG_SHARED && HAVE_SYMVER
288
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
289
{
290
    av_destruct_packet_nofree(pkt);
291
}
292

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

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

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

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

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

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

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

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

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

    
335
    return ret;
336
}
337

    
338

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

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

    
351
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
352
        int id3len = ff_id3v2_tag_len(lpd.buf);
353
        if (lpd.buf_size > id3len + 16) {
354
            lpd.buf += id3len;
355
            lpd.buf_size -= id3len;
356
        }
357
    }
358

    
359
    fmt = NULL;
360
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
361
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
362
            continue;
363
        score = 0;
364
        if (fmt1->read_probe) {
365
            score = fmt1->read_probe(&lpd);
366
        } else if (fmt1->extensions) {
367
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
368
                score = 50;
369
            }
370
        }
371
        if (score > *score_max) {
372
            *score_max = score;
373
            fmt = fmt1;
374
        }else if (score == *score_max)
375
            fmt = NULL;
376
    }
377
    return fmt;
378
}
379

    
380
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
381
    int score=0;
382
    return av_probe_input_format2(pd, is_opened, &score);
383
}
384

    
385
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
386
{
387
    static const struct {
388
        const char *name; enum CodecID id; enum AVMediaType type;
389
    } fmt_id_type[] = {
390
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
391
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
392
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
393
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
394
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
395
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
396
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
397
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
398
        { 0 }
399
    };
400
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
401

    
402
    if (fmt) {
403
        int i;
404
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
405
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
406
        for (i = 0; fmt_id_type[i].name; i++) {
407
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
408
                st->codec->codec_id   = fmt_id_type[i].id;
409
                st->codec->codec_type = fmt_id_type[i].type;
410
                break;
411
            }
412
        }
413
    }
414
    return !!fmt;
415
}
416

    
417
/************************************************************/
418
/* input media file */
419

    
420
/**
421
 * Open a media file from an IO stream. 'fmt' must be specified.
422
 */
423
int av_open_input_stream(AVFormatContext **ic_ptr,
424
                         ByteIOContext *pb, const char *filename,
425
                         AVInputFormat *fmt, AVFormatParameters *ap)
426
{
427
    int err;
428
    AVFormatContext *ic;
429
    AVFormatParameters default_ap;
430

    
431
    if(!ap){
432
        ap=&default_ap;
433
        memset(ap, 0, sizeof(default_ap));
434
    }
435

    
436
    if(!ap->prealloced_context)
437
        ic = avformat_alloc_context();
438
    else
439
        ic = *ic_ptr;
440
    if (!ic) {
441
        err = AVERROR(ENOMEM);
442
        goto fail;
443
    }
444
    ic->iformat = fmt;
445
    ic->pb = pb;
446
    ic->duration = AV_NOPTS_VALUE;
447
    ic->start_time = AV_NOPTS_VALUE;
448
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
449

    
450
    /* allocate private data */
451
    if (fmt->priv_data_size > 0) {
452
        ic->priv_data = av_mallocz(fmt->priv_data_size);
453
        if (!ic->priv_data) {
454
            err = AVERROR(ENOMEM);
455
            goto fail;
456
        }
457
    } else {
458
        ic->priv_data = NULL;
459
    }
460

    
461
    // e.g. AVFMT_NOFILE formats will not have a ByteIOContext
462
    if (ic->pb)
463
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
464

    
465
    if (ic->iformat->read_header) {
466
        err = ic->iformat->read_header(ic, ap);
467
        if (err < 0)
468
            goto fail;
469
    }
470

    
471
    if (pb && !ic->data_offset)
472
        ic->data_offset = url_ftell(ic->pb);
473

    
474
#if FF_API_OLD_METADATA
475
    ff_metadata_demux_compat(ic);
476
#endif
477

    
478
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
479

    
480
    *ic_ptr = ic;
481
    return 0;
482
 fail:
483
    if (ic) {
484
        int i;
485
        av_freep(&ic->priv_data);
486
        for(i=0;i<ic->nb_streams;i++) {
487
            AVStream *st = ic->streams[i];
488
            if (st) {
489
                av_free(st->priv_data);
490
                av_free(st->codec->extradata);
491
                av_free(st->codec);
492
                av_free(st->info);
493
            }
494
            av_free(st);
495
        }
496
    }
497
    av_free(ic);
498
    *ic_ptr = NULL;
499
    return err;
500
}
501

    
502
/** size of probe buffer, for guessing file type from file contents */
503
#define PROBE_BUF_MIN 2048
504
#define PROBE_BUF_MAX (1<<20)
505

    
506
int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
507
                          const char *filename, void *logctx,
508
                          unsigned int offset, unsigned int max_probe_size)
509
{
510
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
511
    unsigned char *buf = NULL;
512
    int ret = 0, probe_size;
513

    
514
    if (!max_probe_size) {
515
        max_probe_size = PROBE_BUF_MAX;
516
    } else if (max_probe_size > PROBE_BUF_MAX) {
517
        max_probe_size = PROBE_BUF_MAX;
518
    } else if (max_probe_size < PROBE_BUF_MIN) {
519
        return AVERROR(EINVAL);
520
    }
521

    
522
    if (offset >= max_probe_size) {
523
        return AVERROR(EINVAL);
524
    }
525

    
526
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
527
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
528
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
529
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
530

    
531
        if (probe_size < offset) {
532
            continue;
533
        }
534

    
535
        /* read probe data */
536
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
537
        if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
538
            /* fail if error was not end of file, otherwise, lower score */
539
            if (ret != AVERROR_EOF) {
540
                av_free(buf);
541
                return ret;
542
            }
543
            score = 0;
544
            ret = 0;            /* error was end of file, nothing read */
545
        }
546
        pd.buf_size += ret;
547
        pd.buf = &buf[offset];
548

    
549
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
550

    
551
        /* guess file format */
552
        *fmt = av_probe_input_format2(&pd, 1, &score);
553
        if(*fmt){
554
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
555
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
556
            }else
557
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
558
        }
559
    }
560

    
561
    if (!*fmt) {
562
        av_free(buf);
563
        return AVERROR_INVALIDDATA;
564
    }
565

    
566
    /* rewind. reuse probe buffer to avoid seeking */
567
    if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
568
        av_free(buf);
569

    
570
    return ret;
571
}
572

    
573
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
574
                       AVInputFormat *fmt,
575
                       int buf_size,
576
                       AVFormatParameters *ap)
577
{
578
    int err;
579
    AVProbeData probe_data, *pd = &probe_data;
580
    ByteIOContext *pb = NULL;
581
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
582

    
583
    pd->filename = "";
584
    if (filename)
585
        pd->filename = filename;
586
    pd->buf = NULL;
587
    pd->buf_size = 0;
588

    
589
    if (!fmt) {
590
        /* guess format if no file can be opened */
591
        fmt = av_probe_input_format(pd, 0);
592
    }
593

    
594
    /* Do not open file if the format does not need it. XXX: specific
595
       hack needed to handle RTSP/TCP */
596
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
597
        /* if no file needed do not try to open one */
598
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
599
            goto fail;
600
        }
601
        if (buf_size > 0) {
602
            url_setbufsize(pb, buf_size);
603
        }
604
        if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
605
            goto fail;
606
        }
607
    }
608

    
609
    /* if still no format found, error */
610
    if (!fmt) {
611
        err = AVERROR_INVALIDDATA;
612
        goto fail;
613
    }
614

    
615
    /* check filename in case an image number is expected */
616
    if (fmt->flags & AVFMT_NEEDNUMBER) {
617
        if (!av_filename_number_test(filename)) {
618
            err = AVERROR_NUMEXPECTED;
619
            goto fail;
620
        }
621
    }
622
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
623
    if (err)
624
        goto fail;
625
    return 0;
626
 fail:
627
    av_freep(&pd->buf);
628
    if (pb)
629
        url_fclose(pb);
630
    if (ap && ap->prealloced_context)
631
        av_free(*ic_ptr);
632
    *ic_ptr = NULL;
633
    return err;
634

    
635
}
636

    
637
/*******************************************************/
638

    
639
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
640
                               AVPacketList **plast_pktl){
641
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
642
    if (!pktl)
643
        return NULL;
644

    
645
    if (*packet_buffer)
646
        (*plast_pktl)->next = pktl;
647
    else
648
        *packet_buffer = pktl;
649

    
650
    /* add the packet in the buffered packet list */
651
    *plast_pktl = pktl;
652
    pktl->pkt= *pkt;
653
    return &pktl->pkt;
654
}
655

    
656
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
657
{
658
    int ret, i;
659
    AVStream *st;
660

    
661
    for(;;){
662
        AVPacketList *pktl = s->raw_packet_buffer;
663

    
664
        if (pktl) {
665
            *pkt = pktl->pkt;
666
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
667
               !s->streams[pkt->stream_index]->probe_packets ||
668
               s->raw_packet_buffer_remaining_size < pkt->size){
669
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
670
                av_freep(&pd->buf);
671
                pd->buf_size = 0;
672
                s->raw_packet_buffer = pktl->next;
673
                s->raw_packet_buffer_remaining_size += pkt->size;
674
                av_free(pktl);
675
                return 0;
676
            }
677
        }
678

    
679
        av_init_packet(pkt);
680
        ret= s->iformat->read_packet(s, pkt);
681
        if (ret < 0) {
682
            if (!pktl || ret == AVERROR(EAGAIN))
683
                return ret;
684
            for (i = 0; i < s->nb_streams; i++)
685
                s->streams[i]->probe_packets = 0;
686
            continue;
687
        }
688
        st= s->streams[pkt->stream_index];
689

    
690
        switch(st->codec->codec_type){
691
        case AVMEDIA_TYPE_VIDEO:
692
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
693
            break;
694
        case AVMEDIA_TYPE_AUDIO:
695
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
696
            break;
697
        case AVMEDIA_TYPE_SUBTITLE:
698
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
699
            break;
700
        }
701

    
702
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
703
                     !st->probe_packets))
704
            return ret;
705

    
706
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
707
        s->raw_packet_buffer_remaining_size -= pkt->size;
708

    
709
        if(st->codec->codec_id == CODEC_ID_PROBE){
710
            AVProbeData *pd = &st->probe_data;
711
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
712
            --st->probe_packets;
713

    
714
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
715
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
716
            pd->buf_size += pkt->size;
717
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
718

    
719
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
720
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
721
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
722
                if(st->codec->codec_id != CODEC_ID_PROBE){
723
                    pd->buf_size=0;
724
                    av_freep(&pd->buf);
725
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
726
                }
727
            }
728
        }
729
    }
730
}
731

    
732
/**********************************************************/
733

    
734
/**
735
 * Get the number of samples of an audio frame. Return -1 on error.
736
 */
737
static int get_audio_frame_size(AVCodecContext *enc, int size)
738
{
739
    int frame_size;
740

    
741
    if(enc->codec_id == CODEC_ID_VORBIS)
742
        return -1;
743

    
744
    if (enc->frame_size <= 1) {
745
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
746

    
747
        if (bits_per_sample) {
748
            if (enc->channels == 0)
749
                return -1;
750
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
751
        } else {
752
            /* used for example by ADPCM codecs */
753
            if (enc->bit_rate == 0)
754
                return -1;
755
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
756
        }
757
    } else {
758
        frame_size = enc->frame_size;
759
    }
760
    return frame_size;
761
}
762

    
763

    
764
/**
765
 * Return the frame duration in seconds. Return 0 if not available.
766
 */
767
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
768
                                   AVCodecParserContext *pc, AVPacket *pkt)
769
{
770
    int frame_size;
771

    
772
    *pnum = 0;
773
    *pden = 0;
774
    switch(st->codec->codec_type) {
775
    case AVMEDIA_TYPE_VIDEO:
776
        if(st->time_base.num*1000LL > st->time_base.den){
777
            *pnum = st->time_base.num;
778
            *pden = st->time_base.den;
779
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
780
            *pnum = st->codec->time_base.num;
781
            *pden = st->codec->time_base.den;
782
            if (pc && pc->repeat_pict) {
783
                *pnum = (*pnum) * (1 + pc->repeat_pict);
784
            }
785
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
786
            //Thus if we have no parser in such case leave duration undefined.
787
            if(st->codec->ticks_per_frame>1 && !pc){
788
                *pnum = *pden = 0;
789
            }
790
        }
791
        break;
792
    case AVMEDIA_TYPE_AUDIO:
793
        frame_size = get_audio_frame_size(st->codec, pkt->size);
794
        if (frame_size < 0)
795
            break;
796
        *pnum = frame_size;
797
        *pden = st->codec->sample_rate;
798
        break;
799
    default:
800
        break;
801
    }
802
}
803

    
804
static int is_intra_only(AVCodecContext *enc){
805
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
806
        return 1;
807
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
808
        switch(enc->codec_id){
809
        case CODEC_ID_MJPEG:
810
        case CODEC_ID_MJPEGB:
811
        case CODEC_ID_LJPEG:
812
        case CODEC_ID_RAWVIDEO:
813
        case CODEC_ID_DVVIDEO:
814
        case CODEC_ID_HUFFYUV:
815
        case CODEC_ID_FFVHUFF:
816
        case CODEC_ID_ASV1:
817
        case CODEC_ID_ASV2:
818
        case CODEC_ID_VCR1:
819
        case CODEC_ID_DNXHD:
820
        case CODEC_ID_JPEG2000:
821
            return 1;
822
        default: break;
823
        }
824
    }
825
    return 0;
826
}
827

    
828
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
829
                                      int64_t dts, int64_t pts)
830
{
831
    AVStream *st= s->streams[stream_index];
832
    AVPacketList *pktl= s->packet_buffer;
833

    
834
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
835
        return;
836

    
837
    st->first_dts= dts - st->cur_dts;
838
    st->cur_dts= dts;
839

    
840
    for(; pktl; pktl= pktl->next){
841
        if(pktl->pkt.stream_index != stream_index)
842
            continue;
843
        //FIXME think more about this check
844
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
845
            pktl->pkt.pts += st->first_dts;
846

    
847
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
848
            pktl->pkt.dts += st->first_dts;
849

    
850
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
851
            st->start_time= pktl->pkt.pts;
852
    }
853
    if (st->start_time == AV_NOPTS_VALUE)
854
        st->start_time = pts;
855
}
856

    
857
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
858
{
859
    AVPacketList *pktl= s->packet_buffer;
860
    int64_t cur_dts= 0;
861

    
862
    if(st->first_dts != AV_NOPTS_VALUE){
863
        cur_dts= st->first_dts;
864
        for(; pktl; pktl= pktl->next){
865
            if(pktl->pkt.stream_index == pkt->stream_index){
866
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
867
                    break;
868
                cur_dts -= pkt->duration;
869
            }
870
        }
871
        pktl= s->packet_buffer;
872
        st->first_dts = cur_dts;
873
    }else if(st->cur_dts)
874
        return;
875

    
876
    for(; pktl; pktl= pktl->next){
877
        if(pktl->pkt.stream_index != pkt->stream_index)
878
            continue;
879
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
880
           && !pktl->pkt.duration){
881
            pktl->pkt.dts= cur_dts;
882
            if(!st->codec->has_b_frames)
883
                pktl->pkt.pts= cur_dts;
884
            cur_dts += pkt->duration;
885
            pktl->pkt.duration= pkt->duration;
886
        }else
887
            break;
888
    }
889
    if(st->first_dts == AV_NOPTS_VALUE)
890
        st->cur_dts= cur_dts;
891
}
892

    
893
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
894
                               AVCodecParserContext *pc, AVPacket *pkt)
895
{
896
    int num, den, presentation_delayed, delay, i;
897
    int64_t offset;
898

    
899
    if (s->flags & AVFMT_FLAG_NOFILLIN)
900
        return;
901

    
902
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
903
        pkt->dts= AV_NOPTS_VALUE;
904

    
905
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
906
        //FIXME Set low_delay = 0 when has_b_frames = 1
907
        st->codec->has_b_frames = 1;
908

    
909
    /* do we have a video B-frame ? */
910
    delay= st->codec->has_b_frames;
911
    presentation_delayed = 0;
912
    /* XXX: need has_b_frame, but cannot get it if the codec is
913
        not initialized */
914
    if (delay &&
915
        pc && pc->pict_type != FF_B_TYPE)
916
        presentation_delayed = 1;
917

    
918
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
919
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
920
        pkt->dts -= 1LL<<st->pts_wrap_bits;
921
    }
922

    
923
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
924
    // we take the conservative approach and discard both
925
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
926
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
927
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
928
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
929
    }
930

    
931
    if (pkt->duration == 0) {
932
        compute_frame_duration(&num, &den, st, pc, pkt);
933
        if (den && num) {
934
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
935

    
936
            if(pkt->duration != 0 && s->packet_buffer)
937
                update_initial_durations(s, st, pkt);
938
        }
939
    }
940

    
941
    /* correct timestamps with byte offset if demuxers only have timestamps
942
       on packet boundaries */
943
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
944
        /* this will estimate bitrate based on this frame's duration and size */
945
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
946
        if(pkt->pts != AV_NOPTS_VALUE)
947
            pkt->pts += offset;
948
        if(pkt->dts != AV_NOPTS_VALUE)
949
            pkt->dts += offset;
950
    }
951

    
952
    if (pc && pc->dts_sync_point >= 0) {
953
        // we have synchronization info from the parser
954
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
955
        if (den > 0) {
956
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
957
            if (pkt->dts != AV_NOPTS_VALUE) {
958
                // got DTS from the stream, update reference timestamp
959
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
960
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
961
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
962
                // compute DTS based on reference timestamp
963
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
964
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
965
            }
966
            if (pc->dts_sync_point > 0)
967
                st->reference_dts = pkt->dts; // new reference
968
        }
969
    }
970

    
971
    /* This may be redundant, but it should not hurt. */
972
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
973
        presentation_delayed = 1;
974

    
975
//    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);
976
    /* interpolate PTS and DTS if they are not present */
977
    //We skip H264 currently because delay and has_b_frames are not reliably set
978
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
979
        if (presentation_delayed) {
980
            /* DTS = decompression timestamp */
981
            /* PTS = presentation timestamp */
982
            if (pkt->dts == AV_NOPTS_VALUE)
983
                pkt->dts = st->last_IP_pts;
984
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
985
            if (pkt->dts == AV_NOPTS_VALUE)
986
                pkt->dts = st->cur_dts;
987

    
988
            /* this is tricky: the dts must be incremented by the duration
989
            of the frame we are displaying, i.e. the last I- or P-frame */
990
            if (st->last_IP_duration == 0)
991
                st->last_IP_duration = pkt->duration;
992
            if(pkt->dts != AV_NOPTS_VALUE)
993
                st->cur_dts = pkt->dts + st->last_IP_duration;
994
            st->last_IP_duration  = pkt->duration;
995
            st->last_IP_pts= pkt->pts;
996
            /* cannot compute PTS if not present (we can compute it only
997
            by knowing the future */
998
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
999
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1000
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1001
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1002
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1003
                    pkt->pts += pkt->duration;
1004
    //                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);
1005
                }
1006
            }
1007

    
1008
            /* presentation is not delayed : PTS and DTS are the same */
1009
            if(pkt->pts == AV_NOPTS_VALUE)
1010
                pkt->pts = pkt->dts;
1011
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1012
            if(pkt->pts == AV_NOPTS_VALUE)
1013
                pkt->pts = st->cur_dts;
1014
            pkt->dts = pkt->pts;
1015
            if(pkt->pts != AV_NOPTS_VALUE)
1016
                st->cur_dts = pkt->pts + pkt->duration;
1017
        }
1018
    }
1019

    
1020
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1021
        st->pts_buffer[0]= pkt->pts;
1022
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1023
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1024
        if(pkt->dts == AV_NOPTS_VALUE)
1025
            pkt->dts= st->pts_buffer[0];
1026
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1027
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1028
        }
1029
        if(pkt->dts > st->cur_dts)
1030
            st->cur_dts = pkt->dts;
1031
    }
1032

    
1033
//    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);
1034

    
1035
    /* update flags */
1036
    if(is_intra_only(st->codec))
1037
        pkt->flags |= AV_PKT_FLAG_KEY;
1038
    else if (pc) {
1039
        pkt->flags = 0;
1040
        /* keyframe computation */
1041
        if (pc->key_frame == 1)
1042
            pkt->flags |= AV_PKT_FLAG_KEY;
1043
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1044
            pkt->flags |= AV_PKT_FLAG_KEY;
1045
    }
1046
    if (pc)
1047
        pkt->convergence_duration = pc->convergence_duration;
1048
}
1049

    
1050

    
1051
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1052
{
1053
    AVStream *st;
1054
    int len, ret, i;
1055

    
1056
    av_init_packet(pkt);
1057

    
1058
    for(;;) {
1059
        /* select current input stream component */
1060
        st = s->cur_st;
1061
        if (st) {
1062
            if (!st->need_parsing || !st->parser) {
1063
                /* no parsing needed: we just output the packet as is */
1064
                /* raw data support */
1065
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1066
                compute_pkt_fields(s, st, NULL, pkt);
1067
                s->cur_st = NULL;
1068
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1069
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1070
                    ff_reduce_index(s, st->index);
1071
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1072
                }
1073
                break;
1074
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1075
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1076
                                       st->cur_ptr, st->cur_len,
1077
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1078
                                       st->cur_pkt.pos);
1079
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1080
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1081
                /* increment read pointer */
1082
                st->cur_ptr += len;
1083
                st->cur_len -= len;
1084

    
1085
                /* return packet if any */
1086
                if (pkt->size) {
1087
                got_packet:
1088
                    pkt->duration = 0;
1089
                    pkt->stream_index = st->index;
1090
                    pkt->pts = st->parser->pts;
1091
                    pkt->dts = st->parser->dts;
1092
                    pkt->pos = st->parser->pos;
1093
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1094
                        s->cur_st = NULL;
1095
                        pkt->destruct= st->cur_pkt.destruct;
1096
                        st->cur_pkt.destruct= NULL;
1097
                        st->cur_pkt.data    = NULL;
1098
                        assert(st->cur_len == 0);
1099
                    }else{
1100
                    pkt->destruct = NULL;
1101
                    }
1102
                    compute_pkt_fields(s, st, st->parser, pkt);
1103

    
1104
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1105
                        ff_reduce_index(s, st->index);
1106
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1107
                                           0, 0, AVINDEX_KEYFRAME);
1108
                    }
1109

    
1110
                    break;
1111
                }
1112
            } else {
1113
                /* free packet */
1114
                av_free_packet(&st->cur_pkt);
1115
                s->cur_st = NULL;
1116
            }
1117
        } else {
1118
            AVPacket cur_pkt;
1119
            /* read next packet */
1120
            ret = av_read_packet(s, &cur_pkt);
1121
            if (ret < 0) {
1122
                if (ret == AVERROR(EAGAIN))
1123
                    return ret;
1124
                /* return the last frames, if any */
1125
                for(i = 0; i < s->nb_streams; i++) {
1126
                    st = s->streams[i];
1127
                    if (st->parser && st->need_parsing) {
1128
                        av_parser_parse2(st->parser, st->codec,
1129
                                        &pkt->data, &pkt->size,
1130
                                        NULL, 0,
1131
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1132
                                        AV_NOPTS_VALUE);
1133
                        if (pkt->size)
1134
                            goto got_packet;
1135
                    }
1136
                }
1137
                /* no more packets: really terminate parsing */
1138
                return ret;
1139
            }
1140
            st = s->streams[cur_pkt.stream_index];
1141
            st->cur_pkt= cur_pkt;
1142

    
1143
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1144
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1145
               st->cur_pkt.pts < st->cur_pkt.dts){
1146
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1147
                    st->cur_pkt.stream_index,
1148
                    st->cur_pkt.pts,
1149
                    st->cur_pkt.dts,
1150
                    st->cur_pkt.size);
1151
//                av_free_packet(&st->cur_pkt);
1152
//                return -1;
1153
            }
1154

    
1155
            if(s->debug & FF_FDEBUG_TS)
1156
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1157
                    st->cur_pkt.stream_index,
1158
                    st->cur_pkt.pts,
1159
                    st->cur_pkt.dts,
1160
                    st->cur_pkt.size,
1161
                    st->cur_pkt.duration,
1162
                    st->cur_pkt.flags);
1163

    
1164
            s->cur_st = st;
1165
            st->cur_ptr = st->cur_pkt.data;
1166
            st->cur_len = st->cur_pkt.size;
1167
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1168
                st->parser = av_parser_init(st->codec->codec_id);
1169
                if (!st->parser) {
1170
                    /* no parser available: just output the raw packets */
1171
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1172
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1173
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1174
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1175
                    st->parser->flags |= PARSER_FLAG_ONCE;
1176
                }
1177
            }
1178
        }
1179
    }
1180
    if(s->debug & FF_FDEBUG_TS)
1181
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1182
            pkt->stream_index,
1183
            pkt->pts,
1184
            pkt->dts,
1185
            pkt->size,
1186
            pkt->duration,
1187
            pkt->flags);
1188

    
1189
    return 0;
1190
}
1191

    
1192
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1193
{
1194
    AVPacketList *pktl;
1195
    int eof=0;
1196
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1197

    
1198
    for(;;){
1199
        pktl = s->packet_buffer;
1200
        if (pktl) {
1201
            AVPacket *next_pkt= &pktl->pkt;
1202

    
1203
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1204
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1205
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1206
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1207
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1208
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1209
                        next_pkt->pts= pktl->pkt.dts;
1210
                    }
1211
                    pktl= pktl->next;
1212
                }
1213
                pktl = s->packet_buffer;
1214
            }
1215

    
1216
            if(   next_pkt->pts != AV_NOPTS_VALUE
1217
               || next_pkt->dts == AV_NOPTS_VALUE
1218
               || !genpts || eof){
1219
                /* read packet from packet buffer, if there is data */
1220
                *pkt = *next_pkt;
1221
                s->packet_buffer = pktl->next;
1222
                av_free(pktl);
1223
                return 0;
1224
            }
1225
        }
1226
        if(genpts){
1227
            int ret= av_read_frame_internal(s, pkt);
1228
            if(ret<0){
1229
                if(pktl && ret != AVERROR(EAGAIN)){
1230
                    eof=1;
1231
                    continue;
1232
                }else
1233
                    return ret;
1234
            }
1235

    
1236
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1237
                                           &s->packet_buffer_end)) < 0)
1238
                return AVERROR(ENOMEM);
1239
        }else{
1240
            assert(!s->packet_buffer);
1241
            return av_read_frame_internal(s, pkt);
1242
        }
1243
    }
1244
}
1245

    
1246
/* XXX: suppress the packet queue */
1247
static void flush_packet_queue(AVFormatContext *s)
1248
{
1249
    AVPacketList *pktl;
1250

    
1251
    for(;;) {
1252
        pktl = s->packet_buffer;
1253
        if (!pktl)
1254
            break;
1255
        s->packet_buffer = pktl->next;
1256
        av_free_packet(&pktl->pkt);
1257
        av_free(pktl);
1258
    }
1259
    while(s->raw_packet_buffer){
1260
        pktl = s->raw_packet_buffer;
1261
        s->raw_packet_buffer = pktl->next;
1262
        av_free_packet(&pktl->pkt);
1263
        av_free(pktl);
1264
    }
1265
    s->packet_buffer_end=
1266
    s->raw_packet_buffer_end= NULL;
1267
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1268
}
1269

    
1270
/*******************************************************/
1271
/* seek support */
1272

    
1273
int av_find_default_stream_index(AVFormatContext *s)
1274
{
1275
    int first_audio_index = -1;
1276
    int i;
1277
    AVStream *st;
1278

    
1279
    if (s->nb_streams <= 0)
1280
        return -1;
1281
    for(i = 0; i < s->nb_streams; i++) {
1282
        st = s->streams[i];
1283
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1284
            return i;
1285
        }
1286
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1287
            first_audio_index = i;
1288
    }
1289
    return first_audio_index >= 0 ? first_audio_index : 0;
1290
}
1291

    
1292
/**
1293
 * Flush the frame reader.
1294
 */
1295
void ff_read_frame_flush(AVFormatContext *s)
1296
{
1297
    AVStream *st;
1298
    int i, j;
1299

    
1300
    flush_packet_queue(s);
1301

    
1302
    s->cur_st = NULL;
1303

    
1304
    /* for each stream, reset read state */
1305
    for(i = 0; i < s->nb_streams; i++) {
1306
        st = s->streams[i];
1307

    
1308
        if (st->parser) {
1309
            av_parser_close(st->parser);
1310
            st->parser = NULL;
1311
            av_free_packet(&st->cur_pkt);
1312
        }
1313
        st->last_IP_pts = AV_NOPTS_VALUE;
1314
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1315
        st->reference_dts = AV_NOPTS_VALUE;
1316
        /* fail safe */
1317
        st->cur_ptr = NULL;
1318
        st->cur_len = 0;
1319

    
1320
        st->probe_packets = MAX_PROBE_PACKETS;
1321

    
1322
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1323
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1324
    }
1325
}
1326

    
1327
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1328
    int i;
1329

    
1330
    for(i = 0; i < s->nb_streams; i++) {
1331
        AVStream *st = s->streams[i];
1332

    
1333
        st->cur_dts = av_rescale(timestamp,
1334
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1335
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1336
    }
1337
}
1338

    
1339
void ff_reduce_index(AVFormatContext *s, int stream_index)
1340
{
1341
    AVStream *st= s->streams[stream_index];
1342
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1343

    
1344
    if((unsigned)st->nb_index_entries >= max_entries){
1345
        int i;
1346
        for(i=0; 2*i<st->nb_index_entries; i++)
1347
            st->index_entries[i]= st->index_entries[2*i];
1348
        st->nb_index_entries= i;
1349
    }
1350
}
1351

    
1352
int av_add_index_entry(AVStream *st,
1353
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1354
{
1355
    AVIndexEntry *entries, *ie;
1356
    int index;
1357

    
1358
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1359
        return -1;
1360

    
1361
    entries = av_fast_realloc(st->index_entries,
1362
                              &st->index_entries_allocated_size,
1363
                              (st->nb_index_entries + 1) *
1364
                              sizeof(AVIndexEntry));
1365
    if(!entries)
1366
        return -1;
1367

    
1368
    st->index_entries= entries;
1369

    
1370
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1371

    
1372
    if(index<0){
1373
        index= st->nb_index_entries++;
1374
        ie= &entries[index];
1375
        assert(index==0 || ie[-1].timestamp < timestamp);
1376
    }else{
1377
        ie= &entries[index];
1378
        if(ie->timestamp != timestamp){
1379
            if(ie->timestamp <= timestamp)
1380
                return -1;
1381
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1382
            st->nb_index_entries++;
1383
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1384
            distance= ie->min_distance;
1385
    }
1386

    
1387
    ie->pos = pos;
1388
    ie->timestamp = timestamp;
1389
    ie->min_distance= distance;
1390
    ie->size= size;
1391
    ie->flags = flags;
1392

    
1393
    return index;
1394
}
1395

    
1396
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1397
                              int flags)
1398
{
1399
    AVIndexEntry *entries= st->index_entries;
1400
    int nb_entries= st->nb_index_entries;
1401
    int a, b, m;
1402
    int64_t timestamp;
1403

    
1404
    a = - 1;
1405
    b = nb_entries;
1406

    
1407
    //optimize appending index entries at the end
1408
    if(b && entries[b-1].timestamp < wanted_timestamp)
1409
        a= b-1;
1410

    
1411
    while (b - a > 1) {
1412
        m = (a + b) >> 1;
1413
        timestamp = entries[m].timestamp;
1414
        if(timestamp >= wanted_timestamp)
1415
            b = m;
1416
        if(timestamp <= wanted_timestamp)
1417
            a = m;
1418
    }
1419
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1420

    
1421
    if(!(flags & AVSEEK_FLAG_ANY)){
1422
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1423
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1424
        }
1425
    }
1426

    
1427
    if(m == nb_entries)
1428
        return -1;
1429
    return  m;
1430
}
1431

    
1432
#define DEBUG_SEEK
1433

    
1434
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1435
    AVInputFormat *avif= s->iformat;
1436
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1437
    int64_t ts_min, ts_max, ts;
1438
    int index;
1439
    int64_t ret;
1440
    AVStream *st;
1441

    
1442
    if (stream_index < 0)
1443
        return -1;
1444

    
1445
#ifdef DEBUG_SEEK
1446
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1447
#endif
1448

    
1449
    ts_max=
1450
    ts_min= AV_NOPTS_VALUE;
1451
    pos_limit= -1; //gcc falsely says it may be uninitialized
1452

    
1453
    st= s->streams[stream_index];
1454
    if(st->index_entries){
1455
        AVIndexEntry *e;
1456

    
1457
        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()
1458
        index= FFMAX(index, 0);
1459
        e= &st->index_entries[index];
1460

    
1461
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1462
            pos_min= e->pos;
1463
            ts_min= e->timestamp;
1464
#ifdef DEBUG_SEEK
1465
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1466
                   pos_min,ts_min);
1467
#endif
1468
        }else{
1469
            assert(index==0);
1470
        }
1471

    
1472
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1473
        assert(index < st->nb_index_entries);
1474
        if(index >= 0){
1475
            e= &st->index_entries[index];
1476
            assert(e->timestamp >= target_ts);
1477
            pos_max= e->pos;
1478
            ts_max= e->timestamp;
1479
            pos_limit= pos_max - e->min_distance;
1480
#ifdef DEBUG_SEEK
1481
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1482
                   pos_max,pos_limit, ts_max);
1483
#endif
1484
        }
1485
    }
1486

    
1487
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1488
    if(pos<0)
1489
        return -1;
1490

    
1491
    /* do the seek */
1492
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1493
        return ret;
1494

    
1495
    av_update_cur_dts(s, st, ts);
1496

    
1497
    return 0;
1498
}
1499

    
1500
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 )){
1501
    int64_t pos, ts;
1502
    int64_t start_pos, filesize;
1503
    int no_change;
1504

    
1505
#ifdef DEBUG_SEEK
1506
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1507
#endif
1508

    
1509
    if(ts_min == AV_NOPTS_VALUE){
1510
        pos_min = s->data_offset;
1511
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1512
        if (ts_min == AV_NOPTS_VALUE)
1513
            return -1;
1514
    }
1515

    
1516
    if(ts_max == AV_NOPTS_VALUE){
1517
        int step= 1024;
1518
        filesize = url_fsize(s->pb);
1519
        pos_max = filesize - 1;
1520
        do{
1521
            pos_max -= step;
1522
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1523
            step += step;
1524
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1525
        if (ts_max == AV_NOPTS_VALUE)
1526
            return -1;
1527

    
1528
        for(;;){
1529
            int64_t tmp_pos= pos_max + 1;
1530
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1531
            if(tmp_ts == AV_NOPTS_VALUE)
1532
                break;
1533
            ts_max= tmp_ts;
1534
            pos_max= tmp_pos;
1535
            if(tmp_pos >= filesize)
1536
                break;
1537
        }
1538
        pos_limit= pos_max;
1539
    }
1540

    
1541
    if(ts_min > ts_max){
1542
        return -1;
1543
    }else if(ts_min == ts_max){
1544
        pos_limit= pos_min;
1545
    }
1546

    
1547
    no_change=0;
1548
    while (pos_min < pos_limit) {
1549
#ifdef DEBUG_SEEK
1550
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1551
               pos_min, pos_max,
1552
               ts_min, ts_max);
1553
#endif
1554
        assert(pos_limit <= pos_max);
1555

    
1556
        if(no_change==0){
1557
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1558
            // interpolate position (better than dichotomy)
1559
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1560
                + pos_min - approximate_keyframe_distance;
1561
        }else if(no_change==1){
1562
            // bisection, if interpolation failed to change min or max pos last time
1563
            pos = (pos_min + pos_limit)>>1;
1564
        }else{
1565
            /* linear search if bisection failed, can only happen if there
1566
               are very few or no keyframes between min/max */
1567
            pos=pos_min;
1568
        }
1569
        if(pos <= pos_min)
1570
            pos= pos_min + 1;
1571
        else if(pos > pos_limit)
1572
            pos= pos_limit;
1573
        start_pos= pos;
1574

    
1575
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1576
        if(pos == pos_max)
1577
            no_change++;
1578
        else
1579
            no_change=0;
1580
#ifdef DEBUG_SEEK
1581
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1582
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1583
               start_pos, no_change);
1584
#endif
1585
        if(ts == AV_NOPTS_VALUE){
1586
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1587
            return -1;
1588
        }
1589
        assert(ts != AV_NOPTS_VALUE);
1590
        if (target_ts <= ts) {
1591
            pos_limit = start_pos - 1;
1592
            pos_max = pos;
1593
            ts_max = ts;
1594
        }
1595
        if (target_ts >= ts) {
1596
            pos_min = pos;
1597
            ts_min = ts;
1598
        }
1599
    }
1600

    
1601
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1602
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1603
#ifdef DEBUG_SEEK
1604
    pos_min = pos;
1605
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1606
    pos_min++;
1607
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1608
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1609
           pos, ts_min, target_ts, ts_max);
1610
#endif
1611
    *ts_ret= ts;
1612
    return pos;
1613
}
1614

    
1615
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1616
    int64_t pos_min, pos_max;
1617
#if 0
1618
    AVStream *st;
1619

1620
    if (stream_index < 0)
1621
        return -1;
1622

1623
    st= s->streams[stream_index];
1624
#endif
1625

    
1626
    pos_min = s->data_offset;
1627
    pos_max = url_fsize(s->pb) - 1;
1628

    
1629
    if     (pos < pos_min) pos= pos_min;
1630
    else if(pos > pos_max) pos= pos_max;
1631

    
1632
    url_fseek(s->pb, pos, SEEK_SET);
1633

    
1634
#if 0
1635
    av_update_cur_dts(s, st, ts);
1636
#endif
1637
    return 0;
1638
}
1639

    
1640
static int av_seek_frame_generic(AVFormatContext *s,
1641
                                 int stream_index, int64_t timestamp, int flags)
1642
{
1643
    int index;
1644
    int64_t ret;
1645
    AVStream *st;
1646
    AVIndexEntry *ie;
1647

    
1648
    st = s->streams[stream_index];
1649

    
1650
    index = av_index_search_timestamp(st, timestamp, flags);
1651

    
1652
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1653
        return -1;
1654

    
1655
    if(index < 0 || index==st->nb_index_entries-1){
1656
        int i;
1657
        AVPacket pkt;
1658

    
1659
        if(st->nb_index_entries){
1660
            assert(st->index_entries);
1661
            ie= &st->index_entries[st->nb_index_entries-1];
1662
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1663
                return ret;
1664
            av_update_cur_dts(s, st, ie->timestamp);
1665
        }else{
1666
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1667
                return ret;
1668
        }
1669
        for(i=0;; i++) {
1670
            int ret;
1671
            do{
1672
                ret = av_read_frame(s, &pkt);
1673
            }while(ret == AVERROR(EAGAIN));
1674
            if(ret<0)
1675
                break;
1676
            av_free_packet(&pkt);
1677
            if(stream_index == pkt.stream_index){
1678
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1679
                    break;
1680
            }
1681
        }
1682
        index = av_index_search_timestamp(st, timestamp, flags);
1683
    }
1684
    if (index < 0)
1685
        return -1;
1686

    
1687
    ff_read_frame_flush(s);
1688
    if (s->iformat->read_seek){
1689
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1690
            return 0;
1691
    }
1692
    ie = &st->index_entries[index];
1693
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1694
        return ret;
1695
    av_update_cur_dts(s, st, ie->timestamp);
1696

    
1697
    return 0;
1698
}
1699

    
1700
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1701
{
1702
    int ret;
1703
    AVStream *st;
1704

    
1705
    ff_read_frame_flush(s);
1706

    
1707
    if(flags & AVSEEK_FLAG_BYTE)
1708
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1709

    
1710
    if(stream_index < 0){
1711
        stream_index= av_find_default_stream_index(s);
1712
        if(stream_index < 0)
1713
            return -1;
1714

    
1715
        st= s->streams[stream_index];
1716
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1717
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1718
    }
1719

    
1720
    /* first, we try the format specific seek */
1721
    if (s->iformat->read_seek)
1722
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1723
    else
1724
        ret = -1;
1725
    if (ret >= 0) {
1726
        return 0;
1727
    }
1728

    
1729
    if(s->iformat->read_timestamp)
1730
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1731
    else
1732
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1733
}
1734

    
1735
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1736
{
1737
    if(min_ts > ts || max_ts < ts)
1738
        return -1;
1739

    
1740
    ff_read_frame_flush(s);
1741

    
1742
    if (s->iformat->read_seek2)
1743
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1744

    
1745
    if(s->iformat->read_timestamp){
1746
        //try to seek via read_timestamp()
1747
    }
1748

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

    
1754
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1755
}
1756

    
1757
/*******************************************************/
1758

    
1759
/**
1760
 * Return TRUE if the stream has accurate duration in any stream.
1761
 *
1762
 * @return TRUE if the stream has accurate duration for at least one component.
1763
 */
1764
static int av_has_duration(AVFormatContext *ic)
1765
{
1766
    int i;
1767
    AVStream *st;
1768

    
1769
    for(i = 0;i < ic->nb_streams; i++) {
1770
        st = ic->streams[i];
1771
        if (st->duration != AV_NOPTS_VALUE)
1772
            return 1;
1773
    }
1774
    return 0;
1775
}
1776

    
1777
/**
1778
 * Estimate the stream timings from the one of each components.
1779
 *
1780
 * Also computes the global bitrate if possible.
1781
 */
1782
static void av_update_stream_timings(AVFormatContext *ic)
1783
{
1784
    int64_t start_time, start_time1, end_time, end_time1;
1785
    int64_t duration, duration1;
1786
    int i;
1787
    AVStream *st;
1788

    
1789
    start_time = INT64_MAX;
1790
    end_time = INT64_MIN;
1791
    duration = INT64_MIN;
1792
    for(i = 0;i < ic->nb_streams; i++) {
1793
        st = ic->streams[i];
1794
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1795
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1796
            if (start_time1 < start_time)
1797
                start_time = start_time1;
1798
            if (st->duration != AV_NOPTS_VALUE) {
1799
                end_time1 = start_time1
1800
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1801
                if (end_time1 > end_time)
1802
                    end_time = end_time1;
1803
            }
1804
        }
1805
        if (st->duration != AV_NOPTS_VALUE) {
1806
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1807
            if (duration1 > duration)
1808
                duration = duration1;
1809
        }
1810
    }
1811
    if (start_time != INT64_MAX) {
1812
        ic->start_time = start_time;
1813
        if (end_time != INT64_MIN) {
1814
            if (end_time - start_time > duration)
1815
                duration = end_time - start_time;
1816
        }
1817
    }
1818
    if (duration != INT64_MIN) {
1819
        ic->duration = duration;
1820
        if (ic->file_size > 0) {
1821
            /* compute the bitrate */
1822
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1823
                (double)ic->duration;
1824
        }
1825
    }
1826
}
1827

    
1828
static void fill_all_stream_timings(AVFormatContext *ic)
1829
{
1830
    int i;
1831
    AVStream *st;
1832

    
1833
    av_update_stream_timings(ic);
1834
    for(i = 0;i < ic->nb_streams; i++) {
1835
        st = ic->streams[i];
1836
        if (st->start_time == AV_NOPTS_VALUE) {
1837
            if(ic->start_time != AV_NOPTS_VALUE)
1838
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1839
            if(ic->duration != AV_NOPTS_VALUE)
1840
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1841
        }
1842
    }
1843
}
1844

    
1845
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1846
{
1847
    int64_t filesize, duration;
1848
    int bit_rate, i;
1849
    AVStream *st;
1850

    
1851
    /* if bit_rate is already set, we believe it */
1852
    if (ic->bit_rate == 0) {
1853
        bit_rate = 0;
1854
        for(i=0;i<ic->nb_streams;i++) {
1855
            st = ic->streams[i];
1856
            bit_rate += st->codec->bit_rate;
1857
        }
1858
        ic->bit_rate = bit_rate;
1859
    }
1860

    
1861
    /* if duration is already set, we believe it */
1862
    if (ic->duration == AV_NOPTS_VALUE &&
1863
        ic->bit_rate != 0 &&
1864
        ic->file_size != 0)  {
1865
        filesize = ic->file_size;
1866
        if (filesize > 0) {
1867
            for(i = 0; i < ic->nb_streams; i++) {
1868
                st = ic->streams[i];
1869
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1870
                if (st->duration == AV_NOPTS_VALUE)
1871
                    st->duration = duration;
1872
            }
1873
        }
1874
    }
1875
}
1876

    
1877
#define DURATION_MAX_READ_SIZE 250000
1878
#define DURATION_MAX_RETRY 3
1879

    
1880
/* only usable for MPEG-PS streams */
1881
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1882
{
1883
    AVPacket pkt1, *pkt = &pkt1;
1884
    AVStream *st;
1885
    int read_size, i, ret;
1886
    int64_t end_time;
1887
    int64_t filesize, offset, duration;
1888
    int retry=0;
1889

    
1890
    ic->cur_st = NULL;
1891

    
1892
    /* flush packet queue */
1893
    flush_packet_queue(ic);
1894

    
1895
    for (i=0; i<ic->nb_streams; i++) {
1896
        st = ic->streams[i];
1897
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1898
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1899

    
1900
        if (st->parser) {
1901
            av_parser_close(st->parser);
1902
            st->parser= NULL;
1903
            av_free_packet(&st->cur_pkt);
1904
        }
1905
    }
1906

    
1907
    /* estimate the end time (duration) */
1908
    /* XXX: may need to support wrapping */
1909
    filesize = ic->file_size;
1910
    end_time = AV_NOPTS_VALUE;
1911
    do{
1912
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1913
    if (offset < 0)
1914
        offset = 0;
1915

    
1916
    url_fseek(ic->pb, offset, SEEK_SET);
1917
    read_size = 0;
1918
    for(;;) {
1919
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1920
            break;
1921

    
1922
        do{
1923
            ret = av_read_packet(ic, pkt);
1924
        }while(ret == AVERROR(EAGAIN));
1925
        if (ret != 0)
1926
            break;
1927
        read_size += pkt->size;
1928
        st = ic->streams[pkt->stream_index];
1929
        if (pkt->pts != AV_NOPTS_VALUE &&
1930
            (st->start_time != AV_NOPTS_VALUE ||
1931
             st->first_dts  != AV_NOPTS_VALUE)) {
1932
            duration = end_time = pkt->pts;
1933
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1934
            else                                   duration -= st->first_dts;
1935
            if (duration < 0)
1936
                duration += 1LL<<st->pts_wrap_bits;
1937
            if (duration > 0) {
1938
                if (st->duration == AV_NOPTS_VALUE ||
1939
                    st->duration < duration)
1940
                    st->duration = duration;
1941
            }
1942
        }
1943
        av_free_packet(pkt);
1944
    }
1945
    }while(   end_time==AV_NOPTS_VALUE
1946
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1947
           && ++retry <= DURATION_MAX_RETRY);
1948

    
1949
    fill_all_stream_timings(ic);
1950

    
1951
    url_fseek(ic->pb, old_offset, SEEK_SET);
1952
    for (i=0; i<ic->nb_streams; i++) {
1953
        st= ic->streams[i];
1954
        st->cur_dts= st->first_dts;
1955
        st->last_IP_pts = AV_NOPTS_VALUE;
1956
    }
1957
}
1958

    
1959
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1960
{
1961
    int64_t file_size;
1962

    
1963
    /* get the file size, if possible */
1964
    if (ic->iformat->flags & AVFMT_NOFILE) {
1965
        file_size = 0;
1966
    } else {
1967
        file_size = url_fsize(ic->pb);
1968
        if (file_size < 0)
1969
            file_size = 0;
1970
    }
1971
    ic->file_size = file_size;
1972

    
1973
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1974
         !strcmp(ic->iformat->name, "mpegts")) &&
1975
        file_size && !url_is_streamed(ic->pb)) {
1976
        /* get accurate estimate from the PTSes */
1977
        av_estimate_timings_from_pts(ic, old_offset);
1978
    } else if (av_has_duration(ic)) {
1979
        /* at least one component has timings - we use them for all
1980
           the components */
1981
        fill_all_stream_timings(ic);
1982
    } else {
1983
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1984
        /* less precise: use bitrate info */
1985
        av_estimate_timings_from_bit_rate(ic);
1986
    }
1987
    av_update_stream_timings(ic);
1988

    
1989
#if 0
1990
    {
1991
        int i;
1992
        AVStream *st;
1993
        for(i = 0;i < ic->nb_streams; i++) {
1994
            st = ic->streams[i];
1995
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1996
               i, (double)st->start_time / AV_TIME_BASE,
1997
               (double)st->duration / AV_TIME_BASE);
1998
        }
1999
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2000
               (double)ic->start_time / AV_TIME_BASE,
2001
               (double)ic->duration / AV_TIME_BASE,
2002
               ic->bit_rate / 1000);
2003
    }
2004
#endif
2005
}
2006

    
2007
static int has_codec_parameters(AVCodecContext *enc)
2008
{
2009
    int val;
2010
    switch(enc->codec_type) {
2011
    case AVMEDIA_TYPE_AUDIO:
2012
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
2013
        if(!enc->frame_size &&
2014
           (enc->codec_id == CODEC_ID_VORBIS ||
2015
            enc->codec_id == CODEC_ID_AAC ||
2016
            enc->codec_id == CODEC_ID_MP1 ||
2017
            enc->codec_id == CODEC_ID_MP2 ||
2018
            enc->codec_id == CODEC_ID_MP3 ||
2019
            enc->codec_id == CODEC_ID_SPEEX))
2020
            return 0;
2021
        break;
2022
    case AVMEDIA_TYPE_VIDEO:
2023
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2024
        break;
2025
    default:
2026
        val = 1;
2027
        break;
2028
    }
2029
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2030
}
2031

    
2032
static int has_decode_delay_been_guessed(AVStream *st)
2033
{
2034
    return st->codec->codec_id != CODEC_ID_H264 ||
2035
        st->codec_info_nb_frames >= 4 + st->codec->has_b_frames;
2036
}
2037

    
2038
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2039
{
2040
    int16_t *samples;
2041
    AVCodec *codec;
2042
    int got_picture, data_size, ret=0;
2043
    AVFrame picture;
2044

    
2045
    if(!st->codec->codec){
2046
        codec = avcodec_find_decoder(st->codec->codec_id);
2047
        if (!codec)
2048
            return -1;
2049
        ret = avcodec_open(st->codec, codec);
2050
        if (ret < 0)
2051
            return ret;
2052
    }
2053

    
2054
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2055
        switch(st->codec->codec_type) {
2056
        case AVMEDIA_TYPE_VIDEO:
2057
            avcodec_get_frame_defaults(&picture);
2058
            ret = avcodec_decode_video2(st->codec, &picture,
2059
                                        &got_picture, avpkt);
2060
            break;
2061
        case AVMEDIA_TYPE_AUDIO:
2062
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2063
            samples = av_malloc(data_size);
2064
            if (!samples)
2065
                goto fail;
2066
            ret = avcodec_decode_audio3(st->codec, samples,
2067
                                        &data_size, avpkt);
2068
            av_free(samples);
2069
            break;
2070
        default:
2071
            break;
2072
        }
2073
    }
2074
 fail:
2075
    return ret;
2076
}
2077

    
2078
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2079
{
2080
    while (tags->id != CODEC_ID_NONE) {
2081
        if (tags->id == id)
2082
            return tags->tag;
2083
        tags++;
2084
    }
2085
    return 0;
2086
}
2087

    
2088
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2089
{
2090
    int i;
2091
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2092
        if(tag == tags[i].tag)
2093
            return tags[i].id;
2094
    }
2095
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2096
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2097
            return tags[i].id;
2098
    }
2099
    return CODEC_ID_NONE;
2100
}
2101

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

    
2112
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2113
{
2114
    int i;
2115
    for(i=0; tags && tags[i]; i++){
2116
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2117
        if(id!=CODEC_ID_NONE) return id;
2118
    }
2119
    return CODEC_ID_NONE;
2120
}
2121

    
2122
static void compute_chapters_end(AVFormatContext *s)
2123
{
2124
    unsigned int i;
2125

    
2126
    for (i=0; i+1<s->nb_chapters; i++)
2127
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2128
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2129
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2130
            s->chapters[i]->end = s->chapters[i+1]->start;
2131
        }
2132

    
2133
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2134
        assert(s->start_time != AV_NOPTS_VALUE);
2135
        assert(s->duration > 0);
2136
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2137
                                           AV_TIME_BASE_Q,
2138
                                           s->chapters[i]->time_base);
2139
    }
2140
}
2141

    
2142
static int get_std_framerate(int i){
2143
    if(i<60*12) return i*1001;
2144
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2145
}
2146

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

    
2167
int av_find_stream_info(AVFormatContext *ic)
2168
{
2169
    int i, count, ret, read_size, j;
2170
    AVStream *st;
2171
    AVPacket pkt1, *pkt;
2172
    int64_t old_offset = url_ftell(ic->pb);
2173

    
2174
    for(i=0;i<ic->nb_streams;i++) {
2175
        AVCodec *codec;
2176
        st = ic->streams[i];
2177
        if (st->codec->codec_id == CODEC_ID_AAC) {
2178
            st->codec->sample_rate = 0;
2179
            st->codec->frame_size = 0;
2180
            st->codec->channels = 0;
2181
        }
2182
        if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2183
/*            if(!st->time_base.num)
2184
                st->time_base= */
2185
            if(!st->codec->time_base.num)
2186
                st->codec->time_base= st->time_base;
2187
        }
2188
        //only for the split stuff
2189
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2190
            st->parser = av_parser_init(st->codec->codec_id);
2191
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2192
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2193
            }
2194
        }
2195
        assert(!st->codec->codec);
2196
        codec = avcodec_find_decoder(st->codec->codec_id);
2197

    
2198
        /* Force decoding of at least one frame of codec data
2199
         * this makes sure the codec initializes the channel configuration
2200
         * and does not trust the values from the container.
2201
         */
2202
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2203
            st->codec->channels = 0;
2204

    
2205
        //try to just open decoders, in case this is enough to get parameters
2206
        if(!has_codec_parameters(st->codec)){
2207
            if (codec)
2208
                avcodec_open(st->codec, codec);
2209
        }
2210
    }
2211

    
2212
    for (i=0; i<ic->nb_streams; i++) {
2213
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2214
    }
2215

    
2216
    count = 0;
2217
    read_size = 0;
2218
    for(;;) {
2219
        if(url_interrupt_cb()){
2220
            ret= AVERROR(EINTR);
2221
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2222
            break;
2223
        }
2224

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

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

    
2276
        if (ret == AVERROR(EAGAIN))
2277
            continue;
2278

    
2279
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2280
        if ((ret = av_dup_packet(pkt)) < 0)
2281
            goto find_stream_info_err;
2282

    
2283
        read_size += pkt->size;
2284

    
2285
        st = ic->streams[pkt->stream_index];
2286
        if (st->codec_info_nb_frames>1) {
2287
            if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2288
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2289
                break;
2290
            }
2291
            st->info->codec_info_duration += pkt->duration;
2292
        }
2293
        {
2294
            int64_t last = st->info->last_dts;
2295
            int64_t duration= pkt->dts - last;
2296

    
2297
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2298
                double dur= duration * av_q2d(st->time_base);
2299

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

    
2328
        /* if still no information, we try to open the codec and to
2329
           decompress the frame. We try to avoid that in most cases as
2330
           it takes longer and uses more memory. For MPEG-4, we need to
2331
           decompress for QuickTime. */
2332
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2333
            try_decode_frame(st, pkt);
2334

    
2335
        st->codec_info_nb_frames++;
2336
        count++;
2337
    }
2338

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

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

    
2368
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2369
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2370
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2371
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2372
                    if(error < best_error){
2373
                        best_error= error;
2374
                        num = get_std_framerate(j);
2375
                    }
2376
                }
2377
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2378
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2379
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2380
            }
2381

    
2382
            if (!st->r_frame_rate.num){
2383
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2384
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2385
                    st->r_frame_rate.num = st->codec->time_base.den;
2386
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2387
                }else{
2388
                    st->r_frame_rate.num = st->time_base.den;
2389
                    st->r_frame_rate.den = st->time_base.num;
2390
                }
2391
            }
2392
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2393
            if(!st->codec->bits_per_coded_sample)
2394
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2395
        }
2396
    }
2397

    
2398
    av_estimate_timings(ic, old_offset);
2399

    
2400
    compute_chapters_end(ic);
2401

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

    
2427
 find_stream_info_err:
2428
    for (i=0; i < ic->nb_streams; i++)
2429
        av_freep(&ic->streams[i]->info);
2430
    return ret;
2431
}
2432

    
2433
/*******************************************************/
2434

    
2435
int av_read_play(AVFormatContext *s)
2436
{
2437
    if (s->iformat->read_play)
2438
        return s->iformat->read_play(s);
2439
    if (s->pb)
2440
        return av_url_read_fpause(s->pb, 0);
2441
    return AVERROR(ENOSYS);
2442
}
2443

    
2444
int av_read_pause(AVFormatContext *s)
2445
{
2446
    if (s->iformat->read_pause)
2447
        return s->iformat->read_pause(s);
2448
    if (s->pb)
2449
        return av_url_read_fpause(s->pb, 1);
2450
    return AVERROR(ENOSYS);
2451
}
2452

    
2453
void av_close_input_stream(AVFormatContext *s)
2454
{
2455
    int i;
2456
    AVStream *st;
2457

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

    
2503
void av_close_input_file(AVFormatContext *s)
2504
{
2505
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2506
    av_close_input_stream(s);
2507
    if (pb)
2508
        url_fclose(pb);
2509
}
2510

    
2511
AVStream *av_new_stream(AVFormatContext *s, int id)
2512
{
2513
    AVStream *st;
2514
    int i;
2515

    
2516
#if FF_API_MAX_STREAMS
2517
    if (s->nb_streams >= MAX_STREAMS){
2518
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2519
        return NULL;
2520
    }
2521
#else
2522
    AVStream **streams;
2523

    
2524
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2525
        return NULL;
2526
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2527
    if (!streams)
2528
        return NULL;
2529
    s->streams = streams;
2530
#endif
2531

    
2532
    st = av_mallocz(sizeof(AVStream));
2533
    if (!st)
2534
        return NULL;
2535
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2536
        av_free(st);
2537
        return NULL;
2538
    }
2539

    
2540
    st->codec= avcodec_alloc_context();
2541
    if (s->iformat) {
2542
        /* no default bitrate if decoding */
2543
        st->codec->bit_rate = 0;
2544
    }
2545
    st->index = s->nb_streams;
2546
    st->id = id;
2547
    st->start_time = AV_NOPTS_VALUE;
2548
    st->duration = AV_NOPTS_VALUE;
2549
        /* we set the current DTS to 0 so that formats without any timestamps
2550
           but durations get some timestamps, formats with some unknown
2551
           timestamps have their first few packets buffered and the
2552
           timestamps corrected before they are returned to the user */
2553
    st->cur_dts = 0;
2554
    st->first_dts = AV_NOPTS_VALUE;
2555
    st->probe_packets = MAX_PROBE_PACKETS;
2556

    
2557
    /* default pts setting is MPEG-like */
2558
    av_set_pts_info(st, 33, 1, 90000);
2559
    st->last_IP_pts = AV_NOPTS_VALUE;
2560
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2561
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2562
    st->reference_dts = AV_NOPTS_VALUE;
2563

    
2564
    st->sample_aspect_ratio = (AVRational){0,1};
2565

    
2566
    s->streams[s->nb_streams++] = st;
2567
    return st;
2568
}
2569

    
2570
AVProgram *av_new_program(AVFormatContext *ac, int id)
2571
{
2572
    AVProgram *program=NULL;
2573
    int i;
2574

    
2575
#ifdef DEBUG_SI
2576
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2577
#endif
2578

    
2579
    for(i=0; i<ac->nb_programs; i++)
2580
        if(ac->programs[i]->id == id)
2581
            program = ac->programs[i];
2582

    
2583
    if(!program){
2584
        program = av_mallocz(sizeof(AVProgram));
2585
        if (!program)
2586
            return NULL;
2587
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2588
        program->discard = AVDISCARD_NONE;
2589
    }
2590
    program->id = id;
2591

    
2592
    return program;
2593
}
2594

    
2595
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2596
{
2597
    AVChapter *chapter = NULL;
2598
    int i;
2599

    
2600
    for(i=0; i<s->nb_chapters; i++)
2601
        if(s->chapters[i]->id == id)
2602
            chapter = s->chapters[i];
2603

    
2604
    if(!chapter){
2605
        chapter= av_mallocz(sizeof(AVChapter));
2606
        if(!chapter)
2607
            return NULL;
2608
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2609
    }
2610
#if FF_API_OLD_METADATA
2611
    av_free(chapter->title);
2612
#endif
2613
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2614
    chapter->id    = id;
2615
    chapter->time_base= time_base;
2616
    chapter->start = start;
2617
    chapter->end   = end;
2618

    
2619
    return chapter;
2620
}
2621

    
2622
/************************************************************/
2623
/* output media file */
2624

    
2625
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2626
{
2627
    int ret;
2628

    
2629
    if (s->oformat->priv_data_size > 0) {
2630
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2631
        if (!s->priv_data)
2632
            return AVERROR(ENOMEM);
2633
    } else
2634
        s->priv_data = NULL;
2635

    
2636
    if (s->oformat->set_parameters) {
2637
        ret = s->oformat->set_parameters(s, ap);
2638
        if (ret < 0)
2639
            return ret;
2640
    }
2641
    return 0;
2642
}
2643

    
2644
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2645
{
2646
    const AVCodecTag *avctag;
2647
    int n;
2648
    enum CodecID id = CODEC_ID_NONE;
2649
    unsigned int tag = 0;
2650

    
2651
    /**
2652
     * Check that tag + id is in the table
2653
     * If neither is in the table -> OK
2654
     * If tag is in the table with another id -> FAIL
2655
     * If id is in the table with another tag -> FAIL unless strict < normal
2656
     */
2657
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2658
        avctag = s->oformat->codec_tag[n];
2659
        while (avctag->id != CODEC_ID_NONE) {
2660
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2661
                id = avctag->id;
2662
                if (id == st->codec->codec_id)
2663
                    return 1;
2664
            }
2665
            if (avctag->id == st->codec->codec_id)
2666
                tag = avctag->tag;
2667
            avctag++;
2668
        }
2669
    }
2670
    if (id != CODEC_ID_NONE)
2671
        return 0;
2672
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2673
        return 0;
2674
    return 1;
2675
}
2676

    
2677
int av_write_header(AVFormatContext *s)
2678
{
2679
    int ret, i;
2680
    AVStream *st;
2681

    
2682
    // some sanity checks
2683
    if (s->nb_streams == 0) {
2684
        av_log(s, AV_LOG_ERROR, "no streams\n");
2685
        return AVERROR(EINVAL);
2686
    }
2687

    
2688
    for(i=0;i<s->nb_streams;i++) {
2689
        st = s->streams[i];
2690

    
2691
        switch (st->codec->codec_type) {
2692
        case AVMEDIA_TYPE_AUDIO:
2693
            if(st->codec->sample_rate<=0){
2694
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2695
                return AVERROR(EINVAL);
2696
            }
2697
            if(!st->codec->block_align)
2698
                st->codec->block_align = st->codec->channels *
2699
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2700
            break;
2701
        case AVMEDIA_TYPE_VIDEO:
2702
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2703
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2704
                return AVERROR(EINVAL);
2705
            }
2706
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2707
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2708
                return AVERROR(EINVAL);
2709
            }
2710
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2711
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2712
                return AVERROR(EINVAL);
2713
            }
2714
            break;
2715
        }
2716

    
2717
        if(s->oformat->codec_tag){
2718
            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)){
2719
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2720
                st->codec->codec_tag= 0;
2721
            }
2722
            if(st->codec->codec_tag){
2723
                if (!validate_codec_tag(s, st)) {
2724
                    char tagbuf[32];
2725
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2726
                    av_log(s, AV_LOG_ERROR,
2727
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2728
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2729
                    return AVERROR_INVALIDDATA;
2730
                }
2731
            }else
2732
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2733
        }
2734

    
2735
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2736
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2737
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2738
    }
2739

    
2740
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2741
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2742
        if (!s->priv_data)
2743
            return AVERROR(ENOMEM);
2744
    }
2745

    
2746
#if FF_API_OLD_METADATA
2747
    ff_metadata_mux_compat(s);
2748
#endif
2749

    
2750
    /* set muxer identification string */
2751
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2752
        AVMetadata *m;
2753
        AVMetadataTag *t;
2754

    
2755
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2756
            return AVERROR(ENOMEM);
2757
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2758
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2759
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2760
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2761
        av_metadata_free(&m);
2762
    }
2763

    
2764
    if(s->oformat->write_header){
2765
        ret = s->oformat->write_header(s);
2766
        if (ret < 0)
2767
            return ret;
2768
    }
2769

    
2770
    /* init PTS generation */
2771
    for(i=0;i<s->nb_streams;i++) {
2772
        int64_t den = AV_NOPTS_VALUE;
2773
        st = s->streams[i];
2774

    
2775
        switch (st->codec->codec_type) {
2776
        case AVMEDIA_TYPE_AUDIO:
2777
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2778
            break;
2779
        case AVMEDIA_TYPE_VIDEO:
2780
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2781
            break;
2782
        default:
2783
            break;
2784
        }
2785
        if (den != AV_NOPTS_VALUE) {
2786
            if (den <= 0)
2787
                return AVERROR_INVALIDDATA;
2788
            av_frac_init(&st->pts, 0, 0, den);
2789
        }
2790
    }
2791
    return 0;
2792
}
2793

    
2794
//FIXME merge with compute_pkt_fields
2795
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2796
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2797
    int num, den, frame_size, i;
2798

    
2799
//    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);
2800

    
2801
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2802
        return -1;*/
2803

    
2804
    /* duration field */
2805
    if (pkt->duration == 0) {
2806
        compute_frame_duration(&num, &den, st, NULL, pkt);
2807
        if (den && num) {
2808
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2809
        }
2810
    }
2811

    
2812
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2813
        pkt->pts= pkt->dts;
2814

    
2815
    //XXX/FIXME this is a temporary hack until all encoders output pts
2816
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2817
        pkt->dts=
2818
//        pkt->pts= st->cur_dts;
2819
        pkt->pts= st->pts.val;
2820
    }
2821

    
2822
    //calculate dts from pts
2823
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2824
        st->pts_buffer[0]= pkt->pts;
2825
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2826
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2827
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2828
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2829

    
2830
        pkt->dts= st->pts_buffer[0];
2831
    }
2832

    
2833
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2834
        av_log(s, AV_LOG_ERROR,
2835
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2836
               st->index, st->cur_dts, pkt->dts);
2837
        return -1;
2838
    }
2839
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2840
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2841
        return -1;
2842
    }
2843

    
2844
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2845
    st->cur_dts= pkt->dts;
2846
    st->pts.val= pkt->dts;
2847

    
2848
    /* update pts */
2849
    switch (st->codec->codec_type) {
2850
    case AVMEDIA_TYPE_AUDIO:
2851
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2852

    
2853
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2854
           likely equal to the encoder delay, but it would be better if we
2855
           had the real timestamps from the encoder */
2856
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2857
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2858
        }
2859
        break;
2860
    case AVMEDIA_TYPE_VIDEO:
2861
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2862
        break;
2863
    default:
2864
        break;
2865
    }
2866
    return 0;
2867
}
2868

    
2869
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2870
{
2871
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2872

    
2873
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2874
        return ret;
2875

    
2876
    ret= s->oformat->write_packet(s, pkt);
2877
    if(!ret)
2878
        ret= url_ferror(s->pb);
2879
    return ret;
2880
}
2881

    
2882
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2883
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2884
{
2885
    AVPacketList **next_point, *this_pktl;
2886

    
2887
    this_pktl = av_mallocz(sizeof(AVPacketList));
2888
    this_pktl->pkt= *pkt;
2889
    pkt->destruct= NULL;             // do not free original but only the copy
2890
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2891

    
2892
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2893
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2894
    }else
2895
        next_point = &s->packet_buffer;
2896

    
2897
    if(*next_point){
2898
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2899
            while(!compare(s, &(*next_point)->pkt, pkt)){
2900
                next_point= &(*next_point)->next;
2901
            }
2902
            goto next_non_null;
2903
        }else{
2904
            next_point = &(s->packet_buffer_end->next);
2905
        }
2906
    }
2907
    assert(!*next_point);
2908

    
2909
    s->packet_buffer_end= this_pktl;
2910
next_non_null:
2911

    
2912
    this_pktl->next= *next_point;
2913

    
2914
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2915
    *next_point= this_pktl;
2916
}
2917

    
2918
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2919
{
2920
    AVStream *st = s->streams[ pkt ->stream_index];
2921
    AVStream *st2= s->streams[ next->stream_index];
2922
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2923
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2924
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2925
}
2926

    
2927
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2928
    AVPacketList *pktl;
2929
    int stream_count=0;
2930
    int i;
2931

    
2932
    if(pkt){
2933
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2934
    }
2935

    
2936
    for(i=0; i < s->nb_streams; i++)
2937
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2938

    
2939
    if(stream_count && (s->nb_streams == stream_count || flush)){
2940
        pktl= s->packet_buffer;
2941
        *out= pktl->pkt;
2942

    
2943
        s->packet_buffer= pktl->next;
2944
        if(!s->packet_buffer)
2945
            s->packet_buffer_end= NULL;
2946

    
2947
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2948
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2949
        av_freep(&pktl);
2950
        return 1;
2951
    }else{
2952
        av_init_packet(out);
2953
        return 0;
2954
    }
2955
}
2956

    
2957
/**
2958
 * Interleave an AVPacket correctly so it can be muxed.
2959
 * @param out the interleaved packet will be output here
2960
 * @param in the input packet
2961
 * @param flush 1 if no further packets are available as input and all
2962
 *              remaining packets should be output
2963
 * @return 1 if a packet was output, 0 if no packet could be output,
2964
 *         < 0 if an error occurred
2965
 */
2966
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2967
    if(s->oformat->interleave_packet)
2968
        return s->oformat->interleave_packet(s, out, in, flush);
2969
    else
2970
        return av_interleave_packet_per_dts(s, out, in, flush);
2971
}
2972

    
2973
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2974
    AVStream *st= s->streams[ pkt->stream_index];
2975

    
2976
    //FIXME/XXX/HACK drop zero sized packets
2977
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2978
        return 0;
2979

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

    
2984
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2985
        return -1;
2986

    
2987
    for(;;){
2988
        AVPacket opkt;
2989
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2990
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2991
            return ret;
2992

    
2993
        ret= s->oformat->write_packet(s, &opkt);
2994

    
2995
        av_free_packet(&opkt);
2996
        pkt= NULL;
2997

    
2998
        if(ret<0)
2999
            return ret;
3000
        if(url_ferror(s->pb))
3001
            return url_ferror(s->pb);
3002
    }
3003
}
3004

    
3005
int av_write_trailer(AVFormatContext *s)
3006
{
3007
    int ret, i;
3008

    
3009
    for(;;){
3010
        AVPacket pkt;
3011
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3012
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3013
            goto fail;
3014
        if(!ret)
3015
            break;
3016

    
3017
        ret= s->oformat->write_packet(s, &pkt);
3018

    
3019
        av_free_packet(&pkt);
3020

    
3021
        if(ret<0)
3022
            goto fail;
3023
        if(url_ferror(s->pb))
3024
            goto fail;
3025
    }
3026

    
3027
    if(s->oformat->write_trailer)
3028
        ret = s->oformat->write_trailer(s);
3029
fail:
3030
    if(ret == 0)
3031
       ret=url_ferror(s->pb);
3032
    for(i=0;i<s->nb_streams;i++) {
3033
        av_freep(&s->streams[i]->priv_data);
3034
        av_freep(&s->streams[i]->index_entries);
3035
    }
3036
    av_freep(&s->priv_data);
3037
    return ret;
3038
}
3039

    
3040
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3041
{
3042
    int i, j;
3043
    AVProgram *program=NULL;
3044
    void *tmp;
3045

    
3046
    if (idx >= ac->nb_streams) {
3047
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3048
        return;
3049
    }
3050

    
3051
    for(i=0; i<ac->nb_programs; i++){
3052
        if(ac->programs[i]->id != progid)
3053
            continue;
3054
        program = ac->programs[i];
3055
        for(j=0; j<program->nb_stream_indexes; j++)
3056
            if(program->stream_index[j] == idx)
3057
                return;
3058

    
3059
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3060
        if(!tmp)
3061
            return;
3062
        program->stream_index = tmp;
3063
        program->stream_index[program->nb_stream_indexes++] = idx;
3064
        return;
3065
    }
3066
}
3067

    
3068
static void print_fps(double d, const char *postfix){
3069
    uint64_t v= lrintf(d*100);
3070
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3071
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3072
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3073
}
3074

    
3075
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3076
{
3077
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3078
        AVMetadataTag *tag=NULL;
3079

    
3080
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3081
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3082
            if(strcmp("language", tag->key))
3083
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3084
        }
3085
    }
3086
}
3087

    
3088
/* "user interface" functions */
3089
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3090
{
3091
    char buf[256];
3092
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3093
    AVStream *st = ic->streams[i];
3094
    int g = av_gcd(st->time_base.num, st->time_base.den);
3095
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3096
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3097
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3098
    /* the pid is an important information, so we display it */
3099
    /* XXX: add a generic system */
3100
    if (flags & AVFMT_SHOW_IDS)
3101
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3102
    if (lang)
3103
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3104
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3105
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3106
    if (st->sample_aspect_ratio.num && // default
3107
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3108
        AVRational display_aspect_ratio;
3109
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3110
                  st->codec->width*st->sample_aspect_ratio.num,
3111
                  st->codec->height*st->sample_aspect_ratio.den,
3112
                  1024*1024);
3113
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3114
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3115
                 display_aspect_ratio.num, display_aspect_ratio.den);
3116
    }
3117
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3118
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3119
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3120
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3121
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3122
        if(st->time_base.den && st->time_base.num)
3123
            print_fps(1/av_q2d(st->time_base), "tbn");
3124
        if(st->codec->time_base.den && st->codec->time_base.num)
3125
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3126
    }
3127
    av_log(NULL, AV_LOG_INFO, "\n");
3128
    dump_metadata(NULL, st->metadata, "    ");
3129
}
3130

    
3131
void dump_format(AVFormatContext *ic,
3132
                 int index,
3133
                 const char *url,
3134
                 int is_output)
3135
{
3136
    int i;
3137
    uint8_t *printed = av_mallocz(ic->nb_streams);
3138
    if (ic->nb_streams && !printed)
3139
        return;
3140

    
3141
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3142
            is_output ? "Output" : "Input",
3143
            index,
3144
            is_output ? ic->oformat->name : ic->iformat->name,
3145
            is_output ? "to" : "from", url);
3146
    dump_metadata(NULL, ic->metadata, "  ");
3147
    if (!is_output) {
3148
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3149
        if (ic->duration != AV_NOPTS_VALUE) {
3150
            int hours, mins, secs, us;
3151
            secs = ic->duration / AV_TIME_BASE;
3152
            us = ic->duration % AV_TIME_BASE;
3153
            mins = secs / 60;
3154
            secs %= 60;
3155
            hours = mins / 60;
3156
            mins %= 60;
3157
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3158
                   (100 * us) / AV_TIME_BASE);
3159
        } else {
3160
            av_log(NULL, AV_LOG_INFO, "N/A");
3161
        }
3162
        if (ic->start_time != AV_NOPTS_VALUE) {
3163
            int secs, us;
3164
            av_log(NULL, AV_LOG_INFO, ", start: ");
3165
            secs = ic->start_time / AV_TIME_BASE;
3166
            us = abs(ic->start_time % AV_TIME_BASE);
3167
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3168
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3169
        }
3170
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3171
        if (ic->bit_rate) {
3172
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3173
        } else {
3174
            av_log(NULL, AV_LOG_INFO, "N/A");
3175
        }
3176
        av_log(NULL, AV_LOG_INFO, "\n");
3177
    }
3178
    for (i = 0; i < ic->nb_chapters; i++) {
3179
        AVChapter *ch = ic->chapters[i];
3180
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3181
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3182
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3183

    
3184
        dump_metadata(NULL, ch->metadata, "    ");
3185
    }
3186
    if(ic->nb_programs) {
3187
        int j, k, total = 0;
3188
        for(j=0; j<ic->nb_programs; j++) {
3189
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3190
                                                  "name", NULL, 0);
3191
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3192
                   name ? name->value : "");
3193
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3194
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3195
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3196
                printed[ic->programs[j]->stream_index[k]] = 1;
3197
            }
3198
            total += ic->programs[j]->nb_stream_indexes;
3199
        }
3200
        if (total < ic->nb_streams)
3201
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3202
    }
3203
    for(i=0;i<ic->nb_streams;i++)
3204
        if (!printed[i])
3205
            dump_stream_format(ic, i, index, is_output);
3206

    
3207
    av_free(printed);
3208
}
3209

    
3210
#if LIBAVFORMAT_VERSION_MAJOR < 53
3211
#include "libavcore/parseutils.h"
3212

    
3213
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3214
{
3215
    return av_parse_video_size(width_ptr, height_ptr, str);
3216
}
3217

    
3218
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3219
{
3220
    AVRational frame_rate;
3221
    int ret = av_parse_video_rate(&frame_rate, arg);
3222
    *frame_rate_num= frame_rate.num;
3223
    *frame_rate_den= frame_rate.den;
3224
    return ret;
3225
}
3226
#endif
3227

    
3228
int64_t av_gettime(void)
3229
{
3230
    struct timeval tv;
3231
    gettimeofday(&tv,NULL);
3232
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3233
}
3234

    
3235
uint64_t ff_ntp_time(void)
3236
{
3237
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3238
}
3239

    
3240
int64_t parse_date(const char *datestr, int duration)
3241
{
3242
    const char *p;
3243
    int64_t t;
3244
    struct tm dt;
3245
    int i;
3246
    static const char * const date_fmt[] = {
3247
        "%Y-%m-%d",
3248
        "%Y%m%d",
3249
    };
3250
    static const char * const time_fmt[] = {
3251
        "%H:%M:%S",
3252
        "%H%M%S",
3253
    };
3254
    const char *q;
3255
    int is_utc, len;
3256
    char lastch;
3257
    int negative = 0;
3258

    
3259
#undef time
3260
    time_t now = time(0);
3261

    
3262
    len = strlen(datestr);
3263
    if (len > 0)
3264
        lastch = datestr[len - 1];
3265
    else
3266
        lastch = '\0';
3267
    is_utc = (lastch == 'z' || lastch == 'Z');
3268

    
3269
    memset(&dt, 0, sizeof(dt));
3270

    
3271
    p = datestr;
3272
    q = NULL;
3273
    if (!duration) {
3274
        if (!strncasecmp(datestr, "now", len))
3275
            return (int64_t) now * 1000000;
3276

    
3277
        /* parse the year-month-day part */
3278
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3279
            q = small_strptime(p, date_fmt[i], &dt);
3280
            if (q) {
3281
                break;
3282
            }
3283
        }
3284

    
3285
        /* if the year-month-day part is missing, then take the
3286
         * current year-month-day time */
3287
        if (!q) {
3288
            if (is_utc) {
3289
                dt = *gmtime(&now);
3290
            } else {
3291
                dt = *localtime(&now);
3292
            }
3293
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3294
        } else {
3295
            p = q;
3296
        }
3297

    
3298
        if (*p == 'T' || *p == 't' || *p == ' ')
3299
            p++;
3300

    
3301
        /* parse the hour-minute-second part */
3302
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3303
            q = small_strptime(p, time_fmt[i], &dt);
3304
            if (q) {
3305
                break;
3306
            }
3307
        }
3308
    } else {
3309
        /* parse datestr as a duration */
3310
        if (p[0] == '-') {
3311
            negative = 1;
3312
            ++p;
3313
        }
3314
        /* parse datestr as HH:MM:SS */
3315
        q = small_strptime(p, time_fmt[0], &dt);
3316
        if (!q) {
3317
            /* parse datestr as S+ */
3318
            dt.tm_sec = strtol(p, (char **)&q, 10);
3319
            if (q == p)
3320
                /* the parsing didn't succeed */
3321
                return INT64_MIN;
3322
            dt.tm_min = 0;
3323
            dt.tm_hour = 0;
3324
        }
3325
    }
3326

    
3327
    /* Now we have all the fields that we can get */
3328
    if (!q) {
3329
        return INT64_MIN;
3330
    }
3331

    
3332
    if (duration) {
3333
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3334
    } else {
3335
        dt.tm_isdst = -1;       /* unknown */
3336
        if (is_utc) {
3337
            t = mktimegm(&dt);
3338
        } else {
3339
            t = mktime(&dt);
3340
        }
3341
    }
3342

    
3343
    t *= 1000000;
3344

    
3345
    /* parse the .m... part */
3346
    if (*q == '.') {
3347
        int val, n;
3348
        q++;
3349
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3350
            if (!isdigit(*q))
3351
                break;
3352
            val += n * (*q - '0');
3353
        }
3354
        t += val;
3355
    }
3356
    return negative ? -t : t;
3357
}
3358

    
3359
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3360
{
3361
    const char *p;
3362
    char tag[128], *q;
3363

    
3364
    p = info;
3365
    if (*p == '?')
3366
        p++;
3367
    for(;;) {
3368
        q = tag;
3369
        while (*p != '\0' && *p != '=' && *p != '&') {
3370
            if ((q - tag) < sizeof(tag) - 1)
3371
                *q++ = *p;
3372
            p++;
3373
        }
3374
        *q = '\0';
3375
        q = arg;
3376
        if (*p == '=') {
3377
            p++;
3378
            while (*p != '&' && *p != '\0') {
3379
                if ((q - arg) < arg_size - 1) {
3380
                    if (*p == '+')
3381
                        *q++ = ' ';
3382
                    else
3383
                        *q++ = *p;
3384
                }
3385
                p++;
3386
            }
3387
        }
3388
        *q = '\0';
3389
        if (!strcmp(tag, tag1))
3390
            return 1;
3391
        if (*p != '&')
3392
            break;
3393
        p++;
3394
    }
3395
    return 0;
3396
}
3397

    
3398
int av_get_frame_filename(char *buf, int buf_size,
3399
                          const char *path, int number)
3400
{
3401
    const char *p;
3402
    char *q, buf1[20], c;
3403
    int nd, len, percentd_found;
3404

    
3405
    q = buf;
3406
    p = path;
3407
    percentd_found = 0;
3408
    for(;;) {
3409
        c = *p++;
3410
        if (c == '\0')
3411
            break;
3412
        if (c == '%') {
3413
            do {
3414
                nd = 0;
3415
                while (isdigit(*p)) {
3416
                    nd = nd * 10 + *p++ - '0';
3417
                }
3418
                c = *p++;
3419
            } while (isdigit(c));
3420

    
3421
            switch(c) {
3422
            case '%':
3423
                goto addchar;
3424
            case 'd':
3425
                if (percentd_found)
3426
                    goto fail;
3427
                percentd_found = 1;
3428
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3429
                len = strlen(buf1);
3430
                if ((q - buf + len) > buf_size - 1)
3431
                    goto fail;
3432
                memcpy(q, buf1, len);
3433
                q += len;
3434
                break;
3435
            default:
3436
                goto fail;
3437
            }
3438
        } else {
3439
        addchar:
3440
            if ((q - buf) < buf_size - 1)
3441
                *q++ = c;
3442
        }
3443
    }
3444
    if (!percentd_found)
3445
        goto fail;
3446
    *q = '\0';
3447
    return 0;
3448
 fail:
3449
    *q = '\0';
3450
    return -1;
3451
}
3452

    
3453
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3454
{
3455
    int len, i, j, c;
3456
#undef fprintf
3457
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3458

    
3459
    for(i=0;i<size;i+=16) {
3460
        len = size - i;
3461
        if (len > 16)
3462
            len = 16;
3463
        PRINT("%08x ", i);
3464
        for(j=0;j<16;j++) {
3465
            if (j < len)
3466
                PRINT(" %02x", buf[i+j]);
3467
            else
3468
                PRINT("   ");
3469
        }
3470
        PRINT(" ");
3471
        for(j=0;j<len;j++) {
3472
            c = buf[i+j];
3473
            if (c < ' ' || c > '~')
3474
                c = '.';
3475
            PRINT("%c", c);
3476
        }
3477
        PRINT("\n");
3478
    }
3479
#undef PRINT
3480
}
3481

    
3482
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3483
{
3484
    hex_dump_internal(NULL, f, 0, buf, size);
3485
}
3486

    
3487
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3488
{
3489
    hex_dump_internal(avcl, NULL, level, buf, size);
3490
}
3491

    
3492
 //FIXME needs to know the time_base
3493
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3494
{
3495
#undef fprintf
3496
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3497
    PRINT("stream #%d:\n", pkt->stream_index);
3498
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3499
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3500
    /* DTS is _always_ valid after av_read_frame() */
3501
    PRINT("  dts=");
3502
    if (pkt->dts == AV_NOPTS_VALUE)
3503
        PRINT("N/A");
3504
    else
3505
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3506
    /* PTS may not be known if B-frames are present. */
3507
    PRINT("  pts=");
3508
    if (pkt->pts == AV_NOPTS_VALUE)
3509
        PRINT("N/A");
3510
    else
3511
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3512
    PRINT("\n");
3513
    PRINT("  size=%d\n", pkt->size);
3514
#undef PRINT
3515
    if (dump_payload)
3516
        av_hex_dump(f, pkt->data, pkt->size);
3517
}
3518

    
3519
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3520
{
3521
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3522
}
3523

    
3524
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3525
{
3526
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3527
}
3528

    
3529
#if FF_API_URL_SPLIT
3530
attribute_deprecated
3531
void ff_url_split(char *proto, int proto_size,
3532
                  char *authorization, int authorization_size,
3533
                  char *hostname, int hostname_size,
3534
                  int *port_ptr,
3535
                  char *path, int path_size,
3536
                  const char *url)
3537
{
3538
    av_url_split(proto, proto_size,
3539
                 authorization, authorization_size,
3540
                 hostname, hostname_size,
3541
                 port_ptr,
3542
                 path, path_size,
3543
                 url);
3544
}
3545
#endif
3546

    
3547
void av_url_split(char *proto, int proto_size,
3548
                  char *authorization, int authorization_size,
3549
                  char *hostname, int hostname_size,
3550
                  int *port_ptr,
3551
                  char *path, int path_size,
3552
                  const char *url)
3553
{
3554
    const char *p, *ls, *at, *col, *brk;
3555

    
3556
    if (port_ptr)               *port_ptr = -1;
3557
    if (proto_size > 0)         proto[0] = 0;
3558
    if (authorization_size > 0) authorization[0] = 0;
3559
    if (hostname_size > 0)      hostname[0] = 0;
3560
    if (path_size > 0)          path[0] = 0;
3561

    
3562
    /* parse protocol */
3563
    if ((p = strchr(url, ':'))) {
3564
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3565
        p++; /* skip ':' */
3566
        if (*p == '/') p++;
3567
        if (*p == '/') p++;
3568
    } else {
3569
        /* no protocol means plain filename */
3570
        av_strlcpy(path, url, path_size);
3571
        return;
3572
    }
3573

    
3574
    /* separate path from hostname */
3575
    ls = strchr(p, '/');
3576
    if(!ls)
3577
        ls = strchr(p, '?');
3578
    if(ls)
3579
        av_strlcpy(path, ls, path_size);
3580
    else
3581
        ls = &p[strlen(p)]; // XXX
3582

    
3583
    /* the rest is hostname, use that to parse auth/port */
3584
    if (ls != p) {
3585
        /* authorization (user[:pass]@hostname) */
3586
        if ((at = strchr(p, '@')) && at < ls) {
3587
            av_strlcpy(authorization, p,
3588
                       FFMIN(authorization_size, at + 1 - p));
3589
            p = at + 1; /* skip '@' */
3590
        }
3591

    
3592
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3593
            /* [host]:port */
3594
            av_strlcpy(hostname, p + 1,
3595
                       FFMIN(hostname_size, brk - p));
3596
            if (brk[1] == ':' && port_ptr)
3597
                *port_ptr = atoi(brk + 2);
3598
        } else if ((col = strchr(p, ':')) && col < ls) {
3599
            av_strlcpy(hostname, p,
3600
                       FFMIN(col + 1 - p, hostname_size));
3601
            if (port_ptr) *port_ptr = atoi(col + 1);
3602
        } else
3603
            av_strlcpy(hostname, p,
3604
                       FFMIN(ls + 1 - p, hostname_size));
3605
    }
3606
}
3607

    
3608
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3609
{
3610
    int i;
3611
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3612
                                           '4', '5', '6', '7',
3613
                                           '8', '9', 'A', 'B',
3614
                                           'C', 'D', 'E', 'F' };
3615
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3616
                                           '4', '5', '6', '7',
3617
                                           '8', '9', 'a', 'b',
3618
                                           'c', 'd', 'e', 'f' };
3619
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3620

    
3621
    for(i = 0; i < s; i++) {
3622
        buff[i * 2]     = hex_table[src[i] >> 4];
3623
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3624
    }
3625

    
3626
    return buff;
3627
}
3628

    
3629
int ff_hex_to_data(uint8_t *data, const char *p)
3630
{
3631
    int c, len, v;
3632

    
3633
    len = 0;
3634
    v = 1;
3635
    for (;;) {
3636
        p += strspn(p, SPACE_CHARS);
3637
        if (*p == '\0')
3638
            break;
3639
        c = toupper((unsigned char) *p++);
3640
        if (c >= '0' && c <= '9')
3641
            c = c - '0';
3642
        else if (c >= 'A' && c <= 'F')
3643
            c = c - 'A' + 10;
3644
        else
3645
            break;
3646
        v = (v << 4) | c;
3647
        if (v & 0x100) {
3648
            if (data)
3649
                data[len] = v;
3650
            len++;
3651
            v = 1;
3652
        }
3653
    }
3654
    return len;
3655
}
3656

    
3657
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3658
                     unsigned int pts_num, unsigned int pts_den)
3659
{
3660
    s->pts_wrap_bits = pts_wrap_bits;
3661

    
3662
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3663
        if(s->time_base.num != pts_num)
3664
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3665
    }else
3666
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3667

    
3668
    if(!s->time_base.num || !s->time_base.den)
3669
        s->time_base.num= s->time_base.den= 0;
3670
}
3671

    
3672
int ff_url_join(char *str, int size, const char *proto,
3673
                const char *authorization, const char *hostname,
3674
                int port, const char *fmt, ...)
3675
{
3676
#if CONFIG_NETWORK
3677
    struct addrinfo hints, *ai;
3678
#endif
3679

    
3680
    str[0] = '\0';
3681
    if (proto)
3682
        av_strlcatf(str, size, "%s://", proto);
3683
    if (authorization && authorization[0])
3684
        av_strlcatf(str, size, "%s@", authorization);
3685
#if CONFIG_NETWORK && defined(AF_INET6)
3686
    /* Determine if hostname is a numerical IPv6 address,
3687
     * properly escape it within [] in that case. */
3688
    memset(&hints, 0, sizeof(hints));
3689
    hints.ai_flags = AI_NUMERICHOST;
3690
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3691
        if (ai->ai_family == AF_INET6) {
3692
            av_strlcat(str, "[", size);
3693
            av_strlcat(str, hostname, size);
3694
            av_strlcat(str, "]", size);
3695
        } else {
3696
            av_strlcat(str, hostname, size);
3697
        }
3698
        freeaddrinfo(ai);
3699
    } else
3700
#endif
3701
        /* Not an IPv6 address, just output the plain string. */
3702
        av_strlcat(str, hostname, size);
3703

    
3704
    if (port >= 0)
3705
        av_strlcatf(str, size, ":%d", port);
3706
    if (fmt) {
3707
        va_list vl;
3708
        int len = strlen(str);
3709

    
3710
        va_start(vl, fmt);
3711
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3712
        va_end(vl);
3713
    }
3714
    return strlen(str);
3715
}
3716

    
3717
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3718
                     AVFormatContext *src)
3719
{
3720
    AVPacket local_pkt;
3721

    
3722
    local_pkt = *pkt;
3723
    local_pkt.stream_index = dst_stream;
3724
    if (pkt->pts != AV_NOPTS_VALUE)
3725
        local_pkt.pts = av_rescale_q(pkt->pts,
3726
                                     src->streams[pkt->stream_index]->time_base,
3727
                                     dst->streams[dst_stream]->time_base);
3728
    if (pkt->dts != AV_NOPTS_VALUE)
3729
        local_pkt.dts = av_rescale_q(pkt->dts,
3730
                                     src->streams[pkt->stream_index]->time_base,
3731
                                     dst->streams[dst_stream]->time_base);
3732
    return av_write_frame(dst, &local_pkt);
3733
}
3734

    
3735
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3736
                        void *context)
3737
{
3738
    const char *ptr = str;
3739

    
3740
    /* Parse key=value pairs. */
3741
    for (;;) {
3742
        const char *key;
3743
        char *dest = NULL, *dest_end;
3744
        int key_len, dest_len = 0;
3745

    
3746
        /* Skip whitespace and potential commas. */
3747
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3748
            ptr++;
3749
        if (!*ptr)
3750
            break;
3751

    
3752
        key = ptr;
3753

    
3754
        if (!(ptr = strchr(key, '=')))
3755
            break;
3756
        ptr++;
3757
        key_len = ptr - key;
3758

    
3759
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3760
        dest_end = dest + dest_len - 1;
3761

    
3762
        if (*ptr == '\"') {
3763
            ptr++;
3764
            while (*ptr && *ptr != '\"') {
3765
                if (*ptr == '\\') {
3766
                    if (!ptr[1])
3767
                        break;
3768
                    if (dest && dest < dest_end)
3769
                        *dest++ = ptr[1];
3770
                    ptr += 2;
3771
                } else {
3772
                    if (dest && dest < dest_end)
3773
                        *dest++ = *ptr;
3774
                    ptr++;
3775
                }
3776
            }
3777
            if (*ptr == '\"')
3778
                ptr++;
3779
        } else {
3780
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3781
                if (dest && dest < dest_end)
3782
                    *dest++ = *ptr;
3783
        }
3784
        if (dest)
3785
            *dest = 0;
3786
    }
3787
}
3788