Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 7d727f13

History | View | Annotate | Download (123 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
    } else {
433
        ic->priv_data = NULL;
434
    }
435

    
436
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
437
    if (ic->pb)
438
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
439

    
440
    if (ic->iformat->read_header) {
441
        err = ic->iformat->read_header(ic, ap);
442
        if (err < 0)
443
            goto fail;
444
    }
445

    
446
    if (pb && !ic->data_offset)
447
        ic->data_offset = avio_tell(ic->pb);
448

    
449
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
450

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

    
473
/** size of probe buffer, for guessing file type from file contents */
474
#define PROBE_BUF_MIN 2048
475
#define PROBE_BUF_MAX (1<<20)
476

    
477
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
478
                          const char *filename, void *logctx,
479
                          unsigned int offset, unsigned int max_probe_size)
480
{
481
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
482
    unsigned char *buf = NULL;
483
    int ret = 0, probe_size;
484

    
485
    if (!max_probe_size) {
486
        max_probe_size = PROBE_BUF_MAX;
487
    } else if (max_probe_size > PROBE_BUF_MAX) {
488
        max_probe_size = PROBE_BUF_MAX;
489
    } else if (max_probe_size < PROBE_BUF_MIN) {
490
        return AVERROR(EINVAL);
491
    }
492

    
493
    if (offset >= max_probe_size) {
494
        return AVERROR(EINVAL);
495
    }
496

    
497
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
498
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
499
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
500
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
501

    
502
        if (probe_size < offset) {
503
            continue;
504
        }
505

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

    
520
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
521

    
522
        /* guess file format */
523
        *fmt = av_probe_input_format2(&pd, 1, &score);
524
        if(*fmt){
525
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
526
                av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
527
            }else
528
                av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
529
        }
530
    }
531

    
532
    if (!*fmt) {
533
        av_free(buf);
534
        return AVERROR_INVALIDDATA;
535
    }
536

    
537
    /* rewind. reuse probe buffer to avoid seeking */
538
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
539
        av_free(buf);
540

    
541
    return ret;
542
}
543

    
544
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
545
                       AVInputFormat *fmt,
546
                       int buf_size,
547
                       AVFormatParameters *ap)
548
{
549
    int err;
550
    AVProbeData probe_data, *pd = &probe_data;
551
    AVIOContext *pb = NULL;
552
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
553

    
554
    pd->filename = "";
555
    if (filename)
556
        pd->filename = filename;
557
    pd->buf = NULL;
558
    pd->buf_size = 0;
559

    
560
    if (!fmt) {
561
        /* guess format if no file can be opened */
562
        fmt = av_probe_input_format(pd, 0);
563
    }
564

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

    
580
    /* if still no format found, error */
581
    if (!fmt) {
582
        err = AVERROR_INVALIDDATA;
583
        goto fail;
584
    }
585

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

    
606
}
607

    
608
/*******************************************************/
609

    
610
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
611
                               AVPacketList **plast_pktl){
612
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
613
    if (!pktl)
614
        return NULL;
615

    
616
    if (*packet_buffer)
617
        (*plast_pktl)->next = pktl;
618
    else
619
        *packet_buffer = pktl;
620

    
621
    /* add the packet in the buffered packet list */
622
    *plast_pktl = pktl;
623
    pktl->pkt= *pkt;
624
    return &pktl->pkt;
625
}
626

    
627
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
628
{
629
    int ret, i;
630
    AVStream *st;
631

    
632
    for(;;){
633
        AVPacketList *pktl = s->raw_packet_buffer;
634

    
635
        if (pktl) {
636
            *pkt = pktl->pkt;
637
            if(s->streams[pkt->stream_index]->request_probe <= 0){
638
                s->raw_packet_buffer = pktl->next;
639
                s->raw_packet_buffer_remaining_size += pkt->size;
640
                av_free(pktl);
641
                return 0;
642
            }
643
        }
644

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

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

    
669
        if(!pktl && st->request_probe <= 0)
670
            return ret;
671

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

    
675
        if(st->request_probe>0){
676
            AVProbeData *pd = &st->probe_data;
677
            int end;
678
            av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
679
            --st->probe_packets;
680

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

    
686
            end=    s->raw_packet_buffer_remaining_size <= 0
687
                 || st->probe_packets<=0;
688

    
689
            if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
690
                int score= set_codec_from_probe_data(s, st, pd);
691
                if(    (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
692
                    || end){
693
                    pd->buf_size=0;
694
                    av_freep(&pd->buf);
695
                    st->request_probe= -1;
696
                    if(st->codec->codec_id != CODEC_ID_NONE){
697
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
698
                    }else
699
                        av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
700
                }
701
            }
702
        }
703
    }
704
}
705

    
706
/**********************************************************/
707

    
708
/**
709
 * Get the number of samples of an audio frame. Return -1 on error.
710
 */
711
static int get_audio_frame_size(AVCodecContext *enc, int size)
712
{
713
    int frame_size;
714

    
715
    if(enc->codec_id == CODEC_ID_VORBIS)
716
        return -1;
717

    
718
    if (enc->frame_size <= 1) {
719
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
720

    
721
        if (bits_per_sample) {
722
            if (enc->channels == 0)
723
                return -1;
724
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
725
        } else {
726
            /* used for example by ADPCM codecs */
727
            if (enc->bit_rate == 0)
728
                return -1;
729
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
730
        }
731
    } else {
732
        frame_size = enc->frame_size;
733
    }
734
    return frame_size;
735
}
736

    
737

    
738
/**
739
 * Return the frame duration in seconds. Return 0 if not available.
740
 */
741
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
742
                                   AVCodecParserContext *pc, AVPacket *pkt)
743
{
744
    int frame_size;
745

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

    
778
static int is_intra_only(AVCodecContext *enc){
779
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
780
        return 1;
781
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
782
        switch(enc->codec_id){
783
        case CODEC_ID_MJPEG:
784
        case CODEC_ID_MJPEGB:
785
        case CODEC_ID_LJPEG:
786
        case CODEC_ID_RAWVIDEO:
787
        case CODEC_ID_DVVIDEO:
788
        case CODEC_ID_HUFFYUV:
789
        case CODEC_ID_FFVHUFF:
790
        case CODEC_ID_ASV1:
791
        case CODEC_ID_ASV2:
792
        case CODEC_ID_VCR1:
793
        case CODEC_ID_DNXHD:
794
        case CODEC_ID_JPEG2000:
795
            return 1;
796
        default: break;
797
        }
798
    }
799
    return 0;
800
}
801

    
802
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
803
                                      int64_t dts, int64_t pts)
804
{
805
    AVStream *st= s->streams[stream_index];
806
    AVPacketList *pktl= s->packet_buffer;
807

    
808
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
809
        return;
810

    
811
    st->first_dts= dts - st->cur_dts;
812
    st->cur_dts= dts;
813

    
814
    for(; pktl; pktl= pktl->next){
815
        if(pktl->pkt.stream_index != stream_index)
816
            continue;
817
        //FIXME think more about this check
818
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
819
            pktl->pkt.pts += st->first_dts;
820

    
821
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
822
            pktl->pkt.dts += st->first_dts;
823

    
824
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
825
            st->start_time= pktl->pkt.pts;
826
    }
827
    if (st->start_time == AV_NOPTS_VALUE)
828
        st->start_time = pts;
829
}
830

    
831
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
832
{
833
    AVPacketList *pktl= s->packet_buffer;
834
    int64_t cur_dts= 0;
835

    
836
    if(st->first_dts != AV_NOPTS_VALUE){
837
        cur_dts= st->first_dts;
838
        for(; pktl; pktl= pktl->next){
839
            if(pktl->pkt.stream_index == pkt->stream_index){
840
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
841
                    break;
842
                cur_dts -= pkt->duration;
843
            }
844
        }
845
        pktl= s->packet_buffer;
846
        st->first_dts = cur_dts;
847
    }else if(st->cur_dts)
848
        return;
849

    
850
    for(; pktl; pktl= pktl->next){
851
        if(pktl->pkt.stream_index != pkt->stream_index)
852
            continue;
853
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
854
           && !pktl->pkt.duration){
855
            pktl->pkt.dts= cur_dts;
856
            if(!st->codec->has_b_frames)
857
                pktl->pkt.pts= cur_dts;
858
            cur_dts += pkt->duration;
859
            pktl->pkt.duration= pkt->duration;
860
        }else
861
            break;
862
    }
863
    if(st->first_dts == AV_NOPTS_VALUE)
864
        st->cur_dts= cur_dts;
865
}
866

    
867
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
868
                               AVCodecParserContext *pc, AVPacket *pkt)
869
{
870
    int num, den, presentation_delayed, delay, i;
871
    int64_t offset;
872

    
873
    if (s->flags & AVFMT_FLAG_NOFILLIN)
874
        return;
875

    
876
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
877
        pkt->dts= AV_NOPTS_VALUE;
878

    
879
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
880
        //FIXME Set low_delay = 0 when has_b_frames = 1
881
        st->codec->has_b_frames = 1;
882

    
883
    /* do we have a video B-frame ? */
884
    delay= st->codec->has_b_frames;
885
    presentation_delayed = 0;
886

    
887
    // ignore delay caused by frame threading so that the mpeg2-without-dts
888
    // warning will not trigger
889
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
890
        delay -= st->codec->thread_count-1;
891

    
892
    /* XXX: need has_b_frame, but cannot get it if the codec is
893
        not initialized */
894
    if (delay &&
895
        pc && pc->pict_type != FF_B_TYPE)
896
        presentation_delayed = 1;
897

    
898
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
899
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
900
        pkt->dts -= 1LL<<st->pts_wrap_bits;
901
    }
902

    
903
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
904
    // we take the conservative approach and discard both
905
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
906
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
907
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
908
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
909
    }
910

    
911
    if (pkt->duration == 0) {
912
        compute_frame_duration(&num, &den, st, pc, pkt);
913
        if (den && num) {
914
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
915

    
916
            if(pkt->duration != 0 && s->packet_buffer)
917
                update_initial_durations(s, st, pkt);
918
        }
919
    }
