Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ ce5e49b0

History | View | Annotate | Download (124 KB)

1
/*
2
 * various utility functions for use within FFmpeg
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* #define DEBUG */
23

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

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

    
47
/**
48
 * @file
49
 * various utility functions for use within FFmpeg
50
 */
51

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

    
57
const char *avformat_configuration(void)
58
{
59
    return FFMPEG_CONFIGURATION;
60
}
61

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

    
68
/* fraction handling */
69

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

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

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

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

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

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

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

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

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

    
158
    if(!filename)
159
        return 0;
160

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

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

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

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

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

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

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

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

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

    
264

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

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

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

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

    
280
    return ret;
281
}
282

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

    
298

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

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

    
311
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
312
        int id3len = ff_id3v2_tag_len(lpd.buf);
313
        if (lpd.buf_size > id3len + 16) {
314
            lpd.buf += id3len;
315
            lpd.buf_size -= id3len;
316
        }
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
            if(!score && fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
327
                score = 1;
328
        } else if (fmt1->extensions) {
329
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
330
                score = 50;
331
            }
332
        }
333
        if (score > score_max) {
334
            score_max = score;
335
            fmt = fmt1;
336
        }else if (score == score_max)
337
            fmt = NULL;
338
    }
339
    *score_ret= score_max;
340
    return fmt;
341
}
342

    
343
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
344
{
345
    int score_ret;
346
    AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
347
    if(score_ret > *score_max){
348
        *score_max= score_ret;
349
        return fmt;
350
    }else
351
        return NULL;
352
}
353

    
354
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
355
    int score=0;
356
    return av_probe_input_format2(pd, is_opened, &score);
357
}
358

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

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

    
392
/************************************************************/
393
/* input media file */
394

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

    
406
    if(!ap){
407
        ap=&default_ap;
408
        memset(ap, 0, sizeof(default_ap));
409
    }
410

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

    
425
    /* allocate private data */
426
    if (fmt->priv_data_size > 0) {
427
        ic->priv_data = av_mallocz(fmt->priv_data_size);
428
        if (!ic->priv_data) {
429
            err = AVERROR(ENOMEM);
430
            goto fail;
431
        }
432
        if (fmt->priv_class) {
433
            *(const AVClass**)ic->priv_data= fmt->priv_class;
434
            av_opt_set_defaults(ic->priv_data);
435
        }
436
    } else {
437
        ic->priv_data = NULL;
438
    }
439

    
440
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
441
    if (ic->pb)
442
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
443

    
444
    if (!(ic->flags&AVFMT_FLAG_PRIV_OPT) && ic->iformat->read_header) {
445
        err = ic->iformat->read_header(ic, ap);
446
        if (err < 0)
447
            goto fail;
448
    }
449

    
450
    if (!(ic->flags&AVFMT_FLAG_PRIV_OPT) && pb && !ic->data_offset)
451
        ic->data_offset = avio_tell(ic->pb);
452

    
453
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
454

    
455
    *ic_ptr = ic;
456
    return 0;
457
 fail:
458
    if (ic) {
459
        int i;
460
        av_freep(&ic->priv_data);
461
        for(i=0;i<ic->nb_streams;i++) {
462
            AVStream *st = ic->streams[i];
463
            if (st) {
464
                av_free(st->priv_data);
465
                av_free(st->codec->extradata);
466
                av_free(st->codec);
467
                av_free(st->info);
468
            }
469
            av_free(st);
470
        }
471
    }
472
    av_free(ic);
473
    *ic_ptr = NULL;
474
    return err;
475
}
476

    
477
int av_demuxer_open(AVFormatContext *ic, AVFormatParameters *ap){
478
    int err;
479

    
480
    if (ic->iformat->read_header) {
481
        err = ic->iformat->read_header(ic, ap);
482
        if (err < 0)
483
            return err;
484
    }
485

    
486
    if (ic->pb && !ic->data_offset)
487
        ic->data_offset = avio_tell(ic->pb);
488

    
489
    return 0;
490
}
491

    
492

    
493
/** size of probe buffer, for guessing file type from file contents */
494
#define PROBE_BUF_MIN 2048
495
#define PROBE_BUF_MAX (1<<20)
496

    
497
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
498
                          const char *filename, void *logctx,
499
                          unsigned int offset, unsigned int max_probe_size)
500
{
501
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
502
    unsigned char *buf = NULL;
503
    int ret = 0, probe_size;
504

    
505
    if (!max_probe_size) {
506
        max_probe_size = PROBE_BUF_MAX;
507
    } else if (max_probe_size > PROBE_BUF_MAX) {
508
        max_probe_size = PROBE_BUF_MAX;
509
    } else if (max_probe_size < PROBE_BUF_MIN) {
510
        return AVERROR(EINVAL);
511
    }
512

    
513
    if (offset >= max_probe_size) {
514
        return AVERROR(EINVAL);
515
    }
516

    
517
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
518
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
519
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
520
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
521

    
522
        if (probe_size < offset) {
523
            continue;
524
        }
525

    
526
        /* read probe data */
527
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
528
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
529
            /* fail if error was not end of file, otherwise, lower score */
530
            if (ret != AVERROR_EOF) {
531
                av_free(buf);
532
                return ret;
533
            }
534
            score = 0;
535
            ret = 0;            /* error was end of file, nothing read */
536
        }
537
        pd.buf_size += ret;
538
        pd.buf = &buf[offset];
539

    
540
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
541

    
542
        /* guess file format */
543
        *fmt = av_probe_input_format2(&pd, 1, &score);
544
        if(*fmt){
545
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
546
                av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
547
            }else
548
                av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
549
        }
550
    }
551

    
552
    if (!*fmt) {
553
        av_free(buf);
554
        return AVERROR_INVALIDDATA;
555
    }
556

    
557
    /* rewind. reuse probe buffer to avoid seeking */
558
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
559
        av_free(buf);
560

    
561
    return ret;
562
}
563

    
564
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
565
                       AVInputFormat *fmt,
566
                       int buf_size,
567
                       AVFormatParameters *ap)
568
{
569
    int err;
570
    AVProbeData probe_data, *pd = &probe_data;
571
    AVIOContext *pb = NULL;
572
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
573

    
574
    pd->filename = "";
575
    if (filename)
576
        pd->filename = filename;
577
    pd->buf = NULL;
578
    pd->buf_size = 0;
579

    
580
    if (!fmt) {
581
        /* guess format if no file can be opened */
582
        fmt = av_probe_input_format(pd, 0);
583
    }
584

    
585
    /* Do not open file if the format does not need it. XXX: specific
586
       hack needed to handle RTSP/TCP */
587
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
588
        /* if no file needed do not try to open one */
589
        if ((err=avio_open(&pb, filename, AVIO_FLAG_READ)) < 0) {
590
            goto fail;
591
        }
592
        if (buf_size > 0) {
593
            ffio_set_buf_size(pb, buf_size);
594
        }
595
        if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
596
            goto fail;
597
        }
598
    }
599

    
600
    /* if still no format found, error */
601
    if (!fmt) {
602
        err = AVERROR_INVALIDDATA;
603
        goto fail;
604
    }
605

    
606
    /* check filename in case an image number is expected */
607
    if (fmt->flags & AVFMT_NEEDNUMBER) {
608
        if (!av_filename_number_test(filename)) {
609
            err = AVERROR(EINVAL);
610
            goto fail;
611
        }
612
    }
613
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
614
    if (err)
615
        goto fail;
616
    return 0;
617
 fail:
618
    av_freep(&pd->buf);
619
    if (pb)
620
        avio_close(pb);
621
    if (ap && ap->prealloced_context)
622
        av_free(*ic_ptr);
623
    *ic_ptr = NULL;
624
    return err;
625

    
626
}
627

    
628
/*******************************************************/
629

    
630
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
631
                               AVPacketList **plast_pktl){
632
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
633
    if (!pktl)
634
        return NULL;
635

    
636
    if (*packet_buffer)
637
        (*plast_pktl)->next = pktl;
638
    else
639
        *packet_buffer = pktl;
640

    
641
    /* add the packet in the buffered packet list */
642
    *plast_pktl = pktl;
643
    pktl->pkt= *pkt;
644
    return &pktl->pkt;
645
}
646

    
647
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
648
{
649
    int ret, i;
650
    AVStream *st;
651

    
652
    for(;;){
653
        AVPacketList *pktl = s->raw_packet_buffer;
654

    
655
        if (pktl) {
656
            *pkt = pktl->pkt;
657
            if(s->streams[pkt->stream_index]->request_probe <= 0){
658
                s->raw_packet_buffer = pktl->next;
659
                s->raw_packet_buffer_remaining_size += pkt->size;
660
                av_free(pktl);
661
                return 0;
662
            }
663
        }
664

    
665
        av_init_packet(pkt);
666
        ret= s->iformat->read_packet(s, pkt);
667
        if (ret < 0) {
668
            if (!pktl || ret == AVERROR(EAGAIN))
669
                return ret;
670
            for (i = 0; i < s->nb_streams; i++)
671
                if(s->streams[i]->request_probe > 0)
672
                    s->streams[i]->request_probe = -1;
673
            continue;
674
        }
675
        st= s->streams[pkt->stream_index];
676

    
677
        switch(st->codec->codec_type){
678
        case AVMEDIA_TYPE_VIDEO:
679
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
680
            break;
681
        case AVMEDIA_TYPE_AUDIO:
682
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
683
            break;
684
        case AVMEDIA_TYPE_SUBTITLE:
685
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
686
            break;
687
        }
688

    
689
        if(!pktl && st->request_probe <= 0)
690
            return ret;
691

    
692
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
693
        s->raw_packet_buffer_remaining_size -= pkt->size;
694

    
695
        if(st->request_probe>0){
696
            AVProbeData *pd = &st->probe_data;
697
            int end;
698
            av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
699
            --st->probe_packets;
700

    
701
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
702
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
703
            pd->buf_size += pkt->size;
704
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
705

    
706
            end=    s->raw_packet_buffer_remaining_size <= 0
707
                 || st->probe_packets<=0;
708

    
709
            if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
710
                int score= set_codec_from_probe_data(s, st, pd);
711
                if(    (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
712
                    || end){
713
                    pd->buf_size=0;
714
                    av_freep(&pd->buf);
715
                    st->request_probe= -1;
716
                    if(st->codec->codec_id != CODEC_ID_NONE){
717
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
718
                    }else
719
                        av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
720
                }
721
            }
722
        }
723
    }
724
}
725

    
726
/**********************************************************/
727

    
728
/**
729
 * Get the number of samples of an audio frame. Return -1 on error.
730
 */
731
static int get_audio_frame_size(AVCodecContext *enc, int size)
732
{
733
    int frame_size;
734

    
735
    if(enc->codec_id == CODEC_ID_VORBIS)
736
        return -1;
737

    
738
    if (enc->frame_size <= 1) {
739
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
740

    
741
        if (bits_per_sample) {
742
            if (enc->channels == 0)
743
                return -1;
744
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
745
        } else {
746
            /* used for example by ADPCM codecs */
747
            if (enc->bit_rate == 0)
748
                return -1;
749
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
750
        }
751
    } else {
752
        frame_size = enc->frame_size;
753
    }
754
    return frame_size;
755
}
756

    
757

    
758
/**
759
 * Return the frame duration in seconds. Return 0 if not available.
760
 */
