Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 67d44149

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
                        int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;
1106
                        ff_reduce_index(s, st->index);
1107
                        av_add_index_entry(st, pos, pkt->dts,
1108
                                           0, 0, AVINDEX_KEYFRAME);
1109
                    }
1110

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

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

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

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

    
1190
    return 0;
1191
}
1192

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

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

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

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

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

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

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

    
1271
/*******************************************************/
1272
/* seek support */
1273

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

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

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

    
1301
    flush_packet_queue(s);
1302

    
1303
    s->cur_st = NULL;
1304

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

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

    
1321
        st->probe_packets = MAX_PROBE_PACKETS;
1322

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

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

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

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

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

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

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

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

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

    
1371
    *index_entries= entries;
1372

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

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

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

    
1396
    return index;
1397
}
1398

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

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

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

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

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

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

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

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

    
1448
#define DEBUG_SEEK
1449

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

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

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

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

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

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

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

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

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

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

    
1511
    av_update_cur_dts(s, st, ts);
1512

    
1513
    return 0;
1514
}
1515

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1713
    return 0;
1714
}
1715

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

    
1721
    ff_read_frame_flush(s);
1722

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

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

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

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

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

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

    
1756
    ff_read_frame_flush(s);
1757

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

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

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

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

    
1773
/*******************************************************/
1774

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

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

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

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

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

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

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

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

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

    
1894
#define DURATION_MAX_READ_SIZE 250000
1895
#define DURATION_MAX_RETRY 3
1896

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

    
1907
    ic->cur_st = NULL;
1908

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

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

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

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

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

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

    
1966
    fill_all_stream_timings(ic);
1967

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2317
        read_size += pkt->size;
2318

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

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

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

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

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

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

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

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

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

    
2448
    av_estimate_timings(ic, old_offset);
2449

    
2450
    compute_chapters_end(ic);
2451

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

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

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

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

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

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

    
2547
/*******************************************************/
2548

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2695
    return program;
2696
}
2697

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

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

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

    
2719
    return chapter;
2720
}
2721

    
2722
/************************************************************/
2723
/* output media file */
2724

    
2725
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2726
{
2727
    if (s->oformat->priv_data_size > 0) {
2728
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2729
        if (!s->priv_data)
2730
            return AVERROR(ENOMEM);
2731
        if (s->oformat->priv_class) {
2732
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2733
            av_opt_set_defaults(s->priv_data);
2734
        }
2735
    } else
2736
        s->priv_data = NULL;
2737

    
2738
    return 0;
2739
}
2740

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3041
    this_pktl->next= *next_point;
3042

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3153
        av_free_packet(&pkt);
3154

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3371
    av_free(printed);
3372
}
3373

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3632
    return buff;
3633
}
3634

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3761
        key = ptr;
3762

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

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

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

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

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