920

    
921
    /* correct timestamps with byte offset if demuxers only have timestamps
922
       on packet boundaries */
923
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
924
        /* this will estimate bitrate based on this frame's duration and size */
925
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
926
        if(pkt->pts != AV_NOPTS_VALUE)
927
            pkt->pts += offset;
928
        if(pkt->dts != AV_NOPTS_VALUE)
929
            pkt->dts += offset;
930
    }
931

    
932
    if (pc && pc->dts_sync_point >= 0) {
933
        // we have synchronization info from the parser
934
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
935
        if (den > 0) {
936
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
937
            if (pkt->dts != AV_NOPTS_VALUE) {
938
                // got DTS from the stream, update reference timestamp
939
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
940
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
941
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
942
                // compute DTS based on reference timestamp
943
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
944
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
945
            }
946
            if (pc->dts_sync_point > 0)
947
                st->reference_dts = pkt->dts; // new reference
948
        }
949
    }
950

    
951
    /* This may be redundant, but it should not hurt. */
952
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
953
        presentation_delayed = 1;
954

    
955
//    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);
956
    /* interpolate PTS and DTS if they are not present */
957
    //We skip H264 currently because delay and has_b_frames are not reliably set
958
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
959
        if (presentation_delayed) {
960
            /* DTS = decompression timestamp */
961
            /* PTS = presentation timestamp */
962
            if (pkt->dts == AV_NOPTS_VALUE)
963
                pkt->dts = st->last_IP_pts;
964
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
965
            if (pkt->dts == AV_NOPTS_VALUE)
966
                pkt->dts = st->cur_dts;
967

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

    
988
            /* presentation is not delayed : PTS and DTS are the same */
989
            if(pkt->pts == AV_NOPTS_VALUE)
990
                pkt->pts = pkt->dts;
991
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
992
            if(pkt->pts == AV_NOPTS_VALUE)
993
                pkt->pts = st->cur_dts;
994
            pkt->dts = pkt->pts;
995
            if(pkt->pts != AV_NOPTS_VALUE)
996
                st->cur_dts = pkt->pts + pkt->duration;
997
        }
998
    }
999

    
1000
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1001
        st->pts_buffer[0]= pkt->pts;
1002
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1003
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1004
        if(pkt->dts == AV_NOPTS_VALUE)
1005
            pkt->dts= st->pts_buffer[0];
1006
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1007
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1008
        }
1009
        if(pkt->dts > st->cur_dts)
1010
            st->cur_dts = pkt->dts;
1011
    }
1012

    
1013
//    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);
1014

    
1015
    /* update flags */
1016
    if(is_intra_only(st->codec))
1017
        pkt->flags |= AV_PKT_FLAG_KEY;
1018
    else if (pc) {
1019
        pkt->flags = 0;
1020
        /* keyframe computation */
1021
        if (pc->key_frame == 1)
1022
            pkt->flags |= AV_PKT_FLAG_KEY;
1023
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1024
            pkt->flags |= AV_PKT_FLAG_KEY;
1025
    }
1026
    if (pc)
1027
        pkt->convergence_duration = pc->convergence_duration;
1028
}
1029

    
1030

    
1031
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1032
{
1033
    AVStream *st;
1034
    int len, ret, i;
1035

    
1036
    av_init_packet(pkt);
1037

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

    
1065
                /* return packet if any */
1066
                if (pkt->size) {
1067
                got_packet:
1068
                    pkt->duration = 0;
1069
                    pkt->stream_index = st->index;
1070
                    pkt->pts = st->parser->pts;
1071
                    pkt->dts = st->parser->dts;
1072
                    pkt->pos = st->parser->pos;
1073
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1074
                        s->cur_st = NULL;
1075
                        pkt->destruct= st->cur_pkt.destruct;
1076
                        st->cur_pkt.destruct= NULL;
1077
                        st->cur_pkt.data    = NULL;
1078
                        assert(st->cur_len == 0);
1079
                    }else{
1080
                    pkt->destruct = NULL;
1081
                    }
1082
                    compute_pkt_fields(s, st, st->parser, pkt);
1083

    
1084
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1085
                        ff_reduce_index(s, st->index);
1086
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1087
                                           0, 0, AVINDEX_KEYFRAME);
1088
                    }
1089

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

    
1123
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1124
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1125
               st->cur_pkt.pts < st->cur_pkt.dts){
1126
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1127
                    st->cur_pkt.stream_index,
1128
                    st->cur_pkt.pts,
1129
                    st->cur_pkt.dts,
1130
                    st->cur_pkt.size);
1131
//                av_free_packet(&st->cur_pkt);
1132
//                return -1;
1133
            }
1134

    
1135
            if(s->debug & FF_FDEBUG_TS)
1136
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1137
                    st->cur_pkt.stream_index,
1138
                    st->cur_pkt.pts,
1139
                    st->cur_pkt.dts,
1140
                    st->cur_pkt.size,
1141
                    st->cur_pkt.duration,
1142
                    st->cur_pkt.flags);
1143

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

    
1169
    return 0;
1170
}
1171

    
1172
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1173
{
1174
    AVPacketList *pktl;
1175
    int eof=0;
1176
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1177

    
1178
    for(;;){
1179
        pktl = s->packet_buffer;
1180
        if (pktl) {
1181
            AVPacket *next_pkt= &pktl->pkt;
1182

    
1183
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1184
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1185
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1186
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1187
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1188
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1189
                        next_pkt->pts= pktl->pkt.dts;
1190
                    }
1191
                    pktl= pktl->next;
1192
                }
1193
                pktl = s->packet_buffer;
1194
            }
1195

    
1196
            if(   next_pkt->pts != AV_NOPTS_VALUE
1197
               || next_pkt->dts == AV_NOPTS_VALUE
1198
               || !genpts || eof){
1199
                /* read packet from packet buffer, if there is data */
1200
                *pkt = *next_pkt;
1201
                s->packet_buffer = pktl->next;
1202
                av_free(pktl);
1203
                return 0;
1204
            }
1205
        }
1206
        if(genpts){
1207
            int ret= av_read_frame_internal(s, pkt);
1208
            if(ret<0){
1209
                if(pktl && ret != AVERROR(EAGAIN)){
1210
                    eof=1;
1211
                    continue;
1212
                }else
1213
                    return ret;
1214
            }
1215

    
1216
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1217
                                           &s->packet_buffer_end)) < 0)
1218
                return AVERROR(ENOMEM);
1219
        }else{
1220
            assert(!s->packet_buffer);
1221
            return av_read_frame_internal(s, pkt);
1222
        }
1223
    }
1224
}
1225

    
1226
/* XXX: suppress the packet queue */
1227
static void flush_packet_queue(AVFormatContext *s)
1228
{
1229
    AVPacketList *pktl;
1230

    
1231
    for(;;) {
1232
        pktl = s->packet_buffer;
1233
        if (!pktl)
1234
            break;
1235
        s->packet_buffer = pktl->next;
1236
        av_free_packet(&pktl->pkt);
1237
        av_free(pktl);
1238
    }
1239
    while(s->raw_packet_buffer){
1240
        pktl = s->raw_packet_buffer;
1241
        s->raw_packet_buffer = pktl->next;
1242
        av_free_packet(&pktl->pkt);
1243
        av_free(pktl);
1244
    }
1245
    s->packet_buffer_end=
1246
    s->raw_packet_buffer_end= NULL;
1247
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1248
}
1249

    
1250
/*******************************************************/
1251
/* seek support */
1252

    
1253
int av_find_default_stream_index(AVFormatContext *s)
1254
{
1255
    int first_audio_index = -1;
1256
    int i;
1257
    AVStream *st;
1258

    
1259
    if (s->nb_streams <= 0)
1260
        return -1;
1261
    for(i = 0; i < s->nb_streams; i++) {
1262
        st = s->streams[i];
1263
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1264
            return i;
1265
        }
1266
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1267
            first_audio_index = i;
1268
    }
1269
    return first_audio_index >= 0 ? first_audio_index : 0;
1270
}
1271

    
1272
/**
1273
 * Flush the frame reader.
1274
 */
1275
void ff_read_frame_flush(AVFormatContext *s)
1276
{
1277
    AVStream *st;
1278
    int i, j;
1279

    
1280
    flush_packet_queue(s);
1281

    
1282
    s->cur_st = NULL;
1283

    
1284
    /* for each stream, reset read state */
1285
    for(i = 0; i < s->nb_streams; i++) {
1286
        st = s->streams[i];
1287

    
1288
        if (st->parser) {
1289
            av_parser_close(st->parser);
1290
            st->parser = NULL;
1291
            av_free_packet(&st->cur_pkt);
1292
        }
1293
        st->last_IP_pts = AV_NOPTS_VALUE;
1294
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1295
        st->reference_dts = AV_NOPTS_VALUE;
1296
        /* fail safe */
1297
        st->cur_ptr = NULL;
1298
        st->cur_len = 0;
1299

    
1300
        st->probe_packets = MAX_PROBE_PACKETS;
1301

    
1302
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1303
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1304
    }
1305
}
1306

    
1307
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1308
    int i;