761
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
762
                                   AVCodecParserContext *pc, AVPacket *pkt)
763
{
764
    int frame_size;
765

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

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

    
822
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
823
                                      int64_t dts, int64_t pts)
824
{
825
    AVStream *st= s->streams[stream_index];
826
    AVPacketList *pktl= s->packet_buffer;
827

    
828
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
829
        return;
830

    
831
    st->first_dts= dts - st->cur_dts;
832
    st->cur_dts= dts;
833

    
834
    for(; pktl; pktl= pktl->next){
835
        if(pktl->pkt.stream_index != stream_index)
836
            continue;
837
        //FIXME think more about this check
838
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
839
            pktl->pkt.pts += st->first_dts;
840

    
841
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
842
            pktl->pkt.dts += st->first_dts;
843

    
844
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
845
            st->start_time= pktl->pkt.pts;
846
    }
847
    if (st->start_time == AV_NOPTS_VALUE)
848
        st->start_time = pts;
849
}
850

    
851
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
852
{
853
    AVPacketList *pktl= s->packet_buffer;
854
    int64_t cur_dts= 0;
855

    
856
    if(st->first_dts != AV_NOPTS_VALUE){
857
        cur_dts= st->first_dts;
858
        for(; pktl; pktl= pktl->next){
859
            if(pktl->pkt.stream_index == pkt->stream_index){
860
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
861
                    break;
862
                cur_dts -= pkt->duration;
863
            }
864
        }
865
        pktl= s->packet_buffer;
866
        st->first_dts = cur_dts;
867
    }else if(st->cur_dts)
868
        return;
869

    
870
    for(; pktl; pktl= pktl->next){
871
        if(pktl->pkt.stream_index != pkt->stream_index)
872
            continue;
873
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
874
           && !pktl->pkt.duration){
875
            pktl->pkt.dts= cur_dts;
876
            if(!st->codec->has_b_frames)
877
                pktl->pkt.pts= cur_dts;
878
            cur_dts += pkt->duration;
879
            pktl->pkt.duration= pkt->duration;
880
        }else
881
            break;
882
    }
883
    if(st->first_dts == AV_NOPTS_VALUE)
884
        st->cur_dts= cur_dts;
885
}
886

    
887
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
888
                               AVCodecParserContext *pc, AVPacket *pkt)
889
{
890
    int num, den, presentation_delayed, delay, i;
891
    int64_t offset;
892

    
893
    if (s->flags & AVFMT_FLAG_NOFILLIN)
894
        return;
895

    
896
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
897
        pkt->dts= AV_NOPTS_VALUE;
898

    
899
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
900
        //FIXME Set low_delay = 0 when has_b_frames = 1
901
        st->codec->has_b_frames = 1;
902

    
903
    /* do we have a video B-frame ? */
904
    delay= st->codec->has_b_frames;
905
    presentation_delayed = 0;
906

    
907
    // ignore delay caused by frame threading so that the mpeg2-without-dts
908
    // warning will not trigger
909
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
910
        delay -= st->codec->thread_count-1;
911

    
912
    /* XXX: need has_b_frame, but cannot get it if the codec is
913
        not initialized */
914
    if (delay &&
915
        pc && pc->pict_type != AV_PICTURE_TYPE_B)
916
        presentation_delayed = 1;
917

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

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

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

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

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

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

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

    
975
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
976
    /* interpolate PTS and DTS if they are not present */
977
    //We skip H264 currently because delay and has_b_frames are not reliably set
978
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
979
        if (presentation_delayed) {
980
            /* DTS = decompression timestamp */
981
            /* PTS = presentation timestamp */
982
            if (pkt->dts == AV_NOPTS_VALUE)
983
                pkt->dts = st->last_IP_pts;
984
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
985
            if (pkt->dts == AV_NOPTS_VALUE)
986
                pkt->dts = st->cur_dts;
987

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

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

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

    
1033
//    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
1034

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

    
1050

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

    
1056
    av_init_packet(pkt);
1057

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

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

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

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

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

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

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

    
1189
    return 0;
1190
}
1191

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

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

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

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

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

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

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

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

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

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

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

    
1300
    flush_packet_queue(s);
1301

    
1302
    s->cur_st = NULL;
1303

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

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

    
1320
        st->probe_packets = MAX_PROBE_PACKETS;
1321

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

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

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

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

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

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

    
1352
int ff_add_index_entry(AVIndexEntry **index_entries,
1353
                       int *nb_index_entries,
1354
                       unsigned int *index_entries_allocated_size,
1355
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1356
{
1357
    AVIndexEntry *entries, *ie;
1358
    int index;
1359

    
1360
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1361
        return -1;
1362

    
1363
    entries = av_fast_realloc(*index_entries,
1364
                              index_entries_allocated_size,
1365
                              (*nb_index_entries + 1) *
1366
                              sizeof(AVIndexEntry));
1367
    if(!entries)
1368
        return -1;
1369

    
1370
    *index_entries= entries;
1371

    
1372
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1373

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

    
1389
    ie->pos = pos;
1390
    ie->timestamp = timestamp;
1391
    ie->min_distance= distance;
1392
    ie->size= size;
1393
    ie->flags = flags;
1394

    
1395
    return index;
1396
}
1397

    
1398
int av_add_index_entry(AVStream *st,
1399
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1400
{
1401
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1402
                              &st->index_entries_allocated_size, pos,
1403
                              timestamp, size, distance, flags);
1404
}
1405

    
1406
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1407
                              int64_t wanted_timestamp, int flags)
1408
{
1409
    int a, b, m;
1410
    int64_t timestamp;
1411

    
1412
    a = - 1;
1413
    b = nb_entries;
1414

    
1415
    //optimize appending index entries at the end
1416
    if(b && entries[b-1].timestamp < wanted_timestamp)
1417
        a= b-1;
1418

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

    
1429
    if(!(flags & AVSEEK_FLAG_ANY)){
1430
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1431
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1432
        }
1433
    }
1434

    
1435
    if(m == nb_entries)
1436
        return -1;
1437
    return  m;
1438
}
1439

    
1440
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1441
                              int flags)
1442
{
1443
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1444
                                     wanted_timestamp, flags);
1445
}
1446

    
1447
#define DEBUG_SEEK
1448

    
1449
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1450
    AVInputFormat *avif= s->iformat;
1451
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1452
    int64_t ts_min, ts_max, ts;
1453
    int index;
1454
    int64_t ret;
1455
    AVStream *st;
1456

    
1457
    if (stream_index < 0)
1458
        return -1;
1459

    
1460
#ifdef DEBUG_SEEK
1461
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1462
#endif
1463

    
1464
    ts_max=
1465
    ts_min= AV_NOPTS_VALUE;
1466
    pos_limit= -1; //gcc falsely says it may be uninitialized
1467

    
1468
    st= s->streams[stream_index];
1469
    if(st->index_entries){
1470
        AVIndexEntry *e;
1471

    
1472
        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()
1473
        index= FFMAX(index, 0);
1474
        e= &st->index_entries[index];
1475

    
1476
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1477
            pos_min= e->pos;
1478
            ts_min= e->timestamp;
1479
#ifdef DEBUG_SEEK
1480
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1481
                   pos_min,ts_min);
1482
#endif
1483
        }else{
1484
            assert(index==0);
1485
        }
1486

    
1487
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1488
        assert(index < st->nb_index_entries);
1489
        if(index >= 0){
1490
            e= &st->index_entries[index];
1491
            assert(e->timestamp >= target_ts);
1492
            pos_max= e->pos;
1493
            ts_max= e->timestamp;
1494
            pos_limit= pos_max - e->min_distance;
1495
#ifdef DEBUG_SEEK
1496
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1497
                   pos_max,pos_limit, ts_max);
1498
#endif
1499
        }
1500
    }
1501

    
1502
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1503
    if(pos<0)
1504
        return -1;
1505

    
1506
    /* do the seek */
1507
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1508
        return ret;
1509

    
1510
    av_update_cur_dts(s, st, ts);
1511

    
1512
    return 0;
1513
}
1514

    
1515
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 )){
1516
    int64_t pos, ts;
1517
    int64_t start_pos, filesize;
1518
    int no_change;
1519

    
1520
#ifdef DEBUG_SEEK
1521
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1522
#endif
1523

    
1524
    if(ts_min == AV_NOPTS_VALUE){
1525
        pos_min = s->data_offset;
1526
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1527
        if (ts_min == AV_NOPTS_VALUE)
1528
            return -1;
1529
    }
1530

    
1531
    if(ts_max == AV_NOPTS_VALUE){
1532
        int step= 1024;
1533
        filesize = avio_size(s->pb);
1534
        pos_max = filesize - 1;
1535
        do{
1536
            pos_max -= step;
1537
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1538
            step += step;
1539
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1540
        if (ts_max == AV_NOPTS_VALUE)
1541
            return -1;
1542

    
1543
        for(;;){
1544
            int64_t tmp_pos= pos_max + 1;
1545
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1546
            if(tmp_ts == AV_NOPTS_VALUE)
1547
                break;
1548
            ts_max= tmp_ts;
1549
            pos_max= tmp_pos;
1550
            if(tmp_pos >= filesize)
1551
                break;
1552
        }
1553
        pos_limit= pos_max;
1554
    }
1555

    
1556
    if(ts_min > ts_max){
1557
        return -1;
1558
    }else if(ts_min == ts_max){
1559
        pos_limit= pos_min;
1560
    }
1561

    
1562
    no_change=0;
1563
    while (pos_min < pos_limit) {
1564
#ifdef DEBUG_SEEK
1565
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1566
               pos_min, pos_max,
1567
               ts_min, ts_max);
1568
#endif
1569
        assert(pos_limit <= pos_max);
1570

    
1571
        if(no_change==0){
1572
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1573
            // interpolate position (better than dichotomy)
1574
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1575
                + pos_min - approximate_keyframe_distance;
1576
        }else if(no_change==1){
1577
            // bisection, if interpolation failed to change min or max pos last time
1578
            pos = (pos_min + pos_limit)>>1;
1579
        }else{
1580
            /* linear search if bisection failed, can only happen if there
1581
               are very few or no keyframes between min/max */
1582
            pos=pos_min;
1583
        }
1584
        if(pos <= pos_min)
1585
            pos= pos_min + 1;
1586
        else if(pos > pos_limit)
1587
            pos= pos_limit;
1588
        start_pos= pos;
1589

    
1590
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1591
        if(pos == pos_max)
1592
            no_change++;
1593
        else
1594
            no_change=0;
1595
#ifdef DEBUG_SEEK
1596
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1597
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1598
               start_pos, no_change);
1599
#endif
1600
        if(ts == AV_NOPTS_VALUE){
1601
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1602
            return -1;
1603
        }
1604
        assert(ts != AV_NOPTS_VALUE);
1605
        if (target_ts <= ts) {
1606
            pos_limit = start_pos - 1;
1607
            pos_max = pos;
1608
            ts_max = ts;
1609
        }
1610
        if (target_ts >= ts) {
1611
            pos_min = pos;
1612
            ts_min = ts;
1613
        }
1614
    }
