Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ cb2c971d

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
#if !FF_API_FIRST_FORMAT
114
static
115
#endif
116
AVInputFormat *first_iformat = NULL;
117
/** head of registered output format linked list */
118
#if !FF_API_FIRST_FORMAT
119
static
120
#endif
121
AVOutputFormat *first_oformat = NULL;
122

    
123
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
124
{
125
    if(f) return f->next;
126
    else  return first_iformat;
127
}
128

    
129
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
130
{
131
    if(f) return f->next;
132
    else  return first_oformat;
133
}
134

    
135
void av_register_input_format(AVInputFormat *format)
136
{
137
    AVInputFormat **p;
138
    p = &first_iformat;
139
    while (*p != NULL) p = &(*p)->next;
140
    *p = format;
141
    format->next = NULL;
142
}
143

    
144
void av_register_output_format(AVOutputFormat *format)
145
{
146
    AVOutputFormat **p;
147
    p = &first_oformat;
148
    while (*p != NULL) p = &(*p)->next;
149
    *p = format;
150
    format->next = NULL;
151
}
152

    
153
int av_match_ext(const char *filename, const char *extensions)
154
{
155
    const char *ext, *p;
156
    char ext1[32], *q;
157

    
158
    if(!filename)
159
        return 0;
160

    
161
    ext = strrchr(filename, '.');
162
    if (ext) {
163
        ext++;
164
        p = extensions;
165
        for(;;) {
166
            q = ext1;
167
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
168
                *q++ = *p++;
169
            *q = '\0';
170
            if (!strcasecmp(ext1, ext))
171
                return 1;
172
            if (*p == '\0')
173
                break;
174
            p++;
175
        }
176
    }
177
    return 0;
178
}
179

    
180
static int match_format(const char *name, const char *names)
181
{
182
    const char *p;
183
    int len, namelen;
184

    
185
    if (!name || !names)
186
        return 0;
187

    
188
    namelen = strlen(name);
189
    while ((p = strchr(names, ','))) {
190
        len = FFMAX(p - names, namelen);
191
        if (!strncasecmp(name, names, len))
192
            return 1;
193
        names = p+1;
194
    }
195
    return !strcasecmp(name, names);
196
}
197

    
198
#if FF_API_GUESS_FORMAT
199
AVOutputFormat *guess_format(const char *short_name, const char *filename,
200
                             const char *mime_type)
201
{
202
    return av_guess_format(short_name, filename, mime_type);
203
}
204
#endif
205

    
206
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
207
                                const char *mime_type)
208
{
209
    AVOutputFormat *fmt = NULL, *fmt_found;
210
    int score_max, score;
211

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

    
241
#if FF_API_GUESS_FORMAT
242
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
243
                             const char *mime_type)
244
{
245
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
246

    
247
    if (fmt) {
248
        AVOutputFormat *stream_fmt;
249
        char stream_format_name[64];
250

    
251
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
252
        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
253

    
254
        if (stream_fmt)
255
            fmt = stream_fmt;
256
    }
257

    
258
    return fmt;
259
}
260
#endif
261

    
262
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
263
                            const char *filename, const char *mime_type, enum AVMediaType type){
264
    if(type == AVMEDIA_TYPE_VIDEO){
265
        enum CodecID codec_id= CODEC_ID_NONE;
266

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

    
281
AVInputFormat *av_find_input_format(const char *short_name)
282
{
283
    AVInputFormat *fmt = NULL;
284
    while ((fmt = av_iformat_next(fmt))) {
285
        if (match_format(short_name, fmt->name))
286
            return fmt;
287
    }
288
    return NULL;
289
}
290

    
291
#if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
292
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
293
{
294
    av_destruct_packet_nofree(pkt);
295
}
296

    
297
FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
298
{
299
    av_destruct_packet(pkt);
300
}
301

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

    
307
FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
308
{
309
    return av_dup_packet(pkt);
310
}
311

    
312
FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
313
{
314
    av_free_packet(pkt);
315
}
316

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

    
324
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
325
{
326
    int ret= av_new_packet(pkt, size);
327

    
328
    if(ret<0)
329
        return ret;
330

    
331
    pkt->pos= url_ftell(s);
332

    
333
    ret= get_buffer(s, pkt->data, size);
334
    if(ret<=0)
335
        av_free_packet(pkt);
336
    else
337
        av_shrink_packet(pkt, ret);
338

    
339
    return ret;
340
}
341

    
342

    
343
int av_filename_number_test(const char *filename)
344
{
345
    char buf[1024];
346
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
347
}
348

    
349
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
350
{
351
    AVProbeData lpd = *pd;
352
    AVInputFormat *fmt1 = NULL, *fmt;
353
    int score;
354

    
355
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
356
        int id3len = ff_id3v2_tag_len(lpd.buf);
357
        if (lpd.buf_size > id3len + 16) {
358
            lpd.buf += id3len;
359
            lpd.buf_size -= id3len;
360
        }
361
    }
362

    
363
    fmt = NULL;
364
    while ((fmt1 = av_iformat_next(fmt1))) {
365
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
366
            continue;
367
        score = 0;
368
        if (fmt1->read_probe) {
369
            score = fmt1->read_probe(&lpd);
370
        } else if (fmt1->extensions) {
371
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
372
                score = 50;
373
            }
374
        }
375
        if (score > *score_max) {
376
            *score_max = score;
377
            fmt = fmt1;
378
        }else if (score == *score_max)
379
            fmt = NULL;
380
    }
381
    return fmt;
382
}
383

    
384
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
385
    int score=0;