1309

    
1310
    for(i = 0; i < s->nb_streams; i++) {
1311
        AVStream *st = s->streams[i];
1312

    
1313
        st->cur_dts = av_rescale(timestamp,
1314
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1315
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1316
    }
1317
}
1318

    
1319
void ff_reduce_index(AVFormatContext *s, int stream_index)
1320
{
1321
    AVStream *st= s->streams[stream_index];
1322
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1323

    
1324
    if((unsigned)st->nb_index_entries >= max_entries){
1325
        int i;
1326
        for(i=0; 2*i<st->nb_index_entries; i++)
1327
            st->index_entries[i]= st->index_entries[2*i];
1328
        st->nb_index_entries= i;
1329
    }
1330
}
1331

    
1332
int ff_add_index_entry(AVIndexEntry **index_entries,
1333
                       int *nb_index_entries,
1334
                       unsigned int *index_entries_allocated_size,
1335
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1336
{
1337
    AVIndexEntry *entries, *ie;
1338
    int index;
1339

    
1340
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1341
        return -1;
1342

    
1343
    entries = av_fast_realloc(*index_entries,
1344
                              index_entries_allocated_size,
1345
                              (*nb_index_entries + 1) *
1346
                              sizeof(AVIndexEntry));
1347
    if(!entries)
1348
        return -1;
1349

    
1350
    *index_entries= entries;
1351

    
1352
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1353

    
1354
    if(index<0){
1355
        index= (*nb_index_entries)++;
1356
        ie= &entries[index];
1357
        assert(index==0 || ie[-1].timestamp < timestamp);
1358
    }else{
1359
        ie= &entries[index];
1360
        if(ie->timestamp != timestamp){
1361
            if(ie->timestamp <= timestamp)
1362
                return -1;
1363
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1364
            (*nb_index_entries)++;
1365
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1366
            distance= ie->min_distance;
1367
    }
1368

    
1369
    ie->pos = pos;
1370
    ie->timestamp = timestamp;
1371
    ie->min_distance= distance;
1372
    ie->size= size;
1373
    ie->flags = flags;
1374

    
1375
    return index;
1376
}
1377

    
1378
int av_add_index_entry(AVStream *st,
1379
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1380
{
1381
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1382
                              &st->index_entries_allocated_size, pos,
1383
                              timestamp, size, distance, flags);
1384
}
1385

    
1386
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1387
                              int64_t wanted_timestamp, int flags)
1388
{
1389
    int a, b, m;
1390
    int64_t timestamp;
1391

    
1392
    a = - 1;
1393
    b = nb_entries;
1394

    
1395
    //optimize appending index entries at the end
1396
    if(b && entries[b-1].timestamp < wanted_timestamp)
1397
        a= b-1;
1398

    
1399
    while (b - a > 1) {
1400
        m = (a + b) >> 1;
1401
        timestamp = entries[m].timestamp;
1402
        if(timestamp >= wanted_timestamp)
1403
            b = m;
1404
        if(timestamp <= wanted_timestamp)
1405
            a = m;
1406
    }
1407
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1408

    
1409
    if(!(flags & AVSEEK_FLAG_ANY)){
1410
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1411
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1412
        }
1413
    }
1414

    
1415
    if(m == nb_entries)
1416
        return -1;
1417
    return  m;
1418
}
1419

    
1420
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1421
                              int flags)
1422
{
1423
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1424
                                     wanted_timestamp, flags);
1425
}
1426

    
1427
#define DEBUG_SEEK
1428

    
1429
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1430
    AVInputFormat *avif= s->iformat;
1431
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1432
    int64_t ts_min, ts_max, ts;
1433
    int index;
1434
    int64_t ret;
1435
    AVStream *st;
1436

    
1437
    if (stream_index < 0)
1438
        return -1;
1439

    
1440
#ifdef DEBUG_SEEK
1441
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1442
#endif
1443

    
1444
    ts_max=
1445
    ts_min= AV_NOPTS_VALUE;
1446
    pos_limit= -1; //gcc falsely says it may be uninitialized
1447

    
1448
    st= s->streams[stream_index];
1449
    if(st->index_entries){
1450
        AVIndexEntry *e;
1451

    
1452
        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()
1453
        index= FFMAX(index, 0);
1454
        e= &st->index_entries[index];
1455

    
1456
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1457
            pos_min= e->pos;
1458
            ts_min= e->timestamp;
1459
#ifdef DEBUG_SEEK
1460
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1461
                   pos_min,ts_min);
1462
#endif
1463
        }else{
1464
            assert(index==0);
1465
        }
1466

    
1467
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1468
        assert(index < st->nb_index_entries);
1469
        if(index >= 0){
1470
            e= &st->index_entries[index];
1471
            assert(e->timestamp >= target_ts);
1472
            pos_max= e->pos;
1473
            ts_max= e->timestamp;
1474
            pos_limit= pos_max - e->min_distance;
1475
#ifdef DEBUG_SEEK
1476
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1477
                   pos_max,pos_limit, ts_max);
1478
#endif
1479
        }
1480
    }
1481

    
1482
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1483
    if(pos<0)
1484
        return -1;
1485

    
1486
    /* do the seek */
1487
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1488
        return ret;
1489

    
1490
    av_update_cur_dts(s, st, ts);
1491

    
1492
    return 0;
1493
}
1494

    
1495
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 )){
1496
    int64_t pos, ts;
1497
    int64_t start_pos, filesize;
1498
    int no_change;
1499

    
1500
#ifdef DEBUG_SEEK
1501
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1502
#endif
1503

    
1504
    if(ts_min == AV_NOPTS_VALUE){
1505
        pos_min = s->data_offset;
1506
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1507
        if (ts_min == AV_NOPTS_VALUE)
1508
            return -1;
1509
    }
1510

    
1511
    if(ts_max == AV_NOPTS_VALUE){
1512
        int step= 1024;
1513
        filesize = avio_size(s->pb);
1514
        pos_max = filesize - 1;
1515
        do{
1516
            pos_max -= step;
1517
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1518
            step += step;
1519
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1520
        if (ts_max == AV_NOPTS_VALUE)
1521
            return -1;
1522

    
1523
        for(;;){
1524
            int64_t tmp_pos= pos_max + 1;
1525
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1526
            if(tmp_ts == AV_NOPTS_VALUE)
1527
                break;
1528
            ts_max= tmp_ts;
1529
            pos_max= tmp_pos;
1530
            if(tmp_pos >= filesize)
1531
                break;
1532
        }
1533
        pos_limit= pos_max;
1534
    }
1535

    
1536
    if(ts_min > ts_max){
1537
        return -1;
1538
    }else if(ts_min == ts_max){
1539
        pos_limit= pos_min;
1540
    }
1541

    
1542
    no_change=0;
1543
    while (pos_min < pos_limit) {
1544
#ifdef DEBUG_SEEK
1545
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1546
               pos_min, pos_max,
1547
               ts_min, ts_max);
1548
#endif
1549
        assert(pos_limit <= pos_max);
1550

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

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

    
1596
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1597
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1598
#ifdef DEBUG_SEEK
1599
    pos_min = pos;
1600
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1601
    pos_min++;
1602
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1603
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1604
           pos, ts_min, target_ts, ts_max);
1605
#endif
1606
    *ts_ret= ts;
1607
    return pos;
1608
}
1609

    
1610
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1611
    int64_t pos_min, pos_max;
1612
#if 0
1613
    AVStream *st;
1614

1615
    if (stream_index < 0)
1616
        return -1;
1617

1618
    st= s->streams[stream_index];
1619
#endif
1620

    
1621
    pos_min = s->data_offset;
1622
    pos_max = avio_size(s->pb) - 1;
1623

    
1624
    if     (pos < pos_min) pos= pos_min;
1625
    else if(pos > pos_max) pos= pos_max;
1626

    
1627
    avio_seek(s->pb, pos, SEEK_SET);
1628

    
1629
#if 0
1630
    av_update_cur_dts(s, st, ts);
1631
#endif
1632
    return 0;
1633
}
1634

    
1635
static int av_seek_frame_generic(AVFormatContext *s,
1636
                                 int stream_index, int64_t timestamp, int flags)