1615

    
1616
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1617
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1618
#ifdef DEBUG_SEEK
1619
    pos_min = pos;
1620
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1621
    pos_min++;
1622
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1623
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1624
           pos, ts_min, target_ts, ts_max);
1625
#endif
1626
    *ts_ret= ts;
1627
    return pos;
1628
}
1629

    
1630
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1631
    int64_t pos_min, pos_max;
1632
#if 0
1633
    AVStream *st;
1634

1635
    if (stream_index < 0)
1636
        return -1;
1637

1638
    st= s->streams[stream_index];
1639
#endif
1640

    
1641
    pos_min = s->data_offset;
1642
    pos_max = avio_size(s->pb) - 1;
1643

    
1644
    if     (pos < pos_min) pos= pos_min;
1645
    else if(pos > pos_max) pos= pos_max;
1646

    
1647
    avio_seek(s->pb, pos, SEEK_SET);
1648

    
1649
#if 0
1650
    av_update_cur_dts(s, st, ts);
1651
#endif
1652
    return 0;
1653
}
1654

    
1655
static int av_seek_frame_generic(AVFormatContext *s,
1656
                                 int stream_index, int64_t timestamp, int flags)
1657
{
1658
    int index;
1659
    int64_t ret;
1660
    AVStream *st;
1661
    AVIndexEntry *ie;
1662

    
1663
    st = s->streams[stream_index];
1664

    
1665
    index = av_index_search_timestamp(st, timestamp, flags);
1666

    
1667
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1668
        return -1;
1669

    
1670
    if(index < 0 || index==st->nb_index_entries-1){
1671
        int i;
1672
        AVPacket pkt;
1673

    
1674
        if(st->nb_index_entries){
1675
            assert(st->index_entries);
1676
            ie= &st->index_entries[st->nb_index_entries-1];
1677
            if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1678
                return ret;
1679
            av_update_cur_dts(s, st, ie->timestamp);
1680
        }else{
1681
            if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1682
                return ret;
1683
        }
1684
        for(i=0;; i++) {
1685
            int ret;
1686
            do{
1687
                ret = av_read_frame(s, &pkt);
1688
            }while(ret == AVERROR(EAGAIN));
1689
            if(ret<0)
1690
                break;
1691
            av_free_packet(&pkt);
1692
            if(stream_index == pkt.stream_index){
1693
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1694
                    break;
1695
            }
1696
        }
1697
        index = av_index_search_timestamp(st, timestamp, flags);
1698
    }
1699
    if (index < 0)
1700
        return -1;
1701

    
1702
    ff_read_frame_flush(s);
1703
    if (s->iformat->read_seek){
1704
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1705
            return 0;
1706
    }
1707
    ie = &st->index_entries[index];
1708
    if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1709
        return ret;
1710
    av_update_cur_dts(s, st, ie->timestamp);
1711

    
1712
    return 0;
1713
}
1714

    
1715
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1716
{
1717
    int ret;
1718
    AVStream *st;
1719

    
1720
    ff_read_frame_flush(s);
1721

    
1722
    if(flags & AVSEEK_FLAG_BYTE)
1723
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1724

    
1725
    if(stream_index < 0){
1726
        stream_index= av_find_default_stream_index(s);
1727
        if(stream_index < 0)
1728
            return -1;
1729

    
1730
        st= s->streams[stream_index];
1731
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1732
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1733
    }
1734

    
1735
    /* first, we try the format specific seek */
1736
    if (s->iformat->read_seek)
1737
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1738
    else
1739
        ret = -1;
1740
    if (ret >= 0) {
1741
        return 0;
1742
    }
1743

    
1744
    if(s->iformat->read_timestamp)
1745
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1746
    else
1747
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1748
}
1749

    
1750
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1751
{
1752
    if(min_ts > ts || max_ts < ts)
1753
        return -1;
1754

    
1755
    ff_read_frame_flush(s);
1756

    
1757
    if (s->iformat->read_seek2)
1758
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1759

    
1760
    if(s->iformat->read_timestamp){
1761
        //try to seek via read_timestamp()
1762
    }
1763

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

    
1769
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1770
}
1771

    
1772
/*******************************************************/
1773

    
1774
/**
1775
 * Return TRUE if the stream has accurate duration in any stream.
1776
 *
1777
 * @return TRUE if the stream has accurate duration for at least one component.
1778
 */
1779
static int av_has_duration(AVFormatContext *ic)
1780
{
1781
    int i;
1782
    AVStream *st;
1783

    
1784
    for(i = 0;i < ic->nb_streams; i++) {
1785
        st = ic->streams[i];
1786
        if (st->duration != AV_NOPTS_VALUE)
1787
            return 1;
1788
    }
1789
    return 0;
1790
}
1791

    
1792
/**
1793
 * Estimate the stream timings from the one of each components.
1794
 *
1795
 * Also computes the global bitrate if possible.
1796
 */
1797
static void av_update_stream_timings(AVFormatContext *ic)
1798
{
1799
    int64_t start_time, start_time1, end_time, end_time1;
1800
    int64_t duration, duration1;
1801
    int i;
1802
    AVStream *st;
1803

    
1804
    start_time = INT64_MAX;
1805
    end_time = INT64_MIN;
1806
    duration = INT64_MIN;
1807
    for(i = 0;i < ic->nb_streams; i++) {
1808
        st = ic->streams[i];
1809
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1810
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1811
            if (start_time1 < start_time)
1812
                start_time = start_time1;
1813
            if (st->duration != AV_NOPTS_VALUE) {
1814
                end_time1 = start_time1
1815
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1816
                if (end_time1 > end_time)
1817
                    end_time = end_time1;
1818
            }
1819
        }
1820
        if (st->duration != AV_NOPTS_VALUE) {
1821
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1822
            if (duration1 > duration)
1823
                duration = duration1;
1824
        }
1825
    }
1826
    if (start_time != INT64_MAX) {
1827
        ic->start_time = start_time;
1828
        if (end_time != INT64_MIN) {
1829
            if (end_time - start_time > duration)
1830
                duration = end_time - start_time;
1831
        }
1832
    }
1833
    if (duration != INT64_MIN) {
1834
        ic->duration = duration;
1835
        if (ic->file_size > 0) {
1836
            /* compute the bitrate */
1837
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1838
                (double)ic->duration;
1839
        }
1840
    }
1841
}
1842

    
1843
static void fill_all_stream_timings(AVFormatContext *ic)
1844
{
1845
    int i;
1846
    AVStream *st;
1847

    
1848
    av_update_stream_timings(ic);
1849
    for(i = 0;i < ic->nb_streams; i++) {
1850
        st = ic->streams[i];
1851
        if (st->start_time == AV_NOPTS_VALUE) {
1852
            if(ic->start_time != AV_NOPTS_VALUE)
1853
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1854
            if(ic->duration != AV_NOPTS_VALUE)
1855
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1856
        }
1857
    }
1858
}
1859

    
1860
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1861
{
1862
    int64_t filesize, duration;
1863
    int bit_rate, i;
1864
    AVStream *st;
1865

    
1866
    /* if bit_rate is already set, we believe it */
1867
    if (ic->bit_rate <= 0) {
1868
        bit_rate = 0;
1869
        for(i=0;i<ic->nb_streams;i++) {
1870
            st = ic->streams[i];
1871
            if (st->codec->bit_rate > 0)
1872
            bit_rate += st->codec->bit_rate;
1873
        }
1874
        ic->bit_rate = bit_rate;
1875
    }
1876

    
1877
    /* if duration is already set, we believe it */
1878
    if (ic->duration == AV_NOPTS_VALUE &&
1879
        ic->bit_rate != 0 &&
1880
        ic->file_size != 0)  {
1881
        filesize = ic->file_size;
1882
        if (filesize > 0) {
1883
            for(i = 0; i < ic->nb_streams; i++) {
1884
                st = ic->streams[i];
1885
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1886
                if (st->duration == AV_NOPTS_VALUE)
1887
                    st->duration = duration;
1888
            }
1889
        }
1890
    }
1891
}
1892

    
1893
#define DURATION_MAX_READ_SIZE 250000
1894
#define DURATION_MAX_RETRY 3
1895

    
1896
/* only usable for MPEG-PS streams */
1897
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1898
{
1899
    AVPacket pkt1, *pkt = &pkt1;
1900
    AVStream *st;
1901
    int read_size, i, ret;
1902
    int64_t end_time;
1903
    int64_t filesize, offset, duration;
1904
    int retry=0;
1905

    
1906
    ic->cur_st = NULL;
1907

    
1908
    /* flush packet queue */
1909
    flush_packet_queue(ic);
1910

    
1911
    for (i=0; i<ic->nb_streams; i++) {
1912
        st = ic->streams[i];
1913
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1914
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1915

    
1916
        if (st->parser) {
1917
            av_parser_close(st->parser);
1918
            st->parser= NULL;
1919
            av_free_packet(&st->cur_pkt);
1920
        }
1921
    }
1922

    
1923
    /* estimate the end time (duration) */
1924
    /* XXX: may need to support wrapping */
1925
    filesize = ic->file_size;
1926
    end_time = AV_NOPTS_VALUE;
1927
    do{
1928
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1929
    if (offset < 0)
1930
        offset = 0;
1931

    
1932
    avio_seek(ic->pb, offset, SEEK_SET);
1933
    read_size = 0;
1934
    for(;;) {
1935
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1936
            break;
1937

    
1938
        do{
1939
            ret = av_read_packet(ic, pkt);
1940
        }while(ret == AVERROR(EAGAIN));
1941
        if (ret != 0)
1942
            break;
1943
        read_size += pkt->size;
1944
        st = ic->streams[pkt->stream_index];
1945
        if (pkt->pts != AV_NOPTS_VALUE &&
1946
            (st->start_time != AV_NOPTS_VALUE ||
1947
             st->first_dts  != AV_NOPTS_VALUE)) {
1948
            duration = end_time = pkt->pts;
1949
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1950
            else                                   duration -= st->first_dts;
1951
            if (duration < 0)
1952
                duration += 1LL<<st->pts_wrap_bits;
1953
            if (duration > 0) {
1954
                if (st->duration == AV_NOPTS_VALUE ||
1955
                    st->duration < duration)
1956
                    st->duration = duration;
1957
            }
1958
        }
1959
        av_free_packet(pkt);
1960
    }
1961
    }while(   end_time==AV_NOPTS_VALUE
1962
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1963
           && ++retry <= DURATION_MAX_RETRY);
1964

    
1965
    fill_all_stream_timings(ic);
1966

    
1967
    avio_seek(ic->pb, old_offset, SEEK_SET);
1968
    for (i=0; i<ic->nb_streams; i++) {
1969
        st= ic->streams[i];
1970
        st->cur_dts= st->first_dts;
1971
        st->last_IP_pts = AV_NOPTS_VALUE;
1972
        st->reference_dts = AV_NOPTS_VALUE;
1973
    }
1974
}
1975

    
1976
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1977
{
1978
    int64_t file_size;
1979

    
1980
    /* get the file size, if possible */
1981
    if (ic->iformat->flags & AVFMT_NOFILE) {
1982
        file_size = 0;
1983
    } else {
1984
        file_size = avio_size(ic->pb);
1985
        if (file_size < 0)
1986
            file_size = 0;
1987
    }
1988
    ic->file_size = file_size;
1989

    
1990
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1991
         !strcmp(ic->iformat->name, "mpegts")) &&
