Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ a2eef3e9

History | View | Annotate | Download (122 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
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2723
{
2724
    const AVCodecTag *avctag;
2725
    int n;
2726
    enum CodecID id = CODEC_ID_NONE;
2727
    unsigned int tag = 0;
2728

    
2729
    /**
2730
     * Check that tag + id is in the table
2731
     * If neither is in the table -> OK
2732
     * If tag is in the table with another id -> FAIL
2733
     * If id is in the table with another tag -> FAIL unless strict < normal
2734
     */
2735
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2736
        avctag = s->oformat->codec_tag[n];
2737
        while (avctag->id != CODEC_ID_NONE) {
2738
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2739
                id = avctag->id;
2740
                if (id == st->codec->codec_id)
2741
                    return 1;
2742
            }
2743
            if (avctag->id == st->codec->codec_id)
2744
                tag = avctag->tag;
2745
            avctag++;
2746
        }
2747
    }
2748
    if (id != CODEC_ID_NONE)
2749
        return 0;
2750
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2751
        return 0;
2752
    return 1;
2753
}
2754

    
2755
int av_write_header(AVFormatContext *s)
2756
{
2757
    int ret, i;
2758
    AVStream *st;
2759

    
2760
    // some sanity checks
2761
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2762
        av_log(s, AV_LOG_ERROR, "no streams\n");
2763
        return AVERROR(EINVAL);
2764
    }
2765

    
2766
    for(i=0;i<s->nb_streams;i++) {
2767
        st = s->streams[i];
2768

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

    
2795
        if(s->oformat->codec_tag){
2796
            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)){
2797
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2798
                st->codec->codec_tag= 0;
2799
            }
2800
            if(st->codec->codec_tag){
2801
                if (!validate_codec_tag(s, st)) {
2802
                    char tagbuf[32];
2803
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2804
                    av_log(s, AV_LOG_ERROR,
2805
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2806
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2807
                    return AVERROR_INVALIDDATA;
2808
                }
2809
            }else
2810
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2811
        }
2812

    
2813
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2814
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2815
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2816
    }
2817

    
2818
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2819
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2820
        if (!s->priv_data)
2821
            return AVERROR(ENOMEM);
2822
    }
2823

    
2824
    /* set muxer identification string */
2825
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2826
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2827
    }
2828

    
2829
    if(s->oformat->write_header){
2830
        ret = s->oformat->write_header(s);
2831
        if (ret < 0)
2832
            return ret;
2833
    }
2834

    
2835
    /* init PTS generation */
2836
    for(i=0;i<s->nb_streams;i++) {
2837
        int64_t den = AV_NOPTS_VALUE;
2838
        st = s->streams[i];
2839

    
2840
        switch (st->codec->codec_type) {
2841
        case AVMEDIA_TYPE_AUDIO:
2842
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2843
            break;
2844
        case AVMEDIA_TYPE_VIDEO:
2845
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2846
            break;
2847
        default:
2848
            break;
2849
        }
2850
        if (den != AV_NOPTS_VALUE) {
2851
            if (den <= 0)
2852
                return AVERROR_INVALIDDATA;
2853
            av_frac_init(&st->pts, 0, 0, den);
2854
        }
2855
    }
2856
    return 0;
2857
}
2858

    
2859
//FIXME merge with compute_pkt_fields
2860
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2861
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2862
    int num, den, frame_size, i;
2863

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

    
2867
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2868
        return AVERROR(EINVAL);*/
2869

    
2870
    /* duration field */
2871
    if (pkt->duration == 0) {
2872
        compute_frame_duration(&num, &den, st, NULL, pkt);
2873
        if (den && num) {
2874
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2875
        }
2876
    }
2877

    
2878
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2879
        pkt->pts= pkt->dts;
2880

    
2881
    //XXX/FIXME this is a temporary hack until all encoders output pts
2882
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2883
        pkt->dts=
2884
//        pkt->pts= st->cur_dts;
2885
        pkt->pts= st->pts.val;
2886
    }
2887

    
2888
    //calculate dts from pts
2889
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2890
        st->pts_buffer[0]= pkt->pts;
2891
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2892
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2893
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2894
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2895

    
2896
        pkt->dts= st->pts_buffer[0];
2897
    }
