Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 4ad0693e

History | View | Annotate | Download (121 KB)

1
/*
2
 * various utility functions for use within Libav
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* #define DEBUG */
23

    
24
#include "avformat.h"
25
#include "avio_internal.h"
26
#include "internal.h"
27
#include "libavcodec/internal.h"
28
#include "libavutil/opt.h"
29
#include "metadata.h"
30
#include "id3v2.h"
31
#include "libavutil/avstring.h"
32
#include "riff.h"
33
#include "audiointerleave.h"
34
#include "url.h"
35
#include <sys/time.h>
36
#include <time.h>
37
#include <strings.h>
38
#include <stdarg.h>
39
#if CONFIG_NETWORK
40
#include "network.h"
41
#endif
42

    
43
#undef NDEBUG
44
#include <assert.h>
45

    
46
/**
47
 * @file
48
 * various utility functions for use within Libav
49
 */
50

    
51
unsigned avformat_version(void)
52
{
53
    return LIBAVFORMAT_VERSION_INT;
54
}
55

    
56
const char *avformat_configuration(void)
57
{
58
    return LIBAV_CONFIGURATION;
59
}
60

    
61
const char *avformat_license(void)
62
{
63
#define LICENSE_PREFIX "libavformat license: "
64
    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
65
}
66

    
67
/* fraction handling */
68

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

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

    
101
    num = f->num + incr;
102
    den = f->den;
103
    if (num < 0) {
104
        f->val += num / den;
105
        num = num % den;
106
        if (num < 0) {
107
            num += den;
108
            f->val--;
109
        }
110
    } else if (num >= den) {
111
        f->val += num / den;
112
        num = num % den;
113
    }
114
    f->num = num;
115
}
116

    
117
/** head of registered input format linked list */
118
static AVInputFormat *first_iformat = NULL;
119
/** head of registered output format linked list */
120
static AVOutputFormat *first_oformat = NULL;
121

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

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

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

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

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

    
157
    if(!filename)
158
        return 0;
159

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

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

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

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

    
197
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
198
                                const char *mime_type)
199
{
200
    AVOutputFormat *fmt = NULL, *fmt_found;
201
    int score_max, score;
202

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

    
232
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
233
                            const char *filename, const char *mime_type, enum AVMediaType type){
234
    if(type == AVMEDIA_TYPE_VIDEO){
235
        enum CodecID codec_id= CODEC_ID_NONE;
236

    
237
#if CONFIG_IMAGE2_MUXER
238
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
239
            codec_id= ff_guess_image2_codec(filename);
240
        }
241
#endif
242
        if(codec_id == CODEC_ID_NONE)
243
            codec_id= fmt->video_codec;
244
        return codec_id;
245
    }else if(type == AVMEDIA_TYPE_AUDIO)
246
        return fmt->audio_codec;
247
    else if (type == AVMEDIA_TYPE_SUBTITLE)
248
        return fmt->subtitle_codec;
249
    else
250
        return CODEC_ID_NONE;
251
}
252

    
253
AVInputFormat *av_find_input_format(const char *short_name)
254
{
255
    AVInputFormat *fmt = NULL;
256
    while ((fmt = av_iformat_next(fmt))) {
257
        if (match_format(short_name, fmt->name))
258
            return fmt;
259
    }
260
    return NULL;
261
}
262

    
263

    
264
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
265
{
266
    int ret= av_new_packet(pkt, size);
267

    
268
    if(ret<0)
269
        return ret;
270

    
271
    pkt->pos= avio_tell(s);
272

    
273
    ret= avio_read(s, pkt->data, size);
274
    if(ret<=0)
275
        av_free_packet(pkt);
276
    else
277
        av_shrink_packet(pkt, ret);
278

    
279
    return ret;
280
}
281

    
282
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
283
{
284
    int ret;
285
    int old_size;
286
    if (!pkt->size)
287
        return av_get_packet(s, pkt, size);
288
    old_size = pkt->size;
289
    ret = av_grow_packet(pkt, size);
290
    if (ret < 0)
291
        return ret;
292
    ret = avio_read(s, pkt->data + old_size, size);
293
    av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
294
    return ret;
295
}
296

    
297

    
298
int av_filename_number_test(const char *filename)
299
{
300
    char buf[1024];
301
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
302
}
303

    
304
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
305
{
306
    AVProbeData lpd = *pd;
307
    AVInputFormat *fmt1 = NULL, *fmt;
308
    int score, id3 = 0;
309

    
310
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
311
        int id3len = ff_id3v2_tag_len(lpd.buf);
312
        if (lpd.buf_size > id3len + 16) {
313
            lpd.buf += id3len;
314
            lpd.buf_size -= id3len;
315
        }
316
        id3 = 1;
317
    }
318

    
319
    fmt = NULL;
320
    while ((fmt1 = av_iformat_next(fmt1))) {
321
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
322
            continue;
323
        score = 0;
324
        if (fmt1->read_probe) {
325
            score = fmt1->read_probe(&lpd);
326
        } else if (fmt1->extensions) {
327
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
328
                score = 50;
329
            }
330
        }
331
        if (score > *score_max) {
332
            *score_max = score;
333
            fmt = fmt1;
334
        }else if (score == *score_max)
335
            fmt = NULL;
336
    }
337

    
338
    /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
339
    if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4) {
340
        while ((fmt = av_iformat_next(fmt)))
341
            if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
342
                *score_max = AVPROBE_SCORE_MAX/4;
343
                break;
344
            }
345
    }
346

    
347
    return fmt;
348
}
349

    
350
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
351
    int score=0;
352
    return av_probe_input_format2(pd, is_opened, &score);
353
}
354

    
355
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
356
{
357
    static const struct {
358
        const char *name; enum CodecID id; enum AVMediaType type;
359
    } fmt_id_type[] = {
360
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
361
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
362
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
363
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
364
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
365
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
366
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
367
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
368
        { 0 }
369
    };
370
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
371

    
372
    if (fmt) {
373
        int i;
374
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
375
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
376
        for (i = 0; fmt_id_type[i].name; i++) {
377
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
378
                st->codec->codec_id   = fmt_id_type[i].id;
379
                st->codec->codec_type = fmt_id_type[i].type;
380
                break;
381
            }
382
        }
383
    }
384
    return !!fmt;
385
}
386

    
387
/************************************************************/
388
/* input media file */
389

    
390
/**
391
 * Open a media file from an IO stream. 'fmt' must be specified.
392
 */
393
int av_open_input_stream(AVFormatContext **ic_ptr,
394
                         AVIOContext *pb, const char *filename,
395
                         AVInputFormat *fmt, AVFormatParameters *ap)
396
{
397
    int err;
398
    AVFormatContext *ic;
399
    AVFormatParameters default_ap;
400

    
401
    if(!ap){
402
        ap=&default_ap;
403
        memset(ap, 0, sizeof(default_ap));
404
    }
405

    
406
    if(!ap->prealloced_context)
407
        ic = avformat_alloc_context();
408
    else
409
        ic = *ic_ptr;
410
    if (!ic) {
411
        err = AVERROR(ENOMEM);
412
        goto fail;
413
    }
414
    ic->iformat = fmt;
415
    ic->pb = pb;
416
    ic->duration = AV_NOPTS_VALUE;
417
    ic->start_time = AV_NOPTS_VALUE;
418
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
419

    
420
    /* allocate private data */
421
    if (fmt->priv_data_size > 0) {
422
        ic->priv_data = av_mallocz(fmt->priv_data_size);
423
        if (!ic->priv_data) {
424
            err = AVERROR(ENOMEM);
425
            goto fail;
426
        }
427
    } else {
428
        ic->priv_data = NULL;
429
    }
430

    
431
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
432
    if (ic->pb)
433
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
434

    
435
    if (ic->iformat->read_header) {
436
        err = ic->iformat->read_header(ic, ap);
437
        if (err < 0)
438
            goto fail;
439
    }
440

    
441
    if (pb && !ic->data_offset)
442
        ic->data_offset = avio_tell(ic->pb);
443

    
444
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
445

    
446
    *ic_ptr = ic;
447
    return 0;
448
 fail:
449
    if (ic) {
450
        int i;
451
        av_freep(&ic->priv_data);
452
        for(i=0;i<ic->nb_streams;i++) {
453
            AVStream *st = ic->streams[i];
454
            if (st) {
455
                av_free(st->priv_data);
456
                av_free(st->codec->extradata);
457
                av_free(st->codec);
458
                av_free(st->info);
459
            }
460
            av_free(st);
461
        }
462
    }
463
    av_free(ic);
464
    *ic_ptr = NULL;
465
    return err;
466
}
467

    
468
/** size of probe buffer, for guessing file type from file contents */
469
#define PROBE_BUF_MIN 2048
470
#define PROBE_BUF_MAX (1<<20)
471

    
472
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
473
                          const char *filename, void *logctx,
474
                          unsigned int offset, unsigned int max_probe_size)
475
{
476
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
477
    unsigned char *buf = NULL;
478
    int ret = 0, probe_size;
479

    
480
    if (!max_probe_size) {
481
        max_probe_size = PROBE_BUF_MAX;
482
    } else if (max_probe_size > PROBE_BUF_MAX) {
483
        max_probe_size = PROBE_BUF_MAX;
484
    } else if (max_probe_size < PROBE_BUF_MIN) {
485
        return AVERROR(EINVAL);
486
    }
487

    
488
    if (offset >= max_probe_size) {
489
        return AVERROR(EINVAL);
490
    }
491

    
492
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
493
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
494
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
495
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
496

    
497
        if (probe_size < offset) {
498
            continue;
499
        }
500

    
501
        /* read probe data */
502
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
503
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
504
            /* fail if error was not end of file, otherwise, lower score */
505
            if (ret != AVERROR_EOF) {
506
                av_free(buf);
507
                return ret;
508
            }
509
            score = 0;
510
            ret = 0;            /* error was end of file, nothing read */
511
        }
512
        pd.buf_size += ret;
513
        pd.buf = &buf[offset];
514

    
515
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
516

    
517
        /* guess file format */
518
        *fmt = av_probe_input_format2(&pd, 1, &score);
519
        if(*fmt){
520
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
521
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
522
            }else
523
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
524
        }
525
    }
526

    
527
    if (!*fmt) {
528
        av_free(buf);
529
        return AVERROR_INVALIDDATA;
530
    }
531

    
532
    /* rewind. reuse probe buffer to avoid seeking */
533
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
534
        av_free(buf);
535

    
536
    return ret;