1992
        file_size && ic->pb->seekable) {
1993
        /* get accurate estimate from the PTSes */
1994
        av_estimate_timings_from_pts(ic, old_offset);
1995
    } else if (av_has_duration(ic)) {
1996
        /* at least one component has timings - we use them for all
1997
           the components */
1998
        fill_all_stream_timings(ic);
1999
    } else {
2000
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2001
        /* less precise: use bitrate info */
2002
        av_estimate_timings_from_bit_rate(ic);
2003
    }
2004
    av_update_stream_timings(ic);
2005

    
2006
#if 0
2007
    {
2008
        int i;
2009
        AVStream *st;
2010
        for(i = 0;i < ic->nb_streams; i++) {
2011
            st = ic->streams[i];
2012
        printf("%d: start_time: %0.3f duration: %0.3f\n",
2013
               i, (double)st->start_time / AV_TIME_BASE,
2014
               (double)st->duration / AV_TIME_BASE);
2015
        }
2016
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2017
               (double)ic->start_time / AV_TIME_BASE,
2018
               (double)ic->duration / AV_TIME_BASE,
2019
               ic->bit_rate / 1000);
2020
    }
2021
#endif
2022
}
2023

    
2024
static int has_codec_parameters(AVCodecContext *enc)
2025
{
2026
    int val;
2027
    switch(enc->codec_type) {
2028
    case AVMEDIA_TYPE_AUDIO:
2029
        val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2030
        if(!enc->frame_size &&
2031
           (enc->codec_id == CODEC_ID_VORBIS ||
2032
            enc->codec_id == CODEC_ID_AAC ||
2033
            enc->codec_id == CODEC_ID_MP1 ||
2034
            enc->codec_id == CODEC_ID_MP2 ||
2035
            enc->codec_id == CODEC_ID_MP3 ||
2036
            enc->codec_id == CODEC_ID_SPEEX ||
2037
            enc->codec_id == CODEC_ID_CELT))
2038
            return 0;
2039
        break;
2040
    case AVMEDIA_TYPE_VIDEO:
2041
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2042
        break;
2043
    default:
2044
        val = 1;
2045
        break;
2046
    }
2047
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2048
}
2049

    
2050
static int has_decode_delay_been_guessed(AVStream *st)
2051
{
2052
    return st->codec->codec_id != CODEC_ID_H264 ||
2053
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2054
}
2055

    
2056
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2057
{
2058
    int16_t *samples;
2059
    AVCodec *codec;
2060
    int got_picture, data_size, ret=0;
2061
    AVFrame picture;
2062

    
2063
    if(!st->codec->codec){
2064
        codec = avcodec_find_decoder(st->codec->codec_id);
2065
        if (!codec)
2066
            return -1;
2067
        ret = avcodec_open(st->codec, codec);
2068
        if (ret < 0)
2069
            return ret;
2070
    }
2071

    
2072
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2073
        switch(st->codec->codec_type) {
2074
        case AVMEDIA_TYPE_VIDEO:
2075
            avcodec_get_frame_defaults(&picture);
2076
            ret = avcodec_decode_video2(st->codec, &picture,
2077
                                        &got_picture, avpkt);
2078
            break;
2079
        case AVMEDIA_TYPE_AUDIO:
2080
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2081
            samples = av_malloc(data_size);
2082
            if (!samples)
2083
                goto fail;
2084
            ret = avcodec_decode_audio3(st->codec, samples,
2085
                                        &data_size, avpkt);
2086
            av_free(samples);
2087
            break;
2088
        default:
2089
            break;
2090
        }
2091
    }
2092
 fail:
2093
    return ret;
2094
}
2095

    
2096
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2097
{
2098
    while (tags->id != CODEC_ID_NONE) {
2099
        if (tags->id == id)
2100
            return tags->tag;
2101
        tags++;
2102
    }
2103
    return 0;
2104
}
2105

    
2106
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2107
{
2108
    int i;
2109
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2110
        if(tag == tags[i].tag)
2111
            return tags[i].id;
2112
    }
2113
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2114
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2115
            return tags[i].id;
2116
    }
2117
    return CODEC_ID_NONE;
2118
}
2119

    
2120
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2121
{
2122
    int i;
2123
    for(i=0; tags && tags[i]; i++){
2124
        int tag= ff_codec_get_tag(tags[i], id);
2125
        if(tag) return tag;
2126
    }
2127
    return 0;
2128
}
2129

    
2130
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2131
{
2132
    int i;
2133
    for(i=0; tags && tags[i]; i++){
2134
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2135
        if(id!=CODEC_ID_NONE) return id;
2136
    }
2137
    return CODEC_ID_NONE;
2138
}
2139

    
2140
static void compute_chapters_end(AVFormatContext *s)
2141
{
2142
    unsigned int i, j;
2143
    int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2144

    
2145
    for (i = 0; i < s->nb_chapters; i++)
2146
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2147
            AVChapter *ch = s->chapters[i];
2148
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2149
                                     : INT64_MAX;
2150

    
2151
            for (j = 0; j < s->nb_chapters; j++) {
2152
                AVChapter *ch1 = s->chapters[j];
2153
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2154
                if (j != i && next_start > ch->start && next_start < end)
2155
                    end = next_start;
2156
            }
2157
            ch->end = (end == INT64_MAX) ? ch->start : end;
2158
        }
2159
}
2160

    
2161
static int get_std_framerate(int i){
2162
    if(i<60*12) return i*1001;
2163
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2164
}
2165

    
2166
/*
2167
 * Is the time base unreliable.
2168
 * This is a heuristic to balance between quick acceptance of the values in
2169
 * the headers vs. some extra checks.
2170
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2171
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2172
 * And there are "variable" fps files this needs to detect as well.
2173
 */
2174
static int tb_unreliable(AVCodecContext *c){
2175
    if(   c->time_base.den >= 101L*c->time_base.num
2176
       || c->time_base.den <    5L*c->time_base.num
2177
/*       || c->codec_tag == AV_RL32("DIVX")
2178
       || c->codec_tag == AV_RL32("XVID")*/
2179
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2180
       || c->codec_id == CODEC_ID_H264
2181
       )
2182
        return 1;
2183
    return 0;
2184
}
2185

    
2186
int av_find_stream_info(AVFormatContext *ic)
2187
{
2188
    int i, count, ret, read_size, j;
2189
    AVStream *st;
2190
    AVPacket pkt1, *pkt;
2191
    int64_t old_offset = avio_tell(ic->pb);
2192

    
2193
    for(i=0;i<ic->nb_streams;i++) {
2194
        AVCodec *codec;
2195
        st = ic->streams[i];
2196
        if (st->codec->codec_id == CODEC_ID_AAC) {
2197
            st->codec->sample_rate = 0;
2198
            st->codec->frame_size = 0;
2199
            st->codec->channels = 0;
2200
        }
2201
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2202
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2203
/*            if(!st->time_base.num)
2204
                st->time_base= */
2205
            if(!st->codec->time_base.num)
2206
                st->codec->time_base= st->time_base;
2207
        }
2208
        //only for the split stuff
2209
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2210
            st->parser = av_parser_init(st->codec->codec_id);
2211
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2212
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2213
            }
2214
        }
2215
        assert(!st->codec->codec);
2216
        codec = avcodec_find_decoder(st->codec->codec_id);
2217

    
2218
        /* Force decoding of at least one frame of codec data
2219
         * this makes sure the codec initializes the channel configuration
2220
         * and does not trust the values from the container.
2221
         */
2222
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2223
            st->codec->channels = 0;
2224

    
2225
        /* Ensure that subtitle_header is properly set. */
2226
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2227
            && codec && !st->codec->codec)
2228
            avcodec_open(st->codec, codec);
2229

    
2230
        //try to just open decoders, in case this is enough to get parameters
2231
        if(!has_codec_parameters(st->codec)){
2232
            if (codec && !st->codec->codec)
2233
                avcodec_open(st->codec, codec);
2234
        }
2235
    }
2236

    
2237
    for (i=0; i<ic->nb_streams; i++) {
2238
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2239
    }
2240

    
2241
    count = 0;
2242
    read_size = 0;
2243
    for(;;) {
2244
        if(url_interrupt_cb()){
2245
            ret= AVERROR_EXIT;
2246
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2247
            break;
2248
        }
2249

    
2250
        /* check if one codec still needs to be handled */
2251
        for(i=0;i<ic->nb_streams;i++) {
2252
            int fps_analyze_framecount = 20;
2253

    
2254
            st = ic->streams[i];
2255
            if (!has_codec_parameters(st->codec))
2256
                break;
2257
            /* if the timebase is coarse (like the usual millisecond precision
2258
               of mkv), we need to analyze more frames to reliably arrive at
2259
               the correct fps */
2260
            if (av_q2d(st->time_base) > 0.0005)
2261
                fps_analyze_framecount *= 2;
2262
            /* variable fps and no guess at the real fps */
2263
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2264
               && st->info->duration_count < fps_analyze_framecount
2265
               && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2266
                break;
2267
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2268
                break;
2269
            if(st->first_dts == AV_NOPTS_VALUE)
2270
                break;
2271
        }
2272
        if (i == ic->nb_streams) {
2273
            /* NOTE: if the format has no header, then we need to read
2274
               some packets to get most of the streams, so we cannot
2275
               stop here */
2276
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2277
                /* if we found the info for all the codecs, we can stop */
2278
                ret = count;
2279
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2280
                break;
2281
            }
2282
        }
2283
        /* we did not get all the codec info, but we read too much data */
2284
        if (read_size >= ic->probesize) {
2285
            ret = count;
2286
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2287
            break;
2288
        }
2289

    
2290
        /* NOTE: a new stream can be added there if no header in file
2291
           (AVFMTCTX_NOHEADER) */
2292
        ret = av_read_frame_internal(ic, &pkt1);
2293
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2294
            /* EOF or error */
2295
            ret = -1; /* we could not have all the codec parameters before EOF */
2296
            for(i=0;i<ic->nb_streams;i++) {
2297
                st = ic->streams[i];
2298
                if (!has_codec_parameters(st->codec)){
2299
                    char buf[256];
2300
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2301
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2302
                } else {
2303
                    ret = 0;
2304
                }
2305
            }
2306
            break;
2307
        }