2898

    
2899
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2900
        av_log(s, AV_LOG_ERROR,
2901
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2902
               st->index, st->cur_dts, pkt->dts);
2903
        return AVERROR(EINVAL);
2904
    }
2905
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2906
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2907
        return AVERROR(EINVAL);
2908
    }
2909

    
2910
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2911
    st->cur_dts= pkt->dts;
2912
    st->pts.val= pkt->dts;
2913

    
2914
    /* update pts */
2915
    switch (st->codec->codec_type) {
2916
    case AVMEDIA_TYPE_AUDIO:
2917
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2918

    
2919
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2920
           likely equal to the encoder delay, but it would be better if we
2921
           had the real timestamps from the encoder */
2922
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2923
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2924
        }
2925
        break;
2926
    case AVMEDIA_TYPE_VIDEO:
2927
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2928
        break;
2929
    default:
2930
        break;
2931
    }
2932
    return 0;
2933
}
2934

    
2935
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2936
{
2937
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2938

    
2939
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2940
        return ret;
2941

    
2942
    ret= s->oformat->write_packet(s, pkt);
2943
    if(!ret)
2944
        ret= url_ferror(s->pb);
2945
    return ret;
2946
}
2947

    
2948
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2949
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2950
{
2951
    AVPacketList **next_point, *this_pktl;
2952

    
2953
    this_pktl = av_mallocz(sizeof(AVPacketList));
2954
    this_pktl->pkt= *pkt;
2955
    pkt->destruct= NULL;             // do not free original but only the copy
2956
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2957

    
2958
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2959
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2960
    }else
2961
        next_point = &s->packet_buffer;
2962

    
2963
    if(*next_point){
2964
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2965
            while(!compare(s, &(*next_point)->pkt, pkt)){
2966
                next_point= &(*next_point)->next;
2967
            }
2968
            goto next_non_null;
2969
        }else{
2970
            next_point = &(s->packet_buffer_end->next);
2971
        }
2972
    }
2973
    assert(!*next_point);
2974

    
2975
    s->packet_buffer_end= this_pktl;
2976
next_non_null:
2977

    
2978
    this_pktl->next= *next_point;
2979

    
2980
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2981
    *next_point= this_pktl;
2982
}
2983

    
2984
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2985
{
2986
    AVStream *st = s->streams[ pkt ->stream_index];
2987
    AVStream *st2= s->streams[ next->stream_index];
2988
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2989
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2990
    int64_t dts1 = av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN);
2991
    if (dts1==next->dts && dts1==av_rescale_rnd(pkt->dts, b, a, AV_ROUND_UP))
2992
        return pkt->stream_index < next->stream_index;
2993
    return dts1 < next->dts;
2994
}
2995

    
2996
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2997
    AVPacketList *pktl;
2998
    int stream_count=0;
2999
    int i;
3000

    
3001
    if(pkt){
3002
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3003
    }
3004

    
3005
    for(i=0; i < s->nb_streams; i++)
3006
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3007

    
3008
    if(stream_count && (s->nb_streams == stream_count || flush)){
3009
        pktl= s->packet_buffer;
3010
        *out= pktl->pkt;
3011

    
3012
        s->packet_buffer= pktl->next;
3013
        if(!s->packet_buffer)
3014
            s->packet_buffer_end= NULL;
3015

    
3016
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3017
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3018
        av_freep(&pktl);
3019
        return 1;
3020
    }else{
3021
        av_init_packet(out);
3022
        return 0;
3023
    }
3024
}
3025

    
3026
/**
3027
 * Interleave an AVPacket correctly so it can be muxed.
3028
 * @param out the interleaved packet will be output here
3029
 * @param in the input packet
3030
 * @param flush 1 if no further packets are available as input and all
3031
 *              remaining packets should be output
3032
 * @return 1 if a packet was output, 0 if no packet could be output,
3033
 *         < 0 if an error occurred
3034
 */
3035
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3036
    if(s->oformat->interleave_packet)
3037
        return s->oformat->interleave_packet(s, out, in, flush);
3038
    else
3039
        return av_interleave_packet_per_dts(s, out, in, flush);
3040
}
3041

    
3042
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3043
    AVStream *st= s->streams[ pkt->stream_index];
3044
    int ret;
3045

    
3046
    //FIXME/XXX/HACK drop zero sized packets
3047
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3048
        return 0;