1637
{
1638
    int index;
1639
    int64_t ret;
1640
    AVStream *st;
1641
    AVIndexEntry *ie;
1642

    
1643
    st = s->streams[stream_index];
1644

    
1645
    index = av_index_search_timestamp(st, timestamp, flags);
1646

    
1647
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1648
        return -1;
1649

    
1650
    if(index < 0 || index==st->nb_index_entries-1){
1651
        int i;
1652
        AVPacket pkt;
1653

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

    
1682
    ff_read_frame_flush(s);
1683
    if (s->iformat->read_seek){
1684
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1685
            return 0;
1686
    }
1687
    ie = &st->index_entries[index];
1688
    if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1689
        return ret;
1690
    av_update_cur_dts(s, st, ie->timestamp);
1691

    
1692
    return 0;
1693
}
1694

    
1695
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1696
{
1697
    int ret;
1698
    AVStream *st;
1699

    
1700
    ff_read_frame_flush(s);
1701

    
1702
    if(flags & AVSEEK_FLAG_BYTE)
1703
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1704

    
1705
    if(stream_index < 0){
1706
        stream_index= av_find_default_stream_index(s);
1707
        if(stream_index < 0)
1708
            return -1;
1709

    
1710
        st= s->streams[stream_index];
1711
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1712
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1713
    }
1714

    
1715
    /* first, we try the format specific seek */
1716
    if (s->iformat->read_seek)
1717
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1718
    else
1719
        ret = -1;
1720
    if (ret >= 0) {
1721
        return 0;
1722
    }
1723

    
1724
    if(s->iformat->read_timestamp)
1725
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1726
    else
1727
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1728
}
1729

    
1730
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1731
{
1732
    if(min_ts > ts || max_ts < ts)
1733
        return -1;
1734

    
1735
    ff_read_frame_flush(s);
1736

    
1737
    if (s->iformat->read_seek2)
1738
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1739

    
1740
    if(s->iformat->read_timestamp){
1741
        //try to seek via read_timestamp()
1742
    }
1743

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

    
1749
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1750
}
1751

    
1752
/*******************************************************/
1753

    
1754
/**
1755
 * Return TRUE if the stream has accurate duration in any stream.
1756
 *
1757
 * @return TRUE if the stream has accurate duration for at least one component.
1758
 */
1759
static int av_has_duration(AVFormatContext *ic)
1760
{
1761
    int i;
1762
    AVStream *st;
1763

    
1764
    for(i = 0;i < ic->nb_streams; i++) {
1765
        st = ic->streams[i];
1766
        if (st->duration != AV_NOPTS_VALUE)
1767
            return 1;
1768
    }
1769
    return 0;
1770
}
1771

    
1772
/**
1773
 * Estimate the stream timings from the one of each components.
1774
 *
1775
 * Also computes the global bitrate if possible.
1776
 */
1777
static void av_update_stream_timings(AVFormatContext *ic)
1778
{
1779
    int64_t start_time, start_time1, end_time, end_time1;
1780
    int64_t duration, duration1;
1781
    int i;
1782
    AVStream *st;
1783

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

    
1823
static void fill_all_stream_timings(AVFormatContext *ic)
1824
{
1825
    int i;
1826
    AVStream *st;
1827

    
1828
    av_update_stream_timings(ic);
1829
    for(i = 0;i < ic->nb_streams; i++) {
1830
        st = ic->streams[i];
1831
        if (st->start_time == AV_NOPTS_VALUE) {
1832
            if(ic->start_time != AV_NOPTS_VALUE)
1833
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1834
            if(ic->duration != AV_NOPTS_VALUE)
1835
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1836
        }
1837
    }
1838
}
1839

    
1840
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1841
{
1842
    int64_t filesize, duration;
1843
    int bit_rate, i;
1844
    AVStream *st;
1845

    
1846
    /* if bit_rate is already set, we believe it */
1847
    if (ic->bit_rate <= 0) {
1848
        bit_rate = 0;
1849
        for(i=0;i<ic->nb_streams;i++) {
1850
            st = ic->streams[i];
1851
            if (st->codec->bit_rate > 0)
1852
            bit_rate += st->codec->bit_rate;
1853
        }
1854
        ic->bit_rate = bit_rate;
1855
    }
1856

    
1857
    /* if duration is already set, we believe it */
1858
    if (ic->duration == AV_NOPTS_VALUE &&
1859
        ic->bit_rate != 0 &&
1860
        ic->file_size != 0)  {
1861
        filesize = ic->file_size;
1862
        if (filesize > 0) {
1863
            for(i = 0; i < ic->nb_streams; i++) {
1864
                st = ic->streams[i];
1865
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1866
                if (st->duration == AV_NOPTS_VALUE)
1867
                    st->duration = duration;
1868
            }
1869
        }
1870
    }
1871
}
1872

    
1873
#define DURATION_MAX_READ_SIZE 250000
1874
#define DURATION_MAX_RETRY 3
1875

    
1876
/* only usable for MPEG-PS streams */
1877
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1878
{
1879
    AVPacket pkt1, *pkt = &pkt1;
1880
    AVStream *st;
1881
    int read_size, i, ret;
1882
    int64_t end_time;
1883
    int64_t filesize, offset, duration;
1884
    int retry=0;
1885

    
1886
    ic->cur_st = NULL;
1887

    
1888
    /* flush packet queue */
1889
    flush_packet_queue(ic);
1890

    
1891
    for (i=0; i<ic->nb_streams; i++) {
1892
        st = ic->streams[i];
1893
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1894
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1895

    
1896
        if (st->parser) {
1897
            av_parser_close(st->parser);
1898
            st->parser= NULL;
1899
            av_free_packet(&st->cur_pkt);
1900
        }
1901
    }
1902

    
1903
    /* estimate the end time (duration) */
1904
    /* XXX: may need to support wrapping */
1905
    filesize = ic->file_size;
1906
    end_time = AV_NOPTS_VALUE;
1907
    do{
1908
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1909
    if (offset < 0)
1910
        offset = 0;
1911

    
1912
    avio_seek(ic->pb, offset, SEEK_SET);
1913
    read_size = 0;
1914
    for(;;) {
1915
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1916
            break;
1917

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

    
1945
    fill_all_stream_timings(ic);
1946

    
1947
    avio_seek(ic->pb, old_offset, SEEK_SET);
1948
    for (i=0; i<ic->nb_streams; i++) {
1949
        st= ic->streams[i];
1950
        st->cur_dts= st->first_dts;
1951
        st->last_IP_pts = AV_NOPTS_VALUE;
1952
        st->reference_dts = AV_NOPTS_VALUE;
1953
    }
1954
}
1955

    
1956
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1957
{
1958
    int64_t file_size;
1959

    
1960
    /* get the file size, if possible */
1961
    if (ic->iformat->flags & AVFMT_NOFILE) {
1962
        file_size = 0;
1963
    } else {
1964
        file_size = avio_size(ic->pb);
1965
        if (file_size < 0)
1966
            file_size = 0;
1967
    }
1968
    ic->file_size = file_size;
1969

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

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

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

    
2030
static int has_decode_delay_been_guessed(AVStream *st)
2031
{
2032
    return st->codec->codec_id != CODEC_ID_H264 ||
2033
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2034
}
2035

    
2036
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2037
{
2038
    int16_t *samples;
2039
    AVCodec *codec;
2040
    int got_picture, data_size, ret=0;
2041
    AVFrame picture;
2042

    
2043
    if(!st->codec->codec){
2044
        codec = avcodec_find_decoder(st->codec->codec_id);
2045
        if (!codec)
2046
            return -1;
2047
        ret = avcodec_open(st->codec, codec);
2048
        if (ret < 0)
2049
            return ret;
2050
    }
2051

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

    
2076
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2077
{
2078
    while (tags->id != CODEC_ID_NONE) {
2079
        if (tags->id == id)
2080
            return tags->tag;
2081
        tags++;
2082
    }
2083
    return 0;
2084
}
2085

    
2086
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2087
{
2088
    int i;
2089
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2090
        if(tag == tags[i].tag)
2091
            return tags[i].id;
2092
    }
2093
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2094
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2095
            return tags[i].id;
2096
    }
2097
    return CODEC_ID_NONE;
2098
}
2099

    
2100
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2101
{
2102
    int i;
2103
    for(i=0; tags && tags[i]; i++){
2104
        int tag= ff_codec_get_tag(tags[i], id);
2105
        if(tag) return tag;
2106
    }
2107
    return 0;
2108
}
2109

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

    
2120
static void compute_chapters_end(AVFormatContext *s)
2121
{
2122
    unsigned int i, j;
2123
    int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2124

    
2125
    for (i = 0; i < s->nb_chapters; i++)
2126
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2127
            AVChapter *ch = s->chapters[i];
2128
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2129
                                     : INT64_MAX;
2130

    
2131
            for (j = 0; j < s->nb_chapters; j++) {
2132
                AVChapter *ch1 = s->chapters[j];
2133
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2134
                if (j != i && next_start > ch->start && next_start < end)
2135
                    end = next_start;
2136
            }
2137
            ch->end = (end == INT64_MAX) ? ch->start : end;
2138
        }
2139
}
2140

    
2141
static int get_std_framerate(int i){
2142
    if(i<60*12) return i*1001;
2143
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2144
}
2145

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

    
2166
int av_find_stream_info(AVFormatContext *ic)
2167
{
2168
    int i, count, ret, read_size, j;
2169
    AVStream *st;
2170
    AVPacket pkt1, *pkt;
2171
    int64_t old_offset = avio_tell(ic->pb);
2172

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

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

    
2205
        /* Ensure that subtitle_header is properly set. */
2206
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2207
            && codec && !st->codec->codec)
2208
            avcodec_open(st->codec, codec);
2209

    
2210
        //try to just open decoders, in case this is enough to get parameters
2211
        if(!has_codec_parameters(st->codec)){
2212
            if (codec && !st->codec->codec)
2213
                avcodec_open(st->codec, codec);
2214
        }
2215
    }
2216

    
2217
    for (i=0; i<ic->nb_streams; i++) {
2218
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2219
    }
2220

    
2221
    count = 0;
2222
    read_size = 0;
2223
    for(;;) {
2224
        if(url_interrupt_cb()){
2225
            ret= AVERROR_EXIT;
2226
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2227
            break;
2228
        }
2229

    
2230
        /* check if one codec still needs to be handled */
2231
        for(i=0;i<ic->nb_streams;i++) {
2232
            int fps_analyze_framecount = 20;
2233

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

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

    
2289
        if (ret == AVERROR(EAGAIN))
2290
            continue;
2291

    
2292
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2293
        if ((ret = av_dup_packet(pkt)) < 0)
2294
            goto find_stream_info_err;
2295

    
2296
        read_size += pkt->size;
2297

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

    
2310
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2311
                double dur= duration * av_q2d(st->time_base);
2312

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

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

    
2348
        st->codec_info_nb_frames++;
2349
        count++;
2350
    }
2351

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

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

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

    
2398
            if (!st->r_frame_rate.num){
2399
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2400
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2401
                    st->r_frame_rate.num = st->codec->time_base.den;
2402
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2403
                }else{
2404
                    st->r_frame_rate.num = st->time_base.den;
2405
                    st->r_frame_rate.den = st->time_base.num;
2406
                }
2407
            }
2408
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2409
            if(!st->codec->bits_per_coded_sample)
2410
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2411
            // set stream disposition based on audio service type
2412
            switch (st->codec->audio_service_type) {
2413
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2414
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2415
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2416
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2417
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2418
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2419
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2420
                st->disposition = AV_DISPOSITION_COMMENT;          break;
2421
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2422
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
2423
            }
2424
        }
2425
    }
2426

    
2427
    av_estimate_timings(ic, old_offset);
2428

    
2429
    compute_chapters_end(ic);
2430

    
2431
#if 0
2432
    /* correct DTS for B-frame streams with no timestamps */
2433
    for(i=0;i<ic->nb_streams;i++) {
2434
        st = ic->streams[i];
2435
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2436
            if(b-frames){
2437
                ppktl = &ic->packet_buffer;
2438
                while(ppkt1){
2439
                    if(ppkt1->stream_index != i)
2440
                        continue;
2441
                    if(ppkt1->pkt->dts < 0)
2442
                        break;
2443
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2444
                        break;
2445
                    ppkt1->pkt->dts -= delta;
2446
                    ppkt1= ppkt1->next;
2447
                }
2448
                if(ppkt1)
2449
                    continue;
2450
                st->cur_dts -= delta;
2451
            }
2452
        }
2453
    }
2454
#endif
2455

    
2456
 find_stream_info_err:
2457
    for (i=0; i < ic->nb_streams; i++)