2308

    
2309
        if (ret == AVERROR(EAGAIN))
2310
            continue;
2311

    
2312
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2313
        if ((ret = av_dup_packet(pkt)) < 0)
2314
            goto find_stream_info_err;
2315

    
2316
        read_size += pkt->size;
2317

    
2318
        st = ic->streams[pkt->stream_index];
2319
        if (st->codec_info_nb_frames>1) {
2320
            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) {
2321
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2322
                break;
2323
            }
2324
            st->info->codec_info_duration += pkt->duration;
2325
        }
2326
        {
2327
            int64_t last = st->info->last_dts;
2328
            int64_t duration= pkt->dts - last;
2329

    
2330
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2331
                double dur= duration * av_q2d(st->time_base);
2332

    
2333
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2334
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2335
                if (st->info->duration_count < 2)
2336
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2337
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2338
                    int framerate= get_std_framerate(i);
2339
                    int ticks= lrintf(dur*framerate/(1001*12));
2340
                    double error= dur - ticks*1001*12/(double)framerate;
2341
                    st->info->duration_error[i] += error*error;
2342
                }
2343
                st->info->duration_count++;
2344
                // ignore the first 4 values, they might have some random jitter
2345
                if (st->info->duration_count > 3)
2346
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2347
            }
2348
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2349
                st->info->last_dts = pkt->dts;
2350
        }
2351
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2352
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2353
            if(i){
2354
                st->codec->extradata_size= i;
2355
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2356
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2357
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2358
            }
2359
        }
2360

    
2361
        /* if still no information, we try to open the codec and to
2362
           decompress the frame. We try to avoid that in most cases as
2363
           it takes longer and uses more memory. For MPEG-4, we need to
2364
           decompress for QuickTime. */
2365
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2366
            try_decode_frame(st, pkt);
2367

    
2368
        st->codec_info_nb_frames++;
2369
        count++;
2370
    }
2371

    
2372
    // close codecs which were opened in try_decode_frame()
2373
    for(i=0;i<ic->nb_streams;i++) {
2374
        st = ic->streams[i];
2375
        if(st->codec->codec)
2376
            avcodec_close(st->codec);
2377
    }
2378
    for(i=0;i<ic->nb_streams;i++) {
2379
        st = ic->streams[i];
2380
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2381
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2382
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2383
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2384
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2385
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2386
                uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2387
                if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2388
                    st->codec->codec_tag= tag;
2389
            }
2390

    
2391
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2392
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2393
            // ipmovie.c produces.
2394
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
2395
                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);
2396
            if (st->info->duration_count && !st->r_frame_rate.num
2397
               && tb_unreliable(st->codec) /*&&
2398
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2399
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2400
                int num = 0;
2401
                double best_error= 2*av_q2d(st->time_base);
2402
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2403

    
2404
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2405
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2406
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2407
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2408
                    if(error < best_error){
2409
                        best_error= error;
2410
                        num = get_std_framerate(j);
2411
                    }
2412
                }
2413
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2414
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2415
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2416
            }
2417

    
2418
            if (!st->r_frame_rate.num){
2419
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2420
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2421
                    st->r_frame_rate.num = st->codec->time_base.den;
2422
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2423
                }else{
2424
                    st->r_frame_rate.num = st->time_base.den;
2425
                    st->r_frame_rate.den = st->time_base.num;
2426
                }
2427
            }
2428
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2429
            if(!st->codec->bits_per_coded_sample)
2430
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2431
            // set stream disposition based on audio service type
2432
            switch (st->codec->audio_service_type) {
2433
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2434
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2435
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2436
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2437
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2438
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2439
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2440
                st->disposition = AV_DISPOSITION_COMMENT;          break;
2441
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2442
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
2443
            }
2444
        }
2445
    }
2446

    
2447
    av_estimate_timings(ic, old_offset);
2448

    
2449
    compute_chapters_end(ic);
2450

    
2451
#if 0
2452
    /* correct DTS for B-frame streams with no timestamps */
2453
    for(i=0;i<ic->nb_streams;i++) {
2454
        st = ic->streams[i];
2455
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2456
            if(b-frames){
2457
                ppktl = &ic->packet_buffer;
2458
                while(ppkt1){
2459
                    if(ppkt1->stream_index != i)
2460
                        continue;
2461
                    if(ppkt1->pkt->dts < 0)
2462
                        break;
2463
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2464
                        break;
2465
                    ppkt1->pkt->dts -= delta;
2466
                    ppkt1= ppkt1->next;
2467
                }
2468
                if(ppkt1)
2469
                    continue;
2470
                st->cur_dts -= delta;
2471
            }
2472
        }
2473
    }
2474
#endif
2475

    
2476
 find_stream_info_err:
2477
    for (i=0; i < ic->nb_streams; i++)
2478
        av_freep(&ic->streams[i]->info);
2479
    return ret;
2480
}
2481

    
2482
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2483
{
2484
    int i, j;
2485

    
2486
    for (i = 0; i < ic->nb_programs; i++)
2487
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2488
            if (ic->programs[i]->stream_index[j] == s)
2489
                return ic->programs[i];
2490
    return NULL;
2491
}
2492

    
2493
int av_find_best_stream(AVFormatContext *ic,
2494
                        enum AVMediaType type,
2495
                        int wanted_stream_nb,
2496
                        int related_stream,
2497
                        AVCodec **decoder_ret,
2498
                        int flags)
2499
{
2500
    int i, nb_streams = ic->nb_streams;
2501
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2502
    unsigned *program = NULL;
2503
    AVCodec *decoder = NULL, *best_decoder = NULL;
2504

    
2505
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2506
        AVProgram *p = find_program_from_stream(ic, related_stream);
2507
        if (p) {
2508
            program = p->stream_index;
2509
            nb_streams = p->nb_stream_indexes;
2510
        }
2511
    }
2512
    for (i = 0; i < nb_streams; i++) {
2513
        int real_stream_index = program ? program[i] : i;
2514
        AVStream *st = ic->streams[real_stream_index];
2515
        AVCodecContext *avctx = st->codec;
2516
        if (avctx->codec_type != type)
2517
            continue;
2518
        if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2519
            continue;
2520
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2521
            continue;
2522
        if (decoder_ret) {
2523
            decoder = avcodec_find_decoder(st->codec->codec_id);
2524
            if (!decoder) {
2525
                if (ret < 0)
2526
                    ret = AVERROR_DECODER_NOT_FOUND;
2527
                continue;
2528
            }
2529
        }
2530
        if (best_count >= st->codec_info_nb_frames)
2531
            continue;
2532
        best_count = st->codec_info_nb_frames;
2533
        ret = real_stream_index;
2534
        best_decoder = decoder;
2535
        if (program && i == nb_streams - 1 && ret < 0) {
2536
            program = NULL;
2537
            nb_streams = ic->nb_streams;
2538
            i = 0; /* no related stream found, try again with everything */
2539
        }
2540
    }
2541
    if (decoder_ret)
2542
        *decoder_ret = best_decoder;
2543
    return ret;
2544
}
2545

    
2546
/*******************************************************/
2547

    
2548
int av_read_play(AVFormatContext *s)
2549
{
2550
    if (s->iformat->read_play)
2551
        return s->iformat->read_play(s);
2552
    if (s->pb)
2553
        return avio_pause(s->pb, 0);
2554
    return AVERROR(ENOSYS);
2555
}
2556

    
2557
int av_read_pause(AVFormatContext *s)
2558
{
2559
    if (s->iformat->read_pause)
2560
        return s->iformat->read_pause(s);
2561
    if (s->pb)
2562
        return avio_pause(s->pb, 1);
2563
    return AVERROR(ENOSYS);
2564
}
2565

    
2566
void av_close_input_stream(AVFormatContext *s)
2567
{
2568
    flush_packet_queue(s);
2569
    if (s->iformat->read_close)
2570
        s->iformat->read_close(s);
2571
    avformat_free_context(s);
2572
}
2573

    
2574
void avformat_free_context(AVFormatContext *s)
2575
{
2576
    int i;
2577
    AVStream *st;
2578

    
2579
    for(i=0;i<s->nb_streams;i++) {
2580
        /* free all data in a stream component */
2581
        st = s->streams[i];
2582
        if (st->parser) {
2583
            av_parser_close(st->parser);
2584
            av_free_packet(&st->cur_pkt);
2585
        }
2586
        av_metadata_free(&st->metadata);
2587
        av_free(st->index_entries);
2588
        av_free(st->codec->extradata);
2589
        av_free(st->codec->subtitle_header);
2590
        av_free(st->codec);
2591
        av_free(st->priv_data);
2592
        av_free(st->info);
2593
        av_free(st);
2594
    }
2595
    for(i=s->nb_programs-1; i>=0; i--) {
2596
        av_metadata_free(&s->programs[i]->metadata);
2597
        av_freep(&s->programs[i]->stream_index);
2598
        av_freep(&s->programs[i]);
2599
    }
2600
    av_freep(&s->programs);
2601
    av_freep(&s->priv_data);
2602
    while(s->nb_chapters--) {
2603
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2604
        av_free(s->chapters[s->nb_chapters]);
2605
    }
2606
    av_freep(&s->chapters);
2607
    av_metadata_free(&s->metadata);
2608
    av_freep(&s->key);
2609
    av_freep(&s->streams);
2610
    av_free(s);
2611
}
2612

    
2613
void av_close_input_file(AVFormatContext *s)
2614
{
2615
    AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2616
    av_close_input_stream(s);
2617
    if (pb)
2618
        avio_close(pb);
2619
}
2620

    
2621
AVStream *av_new_stream(AVFormatContext *s, int id)
2622
{
2623
    AVStream *st;
2624
    int i;
2625
    AVStream **streams;
2626

    
2627
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2628
        return NULL;
2629
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2630
    if (!streams)
2631
        return NULL;
2632
    s->streams = streams;
2633

    
2634
    st = av_mallocz(sizeof(AVStream));
2635
    if (!st)
2636
        return NULL;
2637
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2638
        av_free(st);
2639
        return NULL;
2640
    }
2641

    
2642
    st->codec= avcodec_alloc_context();
2643
    if (s->iformat) {
2644
        /* no default bitrate if decoding */
2645
        st->codec->bit_rate = 0;
2646
    }
2647
    st->index = s->nb_streams;
2648
    st->id = id;
2649
    st->start_time = AV_NOPTS_VALUE;
2650
    st->duration = AV_NOPTS_VALUE;
2651
        /* we set the current DTS to 0 so that formats without any timestamps
2652
           but durations get some timestamps, formats with some unknown
2653
           timestamps have their first few packets buffered and the
2654
           timestamps corrected before they are returned to the user */
2655
    st->cur_dts = 0;
2656
    st->first_dts = AV_NOPTS_VALUE;
2657
    st->probe_packets = MAX_PROBE_PACKETS;
2658

    
2659
    /* default pts setting is MPEG-like */
2660
    av_set_pts_info(st, 33, 1, 90000);
2661
    st->last_IP_pts = AV_NOPTS_VALUE;