3049

    
3050
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3051
            pkt->size, pkt->dts, pkt->pts);
3052
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3053
        return ret;
3054

    
3055
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3056
        return AVERROR(EINVAL);
3057

    
3058
    for(;;){
3059
        AVPacket opkt;
3060
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
3061
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
3062
            return ret;
3063

    
3064
        ret= s->oformat->write_packet(s, &opkt);
3065

    
3066
        av_free_packet(&opkt);
3067
        pkt= NULL;
3068

    
3069
        if(ret<0)
3070
            return ret;
3071
        if(url_ferror(s->pb))
3072
            return url_ferror(s->pb);
3073
    }
3074
}
3075

    
3076
int av_write_trailer(AVFormatContext *s)
3077
{
3078
    int ret, i;
3079

    
3080
    for(;;){
3081
        AVPacket pkt;
3082
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3083
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3084
            goto fail;
3085
        if(!ret)
3086
            break;
3087

    
3088
        ret= s->oformat->write_packet(s, &pkt);
3089

    
3090
        av_free_packet(&pkt);
3091

    
3092
        if(ret<0)
3093
            goto fail;
3094
        if(url_ferror(s->pb))
3095
            goto fail;
3096
    }
3097

    
3098
    if(s->oformat->write_trailer)
3099
        ret = s->oformat->write_trailer(s);
3100
fail:
3101
    if(ret == 0)
3102
       ret=url_ferror(s->pb);
3103
    for(i=0;i<s->nb_streams;i++) {
3104
        av_freep(&s->streams[i]->priv_data);
3105
        av_freep(&s->streams[i]->index_entries);
3106
    }
3107
    av_freep(&s->priv_data);
3108
    return ret;
3109
}
3110

    
3111
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3112
{
3113
    int i, j;
3114
    AVProgram *program=NULL;
3115
    void *tmp;
3116

    
3117
    if (idx >= ac->nb_streams) {
3118
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3119
        return;
3120
    }
3121

    
3122
    for(i=0; i<ac->nb_programs; i++){
3123
        if(ac->programs[i]->id != progid)
3124
            continue;
3125
        program = ac->programs[i];
3126
        for(j=0; j<program->nb_stream_indexes; j++)
3127
            if(program->stream_index[j] == idx)
3128
                return;
3129

    
3130
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3131
        if(!tmp)
3132
            return;
3133
        program->stream_index = tmp;
3134
        program->stream_index[program->nb_stream_indexes++] = idx;
3135
        return;
3136
    }
3137
}
3138

    
3139
static void print_fps(double d, const char *postfix){
3140
    uint64_t v= lrintf(d*100);
3141
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3142
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3143
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3144
}
3145

    
3146
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3147
{
3148
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3149
        AVMetadataTag *tag=NULL;
3150

    
3151
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3152
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3153
            if(strcmp("language", tag->key))
3154
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3155
        }
3156
    }
3157
}
3158

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

    
3222
#if FF_API_DUMP_FORMAT
3223
void dump_format(AVFormatContext *ic,
3224
                 int index,
3225
                 const char *url,
3226
                 int is_output)
3227
{
3228
    av_dump_format(ic, index, url, is_output);
3229
}
3230
#endif
3231

    
3232
void av_dump_format(AVFormatContext *ic,
3233
                    int index,
3234
                    const char *url,
3235
                    int is_output)
3236
{
3237
    int i;
3238
    uint8_t *printed = av_mallocz(ic->nb_streams);
3239
    if (ic->nb_streams && !printed)
3240
        return;
3241

    
3242
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3243
            is_output ? "Output" : "Input",
3244
            index,
3245
            is_output ? ic->oformat->name : ic->iformat->name,
3246
            is_output ? "to" : "from", url);
3247
    dump_metadata(NULL, ic->metadata, "  ");
3248
    if (!is_output) {
3249
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3250
        if (ic->duration != AV_NOPTS_VALUE) {
3251
            int hours, mins, secs, us;
3252
            secs = ic->duration / AV_TIME_BASE;
3253
            us = ic->duration % AV_TIME_BASE;
3254
            mins = secs / 60;
3255
            secs %= 60;
3256
            hours = mins / 60;
3257
            mins %= 60;
3258
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3259
                   (100 * us) / AV_TIME_BASE);
3260
        } else {
3261
            av_log(NULL, AV_LOG_INFO, "N/A");
3262
        }