537
}
538

    
539
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
540
                       AVInputFormat *fmt,
541
                       int buf_size,
542
                       AVFormatParameters *ap)
543
{
544
    int err;
545
    AVProbeData probe_data, *pd = &probe_data;
546
    AVIOContext *pb = NULL;
547
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
548

    
549
    pd->filename = "";
550
    if (filename)
551
        pd->filename = filename;
552
    pd->buf = NULL;
553
    pd->buf_size = 0;
554

    
555
    if (!fmt) {
556
        /* guess format if no file can be opened */
557
        fmt = av_probe_input_format(pd, 0);
558
    }
559

    
560
    /* Do not open file if the format does not need it. XXX: specific
561
       hack needed to handle RTSP/TCP */
562
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
563
        /* if no file needed do not try to open one */
564
        if ((err=avio_open(&pb, filename, AVIO_FLAG_READ)) < 0) {
565
            goto fail;
566
        }
567
        if (buf_size > 0) {
568
            ffio_set_buf_size(pb, buf_size);
569
        }
570
        if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
571
            goto fail;
572
        }
573
    }
574

    
575
    /* if still no format found, error */
576
    if (!fmt) {
577
        err = AVERROR_INVALIDDATA;
578
        goto fail;
579
    }
580

    
581
    /* check filename in case an image number is expected */
582
    if (fmt->flags & AVFMT_NEEDNUMBER) {
583
        if (!av_filename_number_test(filename)) {
584
            err = AVERROR(EINVAL);
585
            goto fail;
586
        }
587
    }
588
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
589
    if (err)
590
        goto fail;
591
    return 0;
592
 fail:
593
    av_freep(&pd->buf);
594
    if (pb)
595
        avio_close(pb);
596
    if (ap && ap->prealloced_context)
597
        av_free(*ic_ptr);
598
    *ic_ptr = NULL;
599
    return err;
600

    
601
}
602

    
603
/*******************************************************/
604

    
605
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
606
                               AVPacketList **plast_pktl){
607
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
608
    if (!pktl)
609
        return NULL;
610

    
611
    if (*packet_buffer)
612
        (*plast_pktl)->next = pktl;
613
    else
614
        *packet_buffer = pktl;
615

    
616
    /* add the packet in the buffered packet list */
617
    *plast_pktl = pktl;
618
    pktl->pkt= *pkt;
619
    return &pktl->pkt;
620
}
621

    
622
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
623
{
624
    int ret, i;
625
    AVStream *st;
626

    
627
    for(;;){
628
        AVPacketList *pktl = s->raw_packet_buffer;
629

    
630
        if (pktl) {
631
            *pkt = pktl->pkt;
632
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
633
               !s->streams[pkt->stream_index]->probe_packets ||
634
               s->raw_packet_buffer_remaining_size < pkt->size){
635
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
636
                av_freep(&pd->buf);
637
                pd->buf_size = 0;
638
                s->raw_packet_buffer = pktl->next;
639
                s->raw_packet_buffer_remaining_size += pkt->size;
640
                av_free(pktl);
641
                return 0;
642
            }
643
        }
644

    
645
        av_init_packet(pkt);
646
        ret= s->iformat->read_packet(s, pkt);
647
        if (ret < 0) {
648
            if (!pktl || ret == AVERROR(EAGAIN))
649
                return ret;
650
            for (i = 0; i < s->nb_streams; i++)
651
                s->streams[i]->probe_packets = 0;
652
            continue;
653
        }
654
        st= s->streams[pkt->stream_index];
655

    
656
        switch(st->codec->codec_type){
657
        case AVMEDIA_TYPE_VIDEO:
658
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
659
            break;
660
        case AVMEDIA_TYPE_AUDIO:
661
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
662
            break;
663
        case AVMEDIA_TYPE_SUBTITLE:
664
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
665
            break;
666
        }
667

    
668
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
669
                     !st->probe_packets))
670
            return ret;
671

    
672
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
673
        s->raw_packet_buffer_remaining_size -= pkt->size;
674

    
675
        if(st->codec->codec_id == CODEC_ID_PROBE){
676
            AVProbeData *pd = &st->probe_data;
677
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
678
            --st->probe_packets;
679

    
680
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
681
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
682
            pd->buf_size += pkt->size;
683
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
684

    
685
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
686
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
687
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
688
                if(st->codec->codec_id != CODEC_ID_PROBE){
689
                    pd->buf_size=0;
690
                    av_freep(&pd->buf);
691
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
692
                }
693
            }
694
        }
695
    }
696
}
697

    
698
/**********************************************************/
699

    
700
/**
701
 * Get the number of samples of an audio frame. Return -1 on error.
702
 */
703
static int get_audio_frame_size(AVCodecContext *enc, int size)
704
{
705
    int frame_size;
706

    
707
    if(enc->codec_id == CODEC_ID_VORBIS)
708
        return -1;
709

    
710
    if (enc->frame_size <= 1) {
711
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
712

    
713
        if (bits_per_sample) {
714
            if (enc->channels == 0)
715
                return -1;
716
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
717
        } else {
718
            /* used for example by ADPCM codecs */
719
            if (enc->bit_rate == 0)
720
                return -1;
721
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
722
        }
723
    } else {
724
        frame_size = enc->frame_size;
725
    }
726
    return frame_size;
727
}
728

    
729

    
730
/**
731
 * Return the frame duration in seconds. Return 0 if not available.
732
 */
733
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
734
                                   AVCodecParserContext *pc, AVPacket *pkt)
735
{
736
    int frame_size;
737

    
738
    *pnum = 0;
739
    *pden = 0;
740
    switch(st->codec->codec_type) {
741
    case AVMEDIA_TYPE_VIDEO:
742
        if(st->time_base.num*1000LL > st->time_base.den){
743
            *pnum = st->time_base.num;
744
            *pden = st->time_base.den;
745
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
746
            *pnum = st->codec->time_base.num;
747
            *pden = st->codec->time_base.den;
748
            if (pc && pc->repeat_pict) {
749
                *pnum = (*pnum) * (1 + pc->repeat_pict);
750
            }
751
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
752
            //Thus if we have no parser in such case leave duration undefined.
753
            if(st->codec->ticks_per_frame>1 && !pc){
754
                *pnum = *pden = 0;
755
            }
756
        }
757
        break;
758
    case AVMEDIA_TYPE_AUDIO:
759
        frame_size = get_audio_frame_size(st->codec, pkt->size);
760
        if (frame_size <= 0 || st->codec->sample_rate <= 0)
761
            break;
762
        *pnum = frame_size;
763
        *pden = st->codec->sample_rate;
764
        break;
765
    default:
766
        break;
767
    }
768
}
769

    
770
static int is_intra_only(AVCodecContext *enc){
771
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
772
        return 1;
773
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
774
        switch(enc->codec_id){
775
        case CODEC_ID_MJPEG:
776
        case CODEC_ID_MJPEGB:
777
        case CODEC_ID_LJPEG:
778
        case CODEC_ID_RAWVIDEO:
779
        case CODEC_ID_DVVIDEO:
780
        case CODEC_ID_HUFFYUV:
781
        case CODEC_ID_FFVHUFF:
782
        case CODEC_ID_ASV1:
783
        case CODEC_ID_ASV2:
784
        case CODEC_ID_VCR1:
785
        case CODEC_ID_DNXHD:
786
        case CODEC_ID_JPEG2000:
787
            return 1;
788
        default: break;
789
        }
790
    }
791
    return 0;
792
}
793

    
794
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
795
                                      int64_t dts, int64_t pts)
796
{
797
    AVStream *st= s->streams[stream_index];
798
    AVPacketList *pktl= s->packet_buffer;
799

    
800
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
801
        return;
802

    
803
    st->first_dts= dts - st->cur_dts;
804
    st->cur_dts= dts;
805

    
806
    for(; pktl; pktl= pktl->next){
807
        if(pktl->pkt.stream_index != stream_index)
808
            continue;
809
        //FIXME think more about this check
810
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
811
            pktl->pkt.pts += st->first_dts;
812

    
813
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
814
            pktl->pkt.dts += st->first_dts;
815

    
816
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
817
            st->start_time= pktl->pkt.pts;
818
    }
819
    if (st->start_time == AV_NOPTS_VALUE)
820
        st->start_time = pts;
821
}
822

    
823
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
824
{
825
    AVPacketList *pktl= s->packet_buffer;
826
    int64_t cur_dts= 0;
827

    
828
    if(st->first_dts != AV_NOPTS_VALUE){
829
        cur_dts= st->first_dts;
830
        for(; pktl; pktl= pktl->next){
831
            if(pktl->pkt.stream_index == pkt->stream_index){
832
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
833
                    break;
834
                cur_dts -= pkt->duration;
835
            }
836
        }
837
        pktl= s->packet_buffer;
838
        st->first_dts = cur_dts;
839
    }else if(st->cur_dts)
840
        return;
841

    
842
    for(; pktl; pktl= pktl->next){
843
        if(pktl->pkt.stream_index != pkt->stream_index)
844
            continue;
845
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
846
           && !pktl->pkt.duration){
847
            pktl->pkt.dts= cur_dts;
848
            if(!st->codec->has_b_frames)
849
                pktl->pkt.pts= cur_dts;
850
            cur_dts += pkt->duration;
851
            pktl->pkt.duration= pkt->duration;
852
        }else
853
            break;
854
    }
855
    if(st->first_dts == AV_NOPTS_VALUE)
856
        st->cur_dts= cur_dts;
857
}
858

    
859
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
860
                               AVCodecParserContext *pc, AVPacket *pkt)
861
{
862
    int num, den, presentation_delayed, delay, i;
863
    int64_t offset;
864

    
865
    if (s->flags & AVFMT_FLAG_NOFILLIN)
866
        return;
867

    
868
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
869
        pkt->dts= AV_NOPTS_VALUE;
870

    
871
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
872
        //FIXME Set low_delay = 0 when has_b_frames = 1
873
        st->codec->has_b_frames = 1;
874

    
875
    /* do we have a video B-frame ? */
876
    delay= st->codec->has_b_frames;
877
    presentation_delayed = 0;
878

    
879
    // ignore delay caused by frame threading so that the mpeg2-without-dts
880
    // warning will not trigger
881
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
882
        delay -= st->codec->thread_count-1;
883

    
884
    /* XXX: need has_b_frame, but cannot get it if the codec is
885
        not initialized */
886
    if (delay &&
887
        pc && pc->pict_type != AV_PICTURE_TYPE_B)
888
        presentation_delayed = 1;
889

    
890
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
891
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
892
        pkt->dts -= 1LL<<st->pts_wrap_bits;
893
    }