2458
        av_freep(&ic->streams[i]->info);
2459
    return ret;
2460
}
2461

    
2462
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2463
{
2464
    int i, j;
2465

    
2466
    for (i = 0; i < ic->nb_programs; i++)
2467
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2468
            if (ic->programs[i]->stream_index[j] == s)
2469
                return ic->programs[i];
2470
    return NULL;
2471
}
2472

    
2473
int av_find_best_stream(AVFormatContext *ic,
2474
                        enum AVMediaType type,
2475
                        int wanted_stream_nb,
2476
                        int related_stream,
2477
                        AVCodec **decoder_ret,
2478
                        int flags)
2479
{
2480
    int i, nb_streams = ic->nb_streams;
2481
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2482
    unsigned *program = NULL;
2483
    AVCodec *decoder = NULL, *best_decoder = NULL;
2484

    
2485
    if (related_stream >= 0 && wanted_stream_nb < 0) {
2486
        AVProgram *p = find_program_from_stream(ic, related_stream);
2487
        if (p) {
2488
            program = p->stream_index;
2489
            nb_streams = p->nb_stream_indexes;
2490
        }
2491
    }
2492
    for (i = 0; i < nb_streams; i++) {
2493
        int real_stream_index = program ? program[i] : i;
2494
        AVStream *st = ic->streams[real_stream_index];
2495
        AVCodecContext *avctx = st->codec;
2496
        if (avctx->codec_type != type)
2497
            continue;
2498
        if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2499
            continue;
2500
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2501
            continue;
2502
        if (decoder_ret) {
2503
            decoder = avcodec_find_decoder(st->codec->codec_id);
2504
            if (!decoder) {
2505
                if (ret < 0)
2506
                    ret = AVERROR_DECODER_NOT_FOUND;
2507
                continue;
2508
            }
2509
        }
2510
        if (best_count >= st->codec_info_nb_frames)
2511
            continue;
2512
        best_count = st->codec_info_nb_frames;
2513
        ret = real_stream_index;
2514
        best_decoder = decoder;
2515
        if (program && i == nb_streams - 1 && ret < 0) {
2516
            program = NULL;
2517
            nb_streams = ic->nb_streams;
2518
            i = 0; /* no related stream found, try again with everything */
2519
        }
2520
    }
2521
    if (decoder_ret)
2522
        *decoder_ret = best_decoder;
2523
    return ret;
2524
}
2525

    
2526
/*******************************************************/
2527

    
2528
int av_read_play(AVFormatContext *s)
2529
{
2530
    if (s->iformat->read_play)
2531
        return s->iformat->read_play(s);
2532
    if (s->pb)
2533
        return avio_pause(s->pb, 0);
2534
    return AVERROR(ENOSYS);
2535
}
2536

    
2537
int av_read_pause(AVFormatContext *s)
2538
{
2539
    if (s->iformat->read_pause)
2540
        return s->iformat->read_pause(s);
2541
    if (s->pb)
2542
        return avio_pause(s->pb, 1);
2543
    return AVERROR(ENOSYS);
2544
}
2545

    
2546
void av_close_input_stream(AVFormatContext *s)
2547
{
2548
    flush_packet_queue(s);
2549
    if (s->iformat->read_close)
2550
        s->iformat->read_close(s);
2551
    avformat_free_context(s);
2552
}
2553

    
2554
void avformat_free_context(AVFormatContext *s)
2555
{
2556
    int i;
2557
    AVStream *st;
2558

    
2559
    for(i=0;i<s->nb_streams;i++) {
2560
        /* free all data in a stream component */
2561
        st = s->streams[i];
2562
        if (st->parser) {
2563
            av_parser_close(st->parser);
2564
            av_free_packet(&st->cur_pkt);
2565
        }
2566
        av_metadata_free(&st->metadata);
2567
        av_free(st->index_entries);
2568
        av_free(st->codec->extradata);
2569
        av_free(st->codec->subtitle_header);
2570
        av_free(st->codec);
2571
        av_free(st->priv_data);
2572
        av_free(st->info);
2573
        av_free(st);
2574
    }
2575
    for(i=s->nb_programs-1; i>=0; i--) {
2576
        av_metadata_free(&s->programs[i]->metadata);
2577
        av_freep(&s->programs[i]->stream_index);
2578
        av_freep(&s->programs[i]);
2579
    }
2580
    av_freep(&s->programs);
2581
    av_freep(&s->priv_data);
2582
    while(s->nb_chapters--) {
2583
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2584
        av_free(s->chapters[s->nb_chapters]);
2585
    }
2586
    av_freep(&s->chapters);
2587
    av_metadata_free(&s->metadata);
2588
    av_freep(&s->key);
2589
    av_freep(&s->streams);
2590
    av_free(s);
2591
}
2592

    
2593
void av_close_input_file(AVFormatContext *s)
2594
{
2595
    AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2596
    av_close_input_stream(s);
2597
    if (pb)
2598
        avio_close(pb);
2599
}
2600

    
2601
AVStream *av_new_stream(AVFormatContext *s, int id)
2602
{
2603
    AVStream *st;
2604
    int i;
2605
    AVStream **streams;
2606

    
2607
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
2608
        return NULL;
2609
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2610
    if (!streams)
2611
        return NULL;
2612
    s->streams = streams;
2613

    
2614
    st = av_mallocz(sizeof(AVStream));
2615
    if (!st)
2616
        return NULL;
2617
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2618
        av_free(st);
2619
        return NULL;
2620
    }
2621

    
2622
    st->codec= avcodec_alloc_context();
2623
    if (s->iformat) {
2624
        /* no default bitrate if decoding */
2625
        st->codec->bit_rate = 0;
2626
    }
2627
    st->index = s->nb_streams;
2628
    st->id = id;
2629
    st->start_time = AV_NOPTS_VALUE;
2630
    st->duration = AV_NOPTS_VALUE;
2631
        /* we set the current DTS to 0 so that formats without any timestamps
2632
           but durations get some timestamps, formats with some unknown
2633
           timestamps have their first few packets buffered and the
2634
           timestamps corrected before they are returned to the user */
2635
    st->cur_dts = 0;
2636
    st->first_dts = AV_NOPTS_VALUE;
2637
    st->probe_packets = MAX_PROBE_PACKETS;
2638

    
2639
    /* default pts setting is MPEG-like */
2640
    av_set_pts_info(st, 33, 1, 90000);
2641
    st->last_IP_pts = AV_NOPTS_VALUE;
2642
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2643
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2644
    st->reference_dts = AV_NOPTS_VALUE;
2645

    
2646
    st->sample_aspect_ratio = (AVRational){0,1};
2647

    
2648
    s->streams[s->nb_streams++] = st;
2649
    return st;
2650
}
2651

    
2652
AVProgram *av_new_program(AVFormatContext *ac, int id)
2653
{
2654
    AVProgram *program=NULL;
2655
    int i;
2656

    
2657
#ifdef DEBUG_SI
2658
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2659
#endif
2660

    
2661
    for(i=0; i<ac->nb_programs; i++)
2662
        if(ac->programs[i]->id == id)
2663
            program = ac->programs[i];
2664

    
2665
    if(!program){
2666
        program = av_mallocz(sizeof(AVProgram));
2667
        if (!program)
2668
            return NULL;
2669
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2670
        program->discard = AVDISCARD_NONE;
2671
    }
2672
    program->id = id;
2673

    
2674
    return program;
2675
}
2676

    
2677
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2678
{
2679
    AVChapter *chapter = NULL;
2680
    int i;
2681

    
2682
    for(i=0; i<s->nb_chapters; i++)
2683
        if(s->chapters[i]->id == id)
2684
            chapter = s->chapters[i];
2685

    
2686
    if(!chapter){
2687
        chapter= av_mallocz(sizeof(AVChapter));
2688
        if(!chapter)
2689
            return NULL;
2690
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2691
    }
2692
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2693
    chapter->id    = id;
2694
    chapter->time_base= time_base;
2695
    chapter->start = start;
2696
    chapter->end   = end;
2697

    
2698
    return chapter;
2699
}
2700

    
2701
/************************************************************/
2702
/* output media file */
2703

    
2704
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2705
{
2706
    int ret;
2707

    
2708
    if (s->oformat->priv_data_size > 0) {
2709
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2710
        if (!s->priv_data)
2711
            return AVERROR(ENOMEM);
2712
        if (s->oformat->priv_class) {
2713
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2714
            av_opt_set_defaults(s->priv_data);
2715
        }
2716
    } else
2717
        s->priv_data = NULL;
2718

    
2719
    return 0;
2720
}
2721

    
2722
AVFormatContext *avformat_alloc_output_context(const char *format, AVOutputFormat *oformat, const char *filename){
2723
    AVFormatContext *s= avformat_alloc_context();
2724
    if(!s)
2725
        goto nomem;
2726

    
2727
    if(!oformat){
2728
        if (format) {
2729
            oformat = av_guess_format(format, NULL, NULL);
2730
            if (!oformat) {
2731
                av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2732
                goto error;
2733
            }
2734
        } else {
2735
            oformat = av_guess_format(NULL, filename, NULL);
2736
            if (!oformat) {
2737
                av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2738
                        filename);
2739
                goto error;
2740
            }
2741
        }
2742
    }
2743

    
2744
    s->oformat= oformat;
2745
    if (s->oformat->priv_data_size > 0) {
2746
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2747
        if (!s->priv_data)
2748
            goto nomem;
2749
        if (s->oformat->priv_class) {
2750
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
2751
            av_opt_set_defaults(s->priv_data);
2752
        }
2753
    } else
2754
        s->priv_data = NULL;
2755

    
2756
    if(filename)
2757
        av_strlcpy(s->filename, filename, sizeof(s->filename));
2758
    return s;
2759
nomem:
2760
    av_log(s, AV_LOG_ERROR, "Out of memory\n");
2761
error:
2762
    avformat_free_context(s);
2763
    return NULL;