3263
        if (ic->start_time != AV_NOPTS_VALUE) {
3264
            int secs, us;
3265
            av_log(NULL, AV_LOG_INFO, ", start: ");
3266
            secs = ic->start_time / AV_TIME_BASE;
3267
            us = abs(ic->start_time % AV_TIME_BASE);
3268
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3269
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3270
        }
3271
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3272
        if (ic->bit_rate) {
3273
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3274
        } else {
3275
            av_log(NULL, AV_LOG_INFO, "N/A");
3276
        }
3277
        av_log(NULL, AV_LOG_INFO, "\n");
3278
    }
3279
    for (i = 0; i < ic->nb_chapters; i++) {
3280
        AVChapter *ch = ic->chapters[i];
3281
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3282
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3283
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3284

    
3285
        dump_metadata(NULL, ch->metadata, "    ");
3286
    }
3287
    if(ic->nb_programs) {
3288
        int j, k, total = 0;
3289
        for(j=0; j<ic->nb_programs; j++) {
3290
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3291
                                                  "name", NULL, 0);
3292
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3293
                   name ? name->value : "");
3294
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3295
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3296
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3297
                printed[ic->programs[j]->stream_index[k]] = 1;
3298
            }
3299
            total += ic->programs[j]->nb_stream_indexes;
3300
        }
3301
        if (total < ic->nb_streams)
3302
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3303
    }
3304
    for(i=0;i<ic->nb_streams;i++)
3305
        if (!printed[i])
3306
            dump_stream_format(ic, i, index, is_output);
3307

    
3308
    av_free(printed);
3309
}
3310

    
3311
int64_t av_gettime(void)
3312
{
3313
    struct timeval tv;
3314
    gettimeofday(&tv,NULL);
3315
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3316
}
3317

    
3318
uint64_t ff_ntp_time(void)
3319
{
3320
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3321
}
3322

    
3323
#if FF_API_PARSE_DATE
3324
#include "libavutil/parseutils.h"
3325

    
3326
int64_t parse_date(const char *timestr, int duration)
3327
{
3328
    int64_t timeval;
3329
    av_parse_time(&timeval, timestr, duration);
3330
    return timeval;
3331
}
3332
#endif
3333

    
3334
#if FF_API_FIND_INFO_TAG
3335
#include "libavutil/parseutils.h"
3336

    
3337
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3338
{
3339
    return av_find_info_tag(arg, arg_size, tag1, info);
3340
}
3341
#endif
3342

    
3343
int av_get_frame_filename(char *buf, int buf_size,
3344
                          const char *path, int number)