386
    return av_probe_input_format2(pd, is_opened, &score);
387
}
388

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

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

    
421
/************************************************************/
422
/* input media file */
423

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

    
435
    if(!ap){
436
        ap=&default_ap;
437
        memset(ap, 0, sizeof(default_ap));
438
    }
439

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

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

    
465
    // e.g. AVFMT_NOFILE formats will not have a ByteIOContext
466
    if (ic->pb)
467
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
468

    
469
    if (ic->iformat->read_header) {
470
        err = ic->iformat->read_header(ic, ap);
471
        if (err < 0)
472
            goto fail;
473
    }
474

    
475
    if (pb && !ic->data_offset)
476
        ic->data_offset = url_ftell(ic->pb);
477

    
478
#if FF_API_OLD_METADATA
479
    ff_metadata_demux_compat(ic);
480
#endif
481

    
482
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
483

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

    
506
/** size of probe buffer, for guessing file type from file contents */
507
#define PROBE_BUF_MIN 2048
508
#define PROBE_BUF_MAX (1<<20)
509

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

    
518
    if (!max_probe_size) {
519
        max_probe_size = PROBE_BUF_MAX;
520
    } else if (max_probe_size > PROBE_BUF_MAX) {
521
        max_probe_size = PROBE_BUF_MAX;
522
    } else if (max_probe_size < PROBE_BUF_MIN) {
523
        return AVERROR(EINVAL);
524
    }
525

    
526
    if (offset >= max_probe_size) {
527
        return AVERROR(EINVAL);
528
    }
529

    
530
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
531
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
532
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
533
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
534

    
535
        if (probe_size < offset) {
536
            continue;
537
        }
538

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

    
553
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
554

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

    
565
    if (!*fmt) {
566
        av_free(buf);
567
        return AVERROR_INVALIDDATA;
568
    }
569

    
570
    /* rewind. reuse probe buffer to avoid seeking */
571
    if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
572
        av_free(buf);
573

    
574
    return ret;
575
}
576

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

    
587
    pd->filename = "";
588
    if (filename)
589
        pd->filename = filename;
590
    pd->buf = NULL;
591
    pd->buf_size = 0;
592

    
593
    if (!fmt) {
594
        /* guess format if no file can be opened */
595
        fmt = av_probe_input_format(pd, 0);
596
    }
597

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

    
613
    /* if still no format found, error */
614
    if (!fmt) {
615
        err = AVERROR_INVALIDDATA;
616
        goto fail;
617
    }
618

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

    
639
}
640

    
641
/*******************************************************/
642

    
643
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
644
                               AVPacketList **plast_pktl){
645
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
646
    if (!pktl)
647
        return NULL;
648

    
649
    if (*packet_buffer)
650
        (*plast_pktl)->next = pktl;
651
    else
652
        *packet_buffer = pktl;
653

    
654
    /* add the packet in the buffered packet list */
655
    *plast_pktl = pktl;
656
    pktl->pkt= *pkt;
657
    return &pktl->pkt;
658
}
659

    
660
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
661
{
662
    int ret, i;
663
    AVStream *st;
664

    
665
    for(;;){
666
        AVPacketList *pktl = s->raw_packet_buffer;
667

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

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

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

    
706
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
707
                     !st->probe_packets))