2764
}
2765

    
2766
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2767
{
2768
    const AVCodecTag *avctag;
2769
    int n;
2770
    enum CodecID id = CODEC_ID_NONE;
2771
    unsigned int tag = 0;
2772

    
2773
    /**
2774
     * Check that tag + id is in the table
2775
     * If neither is in the table -> OK
2776
     * If tag is in the table with another id -> FAIL
2777
     * If id is in the table with another tag -> FAIL unless strict < normal
2778
     */
2779
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2780
        avctag = s->oformat->codec_tag[n];
2781
        while (avctag->id != CODEC_ID_NONE) {
2782
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2783
                id = avctag->id;
2784
                if (id == st->codec->codec_id)
2785
                    return 1;
2786
            }
2787
            if (avctag->id == st->codec->codec_id)
2788
                tag = avctag->tag;
2789
            avctag++;
2790
        }
2791
    }
2792
    if (id != CODEC_ID_NONE)
2793
        return 0;
2794
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2795
        return 0;
2796
    return 1;
2797
}
2798

    
2799
int av_write_header(AVFormatContext *s)
2800
{
2801
    int ret, i;
2802
    AVStream *st;
2803

    
2804
    // some sanity checks
2805
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2806
        av_log(s, AV_LOG_ERROR, "no streams\n");
2807
        return AVERROR(EINVAL);
2808
    }
2809

    
2810
    for(i=0;i<s->nb_streams;i++) {
2811
        st = s->streams[i];
2812

    
2813
        switch (st->codec->codec_type) {
2814
        case AVMEDIA_TYPE_AUDIO:
2815
            if(st->codec->sample_rate<=0){
2816
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2817
                return AVERROR(EINVAL);
2818
            }
2819
            if(!st->codec->block_align)
2820
                st->codec->block_align = st->codec->channels *
2821
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2822
            break;
2823
        case AVMEDIA_TYPE_VIDEO:
2824
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2825
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2826
                return AVERROR(EINVAL);
2827
            }
2828
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2829
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2830
                return AVERROR(EINVAL);
2831
            }
2832
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2833
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2834
                return AVERROR(EINVAL);
2835
            }
2836
            break;
2837
        }
2838

    
2839
        if(s->oformat->codec_tag){
2840
            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)){
2841
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2842
                st->codec->codec_tag= 0;
2843
            }
2844
            if(st->codec->codec_tag){
2845
                if (!validate_codec_tag(s, st)) {
2846
                    char tagbuf[32];
2847
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2848
                    av_log(s, AV_LOG_ERROR,
2849
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2850
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2851
                    return AVERROR_INVALIDDATA;
2852
                }
2853
            }else
2854
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2855
        }
2856

    
2857
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2858
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2859
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2860
    }
2861

    
2862
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2863
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2864
        if (!s->priv_data)
2865
            return AVERROR(ENOMEM);
2866
    }
2867

    
2868
    /* set muxer identification string */
2869
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2870
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2871
    }
2872

    
2873
    if(s->oformat->write_header){
2874
        ret = s->oformat->write_header(s);
2875
        if (ret < 0)
2876
            return ret;
2877
    }
2878

    
2879
    /* init PTS generation */
2880
    for(i=0;i<s->nb_streams;i++) {
2881
        int64_t den = AV_NOPTS_VALUE;
2882
        st = s->streams[i];
2883

    
2884
        switch (st->codec->codec_type) {
2885
        case AVMEDIA_TYPE_AUDIO:
2886
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2887
            break;
2888
        case AVMEDIA_TYPE_VIDEO:
2889
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2890
            break;
2891
        default:
2892
            break;
2893
        }
2894
        if (den != AV_NOPTS_VALUE) {
2895
            if (den <= 0)
2896
                return AVERROR_INVALIDDATA;
2897
            av_frac_init(&st->pts, 0, 0, den);
2898
        }
2899
    }
2900
    return 0;
2901
}
2902

    
2903
//FIXME merge with compute_pkt_fields
2904
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2905
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2906
    int num, den, frame_size, i;
2907

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

    
2911
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2912
        return AVERROR(EINVAL);*/
2913

    
2914
    /* duration field */
2915
    if (pkt->duration == 0) {
2916
        compute_frame_duration(&num, &den, st, NULL, pkt);
2917
        if (den && num) {
2918
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2919
        }
2920
    }
2921

    
2922
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2923
        pkt->pts= pkt->dts;
2924

    
2925
    //XXX/FIXME this is a temporary hack until all encoders output pts
2926
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2927
        pkt->dts=
2928
//        pkt->pts= st->cur_dts;
2929
        pkt->pts= st->pts.val;
2930
    }
2931

    
2932
    //calculate dts from pts
2933
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2934
        st->pts_buffer[0]= pkt->pts;
2935
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2936
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2937
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2938
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2939

    
2940
        pkt->dts= st->pts_buffer[0];
2941
    }
2942

    
2943
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2944
        av_log(s, AV_LOG_ERROR,
2945
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2946
               st->index, st->cur_dts, pkt->dts);
2947
        return AVERROR(EINVAL);
2948
    }
2949
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2950
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2951
        return AVERROR(EINVAL);
2952
    }
2953

    
2954
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2955
    st->cur_dts= pkt->dts;
2956
    st->pts.val= pkt->dts;
2957

    
2958
    /* update pts */
2959
    switch (st->codec->codec_type) {
2960
    case AVMEDIA_TYPE_AUDIO:
2961
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2962

    
2963
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2964
           likely equal to the encoder delay, but it would be better if we
2965
           had the real timestamps from the encoder */
2966
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2967
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2968
        }
2969
        break;
2970
    case AVMEDIA_TYPE_VIDEO:
2971
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2972
        break;
2973
    default:
2974
        break;
2975
    }
2976
    return 0;
2977
}
2978

    
2979
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2980
{
2981
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2982

    
2983
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2984
        return ret;
2985

    
2986
    ret= s->oformat->write_packet(s, pkt);
2987
    if(!ret)
2988
        ret= url_ferror(s->pb);
2989
    return ret;
2990
}
2991

    
2992
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2993
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2994
{
2995
    AVPacketList **next_point, *this_pktl;
2996

    
2997
    this_pktl = av_mallocz(sizeof(AVPacketList));
2998
    this_pktl->pkt= *pkt;
2999
    pkt->destruct= NULL;             // do not free original but only the copy
3000
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3001

    
3002
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3003
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3004
    }else
3005
        next_point = &s->packet_buffer;
3006

    
3007
    if(*next_point){
3008
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3009
            while(!compare(s, &(*next_point)->pkt, pkt)){
3010
                next_point= &(*next_point)->next;
3011
            }
3012
            goto next_non_null;
3013
        }else{
3014
            next_point = &(s->packet_buffer_end->next);
3015
        }
3016
    }
3017
    assert(!*next_point);
3018

    
3019
    s->packet_buffer_end= this_pktl;
3020
next_non_null:
3021

    
3022
    this_pktl->next= *next_point;
3023

    
3024
    s->streams[pkt->stream_index]->last_in_packet_buffer=
3025
    *next_point= this_pktl;
3026
}
3027

    
3028
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3029
{
3030
    AVStream *st = s->streams[ pkt ->stream_index];
3031
    AVStream *st2= s->streams[ next->stream_index];
3032
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3033
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3034
    int64_t dts1 = av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN);
3035
    if (dts1==next->dts && dts1==av_rescale_rnd(pkt->dts, b, a, AV_ROUND_UP))
3036
        return pkt->stream_index < next->stream_index;
3037
    return dts1 < next->dts;
3038
}
3039

    
3040
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3041
    AVPacketList *pktl;
3042
    int stream_count=0;
3043
    int i;
3044

    
3045
    if(pkt){
3046
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3047
    }
3048

    
3049
    for(i=0; i < s->nb_streams; i++)
3050
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3051

    
3052
    if(stream_count && (s->nb_streams == stream_count || flush)){
3053
        pktl= s->packet_buffer;
3054
        *out= pktl->pkt;
3055

    
3056
        s->packet_buffer= pktl->next;
3057
        if(!s->packet_buffer)
3058
            s->packet_buffer_end= NULL;
3059

    
3060
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3061
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3062
        av_freep(&pktl);
3063
        return 1;
3064
    }else{
3065
        av_init_packet(out);
3066
        return 0;
3067
    }
3068
}
3069

    
3070
/**
3071
 * Interleave an AVPacket correctly so it can be muxed.
3072
 * @param out the interleaved packet will be output here
3073
 * @param in the input packet
3074
 * @param flush 1 if no further packets are available as input and all
3075
 *              remaining packets should be output
3076
 * @return 1 if a packet was output, 0 if no packet could be output,
3077
 *         < 0 if an error occurred
3078
 */
3079
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3080
    if(s->oformat->interleave_packet)
3081
        return s->oformat->interleave_packet(s, out, in, flush);
3082
    else
3083
        return av_interleave_packet_per_dts(s, out, in, flush);
3084
}
3085

    
3086
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3087
    AVStream *st= s->streams[ pkt->stream_index];
3088
    int ret;
3089

    
3090
    //FIXME/XXX/HACK drop zero sized packets
3091
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3092
        return 0;
3093

    
3094
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3095
            pkt->size, pkt->dts, pkt->pts);
3096
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3097
        return ret;
3098

    
3099
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3100
        return AVERROR(EINVAL);
3101

    
3102
    for(;;){
3103
        AVPacket opkt;
3104
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3105
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3106
            return ret;
3107

    
3108
        ret= s->oformat->write_packet(s, &opkt);
3109

    
3110
        av_free_packet(&opkt);
3111
        pkt= NULL;
3112

    
3113
        if(ret<0)
3114
            return ret;
3115
        if(url_ferror(s->pb))
3116
            return url_ferror(s->pb);
3117
    }