3345
{
3346
    const char *p;
3347
    char *q, buf1[20], c;
3348
    int nd, len, percentd_found;
3349

    
3350
    q = buf;
3351
    p = path;
3352
    percentd_found = 0;
3353
    for(;;) {
3354
        c = *p++;
3355
        if (c == '\0')
3356
            break;
3357
        if (c == '%') {
3358
            do {
3359
                nd = 0;
3360
                while (isdigit(*p)) {
3361
                    nd = nd * 10 + *p++ - '0';
3362
                }
3363
                c = *p++;
3364
            } while (isdigit(c));
3365

    
3366
            switch(c) {
3367
            case '%':
3368
                goto addchar;
3369
            case 'd':
3370
                if (percentd_found)
3371
                    goto fail;
3372
                percentd_found = 1;
3373
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3374
                len = strlen(buf1);
3375
                if ((q - buf + len) > buf_size - 1)
3376
                    goto fail;
3377
                memcpy(q, buf1, len);
3378
                q += len;
3379
                break;
3380
            default:
3381
                goto fail;
3382
            }
3383
        } else {
3384
        addchar:
3385
            if ((q - buf) < buf_size - 1)
3386
                *q++ = c;
3387
        }
3388
    }
3389
    if (!percentd_found)
3390
        goto fail;
3391
    *q = '\0';
3392
    return 0;
3393
 fail:
3394
    *q = '\0';
3395
    return -1;
3396
}
3397

    
3398
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3399
{
3400
    int len, i, j, c;
3401
#undef fprintf
3402
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3403

    
3404
    for(i=0;i<size;i+=16) {
3405
        len = size - i;
3406
        if (len > 16)
3407
            len = 16;
3408
        PRINT("%08x ", i);
3409
        for(j=0;j<16;j++) {
3410
            if (j < len)
3411
                PRINT(" %02x", buf[i+j]);
3412
            else
3413
                PRINT("   ");
3414
        }
3415
        PRINT(" ");
3416
        for(j=0;j<len;j++) {
3417
            c = buf[i+j];
3418
            if (c < ' ' || c > '~')
3419
                c = '.';
3420
            PRINT("%c", c);
3421
        }
3422
        PRINT("\n");
3423
    }
3424
#undef PRINT
3425
}
3426

    
3427
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3428
{
3429
    hex_dump_internal(NULL, f, 0, buf, size);
3430
}
3431

    
3432
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3433
{
3434
    hex_dump_internal(avcl, NULL, level, buf, size);
3435
}
3436

    
3437
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3438
{
3439
#undef fprintf
3440
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3441
    PRINT("stream #%d:\n", pkt->stream_index);
3442
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3443
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3444
    /* DTS is _always_ valid after av_read_frame() */
3445
    PRINT("  dts=");
3446
    if (pkt->dts == AV_NOPTS_VALUE)
3447
        PRINT("N/A");
3448
    else
3449
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3450
    /* PTS may not be known if B-frames are present. */
3451
    PRINT("  pts=");
3452
    if (pkt->pts == AV_NOPTS_VALUE)
3453
        PRINT("N/A");
3454
    else
3455
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3456
    PRINT("\n");
3457
    PRINT("  size=%d\n", pkt->size);
3458
#undef PRINT
3459
    if (dump_payload)
3460
        av_hex_dump(f, pkt->data, pkt->size);
3461
}
3462

    
3463
#if FF_API_PKT_DUMP
3464
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3465
{
3466
    AVRational tb = { 1, AV_TIME_BASE };
3467
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3468
}
3469
#endif
3470

    
3471
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3472
{
3473
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3474
}
3475

    
3476
#if FF_API_PKT_DUMP
3477
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3478
{
3479
    AVRational tb = { 1, AV_TIME_BASE };
3480
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3481
}
3482
#endif
3483

    
3484
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3485
                      AVStream *st)
3486
{
3487
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3488
}
3489

    
3490
void av_url_split(char *proto, int proto_size,
3491
                  char *authorization, int authorization_size,
3492
                  char *hostname, int hostname_size,
3493
                  int *port_ptr,
3494
                  char *path, int path_size,
3495
                  const char *url)
3496
{
3497
    const char *p, *ls, *at, *col, *brk;
3498

    
3499
    if (port_ptr)               *port_ptr = -1;
3500
    if (proto_size > 0)         proto[0] = 0;
3501
    if (authorization_size > 0) authorization[0] = 0;
3502
    if (hostname_size > 0)      hostname[0] = 0;
3503
    if (path_size > 0)          path[0] = 0;
3504

    
3505
    /* parse protocol */
3506
    if ((p = strchr(url, ':'))) {
3507
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3508
        p++; /* skip ':' */
3509
        if (*p == '/') p++;
3510
        if (*p == '/') p++;
3511
    } else {
3512
        /* no protocol means plain filename */
3513
        av_strlcpy(path, url, path_size);
3514
        return;
3515
    }
3516

    
3517
    /* separate path from hostname */
3518
    ls = strchr(p, '/');
3519
    if(!ls)
3520
        ls = strchr(p, '?');
3521
    if(ls)
3522
        av_strlcpy(path, ls, path_size);
3523
    else
3524
        ls = &p[strlen(p)]; // XXX
3525

    
3526
    /* the rest is hostname, use that to parse auth/port */
3527
    if (ls != p) {
3528
        /* authorization (user[:pass]@hostname) */
3529
        if ((at = strchr(p, '@')) && at < ls) {
3530
            av_strlcpy(authorization, p,
3531
                       FFMIN(authorization_size, at + 1 - p));
3532
            p = at + 1; /* skip '@' */
3533
        }
3534

    
3535
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3536
            /* [host]:port */
3537
            av_strlcpy(hostname, p + 1,
3538
                       FFMIN(hostname_size, brk - p));
3539
            if (brk[1] == ':' && port_ptr)
3540
                *port_ptr = atoi(brk + 2);
3541
        } else if ((col = strchr(p, ':')) && col < ls) {
3542
            av_strlcpy(hostname, p,
3543
                       FFMIN(col + 1 - p, hostname_size));
3544
            if (port_ptr) *port_ptr = atoi(col + 1);
3545
        } else
3546
            av_strlcpy(hostname, p,
3547
                       FFMIN(ls + 1 - p, hostname_size));
3548
    }