2662
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2663
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2664
    st->reference_dts = AV_NOPTS_VALUE;
2665

    
2666
    st->sample_aspect_ratio = (AVRational){0,1};
2667

    
2668
    s->streams[s->nb_streams++] = st;
2669
    return st;
2670
}
2671

    
2672
AVProgram *av_new_program(AVFormatContext *ac, int id)
2673
{
2674
    AVProgram *program=NULL;
2675
    int i;
2676

    
2677
#ifdef DEBUG_SI
2678
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2679
#endif
2680

    
2681
    for(i=0; i<ac->nb_programs; i++)
2682
        if(ac->programs[i]->id == id)
2683
            program = ac->programs[i];
2684

    
2685
    if(!program){
2686
        program = av_mallocz(sizeof(AVProgram));
2687
        if (!program)
2688
            return NULL;
2689
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2690
        program->discard = AVDISCARD_NONE;
2691
    }
2692
    program->id = id;
2693

    
2694
    return program;
2695
}
2696

    
2697
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2698
{
2699
    AVChapter *chapter = NULL;
2700
    int i;
2701

    
2702
    for(i=0; i<s->nb_chapters; i++)
2703
        if(s->chapters[i]->id == id)
2704
            chapter = s->chapters[i];
2705

    
2706
    if(!chapter){
2707
        chapter= av_mallocz(sizeof(AVChapter));
2708
        if(!chapter)
2709
            return NULL;
2710
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2711
    }
2712
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2713
    chapter->id    = id;
2714
    chapter->time_base= time_base;
2715
    chapter->start = start;
2716
    chapter->end   = end;
2717

    
2718
    return chapter;
2719
}
2720

    
2721
/************************************************************/
2722
/* output media file */
2723

    
2724
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2725
{
2726
    int ret;
2727

    
2728
    if (s->oformat->priv_data_size > 0) {
2729
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2730
        if (!s->priv_data)
2731
            return AVERROR(ENOMEM);
2732
        if (s->oformat->priv_class) {
2733
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2734
            av_opt_set_defaults(s->priv_data);
2735
        }
2736
    } else
2737
        s->priv_data = NULL;
2738

    
2739
    return 0;
2740
}
2741

    
2742
AVFormatContext *avformat_alloc_output_context(const char *format, AVOutputFormat *oformat, const char *filename){
2743
    AVFormatContext *s= avformat_alloc_context();
2744
    if(!s)
2745
        goto nomem;
2746

    
2747
    if(!oformat){
2748
        if (format) {
2749
            oformat = av_guess_format(format, NULL, NULL);
2750
            if (!oformat) {
2751
                av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2752
                goto error;
2753
            }
2754
        } else {
2755
            oformat = av_guess_format(NULL, filename, NULL);
2756
            if (!oformat) {
2757
                av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2758
                        filename);
2759
                goto error;
2760
            }
2761
        }
2762
    }
2763

    
2764
    s->oformat= oformat;
2765
    if (s->oformat->priv_data_size > 0) {
2766
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2767
        if (!s->priv_data)
2768
            goto nomem;
2769
        if (s->oformat->priv_class) {
2770
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2771
            av_opt_set_defaults(s->priv_data);
2772
        }
2773
    } else
2774
        s->priv_data = NULL;
2775

    
2776
    if(filename)
2777
        av_strlcpy(s->filename, filename, sizeof(s->filename));
2778
    return s;
2779
nomem:
2780
    av_log(s, AV_LOG_ERROR, "Out of memory\n");
2781
error:
2782
    avformat_free_context(s);
2783
    return NULL;
2784
}
2785

    
2786
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2787
{
2788
    const AVCodecTag *avctag;
2789
    int n;
2790
    enum CodecID id = CODEC_ID_NONE;
2791
    unsigned int tag = 0;
2792

    
2793
    /**
2794
     * Check that tag + id is in the table
2795
     * If neither is in the table -> OK
2796
     * If tag is in the table with another id -> FAIL
2797
     * If id is in the table with another tag -> FAIL unless strict < normal
2798
     */
2799
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2800
        avctag = s->oformat->codec_tag[n];
2801
        while (avctag->id != CODEC_ID_NONE) {
2802
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2803
                id = avctag->id;
2804
                if (id == st->codec->codec_id)
2805
                    return 1;
2806
            }
2807
            if (avctag->id == st->codec->codec_id)
2808
                tag = avctag->tag;
2809
            avctag++;
2810
        }
2811
    }
2812
    if (id != CODEC_ID_NONE)
2813
        return 0;
2814
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2815
        return 0;
2816
    return 1;
2817
}
2818

    
2819
int av_write_header(AVFormatContext *s)
2820
{
2821
    int ret, i;
2822
    AVStream *st;
2823

    
2824
    // some sanity checks
2825
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2826
        av_log(s, AV_LOG_ERROR, "no streams\n");
2827
        return AVERROR(EINVAL);
2828
    }
2829

    
2830
    for(i=0;i<s->nb_streams;i++) {
2831
        st = s->streams[i];
2832

    
2833
        switch (st->codec->codec_type) {
2834
        case AVMEDIA_TYPE_AUDIO:
2835
            if(st->codec->sample_rate<=0){
2836
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2837
                return AVERROR(EINVAL);
2838
            }
2839
            if(!st->codec->block_align)
2840
                st->codec->block_align = st->codec->channels *
2841
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2842
            break;
2843
        case AVMEDIA_TYPE_VIDEO:
2844
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2845
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2846
                return AVERROR(EINVAL);
2847
            }
2848
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2849
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2850
                return AVERROR(EINVAL);
2851
            }
2852
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2853
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2854
                return AVERROR(EINVAL);
2855
            }
2856
            break;
2857
        }
2858

    
2859
        if(s->oformat->codec_tag){
2860
            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)){
2861
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2862
                st->codec->codec_tag= 0;
2863
            }
2864
            if(st->codec->codec_tag){
2865
                if (!validate_codec_tag(s, st)) {
2866
                    char tagbuf[32];
2867
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2868
                    av_log(s, AV_LOG_ERROR,
2869
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2870
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2871
                    return AVERROR_INVALIDDATA;
2872
                }
2873
            }else
2874
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2875
        }
2876

    
2877
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2878
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2879
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2880
    }
2881

    
2882
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2883
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2884
        if (!s->priv_data)
2885
            return AVERROR(ENOMEM);
2886
    }
2887

    
2888
    /* set muxer identification string */
2889
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2890
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2891
    }
2892

    
2893
    if(s->oformat->write_header){
2894
        ret = s->oformat->write_header(s);
2895
        if (ret < 0)
2896
            return ret;
2897
    }
2898

    
2899
    /* init PTS generation */
2900
    for(i=0;i<s->nb_streams;i++) {
2901
        int64_t den = AV_NOPTS_VALUE;
2902
        st = s->streams[i];
2903

    
2904
        switch (st->codec->codec_type) {
2905
        case AVMEDIA_TYPE_AUDIO:
2906
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2907
            break;
2908
        case AVMEDIA_TYPE_VIDEO:
2909
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2910
            break;
2911
        default:
2912
            break;
2913
        }
2914
        if (den != AV_NOPTS_VALUE) {
2915
            if (den <= 0)
2916
                return AVERROR_INVALIDDATA;
2917
            av_frac_init(&st->pts, 0, 0, den);
2918
        }
2919
    }
2920
    return 0;
2921
}
2922

    
2923
//FIXME merge with compute_pkt_fields
2924
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2925
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2926
    int num, den, frame_size, i;
2927

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

    
2931
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2932
        return AVERROR(EINVAL);*/
2933

    
2934
    /* duration field */
2935
    if (pkt->duration == 0) {
2936
        compute_frame_duration(&num, &den, st, NULL, pkt);
2937
        if (den && num) {
2938
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2939
        }
2940
    }
2941

    
2942
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2943
        pkt->pts= pkt->dts;
2944

    
2945
    //XXX/FIXME this is a temporary hack until all encoders output pts
2946
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2947
        pkt->dts=
2948
//        pkt->pts= st->cur_dts;
2949
        pkt->pts= st->pts.val;
2950
    }
2951

    
2952
    //calculate dts from pts
2953
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2954
        st->pts_buffer[0]= pkt->pts;
2955
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2956
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2957
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2958
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2959

    
2960
        pkt->dts= st->pts_buffer[0];
2961
    }
2962

    
2963
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2964
        av_log(s, AV_LOG_ERROR,
2965
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2966
               st->index, st->cur_dts, pkt->dts);
2967
        return AVERROR(EINVAL);
2968
    }
2969
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2970
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2971
        return AVERROR(EINVAL);
2972
    }
2973

    
2974
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2975
    st->cur_dts= pkt->dts;
2976
    st->pts.val= pkt->dts;
2977

    
2978
    /* update pts */
2979
    switch (st->codec->codec_type) {
2980
    case AVMEDIA_TYPE_AUDIO:
2981
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2982

    
2983
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2984
           likely equal to the encoder delay, but it would be better if we
2985
           had the real timestamps from the encoder */
2986
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2987
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2988
        }
2989
        break;
2990
    case AVMEDIA_TYPE_VIDEO:
2991
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2992
        break;
2993
    default:
2994
        break;
2995
    }
2996
    return 0;
2997
}
2998

    
2999
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3000
{
3001
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3002

    
3003
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3004
        return ret;
3005

    
3006
    ret= s->oformat->write_packet(s, pkt);
3007
    if(!ret)
3008
        ret= url_ferror(s->pb);
3009
    return ret;
3010
}
3011

    
3012
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3013
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3014
{
3015
    AVPacketList **next_point, *this_pktl;
3016

    
3017
    this_pktl = av_mallocz(sizeof(AVPacketList));
3018
    this_pktl->pkt= *pkt;
3019
    pkt->destruct= NULL;             // do not free original but only the copy
3020
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3021

    
3022
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3023
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3024
    }else
3025
        next_point = &s->packet_buffer;
3026

    
3027
    if(*next_point){
3028
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3029
            while(!compare(s, &(*next_point)->pkt, pkt)){
3030
                next_point= &(*next_point)->next;
3031
            }
3032
            goto next_non_null;
3033
        }else{
3034
            next_point = &(s->packet_buffer_end->next);
3035
        }
3036
    }
3037
    assert(!*next_point);
3038

    
3039
    s->packet_buffer_end= this_pktl;
3040
next_non_null:
3041

    
3042
    this_pktl->next= *next_point;
3043

    
3044
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3045
    *next_point= this_pktl;
3046
}
3047

    
3048
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3049
{
3050
    AVStream *st = s->streams[ pkt ->stream_index];
3051
    AVStream *st2= s->streams[ next->stream_index];
3052
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3053
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3054
    int64_t dts1 = av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN);
3055
    if (dts1==next->dts && dts1==av_rescale_rnd(pkt->dts, b, a, AV_ROUND_UP))
3056
        return pkt->stream_index < next->stream_index;
3057
    return dts1 < next->dts;
3058
}
3059

    
3060
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3061
    AVPacketList *pktl;
3062
    int stream_count=0;