3118
}
3119

    
3120
int av_write_trailer(AVFormatContext *s)
3121
{
3122
    int ret, i;
3123

    
3124
    for(;;){
3125
        AVPacket pkt;
3126
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3127
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3128
            goto fail;
3129
        if(!ret)
3130
            break;
3131

    
3132
        ret= s->oformat->write_packet(s, &pkt);
3133

    
3134
        av_free_packet(&pkt);
3135

    
3136
        if(ret<0)
3137
            goto fail;
3138
        if(url_ferror(s->pb))
3139
            goto fail;
3140
    }
3141

    
3142
    if(s->oformat->write_trailer)
3143
        ret = s->oformat->write_trailer(s);
3144
fail:
3145
    if(ret == 0)
3146
       ret=url_ferror(s->pb);
3147
    for(i=0;i<s->nb_streams;i++) {
3148
        av_freep(&s->streams[i]->priv_data);
3149
        av_freep(&s->streams[i]->index_entries);
3150
    }
3151
    av_freep(&s->priv_data);
3152
    return ret;
3153
}
3154

    
3155
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3156
{
3157
    int i, j;
3158
    AVProgram *program=NULL;
3159
    void *tmp;
3160

    
3161
    if (idx >= ac->nb_streams) {
3162
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3163
        return;
3164
    }
3165

    
3166
    for(i=0; i<ac->nb_programs; i++){
3167
        if(ac->programs[i]->id != progid)
3168
            continue;
3169
        program = ac->programs[i];
3170
        for(j=0; j<program->nb_stream_indexes; j++)
3171
            if(program->stream_index[j] == idx)
3172
                return;
3173

    
3174
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3175
        if(!tmp)
3176
            return;
3177
        program->stream_index = tmp;
3178
        program->stream_index[program->nb_stream_indexes++] = idx;
3179
        return;
3180
    }
3181
}
3182

    
3183
static void print_fps(double d, const char *postfix){
3184
    uint64_t v= lrintf(d*100);
3185
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3186
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3187
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3188
}
3189

    
3190
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3191
{
3192
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3193
        AVMetadataTag *tag=NULL;
3194

    
3195
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3196
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3197
            if(strcmp("language", tag->key))
3198
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3199
        }
3200
    }
3201
}
3202

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

    
3266
#if FF_API_DUMP_FORMAT
3267
void dump_format(AVFormatContext *ic,
3268
                 int index,
3269
                 const char *url,
3270
                 int is_output)
3271
{
3272
    av_dump_format(ic, index, url, is_output);
3273
}
3274
#endif
3275

    
3276
void av_dump_format(AVFormatContext *ic,
3277
                    int index,
3278
                    const char *url,
3279
                    int is_output)
3280
{
3281
    int i;
3282
    uint8_t *printed = av_mallocz(ic->nb_streams);
3283
    if (ic->nb_streams && !printed)
3284
        return;
3285

    
3286
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3287
            is_output ? "Output" : "Input",
3288
            index,
3289
            is_output ? ic->oformat->name : ic->iformat->name,
3290
            is_output ? "to" : "from", url);
3291
    dump_metadata(NULL, ic->metadata, "  ");
3292
    if (!is_output) {
3293
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3294
        if (ic->duration != AV_NOPTS_VALUE) {
3295
            int hours, mins, secs, us;
3296
            secs = ic->duration / AV_TIME_BASE;
3297
            us = ic->duration % AV_TIME_BASE;
3298
            mins = secs / 60;
3299
            secs %= 60;
3300
            hours = mins / 60;
3301
            mins %= 60;
3302
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3303
                   (100 * us) / AV_TIME_BASE);
3304
        } else {
3305
            av_log(NULL, AV_LOG_INFO, "N/A");
3306
        }
3307
        if (ic->start_time != AV_NOPTS_VALUE) {
3308
            int secs, us;
3309
            av_log(NULL, AV_LOG_INFO, ", start: ");
3310
            secs = ic->start_time / AV_TIME_BASE;
3311
            us = abs(ic->start_time % AV_TIME_BASE);
3312
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3313
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3314
        }
3315
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3316
        if (ic->bit_rate) {
3317
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3318
        } else {
3319
            av_log(NULL, AV_LOG_INFO, "N/A");
3320
        }
3321
        av_log(NULL, AV_LOG_INFO, "\n");
3322
    }
3323
    for (i = 0; i < ic->nb_chapters; i++) {
3324
        AVChapter *ch = ic->chapters[i];
3325
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3326
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3327
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3328

    
3329
        dump_metadata(NULL, ch->metadata, "    ");
3330
    }
3331
    if(ic->nb_programs) {
3332
        int j, k, total = 0;
3333
        for(j=0; j<ic->nb_programs; j++) {
3334
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3335
                                                  "name", NULL, 0);
3336
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3337
                   name ? name->value : "");
3338
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3339
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3340
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3341
                printed[ic->programs[j]->stream_index[k]] = 1;
3342
            }
3343
            total += ic->programs[j]->nb_stream_indexes;
3344
        }
3345
        if (total < ic->nb_streams)
3346
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3347
    }
3348
    for(i=0;i<ic->nb_streams;i++)
3349
        if (!printed[i])
3350
            dump_stream_format(ic, i, index, is_output);
3351

    
3352
    av_free(printed);
3353
}
3354

    
3355
int64_t av_gettime(void)
3356
{
3357
    struct timeval tv;
3358
    gettimeofday(&tv,NULL);
3359
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3360
}
3361

    
3362
uint64_t ff_ntp_time(void)
3363
{
3364
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3365
}
3366

    
3367
#if FF_API_PARSE_DATE
3368
#include "libavutil/parseutils.h"
3369

    
3370
int64_t parse_date(const char *timestr, int duration)
3371
{
3372
    int64_t timeval;
3373
    av_parse_time(&timeval, timestr, duration);
3374
    return timeval;
3375
}
3376
#endif
3377

    
3378
#if FF_API_FIND_INFO_TAG
3379
#include "libavutil/parseutils.h"
3380

    
3381
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3382
{
3383
    return av_find_info_tag(arg, arg_size, tag1, info);
3384
}
3385
#endif
3386

    
3387
int av_get_frame_filename(char *buf, int buf_size,
3388
                          const char *path, int number)
3389
{
3390
    const char *p;
3391
    char *q, buf1[20], c;
3392
    int nd, len, percentd_found;
3393

    
3394
    q = buf;
3395
    p = path;
3396
    percentd_found = 0;
3397
    for(;;) {
3398
        c = *p++;
3399
        if (c == '\0')
3400
            break;
3401
        if (c == '%') {
3402
            do {
3403
                nd = 0;
3404
                while (isdigit(*p)) {
3405
                    nd = nd * 10 + *p++ - '0';
3406
                }
3407
                c = *p++;
3408
            } while (isdigit(c));
3409

    
3410
            switch(c) {
3411
            case '%':
3412
                goto addchar;
3413
            case 'd':
3414
                if (percentd_found)
3415
                    goto fail;
3416
                percentd_found = 1;
3417
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3418
                len = strlen(buf1);
3419
                if ((q - buf + len) > buf_size - 1)
3420
                    goto fail;
3421
                memcpy(q, buf1, len);
3422
                q += len;
3423
                break;
3424
            default:
3425
                goto fail;
3426
            }
3427
        } else {
3428
        addchar:
3429
            if ((q - buf) < buf_size - 1)
3430
                *q++ = c;
3431
        }
3432
    }
3433
    if (!percentd_found)
3434
        goto fail;
3435
    *q = '\0';
3436
    return 0;
3437
 fail:
3438
    *q = '\0';
3439
    return -1;
3440
}
3441

    
3442
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3443
{
3444
    int len, i, j, c;
3445
#undef fprintf
3446
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3447

    
3448
    for(i=0;i<size;i+=16) {
3449
        len = size - i;
3450
        if (len > 16)
3451
            len = 16;
3452
        PRINT("%08x ", i);
3453
        for(j=0;j<16;j++) {
3454
            if (j < len)
3455
                PRINT(" %02x", buf[i+j]);
3456
            else
3457
                PRINT("   ");
3458
        }
3459
        PRINT(" ");
3460
        for(j=0;j<len;j++) {
3461
            c = buf[i+j];
3462
            if (c < ' ' || c > '~')
3463
                c = '.';
3464
            PRINT("%c", c);
3465
        }
3466
        PRINT("\n");
3467
    }
3468
#undef PRINT
3469
}
3470

    
3471
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3472
{
3473
    hex_dump_internal(NULL, f, 0, buf, size);
3474
}
3475

    
3476
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3477
{
3478
    hex_dump_internal(avcl, NULL, level, buf, size);
3479
}
3480

    
3481
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3482
{
3483
#undef fprintf
3484
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3485
    PRINT("stream #%d:\n", pkt->stream_index);
3486
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3487
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3488
    /* DTS is _always_ valid after av_read_frame() */
3489
    PRINT("  dts=");
3490
    if (pkt->dts == AV_NOPTS_VALUE)
3491
        PRINT("N/A");
3492
    else
3493
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3494
    /* PTS may not be known if B-frames are present. */
3495
    PRINT("  pts=");
3496
    if (pkt->pts == AV_NOPTS_VALUE)
3497
        PRINT("N/A");
3498
    else
3499
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3500
    PRINT("\n");
3501
    PRINT("  size=%d\n", pkt->size);
3502
#undef PRINT
3503
    if (dump_payload)
3504
        av_hex_dump(f, pkt->data, pkt->size);
3505
}
3506

    
3507
#if FF_API_PKT_DUMP
3508
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3509
{
3510
    AVRational tb = { 1, AV_TIME_BASE };
3511
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3512
}
3513
#endif
3514

    
3515
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3516
{
3517
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3518
}
3519

    
3520
#if FF_API_PKT_DUMP
3521
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3522
{
3523
    AVRational tb = { 1, AV_TIME_BASE };
3524
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3525
}
3526
#endif
3527

    
3528
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3529
                      AVStream *st)
3530
{
3531
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3532
}
3533

    
3534
void av_url_split(char *proto, int proto_size,
3535
                  char *authorization, int authorization_size,
3536
                  char *hostname, int hostname_size,
3537
                  int *port_ptr,
3538
                  char *path, int path_size,
3539
                  const char *url)