3549
}
3550

    
3551
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3552
{
3553
    int i;
3554
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3555
                                           '4', '5', '6', '7',
3556
                                           '8', '9', 'A', 'B',
3557
                                           'C', 'D', 'E', 'F' };
3558
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3559
                                           '4', '5', '6', '7',
3560
                                           '8', '9', 'a', 'b',
3561
                                           'c', 'd', 'e', 'f' };
3562
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3563

    
3564
    for(i = 0; i < s; i++) {
3565
        buff[i * 2]     = hex_table[src[i] >> 4];
3566
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3567
    }
3568

    
3569
    return buff;
3570
}
3571

    
3572
int ff_hex_to_data(uint8_t *data, const char *p)
3573
{
3574
    int c, len, v;
3575

    
3576
    len = 0;
3577
    v = 1;
3578
    for (;;) {
3579
        p += strspn(p, SPACE_CHARS);
3580
        if (*p == '\0')
3581
            break;
3582
        c = toupper((unsigned char) *p++);
3583
        if (c >= '0' && c <= '9')
3584
            c = c - '0';
3585
        else if (c >= 'A' && c <= 'F')
3586
            c = c - 'A' + 10;
3587
        else
3588
            break;
3589
        v = (v << 4) | c;
3590
        if (v & 0x100) {
3591
            if (data)
3592
                data[len] = v;
3593
            len++;
3594
            v = 1;
3595
        }
3596
    }
3597
    return len;
3598
}
3599

    
3600
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3601
                     unsigned int pts_num, unsigned int pts_den)
3602
{
3603
    AVRational new_tb;
3604
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3605
        if(new_tb.num != pts_num)
3606
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3607
    }else
3608
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3609

    
3610
    if(new_tb.num <= 0 || new_tb.den <= 0) {
3611
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3612
        return;
3613
    }
3614
    s->time_base = new_tb;
3615
    s->pts_wrap_bits = pts_wrap_bits;
3616
}
3617

    
3618
int ff_url_join(char *str, int size, const char *proto,
3619
                const char *authorization, const char *hostname,
3620
                int port, const char *fmt, ...)
3621
{
3622
#if CONFIG_NETWORK
3623
    struct addrinfo hints, *ai;
3624
#endif
3625

    
3626
    str[0] = '\0';
3627
    if (proto)
3628
        av_strlcatf(str, size, "%s://", proto);
3629
    if (authorization && authorization[0])
3630
        av_strlcatf(str, size, "%s@", authorization);
3631
#if CONFIG_NETWORK && defined(AF_INET6)
3632
    /* Determine if hostname is a numerical IPv6 address,
3633
     * properly escape it within [] in that case. */
3634
    memset(&hints, 0, sizeof(hints));
3635
    hints.ai_flags = AI_NUMERICHOST;
3636
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3637
        if (ai->ai_family == AF_INET6) {
3638
            av_strlcat(str, "[", size);
3639
            av_strlcat(str, hostname, size);
3640
            av_strlcat(str, "]", size);
3641
        } else {
3642
            av_strlcat(str, hostname, size);
3643
        }
3644
        freeaddrinfo(ai);
3645
    } else
3646
#endif
3647
        /* Not an IPv6 address, just output the plain string. */
3648
        av_strlcat(str, hostname, size);
3649

    
3650
    if (port >= 0)
3651
        av_strlcatf(str, size, ":%d", port);
3652
    if (fmt) {
3653
        va_list vl;
3654
        int len = strlen(str);
3655

    
3656
        va_start(vl, fmt);
3657
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3658
        va_end(vl);
3659
    }
3660
    return strlen(str);
3661
}
3662

    
3663
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3664
                     AVFormatContext *src)