894

    
895
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
896
    // we take the conservative approach and discard both
897
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
898
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
899
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
900
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
901
    }
902

    
903
    if (pkt->duration == 0) {
904
        compute_frame_duration(&num, &den, st, pc, pkt);
905
        if (den && num) {
906
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
907

    
908
            if(pkt->duration != 0 && s->packet_buffer)
909
                update_initial_durations(s, st, pkt);
910
        }
911
    }
912

    
913
    /* correct timestamps with byte offset if demuxers only have timestamps
914
       on packet boundaries */
915
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
916
        /* this will estimate bitrate based on this frame's duration and size */
917
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
918
        if(pkt->pts != AV_NOPTS_VALUE)
919
            pkt->pts += offset;
920
        if(pkt->dts != AV_NOPTS_VALUE)
921
            pkt->dts += offset;
922
    }
923

    
924
    if (pc && pc->dts_sync_point >= 0) {
925
        // we have synchronization info from the parser
926
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
927
        if (den > 0) {
928
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
929
            if (pkt->dts != AV_NOPTS_VALUE) {
930
                // got DTS from the stream, update reference timestamp
931
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
932
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
933
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
934
                // compute DTS based on reference timestamp
935
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
936
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
937
            }
938
            if (pc->dts_sync_point > 0)
939
                st->reference_dts = pkt->dts; // new reference
940
        }
941
    }
942

    
943
    /* This may be redundant, but it should not hurt. */
944
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
945
        presentation_delayed = 1;
946

    
947
//    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);
948
    /* interpolate PTS and DTS if they are not present */
949
    //We skip H264 currently because delay and has_b_frames are not reliably set
950
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
951
        if (presentation_delayed) {
952
            /* DTS = decompression timestamp */
953
            /* PTS = presentation timestamp */
954
            if (pkt->dts == AV_NOPTS_VALUE)
955
                pkt->dts = st->last_IP_pts;
956
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
957
            if (pkt->dts == AV_NOPTS_VALUE)
958
                pkt->dts = st->cur_dts;
959

    
960
            /* this is tricky: the dts must be incremented by the duration
961
            of the frame we are displaying, i.e. the last I- or P-frame */
962
            if (st->last_IP_duration == 0)
963
                st->last_IP_duration = pkt->duration;
964
            if(pkt->dts != AV_NOPTS_VALUE)
965
                st->cur_dts = pkt->dts + st->last_IP_duration;
966
            st->last_IP_duration  = pkt->duration;
967
            st->last_IP_pts= pkt->pts;
968
            /* cannot compute PTS if not present (we can compute it only
969
            by knowing the future */
970
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
971
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
972
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
973
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
974
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
975
                    pkt->pts += pkt->duration;
976
    //                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);
977
                }
978
            }
979

    
980
            /* presentation is not delayed : PTS and DTS are the same */
981
            if(pkt->pts == AV_NOPTS_VALUE)
982
                pkt->pts = pkt->dts;
983
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
984
            if(pkt->pts == AV_NOPTS_VALUE)
985
                pkt->pts = st->cur_dts;
986
            pkt->dts = pkt->pts;
987
            if(pkt->pts != AV_NOPTS_VALUE)
988
                st->cur_dts = pkt->pts + pkt->duration;
989
        }
990
    }
991

    
992
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
993
        st->pts_buffer[0]= pkt->pts;
994
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
995
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
996
        if(pkt->dts == AV_NOPTS_VALUE)
997
            pkt->dts= st->pts_buffer[0];
998
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
999
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1000
        }
1001
        if(pkt->dts > st->cur_dts)
1002
            st->cur_dts = pkt->dts;
1003
    }
1004

    
1005
//    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);
1006

    
1007
    /* update flags */
1008
    if(is_intra_only(st->codec))
1009
        pkt->flags |= AV_PKT_FLAG_KEY;
1010
    else if (pc) {
1011
        pkt->flags = 0;
1012
        /* keyframe computation */
1013
        if (pc->key_frame == 1)
1014
            pkt->flags |= AV_PKT_FLAG_KEY;
1015
        else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1016
            pkt->flags |= AV_PKT_FLAG_KEY;
1017
    }
1018
    if (pc)
1019
        pkt->convergence_duration = pc->convergence_duration;
1020
}
1021

    
1022

    
1023
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1024
{
1025
    AVStream *st;
1026
    int len, ret, i;
1027

    
1028
    av_init_packet(pkt);
1029

    
1030
    for(;;) {
1031
        /* select current input stream component */
1032
        st = s->cur_st;
1033
        if (st) {
1034
            if (!st->need_parsing || !st->parser) {
1035
                /* no parsing needed: we just output the packet as is */
1036
                /* raw data support */
1037
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1038
                compute_pkt_fields(s, st, NULL, pkt);
1039
                s->cur_st = NULL;
1040
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1041
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1042
                    ff_reduce_index(s, st->index);
1043
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1044
                }
1045
                break;
1046
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1047
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1048
                                       st->cur_ptr, st->cur_len,
1049
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1050
                                       st->cur_pkt.pos);
1051
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1052
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1053
                /* increment read pointer */
1054
                st->cur_ptr += len;
1055
                st->cur_len -= len;
1056

    
1057
                /* return packet if any */
1058
                if (pkt->size) {
1059
                got_packet:
1060
                    pkt->duration = 0;
1061
                    pkt->stream_index = st->index;
1062
                    pkt->pts = st->parser->pts;
1063
                    pkt->dts = st->parser->dts;
1064
                    pkt->pos = st->parser->pos;
1065
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1066
                        s->cur_st = NULL;
1067
                        pkt->destruct= st->cur_pkt.destruct;
1068
                        st->cur_pkt.destruct= NULL;
1069
                        st->cur_pkt.data    = NULL;
1070
                        assert(st->cur_len == 0);
1071
                    }else{
1072
                    pkt->destruct = NULL;
1073
                    }
1074
                    compute_pkt_fields(s, st, st->parser, pkt);
1075

    
1076
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1077
                        ff_reduce_index(s, st->index);
1078
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1079
                                           0, 0, AVINDEX_KEYFRAME);
1080
                    }
1081

    
1082
                    break;
1083
                }
1084
            } else {
1085
                /* free packet */
1086
                av_free_packet(&st->cur_pkt);
1087
                s->cur_st = NULL;
1088
            }
1089
        } else {
1090
            AVPacket cur_pkt;
1091
            /* read next packet */
1092
            ret = av_read_packet(s, &cur_pkt);
1093
            if (ret < 0) {
1094
                if (ret == AVERROR(EAGAIN))
1095
                    return ret;
1096
                /* return the last frames, if any */
1097
                for(i = 0; i < s->nb_streams; i++) {
1098
                    st = s->streams[i];
1099
                    if (st->parser && st->need_parsing) {
1100
                        av_parser_parse2(st->parser, st->codec,
1101
                                        &pkt->data, &pkt->size,
1102
                                        NULL, 0,
1103
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1104
                                        AV_NOPTS_VALUE);
1105
                        if (pkt->size)
1106
                            goto got_packet;
1107
                    }
1108
                }
1109
                /* no more packets: really terminate parsing */
1110
                return ret;
1111
            }
1112
            st = s->streams[cur_pkt.stream_index];
1113
            st->cur_pkt= cur_pkt;
1114

    
1115
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1116
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1117
               st->cur_pkt.pts < st->cur_pkt.dts){
1118
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1119
                    st->cur_pkt.stream_index,
1120
                    st->cur_pkt.pts,
1121
                    st->cur_pkt.dts,
1122
                    st->cur_pkt.size);
1123
//                av_free_packet(&st->cur_pkt);
1124
//                return -1;
1125
            }
1126

    
1127
            if(s->debug & FF_FDEBUG_TS)
1128
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1129
                    st->cur_pkt.stream_index,
1130
                    st->cur_pkt.pts,
1131
                    st->cur_pkt.dts,
1132
                    st->cur_pkt.size,
1133
                    st->cur_pkt.duration,
1134
                    st->cur_pkt.flags);
1135

    
1136
            s->cur_st = st;
1137
            st->cur_ptr = st->cur_pkt.data;
1138
            st->cur_len = st->cur_pkt.size;
1139
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1140
                st->parser = av_parser_init(st->codec->codec_id);
1141
                if (!st->parser) {
1142
                    /* no parser available: just output the raw packets */
1143
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1144
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1145
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1146
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1147
                    st->parser->flags |= PARSER_FLAG_ONCE;
1148
                }
1149
            }
1150
        }
1151
    }
1152
    if(s->debug & FF_FDEBUG_TS)
1153
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1154
            pkt->stream_index,
1155
            pkt->pts,
1156
            pkt->dts,
1157
            pkt->size,
1158
            pkt->duration,
1159
            pkt->flags);
1160

    
1161
    return 0;
1162
}
1163

    
1164
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1165
{
1166
    AVPacketList *pktl;
1167
    int eof=0;
1168
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1169

    
1170
    for(;;){
1171
        pktl = s->packet_buffer;
1172
        if (pktl) {
1173
            AVPacket *next_pkt= &pktl->pkt;
1174

    
1175
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1176
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1177
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1178
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1179
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1180
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1181
                        next_pkt->pts= pktl->pkt.dts;
1182
                    }
1183
                    pktl= pktl->next;
1184
                }
1185
                pktl = s->packet_buffer;
1186
            }
1187

    
1188
            if(   next_pkt->pts != AV_NOPTS_VALUE
1189
               || next_pkt->dts == AV_NOPTS_VALUE
1190
               || !genpts || eof){
1191
                /* read packet from packet buffer, if there is data */
1192
                *pkt = *next_pkt;
1193
                s->packet_buffer = pktl->next;
1194
                av_free(pktl);
1195
                return 0;
1196
            }
1197
        }
1198
        if(genpts){
1199
            int ret= av_read_frame_internal(s, pkt);
1200
            if(ret<0){
1201
                if(pktl && ret != AVERROR(EAGAIN)){
1202
                    eof=1;
1203
                    continue;
1204
                }else
1205
                    return ret;
1206
            }
1207

    
1208
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1209
                                           &s->packet_buffer_end)) < 0)
1210
                return AVERROR(ENOMEM);
1211
        }else{
1212
            assert(!s->packet_buffer);
1213
            return av_read_frame_internal(s, pkt);
1214
        }
1215
    }