3063
    int i;
3064

    
3065
    if(pkt){
3066
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3067
    }
3068

    
3069
    for(i=0; i < s->nb_streams; i++)
3070
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3071

    
3072
    if(stream_count && (s->nb_streams == stream_count || flush)){
3073
        pktl= s->packet_buffer;
3074
        *out= pktl->pkt;
3075

    
3076
        s->packet_buffer= pktl->next;
3077
        if(!s->packet_buffer)
3078
            s->packet_buffer_end= NULL;
3079

    
3080
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3081
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3082
        av_freep(&pktl);
3083
        return 1;
3084
    }else{
3085
        av_init_packet(out);
3086
        return 0;
3087
    }
3088
}
3089

    
3090
/**
3091
 * Interleave an AVPacket correctly so it can be muxed.
3092
 * @param out the interleaved packet will be output here
3093
 * @param in the input packet
3094
 * @param flush 1 if no further packets are available as input and all
3095
 *              remaining packets should be output
3096
 * @return 1 if a packet was output, 0 if no packet could be output,
3097
 *         < 0 if an error occurred
3098
 */
3099
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3100
    if(s->oformat->interleave_packet)
3101
        return s->oformat->interleave_packet(s, out, in, flush);
3102
    else
3103
        return av_interleave_packet_per_dts(s, out, in, flush);
3104
}
3105

    
3106
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3107
    AVStream *st= s->streams[ pkt->stream_index];
3108
    int ret;
3109

    
3110
    //FIXME/XXX/HACK drop zero sized packets
3111
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3112
        return 0;
3113

    
3114
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3115
            pkt->size, pkt->dts, pkt->pts);
3116
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3117
        return ret;
3118

    
3119
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3120
        return AVERROR(EINVAL);
3121

    
3122
    for(;;){
3123
        AVPacket opkt;
3124
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3125
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3126
            return ret;
3127

    
3128
        ret= s->oformat->write_packet(s, &opkt);
3129

    
3130
        av_free_packet(&opkt);
3131
        pkt= NULL;
3132

    
3133
        if(ret<0)
3134
            return ret;
3135
        if(url_ferror(s->pb))
3136
            return url_ferror(s->pb);
3137
    }
3138
}
3139

    
3140
int av_write_trailer(AVFormatContext *s)
3141
{
3142
    int ret, i;
3143

    
3144
    for(;;){
3145
        AVPacket pkt;
3146
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3147
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3148
            goto fail;
3149
        if(!ret)
3150
            break;
3151

    
3152
        ret= s->oformat->write_packet(s, &pkt);
3153

    
3154
        av_free_packet(&pkt);
3155

    
3156
        if(ret<0)
3157
            goto fail;
3158
        if(url_ferror(s->pb))
3159
            goto fail;
3160
    }
3161

    
3162
    if(s->oformat->write_trailer)
3163
        ret = s->oformat->write_trailer(s);
3164
fail:
3165
    if(ret == 0)
3166
       ret=url_ferror(s->pb);
3167
    for(i=0;i<s->nb_streams;i++) {
3168
        av_freep(&s->streams[i]->priv_data);
3169
        av_freep(&s->streams[i]->index_entries);
3170
    }
3171
    av_freep(&s->priv_data);
3172
    return ret;
3173
}
3174

    
3175
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3176
{
3177
    int i, j;
3178
    AVProgram *program=NULL;
3179
    void *tmp;
3180

    
3181
    if (idx >= ac->nb_streams) {
3182
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3183
        return;
3184
    }
3185

    
3186
    for(i=0; i<ac->nb_programs; i++){
3187
        if(ac->programs[i]->id != progid)
3188
            continue;
3189
        program = ac->programs[i];
3190
        for(j=0; j<program->nb_stream_indexes; j++)
3191
            if(program->stream_index[j] == idx)
3192
                return;
3193

    
3194
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3195
        if(!tmp)
3196
            return;
3197
        program->stream_index = tmp;
3198
        program->stream_index[program->nb_stream_indexes++] = idx;
3199
        return;
3200
    }
3201
}
3202

    
3203
static void print_fps(double d, const char *postfix){
3204
    uint64_t v= lrintf(d*100);
3205
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3206
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3207
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3208
}
3209

    
3210
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3211
{
3212
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3213
        AVMetadataTag *tag=NULL;
3214

    
3215
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3216
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3217
            if(strcmp("language", tag->key))
3218
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3219
        }
3220
    }
3221
}
3222

    
3223
/* "user interface" functions */
3224
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3225
{
3226
    char buf[256];
3227
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3228
    AVStream *st = ic->streams[i];
3229
    int g = av_gcd(st->time_base.num, st->time_base.den);
3230
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3231
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3232
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3233
    /* the pid is an important information, so we display it */
3234
    /* XXX: add a generic system */
3235
    if (flags & AVFMT_SHOW_IDS)
3236
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3237
    if (lang)
3238
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3239
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3240
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3241
    if (st->sample_aspect_ratio.num && // default
3242
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3243
        AVRational display_aspect_ratio;
3244
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3245
                  st->codec->width*st->sample_aspect_ratio.num,
3246
                  st->codec->height*st->sample_aspect_ratio.den,
3247
                  1024*1024);
3248
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3249
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3250
                 display_aspect_ratio.num, display_aspect_ratio.den);
3251
    }
3252
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3253
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3254
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3255
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3256
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3257
        if(st->time_base.den && st->time_base.num)
3258
            print_fps(1/av_q2d(st->time_base), "tbn");
3259
        if(st->codec->time_base.den && st->codec->time_base.num)
3260
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3261
    }
3262
    if (st->disposition & AV_DISPOSITION_DEFAULT)
3263
        av_log(NULL, AV_LOG_INFO, " (default)");
3264
    if (st->disposition & AV_DISPOSITION_DUB)
3265
        av_log(NULL, AV_LOG_INFO, " (dub)");
3266
    if (st->disposition & AV_DISPOSITION_ORIGINAL)
3267
        av_log(NULL, AV_LOG_INFO, " (original)");
3268
    if (st->disposition & AV_DISPOSITION_COMMENT)
3269
        av_log(NULL, AV_LOG_INFO, " (comment)");
3270
    if (st->disposition & AV_DISPOSITION_LYRICS)
3271
        av_log(NULL, AV_LOG_INFO, " (lyrics)");
3272
    if (st->disposition & AV_DISPOSITION_KARAOKE)
3273
        av_log(NULL, AV_LOG_INFO, " (karaoke)");
3274
    if (st->disposition & AV_DISPOSITION_FORCED)
3275
        av_log(NULL, AV_LOG_INFO, " (forced)");
3276
    if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3277
        av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3278
    if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3279
        av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3280
    if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3281
        av_log(NULL, AV_LOG_INFO, " (clean effects)");
3282
    av_log(NULL, AV_LOG_INFO, "\n");
3283
    dump_metadata(NULL, st->metadata, "    ");
3284
}
3285

    
3286
#if FF_API_DUMP_FORMAT
3287
void dump_format(AVFormatContext *ic,
3288
                 int index,
3289
                 const char *url,
3290
                 int is_output)
3291
{
3292
    av_dump_format(ic, index, url, is_output);
3293
}
3294
#endif
3295

    
3296
void av_dump_format(AVFormatContext *ic,
3297
                    int index,
3298
                    const char *url,
3299
                    int is_output)
3300
{
3301
    int i;
3302
    uint8_t *printed = av_mallocz(ic->nb_streams);
3303
    if (ic->nb_streams && !printed)
3304
        return;
3305

    
3306
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3307
            is_output ? "Output" : "Input",
3308
            index,
3309
            is_output ? ic->oformat->name : ic->iformat->name,
3310
            is_output ? "to" : "from", url);
3311
    dump_metadata(NULL, ic->metadata, "  ");
3312
    if (!is_output) {
3313
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3314
        if (ic->duration != AV_NOPTS_VALUE) {
3315
            int hours, mins, secs, us;
3316
            secs = ic->duration / AV_TIME_BASE;
3317
            us = ic->duration % AV_TIME_BASE;
3318
            mins = secs / 60;
3319
            secs %= 60;
3320
            hours = mins / 60;
3321
            mins %= 60;
3322
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3323
                   (100 * us) / AV_TIME_BASE);
3324
        } else {
3325
            av_log(NULL, AV_LOG_INFO, "N/A");
3326
        }
3327
        if (ic->start_time != AV_NOPTS_VALUE) {
3328
            int secs, us;
3329
            av_log(NULL, AV_LOG_INFO, ", start: ");
3330
            secs = ic->start_time / AV_TIME_BASE;
3331
            us = abs(ic->start_time % AV_TIME_BASE);
3332
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3333
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3334
        }
3335
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3336
        if (ic->bit_rate) {
3337
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3338
        } else {
3339
            av_log(NULL, AV_LOG_INFO, "N/A");
3340
        }
3341
        av_log(NULL, AV_LOG_INFO, "\n");
3342
    }
3343
    for (i = 0; i < ic->nb_chapters; i++) {
3344
        AVChapter *ch = ic->chapters[i];
3345
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3346
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3347
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3348

    
3349
        dump_metadata(NULL, ch->metadata, "    ");
3350
    }
3351
    if(ic->nb_programs) {
3352
        int j, k, total = 0;
3353
        for(j=0; j<ic->nb_programs; j++) {
3354
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3355
                                                  "name", NULL, 0);
3356
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3357
                   name ? name->value : "");
3358
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3359
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3360
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3361
                printed[ic->programs[j]->stream_index[k]] = 1;
3362
            }
3363
            total += ic->programs[j]->nb_stream_indexes;
3364
        }
3365
        if (total < ic->nb_streams)
3366
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3367
    }
3368
    for(i=0;i<ic->nb_streams;i++)
3369
        if (!printed[i])
3370
            dump_stream_format(ic, i, index, is_output);
3371

    
3372
    av_free(printed);
3373
}
3374

    
3375
int64_t av_gettime(void)
3376
{
3377
    struct timeval tv;
3378
    gettimeofday(&tv,NULL);
3379
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3380
}
3381

    
3382
uint64_t ff_ntp_time(void)
3383
{
3384
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3385
}
3386

    
3387
#if FF_API_PARSE_DATE
3388
#include "libavutil/parseutils.h"
3389

    
3390
int64_t parse_date(const char *timestr, int duration)
3391
{
3392
    int64_t timeval;
3393
    av_parse_time(&timeval, timestr, duration);
3394
    return timeval;
3395
}
3396
#endif
3397

    
3398
#if FF_API_FIND_INFO_TAG
3399
#include "libavutil/parseutils.h"
3400

    
3401
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3402
{
3403
    return av_find_info_tag(arg, arg_size, tag1, info);
3404
}
3405
#endif
3406

    
3407
int av_get_frame_filename(char *buf, int buf_size,
3408
                          const char *path, int number)