3665
{
3666
    AVPacket local_pkt;
3667

    
3668
    local_pkt = *pkt;
3669
    local_pkt.stream_index = dst_stream;
3670
    if (pkt->pts != AV_NOPTS_VALUE)
3671
        local_pkt.pts = av_rescale_q(pkt->pts,
3672
                                     src->streams[pkt->stream_index]->time_base,
3673
                                     dst->streams[dst_stream]->time_base);
3674
    if (pkt->dts != AV_NOPTS_VALUE)
3675
        local_pkt.dts = av_rescale_q(pkt->dts,
3676
                                     src->streams[pkt->stream_index]->time_base,
3677
                                     dst->streams[dst_stream]->time_base);
3678
    return av_write_frame(dst, &local_pkt);
3679
}
3680

    
3681
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3682
                        void *context)
3683
{
3684
    const char *ptr = str;
3685

    
3686
    /* Parse key=value pairs. */
3687
    for (;;) {
3688
        const char *key;
3689
        char *dest = NULL, *dest_end;
3690
        int key_len, dest_len = 0;
3691

    
3692
        /* Skip whitespace and potential commas. */
3693
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3694
            ptr++;
3695
        if (!*ptr)
3696
            break;
3697

    
3698
        key = ptr;
3699

    
3700
        if (!(ptr = strchr(key, '=')))
3701
            break;
3702
        ptr++;
3703
        key_len = ptr - key;
3704

    
3705
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3706
        dest_end = dest + dest_len - 1;
3707

    
3708
        if (*ptr == '\"') {
3709
            ptr++;
3710
            while (*ptr && *ptr != '\"') {
3711
                if (*ptr == '\\') {
3712
                    if (!ptr[1])
3713
                        break;
3714
                    if (dest && dest < dest_end)
3715
                        *dest++ = ptr[1];
3716
                    ptr += 2;
3717
                } else {
3718
                    if (dest && dest < dest_end)
3719
                        *dest++ = *ptr;
3720
                    ptr++;
3721
                }
3722
            }
3723
            if (*ptr == '\"')
3724
                ptr++;
3725
        } else {
3726
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3727
                if (dest && dest < dest_end)
3728
                    *dest++ = *ptr;
3729
        }
3730
        if (dest)
3731
            *dest = 0;
3732
    }
3733
}
3734

    
3735
int ff_find_stream_index(AVFormatContext *s, int id)
3736
{
3737
    int i;
3738
    for (i = 0; i < s->nb_streams; i++) {
3739
        if (s->streams[i]->id == id)
3740
            return i;
3741
    }
3742
    return -1;
3743
}
3744

    
3745
void ff_make_absolute_url(char *buf, int size, const char *base,
3746
                          const char *rel)
3747
{
3748
    char *sep;
3749
    /* Absolute path, relative to the current server */
3750
    if (base && strstr(base, "://") && rel[0] == '/') {
3751
        if (base != buf)
3752
            av_strlcpy(buf, base, size);
3753
        sep = strstr(buf, "://");
3754
        if (sep) {
3755
            sep += 3;
3756
            sep = strchr(sep, '/');
3757
            if (sep)
3758
                *sep = '\0';
3759
        }
3760
        av_strlcat(buf, rel, size);
3761
        return;
3762
    }
3763
    /* If rel actually is an absolute url, just copy it */
3764
    if (!base || strstr(rel, "://") || rel[0] == '/') {
3765
        av_strlcpy(buf, rel, size);
3766
        return;
3767
    }
3768
    if (base != buf)
3769
        av_strlcpy(buf, base, size);
3770
    /* Remove the file name from the base url */
3771
    sep = strrchr(buf, '/');
3772
    if (sep)
3773
        sep[1] = '\0';
3774
    else
3775
        buf[0] = '\0';
3776
    while (av_strstart(rel, "../", NULL) && sep) {
3777
        /* Remove the path delimiter at the end */
3778
        sep[0] = '\0';
3779
        sep = strrchr(buf, '/');
3780
        /* If the next directory name to pop off is "..", break here */
3781
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
3782
            /* Readd the slash we just removed */
3783
            av_strlcat(buf, "/", size);
3784
            break;
3785
        }
3786
        /* Cut off the directory name */
3787
        if (sep)
3788
            sep[1] = '\0';
3789
        else
3790
            buf[0] = '\0';
3791
        rel += 3;
3792
    }
3793
    av_strlcat(buf, rel, size);
3794
}