1216
}
1217

    
1218
/* XXX: suppress the packet queue */
1219
static void flush_packet_queue(AVFormatContext *s)
1220
{
1221
    AVPacketList *pktl;
1222

    
1223
    for(;;) {
1224
        pktl = s->packet_buffer;
1225
        if (!pktl)
1226
            break;
1227
        s->packet_buffer = pktl->next;
1228
        av_free_packet(&pktl->pkt);
1229
        av_free(pktl);
1230
    }
1231
    while(s->raw_packet_buffer){
1232
        pktl = s->raw_packet_buffer;
1233
        s->raw_packet_buffer = pktl->next;
1234
        av_free_packet(&pktl->pkt);
1235
        av_free(pktl);
1236
    }
1237
    s->packet_buffer_end=
1238
    s->raw_packet_buffer_end= NULL;
1239
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1240
}
1241

    
1242
/*******************************************************/
1243
/* seek support */
1244

    
1245
int av_find_default_stream_index(AVFormatContext *s)
1246
{
1247
    int first_audio_index = -1;
1248
    int i;
1249
    AVStream *st;
1250

    
1251
    if (s->nb_streams <= 0)
1252
        return -1;
1253
    for(i = 0; i < s->nb_streams; i++) {
1254
        st = s->streams[i];
1255
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1256
            return i;
1257
        }
1258
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1259
            first_audio_index = i;
1260
    }
1261
    return first_audio_index >= 0 ? first_audio_index : 0;
1262
}
1263

    
1264
/**
1265
 * Flush the frame reader.
1266
 */
1267
void ff_read_frame_flush(AVFormatContext *s)
1268
{
1269
    AVStream *st;
1270
    int i, j;
1271

    
1272
    flush_packet_queue(s);
1273

    
1274
    s->cur_st = NULL;
1275

    
1276
    /* for each stream, reset read state */
1277
    for(i = 0; i < s->nb_streams; i++) {
1278
        st = s->streams[i];
1279

    
1280
        if (st->parser) {
1281
            av_parser_close(st->parser);
1282
            st->parser = NULL;
1283
            av_free_packet(&st->cur_pkt);
1284
        }
1285
        st->last_IP_pts = AV_NOPTS_VALUE;
1286
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1287
        st->reference_dts = AV_NOPTS_VALUE;
1288
        /* fail safe */
1289
        st->cur_ptr = NULL;
1290
        st->cur_len = 0;
1291

    
1292
        st->probe_packets = MAX_PROBE_PACKETS;
1293

    
1294
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1295
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1296
    }
1297
}
1298

    
1299
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1300
    int i;
1301

    
1302
    for(i = 0; i < s->nb_streams; i++) {
1303
        AVStream *st = s->streams[i];
1304

    
1305
        st->cur_dts = av_rescale(timestamp,
1306
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1307
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1308
    }
1309
}
1310

    
1311
void ff_reduce_index(AVFormatContext *s, int stream_index)
1312
{
1313
    AVStream *st= s->streams[stream_index];
1314
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1315

    
1316
    if((unsigned)st->nb_index_entries >= max_entries){
1317
        int i;
1318
        for(i=0; 2*i<st->nb_index_entries; i++)
1319
            st->index_entries[i]= st->index_entries[2*i];
1320
        st->nb_index_entries= i;
1321
    }
1322
}
1323

    
1324
int ff_add_index_entry(AVIndexEntry **index_entries,
1325
                       int *nb_index_entries,
1326
                       unsigned int *index_entries_allocated_size,
1327
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1328
{
1329
    AVIndexEntry *entries, *ie;
1330
    int index;
1331

    
1332
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1333
        return -1;
1334

    
1335
    entries = av_fast_realloc(*index_entries,
1336
                              index_entries_allocated_size,
1337
                              (*nb_index_entries + 1) *
1338
                              sizeof(AVIndexEntry));
1339
    if(!entries)
1340
        return -1;
1341

    
1342
    *index_entries= entries;
1343

    
1344
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1345

    
1346
    if(index<0){
1347
        index= (*nb_index_entries)++;
1348
        ie= &entries[index];
1349
        assert(index==0 || ie[-1].timestamp < timestamp);
1350
    }else{
1351
        ie= &entries[index];
1352
        if(ie->timestamp != timestamp){
1353
            if(ie->timestamp <= timestamp)
1354
                return -1;
1355
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1356
            (*nb_index_entries)++;
1357
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1358
            distance= ie->min_distance;
1359
    }
1360

    
1361
    ie->pos = pos;
1362
    ie->timestamp = timestamp;
1363
    ie->min_distance= distance;
1364
    ie->size= size;
1365
    ie->flags = flags;
1366

    
1367
    return index;
1368
}
1369

    
1370
int av_add_index_entry(AVStream *st,
1371
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1372
{
1373
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1374
                              &st->index_entries_allocated_size, pos,
1375
                              timestamp, size, distance, flags);
1376
}
1377

    
1378
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1379
                              int64_t wanted_timestamp, int flags)
1380
{
1381
    int a, b, m;
1382
    int64_t timestamp;
1383

    
1384
    a = - 1;
1385
    b = nb_entries;
1386

    
1387
    //optimize appending index entries at the end
1388
    if(b && entries[b-1].timestamp < wanted_timestamp)
1389
        a= b-1;
1390

    
1391
    while (b - a > 1) {
1392
        m = (a + b) >> 1;
1393
        timestamp = entries[m].timestamp;
1394
        if(timestamp >= wanted_timestamp)
1395
            b = m;
1396
        if(timestamp <= wanted_timestamp)
1397
            a = m;
1398
    }
1399
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1400

    
1401
    if(!(flags & AVSEEK_FLAG_ANY)){
1402
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1403
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1404
        }
1405
    }
1406

    
1407
    if(m == nb_entries)
1408
        return -1;
1409
    return  m;
1410
}
1411

    
1412
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1413
                              int flags)
1414
{
1415
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1416
                                     wanted_timestamp, flags);
1417
}
1418

    
1419
#define DEBUG_SEEK
1420

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

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

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

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

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

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

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

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

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

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

    
1482
    av_update_cur_dts(s, st, ts);
1483

    
1484
    return 0;
1485
}
1486

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1613
    pos_min = s->data_offset;
1614
    pos_max = avio_size(s->pb) - 1;
1615

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

    
1619
    avio_seek(s->pb, pos, SEEK_SET);
1620

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

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

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

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

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

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

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

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

    
1684
    return 0;
1685
}
1686

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

    
1692
    ff_read_frame_flush(s);
1693

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

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

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

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

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

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

    
1727
    ff_read_frame_flush(s);
1728

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

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

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

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

    
1744
/*******************************************************/
1745

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

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

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

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

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

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

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

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

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

    
1865
#define DURATION_MAX_READ_SIZE 250000
1866
#define DURATION_MAX_RETRY 3
1867

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

    
1878
    ic->cur_st = NULL;
1879

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

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

    
1888
        if (st->parser) {
1889
            av_parser_close(st->parser);
1890
            st->parser= NULL;
1891
            av_free_packet(&st->cur_pkt);
1892
        }
1893
    }
1894

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

    
1904
    avio_seek(ic->pb, offset, SEEK_SET);
1905
    read_size = 0;
1906
    for(;;) {
1907
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1908
            break;
1909

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

    
1937
    fill_all_stream_timings(ic);
1938

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

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

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

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

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

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

    
2018
static int has_decode_delay_been_guessed(AVStream *st)
2019
{
2020
    return st->codec->codec_id != CODEC_ID_H264 ||
2021
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2022
}
2023

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

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

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

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

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

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

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

    
2108
static void compute_chapters_end(AVFormatContext *s)
2109
{
2110
    unsigned int i, j;
2111
    int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2112

    
2113
    for (i = 0; i < s->nb_chapters; i++)
2114
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2115
            AVChapter *ch = s->chapters[i];
2116
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2117
                                     : INT64_MAX;
2118

    
2119
            for (j = 0; j < s->nb_chapters; j++) {
2120
                AVChapter *ch1 = s->chapters[j];
2121
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2122
                if (j != i && next_start > ch->start && next_start < end)
2123
                    end = next_start;
2124
            }
2125
            ch->end = (end == INT64_MAX) ? ch->start : end;
2126
        }
2127
}
2128

    
2129
static int get_std_framerate(int i){
2130
    if(i<60*12) return i*1001;
2131
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2132
}
2133

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

    
2154
int av_find_stream_info(AVFormatContext *ic)
2155
{
2156
    int i, count, ret, read_size, j;
2157
    AVStream *st;
2158
    AVPacket pkt1, *pkt;
2159
    int64_t old_offset = avio_tell(ic->pb);
2160

    
2161
    for(i=0;i<ic->nb_streams;i++) {
2162
        AVCodec *codec;
2163
        st = ic->streams[i];
2164
        if (st->codec->codec_id == CODEC_ID_AAC) {
2165
            st->codec->sample_rate = 0;
2166
            st->codec->frame_size = 0;
2167
            st->codec->channels = 0;
2168
        }
2169
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2170
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2171
/*            if(!st->time_base.num)
2172
                st->time_base= */
2173
            if(!st->codec->time_base.num)
2174
                st->codec->time_base= st->time_base;
2175
        }
2176
        //only for the split stuff
2177
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2178
            st->parser = av_parser_init(st->codec->codec_id);
2179
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2180
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2181
            }
2182
        }
2183
        assert(!st->codec->codec);
2184
        codec = avcodec_find_decoder(st->codec->codec_id);
2185

    
2186
        /* Force decoding of at least one frame of codec data
2187
         * this makes sure the codec initializes the channel configuration
2188
         * and does not trust the values from the container.
2189
         */
2190
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2191
            st->codec->channels = 0;
2192

    
2193
        /* Ensure that subtitle_header is properly set. */
2194
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2195
            && codec && !st->codec->codec)
2196
            avcodec_open(st->codec, codec);
2197

    
2198
        //try to just open decoders, in case this is enough to get parameters
2199
        if(!has_codec_parameters(st->codec)){
2200
            if (codec && !st->codec->codec)
2201
                avcodec_open(st->codec, codec);
2202
        }
2203
    }
2204

    
2205
    for (i=0; i<ic->nb_streams; i++) {
2206
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2207
    }
2208

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

    
2218
        /* check if one codec still needs to be handled */
2219
        for(i=0;i<ic->nb_streams;i++) {
2220
            int fps_analyze_framecount = 20;
2221

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

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

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

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

    
2284
        read_size += pkt->size;
2285

    
2286
        st = ic->streams[pkt->stream_index];
2287
        if (st->codec_info_nb_frames>1) {
2288
            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) {
2289
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2290
                break;
2291
            }
2292
            st->info->codec_info_duration += pkt->duration;
2293
        }