708
            return ret;
709

    
710
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
711
        s->raw_packet_buffer_remaining_size -= pkt->size;
712

    
713
        if(st->codec->codec_id == CODEC_ID_PROBE){
714
            AVProbeData *pd = &st->probe_data;
715
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
716
            --st->probe_packets;
717

    
718
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
719
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
720
            pd->buf_size += pkt->size;
721
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
722

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

    
736
/**********************************************************/
737

    
738
/**
739
 * Get the number of samples of an audio frame. Return -1 on error.
740
 */
741
static int get_audio_frame_size(AVCodecContext *enc, int size)
742
{
743
    int frame_size;
744

    
745
    if(enc->codec_id == CODEC_ID_VORBIS)
746
        return -1;
747

    
748
    if (enc->frame_size <= 1) {
749
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
750

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

    
767

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

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

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

    
832
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
833
                                      int64_t dts, int64_t pts)
834
{
835
    AVStream *st= s->streams[stream_index];
836
    AVPacketList *pktl= s->packet_buffer;
837

    
838
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
839
        return;
840

    
841
    st->first_dts= dts - st->cur_dts;
842
    st->cur_dts= dts;
843

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

    
851
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
852
            pktl->pkt.dts += st->first_dts;
853

    
854
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
855
            st->start_time= pktl->pkt.pts;
856
    }
857
    if (st->start_time == AV_NOPTS_VALUE)
858
        st->start_time = pts;
859
}
860

    
861
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
862
{
863
    AVPacketList *pktl= s->packet_buffer;
864
    int64_t cur_dts= 0;
865

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

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

    
897
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
898
                               AVCodecParserContext *pc, AVPacket *pkt)
899
{
900
    int num, den, presentation_delayed, delay, i;
901
    int64_t offset;
902

    
903
    if (s->flags & AVFMT_FLAG_NOFILLIN)
904
        return;
905

    
906
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
907
        pkt->dts= AV_NOPTS_VALUE;
908

    
909
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
910
        //FIXME Set low_delay = 0 when has_b_frames = 1
911
        st->codec->has_b_frames = 1;
912

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

    
922
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
923
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
924
        pkt->dts -= 1LL<<st->pts_wrap_bits;
925
    }
926

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

    
935
    if (pkt->duration == 0) {
936
        compute_frame_duration(&num, &den, st, pc, pkt);
937
        if (den && num) {
938
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
939

    
940
            if(pkt->duration != 0 && s->packet_buffer)
941
                update_initial_durations(s, st, pkt);
942
        }
943
    }
944

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

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

    
975
    /* This may be redundant, but it should not hurt. */
976
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
977
        presentation_delayed = 1;
978

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

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

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

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

    
1037
//    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);
1038

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

    
1054

    
1055
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1056
{
1057
    AVStream *st;
1058
    int len, ret, i;
1059

    
1060
    av_init_packet(pkt);
1061

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

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

    
1108
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1109
                        ff_reduce_index(s, st->index);
1110
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1111
                                           0, 0, AVINDEX_KEYFRAME);
1112
                    }
1113

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

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

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

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

    
1193
    return 0;
1194
}
1195

    
1196
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1197
{
1198
    AVPacketList *pktl;
1199
    int eof=0;
1200
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1201

    
1202
    for(;;){
1203
        pktl = s->packet_buffer;
1204
        if (pktl) {
1205
            AVPacket *next_pkt= &pktl->pkt;
1206

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

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

    
1240
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1241
                                           &s->packet_buffer_end)) < 0)
1242
                return AVERROR(ENOMEM);
1243
        }else{
1244
            assert(!s->packet_buffer);
1245
            return av_read_frame_internal(s, pkt);
1246
        }
1247
    }