3540
{
3541
    const char *p, *ls, *at, *col, *brk;
3542

    
3543
    if (port_ptr)               *port_ptr = -1;
3544
    if (proto_size > 0)         proto[0] = 0;
3545
    if (authorization_size > 0) authorization[0] = 0;
3546
    if (hostname_size > 0)      hostname[0] = 0;
3547
    if (path_size > 0)          path[0] = 0;
3548

    
3549
    /* parse protocol */
3550
    if ((p = strchr(url, ':'))) {
3551
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3552
        p++; /* skip ':' */
3553
        if (*p == '/') p++;
3554
        if (*p == '/') p++;
3555
    } else {
3556
        /* no protocol means plain filename */
3557
        av_strlcpy(path, url, path_size);
3558
        return;
3559
    }
3560

    
3561
    /* separate path from hostname */
3562
    ls = strchr(p, '/');
3563
    if(!ls)
3564
        ls = strchr(p, '?');
3565
    if(ls)
3566
        av_strlcpy(path, ls, path_size);
3567
    else
3568
        ls = &p[strlen(p)]; // XXX
3569

    
3570
    /* the rest is hostname, use that to parse auth/port */
3571
    if (ls != p) {
3572
        /* authorization (user[:pass]@hostname) */
3573
        if ((at = strchr(p, '@')) && at < ls) {
3574
            av_strlcpy(authorization, p,
3575
                       FFMIN(authorization_size, at + 1 - p));
3576
            p = at + 1; /* skip '@' */
3577
        }
3578

    
3579
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3580
            /* [host]:port */
3581
            av_strlcpy(hostname, p + 1,
3582
                       FFMIN(hostname_size, brk - p));
3583
            if (brk[1] == ':' && port_ptr)
3584
                *port_ptr = atoi(brk + 2);
3585
        } else if ((col = strchr(p, ':')) && col < ls) {
3586
            av_strlcpy(hostname, p,
3587
                       FFMIN(col + 1 - p, hostname_size));
3588
            if (port_ptr) *port_ptr = atoi(col + 1);
3589
        } else
3590
            av_strlcpy(hostname, p,
3591
                       FFMIN(ls + 1 - p, hostname_size));
3592
    }
3593
}
3594

    
3595
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3596
{
3597
    int i;
3598
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3599
                                           '4', '5', '6', '7',
3600
                                           '8', '9', 'A', 'B',
3601
                                           'C', 'D', 'E', 'F' };
3602
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3603
                                           '4', '5', '6', '7',
3604
                                           '8', '9', 'a', 'b',
3605
                                           'c', 'd', 'e', 'f' };
3606
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3607

    
3608
    for(i = 0; i < s; i++) {
3609
        buff[i * 2]     = hex_table[src[i] >> 4];
3610
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3611
    }
3612

    
3613
    return buff;
3614
}
3615

    
3616
int ff_hex_to_data(uint8_t *data, const char *p)
3617
{
3618
    int c, len, v;
3619

    
3620
    len = 0;
3621
    v = 1;
3622
    for (;;) {
3623
        p += strspn(p, SPACE_CHARS);
3624
        if (*p == '\0')
3625
            break;
3626
        c = toupper((unsigned char) *p++);
3627
        if (c >= '0' && c <= '9')
3628
            c = c - '0';
3629
        else if (c >= 'A' && c <= 'F')
3630
            c = c - 'A' + 10;
3631
        else
3632
            break;
3633
        v = (v << 4) | c;
3634
        if (v & 0x100) {
3635
            if (data)
3636
                data[len] = v;
3637
            len++;
3638
            v = 1;
3639
        }
3640
    }
3641
    return len;
3642
}
3643

    
3644
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3645
                     unsigned int pts_num, unsigned int pts_den)
3646
{
3647
    AVRational new_tb;
3648
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3649
        if(new_tb.num != pts_num)
3650
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3651
    }else
3652
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3653

    
3654
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3655
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3656
        return;
3657
    }
3658
    s->time_base = new_tb;
3659
    s->pts_wrap_bits = pts_wrap_bits;
3660
}
3661

    
3662
int ff_url_join(char *str, int size, const char *proto,
3663
                const char *authorization, const char *hostname,
3664
                int port, const char *fmt, ...)
3665
{
3666
#if CONFIG_NETWORK
3667
    struct addrinfo hints, *ai;
3668
#endif
3669

    
3670
    str[0] = '\0';
3671
    if (proto)
3672
        av_strlcatf(str, size, "%s://", proto);
3673
    if (authorization && authorization[0])
3674
        av_strlcatf(str, size, "%s@", authorization);
3675
#if CONFIG_NETWORK && defined(AF_INET6)
3676
    /* Determine if hostname is a numerical IPv6 address,
3677
     * properly escape it within [] in that case. */
3678
    memset(&hints, 0, sizeof(hints));
3679
    hints.ai_flags = AI_NUMERICHOST;
3680
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3681
        if (ai->ai_family == AF_INET6) {
3682
            av_strlcat(str, "[", size);
3683
            av_strlcat(str, hostname, size);
3684
            av_strlcat(str, "]", size);
3685
        } else {
3686
            av_strlcat(str, hostname, size);
3687
        }
3688
        freeaddrinfo(ai);
3689
    } else
3690
#endif
3691
        /* Not an IPv6 address, just output the plain string. */
3692
        av_strlcat(str, hostname, size);
3693

    
3694
    if (port >= 0)
3695
        av_strlcatf(str, size, ":%d", port);
3696
    if (fmt) {
3697
        va_list vl;
3698
        int len = strlen(str);
3699

    
3700
        va_start(vl, fmt);
3701
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3702
        va_end(vl);
3703
    }
3704
    return strlen(str);
3705
}
3706

    
3707
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3708
                     AVFormatContext *src)
3709
{
3710
    AVPacket local_pkt;
3711

    
3712
    local_pkt = *pkt;
3713
    local_pkt.stream_index = dst_stream;
3714
    if (pkt->pts != AV_NOPTS_VALUE)
3715
        local_pkt.pts = av_rescale_q(pkt->pts,
3716
                                     src->streams[pkt->stream_index]->time_base,
3717
                                     dst->streams[dst_stream]->time_base);
3718
    if (pkt->dts != AV_NOPTS_VALUE)
3719
        local_pkt.dts = av_rescale_q(pkt->dts,
3720
                                     src->streams[pkt->stream_index]->time_base,
3721
                                     dst->streams[dst_stream]->time_base);
3722
    return av_write_frame(dst, &local_pkt);
3723
}
3724

    
3725
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3726
                        void *context)
3727
{
3728
    const char *ptr = str;
3729

    
3730
    /* Parse key=value pairs. */
3731
    for (;;) {
3732
        const char *key;
3733
        char *dest = NULL, *dest_end;
3734
        int key_len, dest_len = 0;
3735

    
3736
        /* Skip whitespace and potential commas. */
3737
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3738
            ptr++;
3739
        if (!*ptr)
3740
            break;
3741

    
3742
        key = ptr;
3743

    
3744
        if (!(ptr = strchr(key, '=')))
3745
            break;
3746
        ptr++;
3747
        key_len = ptr - key;
3748

    
3749
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3750
        dest_end = dest + dest_len - 1;
3751

    
3752
        if (*ptr == '\"') {
3753
            ptr++;
3754
            while (*ptr && *ptr != '\"') {
3755
                if (*ptr == '\\') {
3756
                    if (!ptr[1])
3757
                        break;
3758
                    if (dest && dest < dest_end)
3759
                        *dest++ = ptr[1];
3760
                    ptr += 2;
3761
                } else {
3762
                    if (dest && dest < dest_end)
3763
                        *dest++ = *ptr;
3764
                    ptr++;
3765
                }
3766
            }
3767
            if (*ptr == '\"')
3768
                ptr++;
3769
        } else {
3770
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3771
                if (dest && dest < dest_end)
3772
                    *dest++ = *ptr;
3773
        }
3774
        if (dest)
3775
            *dest = 0;
3776
    }
3777
}
3778

    
3779
int ff_find_stream_index(AVFormatContext *s, int id)
3780
{
3781
    int i;
3782
    for (i = 0; i < s->nb_streams; i++) {
3783
        if (s->streams[i]->id == id)
3784
            return i;
3785
    }
3786
    return -1;
3787
}
3788

    
3789
void ff_make_absolute_url(char *buf, int size, const char *base,
3790
                          const char *rel)
3791
{
3792
    char *sep;
3793
    /* Absolute path, relative to the current server */
3794
    if (base && strstr(base, "://") && rel[0] == '/') {
3795
        if (base != buf)
3796
            av_strlcpy(buf, base, size);
3797
        sep = strstr(buf, "://");
3798
        if (sep) {
3799
            sep += 3;
3800
            sep = strchr(sep, '/');
3801
            if (sep)
3802
                *sep = '\0';
3803
        }
3804
        av_strlcat(buf, rel, size);
3805
        return;
3806
    }
3807
    /* If rel actually is an absolute url, just copy it */
3808
    if (!base || strstr(rel, "://") || rel[0] == '/') {
3809
        av_strlcpy(buf, rel, size);
3810
        return;
3811
    }
3812
    if (base != buf)
3813
        av_strlcpy(buf, base, size);
3814
    /* Remove the file name from the base url */
3815
    sep = strrchr(buf, '/');
3816
    if (sep)
3817
        sep[1] = '\0';
3818
    else
3819
        buf[0] = '\0';
3820
    while (av_strstart(rel, "../", NULL) && sep) {
3821
        /* Remove the path delimiter at the end */
3822
        sep[0] = '\0';
3823
        sep = strrchr(buf, '/');
3824
        /* If the next directory name to pop off is "..", break here */
3825
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
3826
            /* Readd the slash we just removed */
3827
            av_strlcat(buf, "/", size);
3828
            break;
3829
        }
3830
        /* Cut off the directory name */
3831
        if (sep)
3832
            sep[1] = '\0';
3833
        else
3834
            buf[0] = '\0';
3835
        rel += 3;
3836
    }
3837
    av_strlcat(buf, rel, size);
3838
}