2294
        {
2295
            int64_t last = st->info->last_dts;
2296
            int64_t duration= pkt->dts - last;
2297

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

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

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

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

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

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

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

    
2383
            if (!st->r_frame_rate.num){
2384
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2385
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2386
                    st->r_frame_rate.num = st->codec->time_base.den;
2387
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2388
                }else{
2389
                    st->r_frame_rate.num = st->time_base.den;
2390
                    st->r_frame_rate.den = st->time_base.num;
2391
                }
2392
            }
2393
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2394
            if(!st->codec->bits_per_coded_sample)
2395
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2396
            // set stream disposition based on audio service type
2397
            switch (st->codec->audio_service_type) {
2398
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2399
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2400
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2401
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2402
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2403
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2404
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2405
                st->disposition = AV_DISPOSITION_COMMENT;          break;
2406
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2407
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
2408
            }
2409
        }
2410
    }
2411

    
2412
    av_estimate_timings(ic, old_offset);
2413

    
2414
    compute_chapters_end(ic);
2415

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

    
2441
 find_stream_info_err:
2442
    for (i=0; i < ic->nb_streams; i++)
2443
        av_freep(&ic->streams[i]->info);
2444
    return ret;
2445
}
2446

    
2447
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2448
{
2449
    int i, j;
2450

    
2451
    for (i = 0; i < ic->nb_programs; i++)
2452
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2453
            if (ic->programs[i]->stream_index[j] == s)
2454
                return ic->programs[i];
2455
    return NULL;
2456
}
2457

    
2458
int av_find_best_stream(AVFormatContext *ic,
2459
                        enum AVMediaType type,
2460
                        int wanted_stream_nb,
2461
                        int related_stream,
2462
                        AVCodec **decoder_ret,
2463
                        int flags)
2464
{
2465
    int i, nb_streams = ic->nb_streams;
2466
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2467
    unsigned *program = NULL;
2468
    AVCodec *decoder = NULL, *best_decoder = NULL;
2469

    
2470
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2471
        AVProgram *p = find_program_from_stream(ic, related_stream);
2472
        if (p) {
2473
            program = p->stream_index;
2474
            nb_streams = p->nb_stream_indexes;
2475
        }
2476
    }
2477
    for (i = 0; i < nb_streams; i++) {
2478
        int real_stream_index = program ? program[i] : i;
2479
        AVStream *st = ic->streams[real_stream_index];
2480
        AVCodecContext *avctx = st->codec;
2481
        if (avctx->codec_type != type)
2482
            continue;
2483
        if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2484
            continue;
2485
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2486
            continue;
2487
        if (decoder_ret) {
2488
            decoder = avcodec_find_decoder(st->codec->codec_id);
2489
            if (!decoder) {
2490
                if (ret < 0)
2491
                    ret = AVERROR_DECODER_NOT_FOUND;
2492
                continue;
2493
            }
2494
        }
2495
        if (best_count >= st->codec_info_nb_frames)
2496
            continue;
2497
        best_count = st->codec_info_nb_frames;
2498
        ret = real_stream_index;
2499
        best_decoder = decoder;
2500
        if (program && i == nb_streams - 1 && ret < 0) {
2501
            program = NULL;
2502
            nb_streams = ic->nb_streams;
2503
            i = 0; /* no related stream found, try again with everything */
2504
        }
2505
    }
2506
    if (decoder_ret)
2507
        *decoder_ret = best_decoder;
2508
    return ret;
2509
}
2510

    
2511
/*******************************************************/
2512

    
2513
int av_read_play(AVFormatContext *s)
2514
{
2515
    if (s->iformat->read_play)
2516
        return s->iformat->read_play(s);
2517
    if (s->pb)
2518
        return avio_pause(s->pb, 0);
2519
    return AVERROR(ENOSYS);
2520
}
2521

    
2522
int av_read_pause(AVFormatContext *s)
2523
{
2524
    if (s->iformat->read_pause)
2525
        return s->iformat->read_pause(s);
2526
    if (s->pb)
2527
        return avio_pause(s->pb, 1);
2528
    return AVERROR(ENOSYS);
2529
}
2530

    
2531
void av_close_input_stream(AVFormatContext *s)
2532
{
2533
    flush_packet_queue(s);
2534
    if (s->iformat->read_close)
2535
        s->iformat->read_close(s);
2536
    avformat_free_context(s);
2537
}
2538

    
2539
void avformat_free_context(AVFormatContext *s)
2540
{
2541
    int i;
2542
    AVStream *st;
2543

    
2544
    for(i=0;i<s->nb_streams;i++) {
2545
        /* free all data in a stream component */
2546
        st = s->streams[i];
2547
        if (st->parser) {
2548
            av_parser_close(st->parser);
2549
            av_free_packet(&st->cur_pkt);
2550
        }
2551
        av_metadata_free(&st->metadata);
2552
        av_free(st->index_entries);
2553
        av_free(st->codec->extradata);
2554
        av_free(st->codec->subtitle_header);
2555
        av_free(st->codec);
2556
        av_free(st->priv_data);
2557
        av_free(st->info);
2558
        av_free(st);
2559
    }
2560
    for(i=s->nb_programs-1; i>=0; i--) {
2561
        av_metadata_free(&s->programs[i]->metadata);
2562
        av_freep(&s->programs[i]->stream_index);
2563
        av_freep(&s->programs[i]);
2564
    }
2565
    av_freep(&s->programs);
2566
    av_freep(&s->priv_data);
2567
    while(s->nb_chapters--) {
2568
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2569
        av_free(s->chapters[s->nb_chapters]);
2570
    }
2571
    av_freep(&s->chapters);
2572
    av_metadata_free(&s->metadata);
2573
    av_freep(&s->key);
2574
    av_freep(&s->streams);
2575
    av_free(s);
2576
}
2577

    
2578
void av_close_input_file(AVFormatContext *s)
2579
{
2580
    AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2581
    av_close_input_stream(s);
2582
    if (pb)
2583
        avio_close(pb);
2584
}
2585

    
2586
AVStream *av_new_stream(AVFormatContext *s, int id)
2587
{
2588
    AVStream *st;
2589
    int i;
2590
    AVStream **streams;
2591

    
2592
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2593
        return NULL;
2594
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2595
    if (!streams)
2596
        return NULL;
2597
    s->streams = streams;
2598

    
2599
    st = av_mallocz(sizeof(AVStream));
2600
    if (!st)
2601
        return NULL;
2602
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2603
        av_free(st);
2604
        return NULL;
2605
    }
2606

    
2607
    st->codec= avcodec_alloc_context();
2608
    if (s->iformat) {
2609
        /* no default bitrate if decoding */
2610
        st->codec->bit_rate = 0;
2611
    }
2612
    st->index = s->nb_streams;
2613
    st->id = id;
2614
    st->start_time = AV_NOPTS_VALUE;
2615
    st->duration = AV_NOPTS_VALUE;
2616
        /* we set the current DTS to 0 so that formats without any timestamps
2617
           but durations get some timestamps, formats with some unknown
2618
           timestamps have their first few packets buffered and the
2619
           timestamps corrected before they are returned to the user */
2620
    st->cur_dts = 0;
2621
    st->first_dts = AV_NOPTS_VALUE;
2622
    st->probe_packets = MAX_PROBE_PACKETS;
2623

    
2624
    /* default pts setting is MPEG-like */
2625
    av_set_pts_info(st, 33, 1, 90000);
2626
    st->last_IP_pts = AV_NOPTS_VALUE;
2627
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2628
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2629
    st->reference_dts = AV_NOPTS_VALUE;
2630

    
2631
    st->sample_aspect_ratio = (AVRational){0,1};
2632

    
2633
    s->streams[s->nb_streams++] = st;
2634
    return st;
2635
}
2636

    
2637
AVProgram *av_new_program(AVFormatContext *ac, int id)
2638
{
2639
    AVProgram *program=NULL;
2640
    int i;
2641

    
2642
#ifdef DEBUG_SI
2643
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2644
#endif
2645

    
2646
    for(i=0; i<ac->nb_programs; i++)
2647
        if(ac->programs[i]->id == id)
2648
            program = ac->programs[i];
2649

    
2650
    if(!program){
2651
        program = av_mallocz(sizeof(AVProgram));
2652
        if (!program)
2653
            return NULL;
2654
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2655
        program->discard = AVDISCARD_NONE;
2656
    }
2657
    program->id = id;
2658

    
2659
    return program;
2660
}
2661

    
2662
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2663
{
2664
    AVChapter *chapter = NULL;
2665
    int i;
2666

    
2667
    for(i=0; i<s->nb_chapters; i++)
2668
        if(s->chapters[i]->id == id)
2669
            chapter = s->chapters[i];
2670

    
2671
    if(!chapter){
2672
        chapter= av_mallocz(sizeof(AVChapter));
2673
        if(!chapter)
2674
            return NULL;
2675
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2676
    }
2677
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2678
    chapter->id    = id;
2679
    chapter->time_base= time_base;
2680
    chapter->start = start;
2681
    chapter->end   = end;
2682

    
2683
    return chapter;
2684
}
2685

    
2686
/************************************************************/
2687
/* output media file */
2688

    
2689
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2690
{
2691
    int ret;
2692

    
2693
    if (s->oformat->priv_data_size > 0) {
2694
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2695
        if (!s->priv_data)
2696
            return AVERROR(ENOMEM);
2697
        if (s->oformat->priv_class) {
2698
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2699
            av_opt_set_defaults(s->priv_data);
2700
        }
2701
    } else
2702
        s->priv_data = NULL;
2703

    
2704
    if (s->oformat->set_parameters) {
2705
        ret = s->oformat->set_parameters(s, ap);
2706
        if (ret < 0)
2707
            return ret;
2708
    }
2709
    return 0;
2710
}
2711

    
2712
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2713
{
2714
    const AVCodecTag *avctag;
2715
    int n;
2716
    enum CodecID id = CODEC_ID_NONE;
2717
    unsigned int tag = 0;
2718

    
2719
    /**
2720
     * Check that tag + id is in the table
2721
     * If neither is in the table -> OK
2722
     * If tag is in the table with another id -> FAIL
2723
     * If id is in the table with another tag -> FAIL unless strict < normal
2724
     */
2725
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2726
        avctag = s->oformat->codec_tag[n];
2727
        while (avctag->id != CODEC_ID_NONE) {
2728
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2729
                id = avctag->id;
2730
                if (id == st->codec->codec_id)
2731
                    return 1;
2732
            }
2733
            if (avctag->id == st->codec->codec_id)
2734
                tag = avctag->tag;
2735
            avctag++;
2736
        }