3409
{
3410
    const char *p;
3411
    char *q, buf1[20], c;
3412
    int nd, len, percentd_found;
3413

    
3414
    q = buf;
3415
    p = path;
3416
    percentd_found = 0;
3417
    for(;;) {
3418
        c = *p++;
3419
        if (c == '\0')
3420
            break;
3421
        if (c == '%') {
3422
            do {
3423
                nd = 0;
3424
                while (isdigit(*p)) {
3425
                    nd = nd * 10 + *p++ - '0';
3426
                }
3427
                c = *p++;
3428
            } while (isdigit(c));
3429

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

    
3462
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3463
{
3464
    int len, i, j, c;
3465
#undef fprintf
3466
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3467

    
3468
    for(i=0;i<size;i+=16) {
3469
        len = size - i;
3470
        if (len > 16)
3471
            len = 16;
3472
        PRINT("%08x ", i);
3473
        for(j=0;j<16;j++) {
3474
            if (j < len)
3475
                PRINT(" %02x", buf[i+j]);
3476
            else
3477
                PRINT("   ");
3478
        }
3479
        PRINT(" ");
3480
        for(j=0;j<len;j++) {
3481
            c = buf[i+j];
3482
            if (c < ' ' || c > '~')
3483
                c = '.';
3484
            PRINT("%c", c);
3485
        }
3486
        PRINT("\n");
3487
    }
3488
#undef PRINT
3489
}
3490

    
3491
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3492
{
3493
    hex_dump_internal(NULL, f, 0, buf, size);
3494
}
3495

    
3496
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3497
{
3498
    hex_dump_internal(avcl, NULL, level, buf, size);
3499
}
3500

    
3501
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3502
{
3503
#undef fprintf
3504
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3505
    PRINT("stream #%d:\n", pkt->stream_index);
3506
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3507
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3508
    /* DTS is _always_ valid after av_read_frame() */
3509
    PRINT("  dts=");
3510
    if (pkt->dts == AV_NOPTS_VALUE)
3511
        PRINT("N/A");
3512
    else
3513
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3514
    /* PTS may not be known if B-frames are present. */
3515
    PRINT("  pts=");
3516
    if (pkt->pts == AV_NOPTS_VALUE)
3517
        PRINT("N/A");
3518
    else
3519
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3520
    PRINT("\n");
3521
    PRINT("  size=%d\n", pkt->size);
3522
#undef PRINT
3523
    if (dump_payload)
3524
        av_hex_dump(f, pkt->data, pkt->size);
3525
}
3526

    
3527
#if FF_API_PKT_DUMP
3528
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3529
{
3530
    AVRational tb = { 1, AV_TIME_BASE };
3531
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3532
}
3533
#endif
3534

    
3535
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3536
{
3537
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3538
}
3539

    
3540
#if FF_API_PKT_DUMP
3541
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3542
{
3543
    AVRational tb = { 1, AV_TIME_BASE };
3544
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3545
}
3546
#endif
3547

    
3548
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3549
                      AVStream *st)
3550
{
3551
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3552
}
3553

    
3554
void av_url_split(char *proto, int proto_size,
3555
                  char *authorization, int authorization_size,
3556
                  char *hostname, int hostname_size,
3557
                  int *port_ptr,
3558
                  char *path, int path_size,
3559
                  const char *url)
3560
{
3561
    const char *p, *ls, *at, *col, *brk;
3562

    
3563
    if (port_ptr)               *port_ptr = -1;
3564
    if (proto_size > 0)         proto[0] = 0;
3565
    if (authorization_size > 0) authorization[0] = 0;
3566
    if (hostname_size > 0)      hostname[0] = 0;
3567
    if (path_size > 0)          path[0] = 0;
3568

    
3569
    /* parse protocol */
3570
    if ((p = strchr(url, ':'))) {
3571
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3572
        p++; /* skip ':' */
3573
        if (*p == '/') p++;
3574
        if (*p == '/') p++;
3575
    } else {
3576
        /* no protocol means plain filename */
3577
        av_strlcpy(path, url, path_size);
3578
        return;
3579
    }
3580

    
3581
    /* separate path from hostname */
3582
    ls = strchr(p, '/');
3583
    if(!ls)
3584
        ls = strchr(p, '?');
3585
    if(ls)
3586
        av_strlcpy(path, ls, path_size);
3587
    else
3588
        ls = &p[strlen(p)]; // XXX
3589

    
3590
    /* the rest is hostname, use that to parse auth/port */
3591
    if (ls != p) {
3592
        /* authorization (user[:pass]@hostname) */
3593
        if ((at = strchr(p, '@')) && at < ls) {
3594
            av_strlcpy(authorization, p,
3595
                       FFMIN(authorization_size, at + 1 - p));
3596
            p = at + 1; /* skip '@' */
3597
        }
3598

    
3599
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3600
            /* [host]:port */
3601
            av_strlcpy(hostname, p + 1,
3602
                       FFMIN(hostname_size, brk - p));
3603
            if (brk[1] == ':' && port_ptr)
3604
                *port_ptr = atoi(brk + 2);
3605
        } else if ((col = strchr(p, ':')) && col < ls) {
3606
            av_strlcpy(hostname, p,
3607
                       FFMIN(col + 1 - p, hostname_size));
3608
            if (port_ptr) *port_ptr = atoi(col + 1);
3609
        } else
3610
            av_strlcpy(hostname, p,
3611
                       FFMIN(ls + 1 - p, hostname_size));
3612
    }
3613
}
3614

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

    
3628
    for(i = 0; i < s; i++) {
3629
        buff[i * 2]     = hex_table[src[i] >> 4];
3630
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3631
    }
3632

    
3633
    return buff;
3634
}
3635

    
3636
int ff_hex_to_data(uint8_t *data, const char *p)
3637
{
3638
    int c, len, v;
3639

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

    
3664
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3665
                     unsigned int pts_num, unsigned int pts_den)
3666
{
3667
    AVRational new_tb;
3668
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3669
        if(new_tb.num != pts_num)
3670
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3671
    }else
3672
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3673

    
3674
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3675
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3676
        return;
3677
    }
3678
    s->time_base = new_tb;
3679
    s->pts_wrap_bits = pts_wrap_bits;
3680
}
3681

    
3682
int ff_url_join(char *str, int size, const char *proto,
3683
                const char *authorization, const char *hostname,
3684
                int port, const char *fmt, ...)
3685
{
3686
#if CONFIG_NETWORK
3687
    struct addrinfo hints, *ai;
3688
#endif
3689

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

    
3714
    if (port >= 0)
3715
        av_strlcatf(str, size, ":%d", port);
3716
    if (fmt) {
3717
        va_list vl;
3718
        int len = strlen(str);
3719

    
3720
        va_start(vl, fmt);
3721
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3722
        va_end(vl);
3723
    }
3724
    return strlen(str);
3725
}
3726

    
3727
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3728
                     AVFormatContext *src)
3729
{
3730
    AVPacket local_pkt;
3731

    
3732
    local_pkt = *pkt;
3733
    local_pkt.stream_index = dst_stream;
3734
    if (pkt->pts != AV_NOPTS_VALUE)
3735
        local_pkt.pts = av_rescale_q(pkt->pts,
3736
                                     src->streams[pkt->stream_index]->time_base,
3737
                                     dst->streams[dst_stream]->time_base);
3738
    if (pkt->dts != AV_NOPTS_VALUE)
3739
        local_pkt.dts = av_rescale_q(pkt->dts,
3740
                                     src->streams[pkt->stream_index]->time_base,
3741
                                     dst->streams[dst_stream]->time_base);
3742
    return av_write_frame(dst, &local_pkt);
3743
}
3744

    
3745
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3746
                        void *context)
3747
{
3748
    const char *ptr = str;
3749

    
3750
    /* Parse key=value pairs. */
3751
    for (;;) {
3752
        const char *key;
3753
        char *dest = NULL, *dest_end;
3754
        int key_len, dest_len = 0;
3755

    
3756
        /* Skip whitespace and potential commas. */
3757
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3758
            ptr++;
3759
        if (!*ptr)
3760
            break;
3761

    
3762
        key = ptr;
3763

    
3764
        if (!(ptr = strchr(key, '=')))
3765
            break;
3766
        ptr++;
3767
        key_len = ptr - key;
3768

    
3769
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3770
        dest_end = dest + dest_len - 1;
3771

    
3772
        if (*ptr == '\"') {
3773
            ptr++;
3774
            while (*ptr && *ptr != '\"') {
3775
                if (*ptr == '\\') {
3776
                    if (!ptr[1])
3777
                        break;
3778
                    if (dest && dest < dest_end)
3779
                        *dest++ = ptr[1];
3780
                    ptr += 2;
3781
                } else {
3782
                    if (dest && dest < dest_end)
3783
                        *dest++ = *ptr;
3784
                    ptr++;
3785
                }
3786
            }
3787
            if (*ptr == '\"')
3788
                ptr++;
3789
        } else {
3790
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3791
                if (dest && dest < dest_end)
3792
                    *dest++ = *ptr;
3793
        }
3794
        if (dest)
3795
            *dest = 0;
3796
    }
3797
}
3798

    
3799
int ff_find_stream_index(AVFormatContext *s, int id)
3800
{
3801
    int i;
3802
    for (i = 0; i < s->nb_streams; i++) {
3803
        if (s->streams[i]->id == id)
3804
            return i;
3805
    }
3806
    return -1;
3807
}
3808

    
3809
void ff_make_absolute_url(char *buf, int size, const char *base,
3810
                          const char *rel)
3811
{
3812
    char *sep;
3813
    /* Absolute path, relative to the current server */
3814
    if (base && strstr(base, "://") && rel[0] == '/') {
3815
        if (base != buf)
3816
            av_strlcpy(buf, base, size);
3817
        sep = strstr(buf, "://");
3818
        if (sep) {
3819
            sep += 3;
3820
            sep = strchr(sep, '/');
3821
            if (sep)
3822
                *sep = '\0';
3823
        }
3824
        av_strlcat(buf, rel, size);
3825
        return;
3826
    }
3827
    /* If rel actually is an absolute url, just copy it */
3828
    if (!base || strstr(rel, "://") || rel[0] == '/') {
3829
        av_strlcpy(buf, rel, size);
3830
        return;
3831
    }
3832
    if (base != buf)
3833
        av_strlcpy(buf, base, size);
3834
    /* Remove the file name from the base url */
3835
    sep = strrchr(buf, '/');
3836
    if (sep)
3837
        sep[1] = '\0';
3838
    else
3839
        buf[0] = '\0';
3840
    while (av_strstart(rel, "../", NULL) && sep) {
3841
        /* Remove the path delimiter at the end */
3842
        sep[0] = '\0';
3843
        sep = strrchr(buf, '/');
3844
        /* If the next directory name to pop off is "..", break here */
3845
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
3846
            /* Readd the slash we just removed */
3847
            av_strlcat(buf, "/", size);
3848
            break;
3849
        }
3850
        /* Cut off the directory name */
3851
        if (sep)
3852
            sep[1] = '\0';
3853
        else
3854
            buf[0] = '\0';
3855
        rel += 3;
3856
    }
3857
    av_strlcat(buf, rel, size);
3858
}