Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 7c152a45

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 == FF_B_TYPE)
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 != FF_B_TYPE)
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 == FF_I_TYPE)
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, stream_number = 0;
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
        AVStream *st = ic->streams[program ? program[i] : i];
2479
        AVCodecContext *avctx = st->codec;
2480
        if (avctx->codec_type != type)
2481
            continue;
2482
        if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2483
            continue;
2484
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2485
            continue;
2486
        if (decoder_ret) {
2487
            decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2488
            if (!decoder) {
2489
                if (ret < 0)
2490
                    ret = AVERROR_DECODER_NOT_FOUND;
2491
                continue;
2492
            }
2493
        }
2494
        if (best_count >= st->codec_info_nb_frames)
2495
            continue;
2496
        best_count = st->codec_info_nb_frames;
2497
        ret = program ? program[i] : i;
2498
        best_decoder = decoder;
2499
        if (program && i == nb_streams - 1 && ret < 0) {
2500
            program = NULL;
2501
            nb_streams = ic->nb_streams;
2502
            i = 0; /* no related stream found, try again with everything */
2503
        }
2504
    }
2505
    if (decoder_ret)
2506
        *decoder_ret = best_decoder;
2507
    return ret;
2508
}
2509

    
2510
/*******************************************************/
2511

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2658
    return program;
2659
}
2660

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

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

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

    
2682
    return chapter;
2683
}
2684

    
2685
/************************************************************/
2686
/* output media file */
2687

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2965
    this_pktl->next= *next_point;
2966

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

    
2971
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2972
{
2973
    AVStream *st = s->streams[ pkt ->stream_index];
2974
    AVStream *st2= s->streams[ next->stream_index];
2975
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2976
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2977
    int64_t dts1 = av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN);
2978
    if (dts1 == next->dts)
2979
        return pkt->stream_index < next->stream_index;
2980
    return dts1 < next->dts;
2981
}
2982

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3075
        av_free_packet(&pkt);
3076

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3289
    av_free(printed);
3290
}
3291

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3550
    return buff;
3551
}
3552

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3679
        key = ptr;
3680

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

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

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

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

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