2737
    }
2738
    if (id != CODEC_ID_NONE)
2739
        return 0;
2740
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2741
        return 0;
2742
    return 1;
2743
}
2744

    
2745
int av_write_header(AVFormatContext *s)
2746
{
2747
    int ret, i;
2748
    AVStream *st;
2749

    
2750
    // some sanity checks
2751
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2752
        av_log(s, AV_LOG_ERROR, "no streams\n");
2753
        return AVERROR(EINVAL);
2754
    }
2755

    
2756
    for(i=0;i<s->nb_streams;i++) {
2757
        st = s->streams[i];
2758

    
2759
        switch (st->codec->codec_type) {
2760
        case AVMEDIA_TYPE_AUDIO:
2761
            if(st->codec->sample_rate<=0){
2762
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2763
                return AVERROR(EINVAL);
2764
            }
2765
            if(!st->codec->block_align)
2766
                st->codec->block_align = st->codec->channels *
2767
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2768
            break;
2769
        case AVMEDIA_TYPE_VIDEO:
2770
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2771
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2772
                return AVERROR(EINVAL);
2773
            }
2774
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2775
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2776
                return AVERROR(EINVAL);
2777
            }
2778
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2779
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2780
                return AVERROR(EINVAL);
2781
            }
2782
            break;
2783
        }
2784

    
2785
        if(s->oformat->codec_tag){
2786
            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)){
2787
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2788
                st->codec->codec_tag= 0;
2789
            }
2790
            if(st->codec->codec_tag){
2791
                if (!validate_codec_tag(s, st)) {
2792
                    char tagbuf[32];
2793
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2794
                    av_log(s, AV_LOG_ERROR,
2795
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2796
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2797
                    return AVERROR_INVALIDDATA;
2798
                }
2799
            }else
2800
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2801
        }
2802

    
2803
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2804
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2805
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2806
    }
2807

    
2808
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2809
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2810
        if (!s->priv_data)
2811
            return AVERROR(ENOMEM);
2812
    }
2813

    
2814
    /* set muxer identification string */
2815
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2816
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2817
    }
2818

    
2819
    if(s->oformat->write_header){
2820
        ret = s->oformat->write_header(s);
2821
        if (ret < 0)
2822
            return ret;
2823
    }
2824

    
2825
    /* init PTS generation */
2826
    for(i=0;i<s->nb_streams;i++) {
2827
        int64_t den = AV_NOPTS_VALUE;
2828
        st = s->streams[i];
2829

    
2830
        switch (st->codec->codec_type) {
2831
        case AVMEDIA_TYPE_AUDIO:
2832
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2833
            break;
2834
        case AVMEDIA_TYPE_VIDEO:
2835
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2836
            break;
2837
        default:
2838
            break;
2839
        }
2840
        if (den != AV_NOPTS_VALUE) {
2841
            if (den <= 0)
2842
                return AVERROR_INVALIDDATA;
2843
            av_frac_init(&st->pts, 0, 0, den);
2844
        }
2845
    }
2846
    return 0;
2847
}
2848

    
2849
//FIXME merge with compute_pkt_fields
2850
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2851
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2852
    int num, den, frame_size, i;
2853

    
2854
    av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2855
            pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2856

    
2857
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2858
        return -1;*/
2859

    
2860
    /* duration field */
2861
    if (pkt->duration == 0) {
2862
        compute_frame_duration(&num, &den, st, NULL, pkt);
2863
        if (den && num) {
2864
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2865
        }
2866
    }
2867

    
2868
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2869
        pkt->pts= pkt->dts;
2870

    
2871
    //XXX/FIXME this is a temporary hack until all encoders output pts
2872
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2873
        pkt->dts=
2874
//        pkt->pts= st->cur_dts;
2875
        pkt->pts= st->pts.val;
2876
    }
2877

    
2878
    //calculate dts from pts
2879
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2880
        st->pts_buffer[0]= pkt->pts;
2881
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2882
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2883
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2884
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2885

    
2886
        pkt->dts= st->pts_buffer[0];
2887
    }
2888

    
2889
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2890
        av_log(s, AV_LOG_ERROR,
2891
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2892
               st->index, st->cur_dts, pkt->dts);
2893
        return -1;
2894
    }
2895
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2896
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2897
        return -1;
2898
    }
2899

    
2900
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2901
    st->cur_dts= pkt->dts;
2902
    st->pts.val= pkt->dts;
2903

    
2904
    /* update pts */
2905
    switch (st->codec->codec_type) {
2906
    case AVMEDIA_TYPE_AUDIO:
2907
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2908

    
2909
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2910
           likely equal to the encoder delay, but it would be better if we
2911
           had the real timestamps from the encoder */
2912
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2913
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2914
        }
2915
        break;
2916
    case AVMEDIA_TYPE_VIDEO:
2917
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2918
        break;
2919
    default:
2920
        break;
2921
    }
2922
    return 0;
2923
}
2924

    
2925
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2926
{
2927
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2928

    
2929
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2930
        return ret;
2931

    
2932
    ret= s->oformat->write_packet(s, pkt);
2933
    return ret;
2934
}
2935

    
2936
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2937
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2938
{
2939
    AVPacketList **next_point, *this_pktl;
2940

    
2941
    this_pktl = av_mallocz(sizeof(AVPacketList));
2942
    this_pktl->pkt= *pkt;
2943
    pkt->destruct= NULL;             // do not free original but only the copy
2944
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2945

    
2946
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2947
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2948
    }else
2949
        next_point = &s->packet_buffer;
2950

    
2951
    if(*next_point){
2952
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2953
            while(!compare(s, &(*next_point)->pkt, pkt)){
2954
                next_point= &(*next_point)->next;
2955
            }
2956
            goto next_non_null;
2957
        }else{
2958
            next_point = &(s->packet_buffer_end->next);
2959
        }
2960
    }
2961
    assert(!*next_point);
2962

    
2963
    s->packet_buffer_end= this_pktl;
2964
next_non_null:
2965

    
2966
    this_pktl->next= *next_point;
2967

    
2968
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2969
    *next_point= this_pktl;
2970
}
2971

    
2972
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2973
{
2974
    AVStream *st = s->streams[ pkt ->stream_index];
2975
    AVStream *st2= s->streams[ next->stream_index];
2976
    int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
2977
                             st->time_base);
2978

    
2979
    if (comp == 0)
2980
        return pkt->stream_index < next->stream_index;
2981
    return comp > 0;
2982
}
2983

    
2984
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2985
    AVPacketList *pktl;
2986
    int stream_count=0;
2987
    int i;
2988

    
2989
    if(pkt){
2990
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2991
    }
2992

    
2993
    for(i=0; i < s->nb_streams; i++)
2994
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2995

    
2996
    if(stream_count && (s->nb_streams == stream_count || flush)){
2997
        pktl= s->packet_buffer;
2998
        *out= pktl->pkt;
2999

    
3000
        s->packet_buffer= pktl->next;
3001
        if(!s->packet_buffer)
3002
            s->packet_buffer_end= NULL;
3003

    
3004
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3005
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3006
        av_freep(&pktl);
3007
        return 1;
3008
    }else{
3009
        av_init_packet(out);
3010
        return 0;
3011
    }
3012
}
3013

    
3014
/**
3015
 * Interleave an AVPacket correctly so it can be muxed.
3016
 * @param out the interleaved packet will be output here
3017
 * @param in the input packet
3018
 * @param flush 1 if no further packets are available as input and all
3019
 *              remaining packets should be output
3020
 * @return 1 if a packet was output, 0 if no packet could be output,
3021
 *         < 0 if an error occurred
3022
 */
3023
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3024
    if(s->oformat->interleave_packet)
3025
        return s->oformat->interleave_packet(s, out, in, flush);
3026
    else
3027
        return av_interleave_packet_per_dts(s, out, in, flush);
3028
}
3029

    
3030
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3031
    AVStream *st= s->streams[ pkt->stream_index];
3032
    int ret;
3033

    
3034
    //FIXME/XXX/HACK drop zero sized packets
3035
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3036
        return 0;
3037

    
3038
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3039
            pkt->size, pkt->dts, pkt->pts);
3040
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3041
        return ret;
3042

    
3043
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3044
        return AVERROR(EINVAL);
3045

    
3046
    for(;;){
3047
        AVPacket opkt;
3048
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3049
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3050
            return ret;
3051

    
3052
        ret= s->oformat->write_packet(s, &opkt);
3053

    
3054
        av_free_packet(&opkt);
3055
        pkt= NULL;
3056

    
3057
        if(ret<0)
3058
            return ret;
3059
    }
3060
}
3061

    
3062
int av_write_trailer(AVFormatContext *s)
3063
{
3064
    int ret, i;
3065

    
3066
    for(;;){
3067
        AVPacket pkt;
3068
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3069
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3070
            goto fail;
3071
        if(!ret)
3072
            break;
3073

    
3074
        ret= s->oformat->write_packet(s, &pkt);
3075

    
3076
        av_free_packet(&pkt);
3077

    
3078
        if(ret<0)
3079
            goto fail;
3080
    }
3081

    
3082
    if(s->oformat->write_trailer)
3083
        ret = s->oformat->write_trailer(s);
3084
fail:
3085
    for(i=0;i<s->nb_streams;i++) {
3086
        av_freep(&s->streams[i]->priv_data);
3087
        av_freep(&s->streams[i]->index_entries);
3088
    }
3089
    av_freep(&s->priv_data);
3090
    return ret;
3091
}
3092

    
3093
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3094
{
3095
    int i, j;
3096
    AVProgram *program=NULL;
3097
    void *tmp;
3098

    
3099
    if (idx >= ac->nb_streams) {
3100
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3101
        return;
3102
    }
3103

    
3104
    for(i=0; i<ac->nb_programs; i++){
3105
        if(ac->programs[i]->id != progid)
3106
            continue;
3107
        program = ac->programs[i];
3108
        for(j=0; j<program->nb_stream_indexes; j++)
3109
            if(program->stream_index[j] == idx)
3110
                return;
3111

    
3112
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3113
        if(!tmp)
3114
            return;
3115
        program->stream_index = tmp;
3116
        program->stream_index[program->nb_stream_indexes++] = idx;
3117
        return;
3118
    }
3119
}
3120

    
3121
static void print_fps(double d, const char *postfix){
3122
    uint64_t v= lrintf(d*100);
3123
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3124
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3125
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3126
}
3127

    
3128
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3129
{
3130
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3131
        AVMetadataTag *tag=NULL;
3132

    
3133
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3134
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3135
            if(strcmp("language", tag->key))
3136
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3137
        }