1248
}
1249

    
1250
/* XXX: suppress the packet queue */
1251
static void flush_packet_queue(AVFormatContext *s)
1252
{
1253
    AVPacketList *pktl;
1254

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

    
1274
/*******************************************************/
1275
/* seek support */
1276

    
1277
int av_find_default_stream_index(AVFormatContext *s)
1278
{
1279
    int first_audio_index = -1;
1280
    int i;
1281
    AVStream *st;
1282

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

    
1296
/**
1297
 * Flush the frame reader.
1298
 */
1299
void ff_read_frame_flush(AVFormatContext *s)
1300
{
1301
    AVStream *st;
1302
    int i, j;
1303

    
1304
    flush_packet_queue(s);
1305

    
1306
    s->cur_st = NULL;
1307

    
1308
    /* for each stream, reset read state */
1309
    for(i = 0; i < s->nb_streams; i++) {
1310
        st = s->streams[i];
1311

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

    
1324
        st->probe_packets = MAX_PROBE_PACKETS;
1325

    
1326
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1327
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1328
    }
1329
}
1330

    
1331
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1332
    int i;
1333

    
1334
    for(i = 0; i < s->nb_streams; i++) {
1335
        AVStream *st = s->streams[i];
1336

    
1337
        st->cur_dts = av_rescale(timestamp,
1338
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1339
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1340
    }
1341
}
1342

    
1343
void ff_reduce_index(AVFormatContext *s, int stream_index)
1344
{
1345
    AVStream *st= s->streams[stream_index];
1346
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1347

    
1348
    if((unsigned)st->nb_index_entries >= max_entries){
1349
        int i;
1350
        for(i=0; 2*i<st->nb_index_entries; i++)
1351
            st->index_entries[i]= st->index_entries[2*i];
1352
        st->nb_index_entries= i;
1353
    }
1354
}
1355

    
1356
int av_add_index_entry(AVStream *st,
1357
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1358
{
1359
    AVIndexEntry *entries, *ie;
1360
    int index;
1361

    
1362
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1363
        return -1;
1364

    
1365
    entries = av_fast_realloc(st->index_entries,
1366
                              &st->index_entries_allocated_size,
1367
                              (st->nb_index_entries + 1) *
1368
                              sizeof(AVIndexEntry));
1369
    if(!entries)
1370
        return -1;
1371

    
1372
    st->index_entries= entries;
1373

    
1374
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1375

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

    
1391
    ie->pos = pos;
1392
    ie->timestamp = timestamp;
1393
    ie->min_distance= distance;
1394
    ie->size= size;
1395
    ie->flags = flags;
1396

    
1397
    return index;
1398
}
1399

    
1400
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1401
                              int flags)
1402
{
1403
    AVIndexEntry *entries= st->index_entries;
1404
    int nb_entries= st->nb_index_entries;
1405
    int a, b, m;
1406
    int64_t timestamp;
1407

    
1408
    a = - 1;
1409
    b = nb_entries;
1410

    
1411
    //optimize appending index entries at the end
1412
    if(b && entries[b-1].timestamp < wanted_timestamp)
1413
        a= b-1;
1414

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

    
1425
    if(!(flags & AVSEEK_FLAG_ANY)){
1426
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1427
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1428
        }
1429
    }
1430

    
1431
    if(m == nb_entries)
1432
        return -1;
1433
    return  m;
1434
}
1435

    
1436
#define DEBUG_SEEK
1437

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

    
1446
    if (stream_index < 0)
1447
        return -1;
1448

    
1449
#ifdef DEBUG_SEEK
1450
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1451
#endif
1452

    
1453
    ts_max=
1454
    ts_min= AV_NOPTS_VALUE;
1455
    pos_limit= -1; //gcc falsely says it may be uninitialized
1456

    
1457
    st= s->streams[stream_index];
1458
    if(st->index_entries){
1459
        AVIndexEntry *e;
1460

    
1461
        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()
1462
        index= FFMAX(index, 0);
1463
        e= &st->index_entries[index];
1464

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

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

    
1491
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1492
    if(pos<0)
1493
        return -1;
1494

    
1495
    /* do the seek */
1496
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1497
        return ret;
1498

    
1499
    av_update_cur_dts(s, st, ts);
1500

    
1501
    return 0;
1502
}
1503

    
1504
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 )){
1505
    int64_t pos, ts;
1506
    int64_t start_pos, filesize;
1507
    int no_change;
1508

    
1509
#ifdef DEBUG_SEEK
1510
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1511
#endif
1512

    
1513
    if(ts_min == AV_NOPTS_VALUE){
1514
        pos_min = s->data_offset;
1515
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1516
        if (ts_min == AV_NOPTS_VALUE)
1517
            return -1;
1518
    }
1519

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

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

    
1545
    if(ts_min > ts_max){
1546
        return -1;
1547
    }else if(ts_min == ts_max){
1548
        pos_limit= pos_min;
1549
    }
1550

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

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

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

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

    
1619
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1620
    int64_t pos_min, pos_max;
1621
#if 0
1622
    AVStream *st;
1623

1624
    if (stream_index < 0)
1625
        return -1;
1626

1627
    st= s->streams[stream_index];
1628
#endif
1629

    
1630
    pos_min = s->data_offset;
1631
    pos_max = url_fsize(s->pb) - 1;
1632

    
1633
    if     (pos < pos_min) pos= pos_min;
1634
    else if(pos > pos_max) pos= pos_max;
1635

    
1636
    url_fseek(s->pb, pos, SEEK_SET);
1637

    
1638
#if 0
1639
    av_update_cur_dts(s, st, ts);
1640
#endif
1641
    return 0;
1642
}
1643

    
1644
static int av_seek_frame_generic(AVFormatContext *s,
1645
                                 int stream_index, int64_t timestamp, int flags)