3138
    }
3139
}
3140

    
3141
/* "user interface" functions */
3142
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3143
{
3144
    char buf[256];
3145
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3146
    AVStream *st = ic->streams[i];
3147
    int g = av_gcd(st->time_base.num, st->time_base.den);
3148
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3149
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3150
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3151
    /* the pid is an important information, so we display it */
3152
    /* XXX: add a generic system */
3153
    if (flags & AVFMT_SHOW_IDS)
3154
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3155
    if (lang)
3156
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3157
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3158
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3159
    if (st->sample_aspect_ratio.num && // default
3160
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3161
        AVRational display_aspect_ratio;
3162
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3163
                  st->codec->width*st->sample_aspect_ratio.num,
3164
                  st->codec->height*st->sample_aspect_ratio.den,
3165
                  1024*1024);
3166
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3167
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3168
                 display_aspect_ratio.num, display_aspect_ratio.den);
3169
    }
3170
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3171
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3172
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3173
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3174
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3175
        if(st->time_base.den && st->time_base.num)
3176
            print_fps(1/av_q2d(st->time_base), "tbn");
3177
        if(st->codec->time_base.den && st->codec->time_base.num)
3178
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3179
    }
3180
    if (st->disposition & AV_DISPOSITION_DEFAULT)
3181
        av_log(NULL, AV_LOG_INFO, " (default)");
3182
    if (st->disposition & AV_DISPOSITION_DUB)
3183
        av_log(NULL, AV_LOG_INFO, " (dub)");
3184
    if (st->disposition & AV_DISPOSITION_ORIGINAL)
3185
        av_log(NULL, AV_LOG_INFO, " (original)");
3186
    if (st->disposition & AV_DISPOSITION_COMMENT)
3187
        av_log(NULL, AV_LOG_INFO, " (comment)");
3188
    if (st->disposition & AV_DISPOSITION_LYRICS)
3189
        av_log(NULL, AV_LOG_INFO, " (lyrics)");
3190
    if (st->disposition & AV_DISPOSITION_KARAOKE)
3191
        av_log(NULL, AV_LOG_INFO, " (karaoke)");
3192
    if (st->disposition & AV_DISPOSITION_FORCED)
3193
        av_log(NULL, AV_LOG_INFO, " (forced)");
3194
    if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3195
        av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3196
    if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3197
        av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3198
    if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3199
        av_log(NULL, AV_LOG_INFO, " (clean effects)");
3200
    av_log(NULL, AV_LOG_INFO, "\n");
3201
    dump_metadata(NULL, st->metadata, "    ");
3202
}
3203

    
3204
#if FF_API_DUMP_FORMAT
3205
void dump_format(AVFormatContext *ic,
3206
                 int index,
3207
                 const char *url,
3208
                 int is_output)
3209
{
3210
    av_dump_format(ic, index, url, is_output);
3211
}
3212
#endif
3213

    
3214
void av_dump_format(AVFormatContext *ic,
3215
                    int index,
3216
                    const char *url,
3217
                    int is_output)
3218
{
3219
    int i;
3220
    uint8_t *printed = av_mallocz(ic->nb_streams);
3221
    if (ic->nb_streams && !printed)
3222
        return;
3223

    
3224
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3225
            is_output ? "Output" : "Input",
3226
            index,
3227
            is_output ? ic->oformat->name : ic->iformat->name,
3228
            is_output ? "to" : "from", url);
3229
    dump_metadata(NULL, ic->metadata, "  ");
3230
    if (!is_output) {
3231
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3232
        if (ic->duration != AV_NOPTS_VALUE) {
3233
            int hours, mins, secs, us;
3234
            secs = ic->duration / AV_TIME_BASE;
3235
            us = ic->duration % AV_TIME_BASE;
3236
            mins = secs / 60;
3237
            secs %= 60;
3238
            hours = mins / 60;
3239
            mins %= 60;
3240
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3241
                   (100 * us) / AV_TIME_BASE);
3242
        } else {
3243
            av_log(NULL, AV_LOG_INFO, "N/A");
3244
        }
3245
        if (ic->start_time != AV_NOPTS_VALUE) {
3246
            int secs, us;
3247
            av_log(NULL, AV_LOG_INFO, ", start: ");
3248
            secs = ic->start_time / AV_TIME_BASE;
3249
            us = abs(ic->start_time % AV_TIME_BASE);
3250
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3251
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3252
        }
3253
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3254
        if (ic->bit_rate) {
3255
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3256
        } else {
3257
            av_log(NULL, AV_LOG_INFO, "N/A");
3258
        }
3259
        av_log(NULL, AV_LOG_INFO, "\n");
3260
    }
3261
    for (i = 0; i < ic->nb_chapters; i++) {
3262
        AVChapter *ch = ic->chapters[i];
3263
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3264
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3265
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3266

    
3267
        dump_metadata(NULL, ch->metadata, "    ");
3268
    }
3269
    if(ic->nb_programs) {
3270
        int j, k, total = 0;
3271
        for(j=0; j<ic->nb_programs; j++) {
3272
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3273
                                                  "name", NULL, 0);
3274
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3275
                   name ? name->value : "");
3276
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3277
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3278
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3279
                printed[ic->programs[j]->stream_index[k]] = 1;
3280
            }
3281
            total += ic->programs[j]->nb_stream_indexes;
3282
        }
3283
        if (total < ic->nb_streams)
3284
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3285
    }
3286
    for(i=0;i<ic->nb_streams;i++)
3287
        if (!printed[i])
3288
            dump_stream_format(ic, i, index, is_output);
3289

    
3290
    av_free(printed);
3291
}
3292

    
3293
int64_t av_gettime(void)
3294
{
3295
    struct timeval tv;
3296
    gettimeofday(&tv,NULL);
3297
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3298
}
3299

    
3300
uint64_t ff_ntp_time(void)
3301
{
3302
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3303
}
3304

    
3305
#if FF_API_PARSE_DATE
3306
#include "libavutil/parseutils.h"
3307

    
3308
int64_t parse_date(const char *timestr, int duration)
3309
{
3310
    int64_t timeval;
3311
    av_parse_time(&timeval, timestr, duration);
3312
    return timeval;
3313
}
3314
#endif
3315

    
3316
#if FF_API_FIND_INFO_TAG
3317
#include "libavutil/parseutils.h"
3318

    
3319
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3320
{
3321
    return av_find_info_tag(arg, arg_size, tag1, info);
3322
}
3323
#endif
3324

    
3325
int av_get_frame_filename(char *buf, int buf_size,
3326
                          const char *path, int number)
3327
{
3328
    const char *p;
3329
    char *q, buf1[20], c;
3330
    int nd, len, percentd_found;
3331

    
3332
    q = buf;
3333
    p = path;
3334
    percentd_found = 0;
3335
    for(;;) {
3336
        c = *p++;
3337
        if (c == '\0')
3338
            break;
3339
        if (c == '%') {
3340
            do {
3341
                nd = 0;
3342
                while (isdigit(*p)) {
3343
                    nd = nd * 10 + *p++ - '0';
3344
                }
3345
                c = *p++;
3346
            } while (isdigit(c));
3347

    
3348
            switch(c) {
3349
            case '%':
3350
                goto addchar;
3351
            case 'd':
3352
                if (percentd_found)
3353
                    goto fail;
3354
                percentd_found = 1;
3355
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3356
                len = strlen(buf1);
3357
                if ((q - buf + len) > buf_size - 1)
3358
                    goto fail;
3359
                memcpy(q, buf1, len);
3360
                q += len;
3361
                break;
3362
            default:
3363
                goto fail;
3364
            }
3365
        } else {
3366
        addchar:
3367
            if ((q - buf) < buf_size - 1)
3368
                *q++ = c;
3369
        }
3370
    }
3371
    if (!percentd_found)
3372
        goto fail;
3373
    *q = '\0';
3374
    return 0;
3375
 fail:
3376
    *q = '\0';
3377
    return -1;
3378
}
3379

    
3380
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3381
{
3382
    int len, i, j, c;
3383
#undef fprintf
3384
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3385

    
3386
    for(i=0;i<size;i+=16) {
3387
        len = size - i;
3388
        if (len > 16)
3389
            len = 16;
3390
        PRINT("%08x ", i);
3391
        for(j=0;j<16;j++) {
3392
            if (j < len)
3393
                PRINT(" %02x", buf[i+j]);
3394
            else
3395
                PRINT("   ");
3396
        }
3397
        PRINT(" ");
3398
        for(j=0;j<len;j++) {
3399
            c = buf[i+j];
3400
            if (c < ' ' || c > '~')
3401
                c = '.';
3402
            PRINT("%c", c);
3403
        }
3404
        PRINT("\n");
3405
    }
3406
#undef PRINT
3407
}
3408

    
3409
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3410
{
3411
    hex_dump_internal(NULL, f, 0, buf, size);
3412
}
3413

    
3414
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3415
{
3416
    hex_dump_internal(avcl, NULL, level, buf, size);
3417
}
3418

    
3419
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3420
{
3421
#undef fprintf
3422
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3423
    PRINT("stream #%d:\n", pkt->stream_index);
3424
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3425
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3426
    /* DTS is _always_ valid after av_read_frame() */
3427
    PRINT("  dts=");
3428
    if (pkt->dts == AV_NOPTS_VALUE)
3429
        PRINT("N/A");
3430
    else
3431
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3432
    /* PTS may not be known if B-frames are present. */
3433
    PRINT("  pts=");
3434
    if (pkt->pts == AV_NOPTS_VALUE)
3435
        PRINT("N/A");
3436
    else
3437
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3438
    PRINT("\n");
3439
    PRINT("  size=%d\n", pkt->size);
3440
#undef PRINT
3441
    if (dump_payload)
3442
        av_hex_dump(f, pkt->data, pkt->size);
3443
}
3444

    
3445
#if FF_API_PKT_DUMP
3446
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3447
{
3448
    AVRational tb = { 1, AV_TIME_BASE };
3449
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3450
}
3451
#endif
3452

    
3453
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3454
{
3455
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3456
}
3457

    
3458
#if FF_API_PKT_DUMP
3459
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3460
{
3461
    AVRational tb = { 1, AV_TIME_BASE };
3462
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3463
}
3464
#endif
3465

    
3466
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3467
                      AVStream *st)
3468
{
3469
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3470
}
3471

    
3472
void av_url_split(char *proto, int proto_size,
3473
                  char *authorization, int authorization_size,
3474
                  char *hostname, int hostname_size,
3475
                  int *port_ptr,
3476
                  char *path, int path_size,
3477
                  const char *url)
3478
{
3479
    const char *p, *ls, *at, *col, *brk;
3480

    
3481
    if (port_ptr)               *port_ptr = -1;
3482
    if (proto_size > 0)         proto[0] = 0;
3483
    if (authorization_size > 0) authorization[0] = 0;
3484
    if (hostname_size > 0)      hostname[0] = 0;
3485
    if (path_size > 0)          path[0] = 0;
3486

    
3487
    /* parse protocol */
3488
    if ((p = strchr(url, ':'))) {
3489
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3490
        p++; /* skip ':' */
3491
        if (*p == '/') p++;
3492
        if (*p == '/') p++;
3493
    } else {
3494
        /* no protocol means plain filename */
3495
        av_strlcpy(path, url, path_size);
3496
        return;
3497
    }
3498

    
3499
    /* separate path from hostname */
3500
    ls = strchr(p, '/');
3501
    if(!ls)
3502
        ls = strchr(p, '?');
3503
    if(ls)
3504
        av_strlcpy(path, ls, path_size);
3505
    else
3506
        ls = &p[strlen(p)]; // XXX
3507

    
3508
    /* the rest is hostname, use that to parse auth/port */
3509
    if (ls != p) {
3510
        /* authorization (user[:pass]@hostname) */
3511
        if ((at = strchr(p, '@')) && at < ls) {
3512
            av_strlcpy(authorization, p,
3513
                       FFMIN(authorization_size, at + 1 - p));
3514
            p = at + 1; /* skip '@' */
3515
        }
3516

    
3517
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3518
            /* [host]:port */
3519
            av_strlcpy(hostname, p + 1,
3520
                       FFMIN(hostname_size, brk - p));
3521
            if (brk[1] == ':' && port_ptr)
3522
                *port_ptr = atoi(brk + 2);
3523
        } else if ((col = strchr(p, ':')) && col < ls) {
3524
            av_strlcpy(hostname, p,
3525
                       FFMIN(col + 1 - p, hostname_size));
3526
            if (port_ptr) *port_ptr = atoi(col + 1);
3527
        } else
3528
            av_strlcpy(hostname, p,
3529
                       FFMIN(ls + 1 - p, hostname_size));
3530
    }
3531
}
3532

    
3533
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3534
{
3535
    int i;
3536
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3537
                                           '4', '5', '6', '7',
3538
                                           '8', '9', 'A', 'B',
3539
                                           'C', 'D', 'E', 'F' };
3540
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3541
                                           '4', '5', '6', '7',
3542
                                           '8', '9', 'a', 'b',
3543
                                           'c', 'd', 'e', 'f' };
3544
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3545

    
3546
    for(i = 0; i < s; i++) {
3547
        buff[i * 2]     = hex_table[src[i] >> 4];
3548
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3549
    }
3550

    
3551
    return buff;
3552
}
3553

    
3554
int ff_hex_to_data(uint8_t *data, const char *p)
3555
{
3556
    int c, len, v;
3557

    
3558
    len = 0;
3559
    v = 1;
3560
    for (;;) {
3561
        p += strspn(p, SPACE_CHARS);
3562
        if (*p == '\0')
3563
            break;
3564
        c = toupper((unsigned char) *p++);
3565
        if (c >= '0' && c <= '9')
3566
            c = c - '0';
3567
        else if (c >= 'A' && c <= 'F')
3568
            c = c - 'A' + 10;
3569
        else
3570
            break;
3571
        v = (v << 4) | c;
3572
        if (v & 0x100) {
3573
            if (data)
3574
                data[len] = v;
3575
            len++;
3576
            v = 1;
3577
        }
3578
    }
3579
    return len;
3580
}
3581

    
3582
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3583
                     unsigned int pts_num, unsigned int pts_den)
3584
{
3585
    AVRational new_tb;
3586
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3587
        if(new_tb.num != pts_num)
3588
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3589
    }else
3590
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3591

    
3592
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3593
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3594
        return;
3595
    }
3596
    s->time_base = new_tb;
3597
    s->pts_wrap_bits = pts_wrap_bits;
3598
}
3599

    
3600
int ff_url_join(char *str, int size, const char *proto,
3601
                const char *authorization, const char *hostname,
3602
                int port, const char *fmt, ...)
3603
{
3604
#if CONFIG_NETWORK
3605
    struct addrinfo hints, *ai;
3606
#endif
3607

    
3608
    str[0] = '\0';
3609
    if (proto)
3610
        av_strlcatf(str, size, "%s://", proto);
3611
    if (authorization && authorization[0])
3612
        av_strlcatf(str, size, "%s@", authorization);
3613
#if CONFIG_NETWORK && defined(AF_INET6)
3614
    /* Determine if hostname is a numerical IPv6 address,
3615
     * properly escape it within [] in that case. */
3616
    memset(&hints, 0, sizeof(hints));
3617
    hints.ai_flags = AI_NUMERICHOST;
3618
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3619
        if (ai->ai_family == AF_INET6) {
3620
            av_strlcat(str, "[", size);
3621
            av_strlcat(str, hostname, size);
3622
            av_strlcat(str, "]", size);
3623
        } else {
3624
            av_strlcat(str, hostname, size);
3625
        }
3626
        freeaddrinfo(ai);
3627
    } else
3628
#endif
3629
        /* Not an IPv6 address, just output the plain string. */
3630
        av_strlcat(str, hostname, size);
3631

    
3632
    if (port >= 0)
3633
        av_strlcatf(str, size, ":%d", port);
3634
    if (fmt) {
3635
        va_list vl;
3636
        int len = strlen(str);
3637

    
3638
        va_start(vl, fmt);
3639
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3640
        va_end(vl);
3641
    }
3642
    return strlen(str);
3643
}
3644

    
3645
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3646
                     AVFormatContext *src)
3647
{
3648
    AVPacket local_pkt;
3649

    
3650
    local_pkt = *pkt;
3651
    local_pkt.stream_index = dst_stream;
3652
    if (pkt->pts != AV_NOPTS_VALUE)
3653
        local_pkt.pts = av_rescale_q(pkt->pts,
3654
                                     src->streams[pkt->stream_index]->time_base,
3655
                                     dst->streams[dst_stream]->time_base);
3656
    if (pkt->dts != AV_NOPTS_VALUE)
3657
        local_pkt.dts = av_rescale_q(pkt->dts,
3658
                                     src->streams[pkt->stream_index]->time_base,
3659
                                     dst->streams[dst_stream]->time_base);
3660
    return av_write_frame(dst, &local_pkt);
3661
}
3662

    
3663
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3664
                        void *context)
3665
{
3666
    const char *ptr = str;
3667

    
3668
    /* Parse key=value pairs. */
3669
    for (;;) {
3670
        const char *key;
3671
        char *dest = NULL, *dest_end;
3672
        int key_len, dest_len = 0;
3673

    
3674
        /* Skip whitespace and potential commas. */
3675
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3676
            ptr++;
3677
        if (!*ptr)
3678
            break;
3679

    
3680
        key = ptr;
3681

    
3682
        if (!(ptr = strchr(key, '=')))
3683
            break;
3684
        ptr++;
3685
        key_len = ptr - key;
3686

    
3687
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3688
        dest_end = dest + dest_len - 1;
3689

    
3690
        if (*ptr == '\"') {
3691
            ptr++;
3692
            while (*ptr && *ptr != '\"') {
3693
                if (*ptr == '\\') {
3694
                    if (!ptr[1])
3695
                        break;
3696
                    if (dest && dest < dest_end)
3697
                        *dest++ = ptr[1];
3698
                    ptr += 2;
3699
                } else {
3700
                    if (dest && dest < dest_end)
3701
                        *dest++ = *ptr;
3702
                    ptr++;
3703
                }
3704
            }
3705
            if (*ptr == '\"')
3706
                ptr++;
3707
        } else {
3708
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3709
                if (dest && dest < dest_end)
3710
                    *dest++ = *ptr;
3711
        }
3712
        if (dest)
3713
            *dest = 0;
3714
    }
3715
}
3716

    
3717
int ff_find_stream_index(AVFormatContext *s, int id)
3718
{
3719
    int i;
3720
    for (i = 0; i < s->nb_streams; i++) {
3721
        if (s->streams[i]->id == id)
3722
            return i;
3723
    }
3724
    return -1;
3725
}
3726

    
3727
void ff_make_absolute_url(char *buf, int size, const char *base,
3728
                          const char *rel)
3729
{
3730
    char *sep;
3731
    /* Absolute path, relative to the current server */
3732
    if (base && strstr(base, "://") && rel[0] == '/') {
3733
        if (base != buf)
3734
            av_strlcpy(buf, base, size);
3735
        sep = strstr(buf, "://");
3736
        if (sep) {
3737
            sep += 3;
3738
            sep = strchr(sep, '/');
3739
            if (sep)
3740
                *sep = '\0';
3741
        }
3742
        av_strlcat(buf, rel, size);
3743
        return;
3744
    }
3745
    /* If rel actually is an absolute url, just copy it */
3746
    if (!base || strstr(rel, "://") || rel[0] == '/') {
3747
        av_strlcpy(buf, rel, size);
3748
        return;
3749
    }
3750
    if (base != buf)
3751
        av_strlcpy(buf, base, size);
3752
    /* Remove the file name from the base url */
3753
    sep = strrchr(buf, '/');
3754
    if (sep)
3755
        sep[1] = '\0';
3756
    else
3757
        buf[0] = '\0';
3758
    while (av_strstart(rel, "../", NULL) && sep) {
3759
        /* Remove the path delimiter at the end */
3760
        sep[0] = '\0';
3761
        sep = strrchr(buf, '/');
3762
        /* If the next directory name to pop off is "..", break here */
3763
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
3764
            /* Readd the slash we just removed */
3765
            av_strlcat(buf, "/", size);
3766
            break;
3767
        }
3768
        /* Cut off the directory name */
3769
        if (sep)
3770
            sep[1] = '\0';
3771
        else
3772
            buf[0] = '\0';
3773
        rel += 3;
3774
    }
3775
    av_strlcat(buf, rel, size);
3776
}