1646
{
1647
    int index;
1648
    int64_t ret;
1649
    AVStream *st;
1650
    AVIndexEntry *ie;
1651

    
1652
    st = s->streams[stream_index];
1653

    
1654
    index = av_index_search_timestamp(st, timestamp, flags);
1655

    
1656
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1657
        return -1;
1658

    
1659
    if(index < 0 || index==st->nb_index_entries-1){
1660
        int i;
1661
        AVPacket pkt;
1662

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

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

    
1701
    return 0;
1702
}
1703

    
1704
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1705
{
1706
    int ret;
1707
    AVStream *st;
1708

    
1709
    ff_read_frame_flush(s);
1710

    
1711
    if(flags & AVSEEK_FLAG_BYTE)
1712
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1713

    
1714
    if(stream_index < 0){
1715
        stream_index= av_find_default_stream_index(s);
1716
        if(stream_index < 0)
1717
            return -1;
1718

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

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

    
1733
    if(s->iformat->read_timestamp)
1734
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1735
    else
1736
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1737
}
1738

    
1739
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1740
{
1741
    if(min_ts > ts || max_ts < ts)
1742
        return -1;
1743

    
1744
    ff_read_frame_flush(s);
1745

    
1746
    if (s->iformat->read_seek2)
1747
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1748

    
1749
    if(s->iformat->read_timestamp){
1750
        //try to seek via read_timestamp()
1751
    }
1752

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

    
1758
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1759
}
1760

    
1761
/*******************************************************/
1762

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

    
1773
    for(i = 0;i < ic->nb_streams; i++) {
1774
        st = ic->streams[i];
1775
        if (st->duration != AV_NOPTS_VALUE)
1776
            return 1;
1777
    }
1778
    return 0;
1779
}
1780

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

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

    
1832
static void fill_all_stream_timings(AVFormatContext *ic)
1833
{
1834
    int i;
1835
    AVStream *st;
1836

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

    
1849
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1850
{
1851
    int64_t filesize, duration;
1852
    int bit_rate, i;
1853
    AVStream *st;
1854

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

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

    
1881
#define DURATION_MAX_READ_SIZE 250000
1882
#define DURATION_MAX_RETRY 3
1883

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

    
1894
    ic->cur_st = NULL;
1895

    
1896
    /* flush packet queue */
1897
    flush_packet_queue(ic);
1898

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

    
1904
        if (st->parser) {
1905
            av_parser_close(st->parser);
1906
            st->parser= NULL;
1907
            av_free_packet(&st->cur_pkt);
1908
        }
1909
    }
1910

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

    
1920
    url_fseek(ic->pb, offset, SEEK_SET);
1921
    read_size = 0;
1922
    for(;;) {
1923
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1924
            break;
1925

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

    
1953
    fill_all_stream_timings(ic);
1954

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

    
1963
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1964
{
1965
    int64_t file_size;
1966

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

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

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

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

    
2036
static int has_decode_delay_been_guessed(AVStream *st)
2037
{
2038
    return st->codec->codec_id != CODEC_ID_H264 ||
2039
        st->codec_info_nb_frames >= 4 + st->codec->has_b_frames;
2040
}
2041

    
2042
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2043
{
2044
    int16_t *samples;
2045
    AVCodec *codec;
2046
    int got_picture, data_size, ret=0;
2047
    AVFrame picture;
2048

    
2049
    if(!st->codec->codec){
2050
        codec = avcodec_find_decoder(st->codec->codec_id);
2051
        if (!codec)
2052
            return -1;
2053
        ret = avcodec_open(st->codec, codec);
2054
        if (ret < 0)
2055
            return ret;
2056
    }
2057

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

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

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

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

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

    
2126
static void compute_chapters_end(AVFormatContext *s)
2127
{
2128
    unsigned int i;
2129

    
2130
    for (i=0; i+1<s->nb_chapters; i++)
2131
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2132
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2133
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2134
            s->chapters[i]->end = s->chapters[i+1]->start;
2135
        }
2136

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

    
2146
static int get_std_framerate(int i){
2147
    if(i<60*12) return i*1001;
2148
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2149
}
2150

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

    
2171
int av_find_stream_info(AVFormatContext *ic)
2172
{
2173
    int i, count, ret, read_size, j;
2174
    AVStream *st;
2175
    AVPacket pkt1, *pkt;
2176
    int64_t old_offset = url_ftell(ic->pb);
2177

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

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

    
2209
        /* Ensure that subtitle_header is properly set. */
2210
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2211
            && codec && !st->codec->codec)
2212
            avcodec_open(st->codec, codec);
2213

    
2214
        //try to just open decoders, in case this is enough to get parameters
2215
        if(!has_codec_parameters(st->codec)){
2216
            if (codec && !st->codec->codec)
2217
                avcodec_open(st->codec, codec);
2218
        }
2219
    }
2220

    
2221
    for (i=0; i<ic->nb_streams; i++) {
2222
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2223
    }
2224

    
2225
    count = 0;
2226
    read_size = 0;
2227
    for(;;) {
2228
        if(url_interrupt_cb()){
2229
            ret= AVERROR(EINTR);
2230
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2231
            break;
2232
        }
2233

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

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

    
2285
        if (ret == AVERROR(EAGAIN))
2286
            continue;
2287

    
2288
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2289
        if ((ret = av_dup_packet(pkt)) < 0)
2290
            goto find_stream_info_err;
2291

    
2292
        read_size += pkt->size;
2293

    
2294
        st = ic->streams[pkt->stream_index];
2295
        if (st->codec_info_nb_frames>1) {
2296
            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) {
2297
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2298
                break;
2299
            }
2300
            st->info->codec_info_duration += pkt->duration;
2301
        }
2302
        {
2303
            int64_t last = st->info->last_dts;
2304
            int64_t duration= pkt->dts - last;
2305

    
2306
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2307
                double dur= duration * av_q2d(st->time_base);
2308

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

    
2337
        /* if still no information, we try to open the codec and to
2338
           decompress the frame. We try to avoid that in most cases as
2339
           it takes longer and uses more memory. For MPEG-4, we need to
2340
           decompress for QuickTime. */
2341
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2342
            try_decode_frame(st, pkt);
2343

    
2344
        st->codec_info_nb_frames++;
2345
        count++;
2346
    }
2347

    
2348
    // close codecs which were opened in try_decode_frame()
2349
    for(i=0;i<ic->nb_streams;i++) {
2350
        st = ic->streams[i];
2351
        if(st->codec->codec)
2352
            avcodec_close(st->codec);
2353
    }
2354
    for(i=0;i<ic->nb_streams;i++) {
2355
        st = ic->streams[i];
2356
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2357
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2358
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2359
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2360
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2361
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2362
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2363

    
2364
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2365
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2366
            // ipmovie.c produces.
2367
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2368
                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);
2369
            if (st->info->duration_count && !st->r_frame_rate.num
2370
               && tb_unreliable(st->codec) /*&&
2371
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2372
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2373
                int num = 0;
2374
                double best_error= 2*av_q2d(st->time_base);
2375
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2376

    
2377
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2378
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2379
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2380
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2381
                    if(error < best_error){
2382
                        best_error= error;
2383
                        num = get_std_framerate(j);
2384
                    }
2385
                }
2386
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2387
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2388
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2389
            }
2390

    
2391
            if (!st->r_frame_rate.num){
2392
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2393
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2394
                    st->r_frame_rate.num = st->codec->time_base.den;
2395
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2396
                }else{
2397
                    st->r_frame_rate.num = st->time_base.den;
2398
                    st->r_frame_rate.den = st->time_base.num;
2399
                }
2400
            }
2401
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2402
            if(!st->codec->bits_per_coded_sample)
2403
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2404
        }
2405
    }
2406

    
2407
    av_estimate_timings(ic, old_offset);
2408

    
2409
    compute_chapters_end(ic);
2410

    
2411
#if 0
2412
    /* correct DTS for B-frame streams with no timestamps */
2413
    for(i=0;i<ic->nb_streams;i++) {
2414
        st = ic->streams[i];
2415
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2416
            if(b-frames){
2417
                ppktl = &ic->packet_buffer;
2418
                while(ppkt1){
2419
                    if(ppkt1->stream_index != i)
2420
                        continue;
2421
                    if(ppkt1->pkt->dts < 0)
2422
                        break;
2423
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2424
                        break;
2425
                    ppkt1->pkt->dts -= delta;
2426
                    ppkt1= ppkt1->next;
2427
                }
2428
                if(ppkt1)
2429
                    continue;
2430
                st->cur_dts -= delta;
2431
            }
2432
        }
2433
    }
2434
#endif
2435

    
2436
 find_stream_info_err:
2437
    for (i=0; i < ic->nb_streams; i++)
2438
        av_freep(&ic->streams[i]->info);
2439
    return ret;
2440
}
2441

    
2442
/*******************************************************/
2443

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

    
2453
int av_read_pause(AVFormatContext *s)
2454
{
2455
    if (s->iformat->read_pause)
2456
        return s->iformat->read_pause(s);
2457
    if (s->pb)
2458
        return av_url_read_fpause(s->pb, 1);
2459
    return AVERROR(ENOSYS);
2460
}
2461

    
2462
void av_close_input_stream(AVFormatContext *s)
2463
{
2464
    int i;
2465
    AVStream *st;
2466

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

    
2513
void av_close_input_file(AVFormatContext *s)
2514
{
2515
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2516
    av_close_input_stream(s);
2517
    if (pb)
2518
        url_fclose(pb);
2519
}
2520

    
2521
AVStream *av_new_stream(AVFormatContext *s, int id)
2522
{
2523
    AVStream *st;
2524
    int i;
2525

    
2526
#if FF_API_MAX_STREAMS
2527
    if (s->nb_streams >= MAX_STREAMS){
2528
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2529
        return NULL;
2530
    }
2531
#else
2532
    AVStream **streams;
2533

    
2534
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2535
        return NULL;
2536
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2537
    if (!streams)
2538
        return NULL;
2539
    s->streams = streams;
2540
#endif
2541

    
2542
    st = av_mallocz(sizeof(AVStream));
2543
    if (!st)
2544
        return NULL;
2545
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2546
        av_free(st);
2547
        return NULL;
2548
    }
2549

    
2550
    st->codec= avcodec_alloc_context();
2551
    if (s->iformat) {
2552
        /* no default bitrate if decoding */
2553
        st->codec->bit_rate = 0;
2554
    }
2555
    st->index = s->nb_streams;
2556
    st->id = id;
2557
    st->start_time = AV_NOPTS_VALUE;
2558
    st->duration = AV_NOPTS_VALUE;
2559
        /* we set the current DTS to 0 so that formats without any timestamps
2560
           but durations get some timestamps, formats with some unknown
2561
           timestamps have their first few packets buffered and the
2562
           timestamps corrected before they are returned to the user */
2563
    st->cur_dts = 0;
2564
    st->first_dts = AV_NOPTS_VALUE;
2565
    st->probe_packets = MAX_PROBE_PACKETS;
2566

    
2567
    /* default pts setting is MPEG-like */
2568
    av_set_pts_info(st, 33, 1, 90000);
2569
    st->last_IP_pts = AV_NOPTS_VALUE;
2570
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2571
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2572
    st->reference_dts = AV_NOPTS_VALUE;
2573

    
2574
    st->sample_aspect_ratio = (AVRational){0,1};
2575

    
2576
    s->streams[s->nb_streams++] = st;
2577
    return st;
2578
}
2579

    
2580
AVProgram *av_new_program(AVFormatContext *ac, int id)
2581
{
2582
    AVProgram *program=NULL;
2583
    int i;
2584

    
2585
#ifdef DEBUG_SI
2586
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2587
#endif
2588

    
2589
    for(i=0; i<ac->nb_programs; i++)
2590
        if(ac->programs[i]->id == id)
2591
            program = ac->programs[i];
2592

    
2593
    if(!program){
2594
        program = av_mallocz(sizeof(AVProgram));
2595
        if (!program)
2596
            return NULL;
2597
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2598
        program->discard = AVDISCARD_NONE;
2599
    }
2600
    program->id = id;
2601

    
2602
    return program;
2603
}
2604

    
2605
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2606
{
2607
    AVChapter *chapter = NULL;
2608
    int i;
2609

    
2610
    for(i=0; i<s->nb_chapters; i++)
2611
        if(s->chapters[i]->id == id)
2612
            chapter = s->chapters[i];
2613

    
2614
    if(!chapter){
2615
        chapter= av_mallocz(sizeof(AVChapter));
2616
        if(!chapter)
2617
            return NULL;
2618
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2619
    }
2620
#if FF_API_OLD_METADATA
2621
    av_free(chapter->title);
2622
#endif
2623
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2624
    chapter->id    = id;
2625
    chapter->time_base= time_base;
2626
    chapter->start = start;
2627
    chapter->end   = end;
2628

    
2629
    return chapter;
2630
}
2631

    
2632
/************************************************************/
2633
/* output media file */
2634

    
2635
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2636
{
2637
    int ret;
2638

    
2639
    if (s->oformat->priv_data_size > 0) {
2640
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2641
        if (!s->priv_data)
2642
            return AVERROR(ENOMEM);
2643
    } else
2644
        s->priv_data = NULL;
2645

    
2646
    if (s->oformat->set_parameters) {
2647
        ret = s->oformat->set_parameters(s, ap);
2648
        if (ret < 0)
2649
            return ret;
2650
    }
2651
    return 0;
2652
}
2653

    
2654
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2655
{
2656
    const AVCodecTag *avctag;
2657
    int n;
2658
    enum CodecID id = CODEC_ID_NONE;
2659
    unsigned int tag = 0;
2660

    
2661
    /**
2662
     * Check that tag + id is in the table
2663
     * If neither is in the table -> OK
2664
     * If tag is in the table with another id -> FAIL
2665
     * If id is in the table with another tag -> FAIL unless strict < normal
2666
     */
2667
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2668
        avctag = s->oformat->codec_tag[n];
2669
        while (avctag->id != CODEC_ID_NONE) {
2670
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2671
                id = avctag->id;
2672
                if (id == st->codec->codec_id)
2673
                    return 1;
2674
            }
2675
            if (avctag->id == st->codec->codec_id)
2676
                tag = avctag->tag;
2677
            avctag++;
2678
        }
2679
    }
2680
    if (id != CODEC_ID_NONE)
2681
        return 0;
2682
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2683
        return 0;
2684
    return 1;
2685
}
2686

    
2687
int av_write_header(AVFormatContext *s)
2688
{
2689
    int ret, i;
2690
    AVStream *st;
2691

    
2692
    // some sanity checks
2693
    if (s->nb_streams == 0) {
2694
        av_log(s, AV_LOG_ERROR, "no streams\n");
2695
        return AVERROR(EINVAL);
2696
    }
2697

    
2698
    for(i=0;i<s->nb_streams;i++) {
2699
        st = s->streams[i];
2700

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

    
2727
        if(s->oformat->codec_tag){
2728
            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)){
2729
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2730
                st->codec->codec_tag= 0;
2731
            }
2732
            if(st->codec->codec_tag){
2733
                if (!validate_codec_tag(s, st)) {
2734
                    char tagbuf[32];
2735
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2736
                    av_log(s, AV_LOG_ERROR,
2737
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2738
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2739
                    return AVERROR_INVALIDDATA;
2740
                }
2741
            }else
2742
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2743
        }
2744

    
2745
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2746
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2747
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2748
    }
2749

    
2750
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2751
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2752
        if (!s->priv_data)
2753
            return AVERROR(ENOMEM);
2754
    }
2755

    
2756
#if FF_API_OLD_METADATA
2757
    ff_metadata_mux_compat(s);
2758
#endif
2759

    
2760
    /* set muxer identification string */
2761
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2762
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2763
    }
2764

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2913
    this_pktl->next= *next_point;
2914

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3020
        av_free_packet(&pkt);
3021

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3208
    av_free(printed);
3209
}
3210

    
3211
#if FF_API_PARSE_FRAME_PARAM
3212
#include "libavcore/parseutils.h"
3213

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3344
    t *= 1000000;
3345

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3627
    return buff;
3628
}
3629

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3753
        key = ptr;
3754

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

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

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