Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ e7e291e9

History | View | Annotate | Download (110 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
#include "avformat.h"
22
#include "internal.h"
23
#include "libavcodec/opt.h"
24
#include "metadata.h"
25
#include "libavutil/avstring.h"
26
#include "riff.h"
27
#include "audiointerleave.h"
28
#include <sys/time.h>
29
#include <time.h>
30
#include <strings.h>
31
#include <stdarg.h>
32
#if CONFIG_NETWORK
33
#include "network.h"
34
#endif
35

    
36
#undef NDEBUG
37
#include <assert.h>
38

    
39
/**
40
 * @file libavformat/utils.c
41
 * various utility functions for use within FFmpeg
42
 */
43

    
44
unsigned avformat_version(void)
45
{
46
    return LIBAVFORMAT_VERSION_INT;
47
}
48

    
49
const char *avformat_configuration(void)
50
{
51
    return FFMPEG_CONFIGURATION;
52
}
53

    
54
const char *avformat_license(void)
55
{
56
#define LICENSE_PREFIX "libavformat license: "
57
    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
58
}
59

    
60
/* fraction handling */
61

    
62
/**
63
 * f = val + (num / den) + 0.5.
64
 *
65
 * 'num' is normalized so that it is such as 0 <= num < den.
66
 *
67
 * @param f fractional number
68
 * @param val integer value
69
 * @param num must be >= 0
70
 * @param den must be >= 1
71
 */
72
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
73
{
74
    num += (den >> 1);
75
    if (num >= den) {
76
        val += num / den;
77
        num = num % den;
78
    }
79
    f->val = val;
80
    f->num = num;
81
    f->den = den;
82
}
83

    
84
/**
85
 * Fractional addition to f: f = f + (incr / f->den).
86
 *
87
 * @param f fractional number
88
 * @param incr increment, can be positive or negative
89
 */
90
static void av_frac_add(AVFrac *f, int64_t incr)
91
{
92
    int64_t num, den;
93

    
94
    num = f->num + incr;
95
    den = f->den;
96
    if (num < 0) {
97
        f->val += num / den;
98
        num = num % den;
99
        if (num < 0) {
100
            num += den;
101
            f->val--;
102
        }
103
    } else if (num >= den) {
104
        f->val += num / den;
105
        num = num % den;
106
    }
107
    f->num = num;
108
}
109

    
110
/** head of registered input format linked list */
111
AVInputFormat *first_iformat = NULL;
112
/** head of registered output format linked list */
113
AVOutputFormat *first_oformat = NULL;
114

    
115
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
116
{
117
    if(f) return f->next;
118
    else  return first_iformat;
119
}
120

    
121
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
122
{
123
    if(f) return f->next;
124
    else  return first_oformat;
125
}
126

    
127
void av_register_input_format(AVInputFormat *format)
128
{
129
    AVInputFormat **p;
130
    p = &first_iformat;
131
    while (*p != NULL) p = &(*p)->next;
132
    *p = format;
133
    format->next = NULL;
134
}
135

    
136
void av_register_output_format(AVOutputFormat *format)
137
{
138
    AVOutputFormat **p;
139
    p = &first_oformat;
140
    while (*p != NULL) p = &(*p)->next;
141
    *p = format;
142
    format->next = NULL;
143
}
144

    
145
#if LIBAVFORMAT_VERSION_MAJOR < 53
146
int match_ext(const char *filename, const char *extensions)
147
{
148
    return av_match_ext(filename, extensions);
149
}
150
#endif
151

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

    
157
    if(!filename)
158
        return 0;
159

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

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

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

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

    
197
#if LIBAVFORMAT_VERSION_MAJOR < 53
198
AVOutputFormat *guess_format(const char *short_name, const char *filename,
199
                             const char *mime_type)
200
{
201
    return av_guess_format(short_name, filename, mime_type);
202
}
203
#endif
204

    
205
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
206
                                const char *mime_type)
207
{
208
    AVOutputFormat *fmt, *fmt_found;
209
    int score_max, score;
210

    
211
    /* specific test for image sequences */
212
#if CONFIG_IMAGE2_MUXER
213
    if (!short_name && filename &&
214
        av_filename_number_test(filename) &&
215
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
216
        return av_guess_format("image2", NULL, NULL);
217
    }
218
#endif
219
    /* Find the proper file type. */
220
    fmt_found = NULL;
221
    score_max = 0;
222
    fmt = first_oformat;
223
    while (fmt != NULL) {
224
        score = 0;
225
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
226
            score += 100;
227
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
228
            score += 10;
229
        if (filename && fmt->extensions &&
230
            av_match_ext(filename, fmt->extensions)) {
231
            score += 5;
232
        }
233
        if (score > score_max) {
234
            score_max = score;
235
            fmt_found = fmt;
236
        }
237
        fmt = fmt->next;
238
    }
239
    return fmt_found;
240
}
241

    
242
#if LIBAVFORMAT_VERSION_MAJOR < 53
243
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
244
                             const char *mime_type)
245
{
246
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
247

    
248
    if (fmt) {
249
        AVOutputFormat *stream_fmt;
250
        char stream_format_name[64];
251

    
252
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
253
        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
254

    
255
        if (stream_fmt)
256
            fmt = stream_fmt;
257
    }
258

    
259
    return fmt;
260
}
261
#endif
262

    
263
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
264
                            const char *filename, const char *mime_type, enum CodecType type){
265
    if(type == CODEC_TYPE_VIDEO){
266
        enum CodecID codec_id= CODEC_ID_NONE;
267

    
268
#if CONFIG_IMAGE2_MUXER
269
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
270
            codec_id= av_guess_image2_codec(filename);
271
        }
272
#endif
273
        if(codec_id == CODEC_ID_NONE)
274
            codec_id= fmt->video_codec;
275
        return codec_id;
276
    }else if(type == CODEC_TYPE_AUDIO)
277
        return fmt->audio_codec;
278
    else
279
        return CODEC_ID_NONE;
280
}
281

    
282
AVInputFormat *av_find_input_format(const char *short_name)
283
{
284
    AVInputFormat *fmt;
285
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
286
        if (match_format(short_name, fmt->name))
287
            return fmt;
288
    }
289
    return NULL;
290
}
291

    
292
/* memory handling */
293

    
294

    
295
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
296
{
297
    int ret= av_new_packet(pkt, size);
298

    
299
    if(ret<0)
300
        return ret;
301

    
302
    pkt->pos= url_ftell(s);
303

    
304
    ret= get_buffer(s, pkt->data, size);
305
    if(ret<=0)
306
        av_free_packet(pkt);
307
    else
308
        av_shrink_packet(pkt, ret);
309

    
310
    return ret;
311
}
312

    
313

    
314
int av_filename_number_test(const char *filename)
315
{
316
    char buf[1024];
317
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
318
}
319

    
320
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
321
{
322
    AVInputFormat *fmt1, *fmt;
323
    int score;
324

    
325
    fmt = NULL;
326
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
327
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
328
            continue;
329
        score = 0;
330
        if (fmt1->read_probe) {
331
            score = fmt1->read_probe(pd);
332
        } else if (fmt1->extensions) {
333
            if (av_match_ext(pd->filename, fmt1->extensions)) {
334
                score = 50;
335
            }
336
        }
337
        if (score > *score_max) {
338
            *score_max = score;
339
            fmt = fmt1;
340
        }else if (score == *score_max)
341
            fmt = NULL;
342
    }
343
    return fmt;
344
}
345

    
346
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
347
    int score=0;
348
    return av_probe_input_format2(pd, is_opened, &score);
349
}
350

    
351
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
352
{
353
    AVInputFormat *fmt;
354
    fmt = av_probe_input_format2(pd, 1, &score);
355

    
356
    if (fmt) {
357
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
358
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
359
        if (!strcmp(fmt->name, "mp3")) {
360
            st->codec->codec_id = CODEC_ID_MP3;
361
            st->codec->codec_type = CODEC_TYPE_AUDIO;
362
        } else if (!strcmp(fmt->name, "ac3")) {
363
            st->codec->codec_id = CODEC_ID_AC3;
364
            st->codec->codec_type = CODEC_TYPE_AUDIO;
365
        } else if (!strcmp(fmt->name, "eac3")) {
366
            st->codec->codec_id = CODEC_ID_EAC3;
367
            st->codec->codec_type = CODEC_TYPE_AUDIO;
368
        } else if (!strcmp(fmt->name, "mpegvideo")) {
369
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
370
            st->codec->codec_type = CODEC_TYPE_VIDEO;
371
        } else if (!strcmp(fmt->name, "m4v")) {
372
            st->codec->codec_id = CODEC_ID_MPEG4;
373
            st->codec->codec_type = CODEC_TYPE_VIDEO;
374
        } else if (!strcmp(fmt->name, "h264")) {
375
            st->codec->codec_id = CODEC_ID_H264;
376
            st->codec->codec_type = CODEC_TYPE_VIDEO;
377
        } else if (!strcmp(fmt->name, "dts")) {
378
            st->codec->codec_id = CODEC_ID_DTS;
379
            st->codec->codec_type = CODEC_TYPE_AUDIO;
380
        }
381
    }
382
    return !!fmt;
383
}
384

    
385
/************************************************************/
386
/* input media file */
387

    
388
/**
389
 * Open a media file from an IO stream. 'fmt' must be specified.
390
 */
391
int av_open_input_stream(AVFormatContext **ic_ptr,
392
                         ByteIOContext *pb, const char *filename,
393
                         AVInputFormat *fmt, AVFormatParameters *ap)
394
{
395
    int err;
396
    AVFormatContext *ic;
397
    AVFormatParameters default_ap;
398

    
399
    if(!ap){
400
        ap=&default_ap;
401
        memset(ap, 0, sizeof(default_ap));
402
    }
403

    
404
    if(!ap->prealloced_context)
405
        ic = avformat_alloc_context();
406
    else
407
        ic = *ic_ptr;
408
    if (!ic) {
409
        err = AVERROR(ENOMEM);
410
        goto fail;
411
    }
412
    ic->iformat = fmt;
413
    ic->pb = pb;
414
    ic->duration = AV_NOPTS_VALUE;
415
    ic->start_time = AV_NOPTS_VALUE;
416
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
417

    
418
    /* allocate private data */
419
    if (fmt->priv_data_size > 0) {
420
        ic->priv_data = av_mallocz(fmt->priv_data_size);
421
        if (!ic->priv_data) {
422
            err = AVERROR(ENOMEM);
423
            goto fail;
424
        }
425
    } else {
426
        ic->priv_data = NULL;
427
    }
428

    
429
    if (ic->iformat->read_header) {
430
        err = ic->iformat->read_header(ic, ap);
431
        if (err < 0)
432
            goto fail;
433
    }
434

    
435
    if (pb && !ic->data_offset)
436
        ic->data_offset = url_ftell(ic->pb);
437

    
438
#if LIBAVFORMAT_VERSION_MAJOR < 53
439
    ff_metadata_demux_compat(ic);
440
#endif
441

    
442
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
443

    
444
    *ic_ptr = ic;
445
    return 0;
446
 fail:
447
    if (ic) {
448
        int i;
449
        av_freep(&ic->priv_data);
450
        for(i=0;i<ic->nb_streams;i++) {
451
            AVStream *st = ic->streams[i];
452
            if (st) {
453
                av_free(st->priv_data);
454
                av_free(st->codec->extradata);
455
            }
456
            av_free(st);
457
        }
458
    }
459
    av_free(ic);
460
    *ic_ptr = NULL;
461
    return err;
462
}
463

    
464
/** size of probe buffer, for guessing file type from file contents */
465
#define PROBE_BUF_MIN 2048
466
#define PROBE_BUF_MAX (1<<20)
467

    
468
int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
469
                          const char *filename, void *logctx,
470
                          unsigned int offset, unsigned int max_probe_size)
471
{
472
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
473
    unsigned char *buf = NULL;
474
    int probe_size;
475

    
476
    if (!max_probe_size) {
477
        max_probe_size = PROBE_BUF_MAX;
478
    } else if (max_probe_size > PROBE_BUF_MAX) {
479
        max_probe_size = PROBE_BUF_MAX;
480
    } else if (max_probe_size < PROBE_BUF_MIN) {
481
        return AVERROR(EINVAL);
482
    }
483

    
484
    if (offset >= max_probe_size) {
485
        return AVERROR(EINVAL);
486
    }
487

    
488
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt; probe_size<<=1){
489
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
490
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
491

    
492
        if (probe_size < offset) {
493
            continue;
494
        }
495

    
496
        /* read probe data */
497
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
498
        if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
499
            av_free(buf);
500
            return ret;
501
        }
502
        pd.buf_size += ret;
503
        pd.buf = &buf[offset];
504

    
505
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
506

    
507
        /* guess file format */
508
        *fmt = av_probe_input_format2(&pd, 1, &score);
509
        if(*fmt){
510
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
511
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
512
            }else
513
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
514
        }
515
    }
516

    
517
    av_free(buf);
518
    if (url_fseek(*pb, 0, SEEK_SET) < 0) {
519
        url_fclose(*pb);
520
        if (url_fopen(pb, filename, URL_RDONLY) < 0)
521
            return AVERROR(EIO);
522
    }
523

    
524
    return 0;
525
}
526

    
527
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
528
                       AVInputFormat *fmt,
529
                       int buf_size,
530
                       AVFormatParameters *ap)
531
{
532
    int err;
533
    AVProbeData probe_data, *pd = &probe_data;
534
    ByteIOContext *pb = NULL;
535
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
536

    
537
    pd->filename = "";
538
    if (filename)
539
        pd->filename = filename;
540
    pd->buf = NULL;
541
    pd->buf_size = 0;
542

    
543
    if (!fmt) {
544
        /* guess format if no file can be opened */
545
        fmt = av_probe_input_format(pd, 0);
546
    }
547

    
548
    /* Do not open file if the format does not need it. XXX: specific
549
       hack needed to handle RTSP/TCP */
550
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
551
        /* if no file needed do not try to open one */
552
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
553
            goto fail;
554
        }
555
        if (buf_size > 0) {
556
            url_setbufsize(pb, buf_size);
557
        }
558
        if ((err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, 0)) < 0) {
559
            goto fail;
560
        }
561
    }
562

    
563
    /* if still no format found, error */
564
    if (!fmt) {
565
        err = AVERROR_NOFMT;
566
        goto fail;
567
    }
568

    
569
    /* check filename in case an image number is expected */
570
    if (fmt->flags & AVFMT_NEEDNUMBER) {
571
        if (!av_filename_number_test(filename)) {
572
            err = AVERROR_NUMEXPECTED;
573
            goto fail;
574
        }
575
    }
576
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
577
    if (err)
578
        goto fail;
579
    return 0;
580
 fail:
581
    av_freep(&pd->buf);
582
    if (pb)
583
        url_fclose(pb);
584
    if (ap && ap->prealloced_context)
585
        av_free(*ic_ptr);
586
    *ic_ptr = NULL;
587
    return err;
588

    
589
}
590

    
591
/*******************************************************/
592

    
593
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
594
                               AVPacketList **plast_pktl){
595
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
596
    if (!pktl)
597
        return NULL;
598

    
599
    if (*packet_buffer)
600
        (*plast_pktl)->next = pktl;
601
    else
602
        *packet_buffer = pktl;
603

    
604
    /* add the packet in the buffered packet list */
605
    *plast_pktl = pktl;
606
    pktl->pkt= *pkt;
607
    return &pktl->pkt;
608
}
609

    
610
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
611
{
612
    int ret, i;
613
    AVStream *st;
614

    
615
    for(;;){
616
        AVPacketList *pktl = s->raw_packet_buffer;
617

    
618
        if (pktl) {
619
            *pkt = pktl->pkt;
620
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
621
               !s->streams[pkt->stream_index]->probe_packets ||
622
               s->raw_packet_buffer_remaining_size < pkt->size){
623
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
624
                av_freep(&pd->buf);
625
                pd->buf_size = 0;
626
                s->raw_packet_buffer = pktl->next;
627
                s->raw_packet_buffer_remaining_size += pkt->size;
628
                av_free(pktl);
629
                return 0;
630
            }
631
        }
632

    
633
        av_init_packet(pkt);
634
        ret= s->iformat->read_packet(s, pkt);
635
        if (ret < 0) {
636
            if (!pktl || ret == AVERROR(EAGAIN))
637
                return ret;
638
            for (i = 0; i < s->nb_streams; i++)
639
                s->streams[i]->probe_packets = 0;
640
            continue;
641
        }
642
        st= s->streams[pkt->stream_index];
643

    
644
        switch(st->codec->codec_type){
645
        case CODEC_TYPE_VIDEO:
646
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
647
            break;
648
        case CODEC_TYPE_AUDIO:
649
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
650
            break;
651
        case CODEC_TYPE_SUBTITLE:
652
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
653
            break;
654
        }
655

    
656
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
657
                     !st->probe_packets))
658
            return ret;
659

    
660
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
661
        s->raw_packet_buffer_remaining_size -= pkt->size;
662

    
663
        if(st->codec->codec_id == CODEC_ID_PROBE){
664
            AVProbeData *pd = &st->probe_data;
665
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
666
            --st->probe_packets;
667

    
668
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
669
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
670
            pd->buf_size += pkt->size;
671
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
672

    
673
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
674
                set_codec_from_probe_data(s, st, pd, 1);
675
                if(st->codec->codec_id != CODEC_ID_PROBE){
676
                    pd->buf_size=0;
677
                    av_freep(&pd->buf);
678
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
679
                }
680
            }
681
        }
682
    }
683
}
684

    
685
/**********************************************************/
686

    
687
/**
688
 * Get the number of samples of an audio frame. Return -1 on error.
689
 */
690
static int get_audio_frame_size(AVCodecContext *enc, int size)
691
{
692
    int frame_size;
693

    
694
    if(enc->codec_id == CODEC_ID_VORBIS)
695
        return -1;
696

    
697
    if (enc->frame_size <= 1) {
698
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
699

    
700
        if (bits_per_sample) {
701
            if (enc->channels == 0)
702
                return -1;
703
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
704
        } else {
705
            /* used for example by ADPCM codecs */
706
            if (enc->bit_rate == 0)
707
                return -1;
708
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
709
        }
710
    } else {
711
        frame_size = enc->frame_size;
712
    }
713
    return frame_size;
714
}
715

    
716

    
717
/**
718
 * Return the frame duration in seconds. Return 0 if not available.
719
 */
720
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
721
                                   AVCodecParserContext *pc, AVPacket *pkt)
722
{
723
    int frame_size;
724

    
725
    *pnum = 0;
726
    *pden = 0;
727
    switch(st->codec->codec_type) {
728
    case CODEC_TYPE_VIDEO:
729
        if(st->time_base.num*1000LL > st->time_base.den){
730
            *pnum = st->time_base.num;
731
            *pden = st->time_base.den;
732
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
733
            *pnum = st->codec->time_base.num;
734
            *pden = st->codec->time_base.den;
735
            if (pc && pc->repeat_pict) {
736
                *pnum = (*pnum) * (1 + pc->repeat_pict);
737
            }
738
        }
739
        break;
740
    case CODEC_TYPE_AUDIO:
741
        frame_size = get_audio_frame_size(st->codec, pkt->size);
742
        if (frame_size < 0)
743
            break;
744
        *pnum = frame_size;
745
        *pden = st->codec->sample_rate;
746
        break;
747
    default:
748
        break;
749
    }
750
}
751

    
752
static int is_intra_only(AVCodecContext *enc){
753
    if(enc->codec_type == CODEC_TYPE_AUDIO){
754
        return 1;
755
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
756
        switch(enc->codec_id){
757
        case CODEC_ID_MJPEG:
758
        case CODEC_ID_MJPEGB:
759
        case CODEC_ID_LJPEG:
760
        case CODEC_ID_RAWVIDEO:
761
        case CODEC_ID_DVVIDEO:
762
        case CODEC_ID_HUFFYUV:
763
        case CODEC_ID_FFVHUFF:
764
        case CODEC_ID_ASV1:
765
        case CODEC_ID_ASV2:
766
        case CODEC_ID_VCR1:
767
        case CODEC_ID_DNXHD:
768
        case CODEC_ID_JPEG2000:
769
            return 1;
770
        default: break;
771
        }
772
    }
773
    return 0;
774
}
775

    
776
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
777
                                      int64_t dts, int64_t pts)
778
{
779
    AVStream *st= s->streams[stream_index];
780
    AVPacketList *pktl= s->packet_buffer;
781

    
782
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
783
        return;
784

    
785
    st->first_dts= dts - st->cur_dts;
786
    st->cur_dts= dts;
787

    
788
    for(; pktl; pktl= pktl->next){
789
        if(pktl->pkt.stream_index != stream_index)
790
            continue;
791
        //FIXME think more about this check
792
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
793
            pktl->pkt.pts += st->first_dts;
794

    
795
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
796
            pktl->pkt.dts += st->first_dts;
797

    
798
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
799
            st->start_time= pktl->pkt.pts;
800
    }
801
    if (st->start_time == AV_NOPTS_VALUE)
802
        st->start_time = pts;
803
}
804

    
805
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
806
{
807
    AVPacketList *pktl= s->packet_buffer;
808
    int64_t cur_dts= 0;
809

    
810
    if(st->first_dts != AV_NOPTS_VALUE){
811
        cur_dts= st->first_dts;
812
        for(; pktl; pktl= pktl->next){
813
            if(pktl->pkt.stream_index == pkt->stream_index){
814
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
815
                    break;
816
                cur_dts -= pkt->duration;
817
            }
818
        }
819
        pktl= s->packet_buffer;
820
        st->first_dts = cur_dts;
821
    }else if(st->cur_dts)
822
        return;
823

    
824
    for(; pktl; pktl= pktl->next){
825
        if(pktl->pkt.stream_index != pkt->stream_index)
826
            continue;
827
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
828
           && !pktl->pkt.duration){
829
            pktl->pkt.dts= cur_dts;
830
            if(!st->codec->has_b_frames)
831
                pktl->pkt.pts= cur_dts;
832
            cur_dts += pkt->duration;
833
            pktl->pkt.duration= pkt->duration;
834
        }else
835
            break;
836
    }
837
    if(st->first_dts == AV_NOPTS_VALUE)
838
        st->cur_dts= cur_dts;
839
}
840

    
841
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
842
                               AVCodecParserContext *pc, AVPacket *pkt)
843
{
844
    int num, den, presentation_delayed, delay, i;
845
    int64_t offset;
846

    
847
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
848
        pkt->dts= AV_NOPTS_VALUE;
849

    
850
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
851
        //FIXME Set low_delay = 0 when has_b_frames = 1
852
        st->codec->has_b_frames = 1;
853

    
854
    /* do we have a video B-frame ? */
855
    delay= st->codec->has_b_frames;
856
    presentation_delayed = 0;
857
    /* XXX: need has_b_frame, but cannot get it if the codec is
858
        not initialized */
859
    if (delay &&
860
        pc && pc->pict_type != FF_B_TYPE)
861
        presentation_delayed = 1;
862

    
863
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
864
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
865
        pkt->dts -= 1LL<<st->pts_wrap_bits;
866
    }
867

    
868
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
869
    // we take the conservative approach and discard both
870
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
871
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
872
        av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
873
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
874
    }
875

    
876
    if (pkt->duration == 0) {
877
        compute_frame_duration(&num, &den, st, pc, pkt);
878
        if (den && num) {
879
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
880

    
881
            if(pkt->duration != 0 && s->packet_buffer)
882
                update_initial_durations(s, st, pkt);
883
        }
884
    }
885

    
886
    /* correct timestamps with byte offset if demuxers only have timestamps
887
       on packet boundaries */
888
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
889
        /* this will estimate bitrate based on this frame's duration and size */
890
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
891
        if(pkt->pts != AV_NOPTS_VALUE)
892
            pkt->pts += offset;
893
        if(pkt->dts != AV_NOPTS_VALUE)
894
            pkt->dts += offset;
895
    }
896

    
897
    if (pc && pc->dts_sync_point >= 0) {
898
        // we have synchronization info from the parser
899
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
900
        if (den > 0) {
901
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
902
            if (pkt->dts != AV_NOPTS_VALUE) {
903
                // got DTS from the stream, update reference timestamp
904
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
905
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
906
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
907
                // compute DTS based on reference timestamp
908
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
909
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
910
            }
911
            if (pc->dts_sync_point > 0)
912
                st->reference_dts = pkt->dts; // new reference
913
        }
914
    }
915

    
916
    /* This may be redundant, but it should not hurt. */
917
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
918
        presentation_delayed = 1;
919

    
920
//    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);
921
    /* interpolate PTS and DTS if they are not present */
922
    //We skip H264 currently because delay and has_b_frames are not reliably set
923
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
924
        if (presentation_delayed) {
925
            /* DTS = decompression timestamp */
926
            /* PTS = presentation timestamp */
927
            if (pkt->dts == AV_NOPTS_VALUE)
928
                pkt->dts = st->last_IP_pts;
929
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
930
            if (pkt->dts == AV_NOPTS_VALUE)
931
                pkt->dts = st->cur_dts;
932

    
933
            /* this is tricky: the dts must be incremented by the duration
934
            of the frame we are displaying, i.e. the last I- or P-frame */
935
            if (st->last_IP_duration == 0)
936
                st->last_IP_duration = pkt->duration;
937
            if(pkt->dts != AV_NOPTS_VALUE)
938
                st->cur_dts = pkt->dts + st->last_IP_duration;
939
            st->last_IP_duration  = pkt->duration;
940
            st->last_IP_pts= pkt->pts;
941
            /* cannot compute PTS if not present (we can compute it only
942
            by knowing the future */
943
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
944
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
945
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
946
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
947
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
948
                    pkt->pts += pkt->duration;
949
    //                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);
950
                }
951
            }
952

    
953
            /* presentation is not delayed : PTS and DTS are the same */
954
            if(pkt->pts == AV_NOPTS_VALUE)
955
                pkt->pts = pkt->dts;
956
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
957
            if(pkt->pts == AV_NOPTS_VALUE)
958
                pkt->pts = st->cur_dts;
959
            pkt->dts = pkt->pts;
960
            if(pkt->pts != AV_NOPTS_VALUE)
961
                st->cur_dts = pkt->pts + pkt->duration;
962
        }
963
    }
964

    
965
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
966
        st->pts_buffer[0]= pkt->pts;
967
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
968
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
969
        if(pkt->dts == AV_NOPTS_VALUE)
970
            pkt->dts= st->pts_buffer[0];
971
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
972
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
973
        }
974
        if(pkt->dts > st->cur_dts)
975
            st->cur_dts = pkt->dts;
976
    }
977

    
978
//    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);
979

    
980
    /* update flags */
981
    if(is_intra_only(st->codec))
982
        pkt->flags |= PKT_FLAG_KEY;
983
    else if (pc) {
984
        pkt->flags = 0;
985
        /* keyframe computation */
986
        if (pc->key_frame == 1)
987
            pkt->flags |= PKT_FLAG_KEY;
988
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
989
            pkt->flags |= PKT_FLAG_KEY;
990
    }
991
    if (pc)
992
        pkt->convergence_duration = pc->convergence_duration;
993
}
994

    
995

    
996
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
997
{
998
    AVStream *st;
999
    int len, ret, i;
1000

    
1001
    av_init_packet(pkt);
1002

    
1003
    for(;;) {
1004
        /* select current input stream component */
1005
        st = s->cur_st;
1006
        if (st) {
1007
            if (!st->need_parsing || !st->parser) {
1008
                /* no parsing needed: we just output the packet as is */
1009
                /* raw data support */
1010
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1011
                compute_pkt_fields(s, st, NULL, pkt);
1012
                s->cur_st = NULL;
1013
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1014
                    (pkt->flags & PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1015
                    ff_reduce_index(s, st->index);
1016
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1017
                }
1018
                break;
1019
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1020
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1021
                                       st->cur_ptr, st->cur_len,
1022
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1023
                                       st->cur_pkt.pos);
1024
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1025
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1026
                /* increment read pointer */
1027
                st->cur_ptr += len;
1028
                st->cur_len -= len;
1029

    
1030
                /* return packet if any */
1031
                if (pkt->size) {
1032
                got_packet:
1033
                    pkt->duration = 0;
1034
                    pkt->stream_index = st->index;
1035
                    pkt->pts = st->parser->pts;
1036
                    pkt->dts = st->parser->dts;
1037
                    pkt->pos = st->parser->pos;
1038
                    pkt->destruct = NULL;
1039
                    compute_pkt_fields(s, st, st->parser, pkt);
1040

    
1041
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
1042
                        ff_reduce_index(s, st->index);
1043
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1044
                                           0, 0, AVINDEX_KEYFRAME);
1045
                    }
1046

    
1047
                    break;
1048
                }
1049
            } else {
1050
                /* free packet */
1051
                av_free_packet(&st->cur_pkt);
1052
                s->cur_st = NULL;
1053
            }
1054
        } else {
1055
            AVPacket cur_pkt;
1056
            /* read next packet */
1057
            ret = av_read_packet(s, &cur_pkt);
1058
            if (ret < 0) {
1059
                if (ret == AVERROR(EAGAIN))
1060
                    return ret;
1061
                /* return the last frames, if any */
1062
                for(i = 0; i < s->nb_streams; i++) {
1063
                    st = s->streams[i];
1064
                    if (st->parser && st->need_parsing) {
1065
                        av_parser_parse2(st->parser, st->codec,
1066
                                        &pkt->data, &pkt->size,
1067
                                        NULL, 0,
1068
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1069
                                        AV_NOPTS_VALUE);
1070
                        if (pkt->size)
1071
                            goto got_packet;
1072
                    }
1073
                }
1074
                /* no more packets: really terminate parsing */
1075
                return ret;
1076
            }
1077
            st = s->streams[cur_pkt.stream_index];
1078
            st->cur_pkt= cur_pkt;
1079

    
1080
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1081
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1082
               st->cur_pkt.pts < st->cur_pkt.dts){
1083
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1084
                    st->cur_pkt.stream_index,
1085
                    st->cur_pkt.pts,
1086
                    st->cur_pkt.dts,
1087
                    st->cur_pkt.size);
1088
//                av_free_packet(&st->cur_pkt);
1089
//                return -1;
1090
            }
1091

    
1092
            if(s->debug & FF_FDEBUG_TS)
1093
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1094
                    st->cur_pkt.stream_index,
1095
                    st->cur_pkt.pts,
1096
                    st->cur_pkt.dts,
1097
                    st->cur_pkt.size,
1098
                    st->cur_pkt.duration,
1099
                    st->cur_pkt.flags);
1100

    
1101
            s->cur_st = st;
1102
            st->cur_ptr = st->cur_pkt.data;
1103
            st->cur_len = st->cur_pkt.size;
1104
            if (st->need_parsing && !st->parser) {
1105
                st->parser = av_parser_init(st->codec->codec_id);
1106
                if (!st->parser) {
1107
                    /* no parser available: just output the raw packets */
1108
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1109
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1110
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1111
                }
1112
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1113
                    st->parser->next_frame_offset=
1114
                    st->parser->cur_offset= st->cur_pkt.pos;
1115
                }
1116
            }
1117
        }
1118
    }
1119
    if(s->debug & FF_FDEBUG_TS)
1120
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1121
            pkt->stream_index,
1122
            pkt->pts,
1123
            pkt->dts,
1124
            pkt->size,
1125
            pkt->duration,
1126
            pkt->flags);
1127

    
1128
    return 0;
1129
}
1130

    
1131
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1132
{
1133
    AVPacketList *pktl;
1134
    int eof=0;
1135
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1136

    
1137
    for(;;){
1138
        pktl = s->packet_buffer;
1139
        if (pktl) {
1140
            AVPacket *next_pkt= &pktl->pkt;
1141

    
1142
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1143
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1144
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1145
                       && next_pkt->dts < pktl->pkt.dts
1146
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1147
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1148
                        next_pkt->pts= pktl->pkt.dts;
1149
                    }
1150
                    pktl= pktl->next;
1151
                }
1152
                pktl = s->packet_buffer;
1153
            }
1154

    
1155
            if(   next_pkt->pts != AV_NOPTS_VALUE
1156
               || next_pkt->dts == AV_NOPTS_VALUE
1157
               || !genpts || eof){
1158
                /* read packet from packet buffer, if there is data */
1159
                *pkt = *next_pkt;
1160
                s->packet_buffer = pktl->next;
1161
                av_free(pktl);
1162
                return 0;
1163
            }
1164
        }
1165
        if(genpts){
1166
            int ret= av_read_frame_internal(s, pkt);
1167
            if(ret<0){
1168
                if(pktl && ret != AVERROR(EAGAIN)){
1169
                    eof=1;
1170
                    continue;
1171
                }else
1172
                    return ret;
1173
            }
1174

    
1175
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1176
                                           &s->packet_buffer_end)) < 0)
1177
                return AVERROR(ENOMEM);
1178
        }else{
1179
            assert(!s->packet_buffer);
1180
            return av_read_frame_internal(s, pkt);
1181
        }
1182
    }
1183
}
1184

    
1185
/* XXX: suppress the packet queue */
1186
static void flush_packet_queue(AVFormatContext *s)
1187
{
1188
    AVPacketList *pktl;
1189

    
1190
    for(;;) {
1191
        pktl = s->packet_buffer;
1192
        if (!pktl)
1193
            break;
1194
        s->packet_buffer = pktl->next;
1195
        av_free_packet(&pktl->pkt);
1196
        av_free(pktl);
1197
    }
1198
    while(s->raw_packet_buffer){
1199
        pktl = s->raw_packet_buffer;
1200
        s->raw_packet_buffer = pktl->next;
1201
        av_free_packet(&pktl->pkt);
1202
        av_free(pktl);
1203
    }
1204
    s->packet_buffer_end=
1205
    s->raw_packet_buffer_end= NULL;
1206
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1207
}
1208

    
1209
/*******************************************************/
1210
/* seek support */
1211

    
1212
int av_find_default_stream_index(AVFormatContext *s)
1213
{
1214
    int first_audio_index = -1;
1215
    int i;
1216
    AVStream *st;
1217

    
1218
    if (s->nb_streams <= 0)
1219
        return -1;
1220
    for(i = 0; i < s->nb_streams; i++) {
1221
        st = s->streams[i];
1222
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1223
            return i;
1224
        }
1225
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1226
            first_audio_index = i;
1227
    }
1228
    return first_audio_index >= 0 ? first_audio_index : 0;
1229
}
1230

    
1231
/**
1232
 * Flush the frame reader.
1233
 */
1234
void av_read_frame_flush(AVFormatContext *s)
1235
{
1236
    AVStream *st;
1237
    int i, j;
1238

    
1239
    flush_packet_queue(s);
1240

    
1241
    s->cur_st = NULL;
1242

    
1243
    /* for each stream, reset read state */
1244
    for(i = 0; i < s->nb_streams; i++) {
1245
        st = s->streams[i];
1246

    
1247
        if (st->parser) {
1248
            av_parser_close(st->parser);
1249
            st->parser = NULL;
1250
            av_free_packet(&st->cur_pkt);
1251
        }
1252
        st->last_IP_pts = AV_NOPTS_VALUE;
1253
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1254
        st->reference_dts = AV_NOPTS_VALUE;
1255
        /* fail safe */
1256
        st->cur_ptr = NULL;
1257
        st->cur_len = 0;
1258

    
1259
        st->probe_packets = MAX_PROBE_PACKETS;
1260

    
1261
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1262
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1263
    }
1264
}
1265

    
1266
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1267
    int i;
1268

    
1269
    for(i = 0; i < s->nb_streams; i++) {
1270
        AVStream *st = s->streams[i];
1271

    
1272
        st->cur_dts = av_rescale(timestamp,
1273
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1274
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1275
    }
1276
}
1277

    
1278
void ff_reduce_index(AVFormatContext *s, int stream_index)
1279
{
1280
    AVStream *st= s->streams[stream_index];
1281
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1282

    
1283
    if((unsigned)st->nb_index_entries >= max_entries){
1284
        int i;
1285
        for(i=0; 2*i<st->nb_index_entries; i++)
1286
            st->index_entries[i]= st->index_entries[2*i];
1287
        st->nb_index_entries= i;
1288
    }
1289
}
1290

    
1291
int av_add_index_entry(AVStream *st,
1292
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1293
{
1294
    AVIndexEntry *entries, *ie;
1295
    int index;
1296

    
1297
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1298
        return -1;
1299

    
1300
    entries = av_fast_realloc(st->index_entries,
1301
                              &st->index_entries_allocated_size,
1302
                              (st->nb_index_entries + 1) *
1303
                              sizeof(AVIndexEntry));
1304
    if(!entries)
1305
        return -1;
1306

    
1307
    st->index_entries= entries;
1308

    
1309
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1310

    
1311
    if(index<0){
1312
        index= st->nb_index_entries++;
1313
        ie= &entries[index];
1314
        assert(index==0 || ie[-1].timestamp < timestamp);
1315
    }else{
1316
        ie= &entries[index];
1317
        if(ie->timestamp != timestamp){
1318
            if(ie->timestamp <= timestamp)
1319
                return -1;
1320
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1321
            st->nb_index_entries++;
1322
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1323
            distance= ie->min_distance;
1324
    }
1325

    
1326
    ie->pos = pos;
1327
    ie->timestamp = timestamp;
1328
    ie->min_distance= distance;
1329
    ie->size= size;
1330
    ie->flags = flags;
1331

    
1332
    return index;
1333
}
1334

    
1335
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1336
                              int flags)
1337
{
1338
    AVIndexEntry *entries= st->index_entries;
1339
    int nb_entries= st->nb_index_entries;
1340
    int a, b, m;
1341
    int64_t timestamp;
1342

    
1343
    a = - 1;
1344
    b = nb_entries;
1345

    
1346
    while (b - a > 1) {
1347
        m = (a + b) >> 1;
1348
        timestamp = entries[m].timestamp;
1349
        if(timestamp >= wanted_timestamp)
1350
            b = m;
1351
        if(timestamp <= wanted_timestamp)
1352
            a = m;
1353
    }
1354
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1355

    
1356
    if(!(flags & AVSEEK_FLAG_ANY)){
1357
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1358
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1359
        }
1360
    }
1361

    
1362
    if(m == nb_entries)
1363
        return -1;
1364
    return  m;
1365
}
1366

    
1367
#define DEBUG_SEEK
1368

    
1369
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1370
    AVInputFormat *avif= s->iformat;
1371
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1372
    int64_t ts_min, ts_max, ts;
1373
    int index;
1374
    int64_t ret;
1375
    AVStream *st;
1376

    
1377
    if (stream_index < 0)
1378
        return -1;
1379

    
1380
#ifdef DEBUG_SEEK
1381
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1382
#endif
1383

    
1384
    ts_max=
1385
    ts_min= AV_NOPTS_VALUE;
1386
    pos_limit= -1; //gcc falsely says it may be uninitialized
1387

    
1388
    st= s->streams[stream_index];
1389
    if(st->index_entries){
1390
        AVIndexEntry *e;
1391

    
1392
        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()
1393
        index= FFMAX(index, 0);
1394
        e= &st->index_entries[index];
1395

    
1396
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1397
            pos_min= e->pos;
1398
            ts_min= e->timestamp;
1399
#ifdef DEBUG_SEEK
1400
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1401
                   pos_min,ts_min);
1402
#endif
1403
        }else{
1404
            assert(index==0);
1405
        }
1406

    
1407
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1408
        assert(index < st->nb_index_entries);
1409
        if(index >= 0){
1410
            e= &st->index_entries[index];
1411
            assert(e->timestamp >= target_ts);
1412
            pos_max= e->pos;
1413
            ts_max= e->timestamp;
1414
            pos_limit= pos_max - e->min_distance;
1415
#ifdef DEBUG_SEEK
1416
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1417
                   pos_max,pos_limit, ts_max);
1418
#endif
1419
        }
1420
    }
1421

    
1422
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1423
    if(pos<0)
1424
        return -1;
1425

    
1426
    /* do the seek */
1427
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1428
        return ret;
1429

    
1430
    av_update_cur_dts(s, st, ts);
1431

    
1432
    return 0;
1433
}
1434

    
1435
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 )){
1436
    int64_t pos, ts;
1437
    int64_t start_pos, filesize;
1438
    int no_change;
1439

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

    
1444
    if(ts_min == AV_NOPTS_VALUE){
1445
        pos_min = s->data_offset;
1446
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1447
        if (ts_min == AV_NOPTS_VALUE)
1448
            return -1;
1449
    }
1450

    
1451
    if(ts_max == AV_NOPTS_VALUE){
1452
        int step= 1024;
1453
        filesize = url_fsize(s->pb);
1454
        pos_max = filesize - 1;
1455
        do{
1456
            pos_max -= step;
1457
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1458
            step += step;
1459
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1460
        if (ts_max == AV_NOPTS_VALUE)
1461
            return -1;
1462

    
1463
        for(;;){
1464
            int64_t tmp_pos= pos_max + 1;
1465
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1466
            if(tmp_ts == AV_NOPTS_VALUE)
1467
                break;
1468
            ts_max= tmp_ts;
1469
            pos_max= tmp_pos;
1470
            if(tmp_pos >= filesize)
1471
                break;
1472
        }
1473
        pos_limit= pos_max;
1474
    }
1475

    
1476
    if(ts_min > ts_max){
1477
        return -1;
1478
    }else if(ts_min == ts_max){
1479
        pos_limit= pos_min;
1480
    }
1481

    
1482
    no_change=0;
1483
    while (pos_min < pos_limit) {
1484
#ifdef DEBUG_SEEK
1485
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1486
               pos_min, pos_max,
1487
               ts_min, ts_max);
1488
#endif
1489
        assert(pos_limit <= pos_max);
1490

    
1491
        if(no_change==0){
1492
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1493
            // interpolate position (better than dichotomy)
1494
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1495
                + pos_min - approximate_keyframe_distance;
1496
        }else if(no_change==1){
1497
            // bisection, if interpolation failed to change min or max pos last time
1498
            pos = (pos_min + pos_limit)>>1;
1499
        }else{
1500
            /* linear search if bisection failed, can only happen if there
1501
               are very few or no keyframes between min/max */
1502
            pos=pos_min;
1503
        }
1504
        if(pos <= pos_min)
1505
            pos= pos_min + 1;
1506
        else if(pos > pos_limit)
1507
            pos= pos_limit;
1508
        start_pos= pos;
1509

    
1510
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1511
        if(pos == pos_max)
1512
            no_change++;
1513
        else
1514
            no_change=0;
1515
#ifdef DEBUG_SEEK
1516
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1517
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1518
               start_pos, no_change);
1519
#endif
1520
        if(ts == AV_NOPTS_VALUE){
1521
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1522
            return -1;
1523
        }
1524
        assert(ts != AV_NOPTS_VALUE);
1525
        if (target_ts <= ts) {
1526
            pos_limit = start_pos - 1;
1527
            pos_max = pos;
1528
            ts_max = ts;
1529
        }
1530
        if (target_ts >= ts) {
1531
            pos_min = pos;
1532
            ts_min = ts;
1533
        }
1534
    }
1535

    
1536
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1537
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1538
#ifdef DEBUG_SEEK
1539
    pos_min = pos;
1540
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1541
    pos_min++;
1542
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1543
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1544
           pos, ts_min, target_ts, ts_max);
1545
#endif
1546
    *ts_ret= ts;
1547
    return pos;
1548
}
1549

    
1550
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1551
    int64_t pos_min, pos_max;
1552
#if 0
1553
    AVStream *st;
1554

1555
    if (stream_index < 0)
1556
        return -1;
1557

1558
    st= s->streams[stream_index];
1559
#endif
1560

    
1561
    pos_min = s->data_offset;
1562
    pos_max = url_fsize(s->pb) - 1;
1563

    
1564
    if     (pos < pos_min) pos= pos_min;
1565
    else if(pos > pos_max) pos= pos_max;
1566

    
1567
    url_fseek(s->pb, pos, SEEK_SET);
1568

    
1569
#if 0
1570
    av_update_cur_dts(s, st, ts);
1571
#endif
1572
    return 0;
1573
}
1574

    
1575
static int av_seek_frame_generic(AVFormatContext *s,
1576
                                 int stream_index, int64_t timestamp, int flags)
1577
{
1578
    int index;
1579
    int64_t ret;
1580
    AVStream *st;
1581
    AVIndexEntry *ie;
1582

    
1583
    st = s->streams[stream_index];
1584

    
1585
    index = av_index_search_timestamp(st, timestamp, flags);
1586

    
1587
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1588
        return -1;
1589

    
1590
    if(index < 0 || index==st->nb_index_entries-1){
1591
        int i;
1592
        AVPacket pkt;
1593

    
1594
        if(st->nb_index_entries){
1595
            assert(st->index_entries);
1596
            ie= &st->index_entries[st->nb_index_entries-1];
1597
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1598
                return ret;
1599
            av_update_cur_dts(s, st, ie->timestamp);
1600
        }else{
1601
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1602
                return ret;
1603
        }
1604
        for(i=0;; i++) {
1605
            int ret;
1606
            do{
1607
                ret = av_read_frame(s, &pkt);
1608
            }while(ret == AVERROR(EAGAIN));
1609
            if(ret<0)
1610
                break;
1611
            av_free_packet(&pkt);
1612
            if(stream_index == pkt.stream_index){
1613
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1614
                    break;
1615
            }
1616
        }
1617
        index = av_index_search_timestamp(st, timestamp, flags);
1618
    }
1619
    if (index < 0)
1620
        return -1;
1621

    
1622
    av_read_frame_flush(s);
1623
    if (s->iformat->read_seek){
1624
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1625
            return 0;
1626
    }
1627
    ie = &st->index_entries[index];
1628
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1629
        return ret;
1630
    av_update_cur_dts(s, st, ie->timestamp);
1631

    
1632
    return 0;
1633
}
1634

    
1635
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1636
{
1637
    int ret;
1638
    AVStream *st;
1639

    
1640
    av_read_frame_flush(s);
1641

    
1642
    if(flags & AVSEEK_FLAG_BYTE)
1643
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1644

    
1645
    if(stream_index < 0){
1646
        stream_index= av_find_default_stream_index(s);
1647
        if(stream_index < 0)
1648
            return -1;
1649

    
1650
        st= s->streams[stream_index];
1651
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1652
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1653
    }
1654

    
1655
    /* first, we try the format specific seek */
1656
    if (s->iformat->read_seek)
1657
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1658
    else
1659
        ret = -1;
1660
    if (ret >= 0) {
1661
        return 0;
1662
    }
1663

    
1664
    if(s->iformat->read_timestamp)
1665
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1666
    else
1667
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1668
}
1669

    
1670
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1671
{
1672
    if(min_ts > ts || max_ts < ts)
1673
        return -1;
1674

    
1675
    av_read_frame_flush(s);
1676

    
1677
    if (s->iformat->read_seek2)
1678
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1679

    
1680
    if(s->iformat->read_timestamp){
1681
        //try to seek via read_timestamp()
1682
    }
1683

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

    
1689
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1690
}
1691

    
1692
/*******************************************************/
1693

    
1694
/**
1695
 * Returns TRUE if the stream has accurate duration in any stream.
1696
 *
1697
 * @return TRUE if the stream has accurate duration for at least one component.
1698
 */
1699
static int av_has_duration(AVFormatContext *ic)
1700
{
1701
    int i;
1702
    AVStream *st;
1703

    
1704
    for(i = 0;i < ic->nb_streams; i++) {
1705
        st = ic->streams[i];
1706
        if (st->duration != AV_NOPTS_VALUE)
1707
            return 1;
1708
    }
1709
    return 0;
1710
}
1711

    
1712
/**
1713
 * Estimate the stream timings from the one of each components.
1714
 *
1715
 * Also computes the global bitrate if possible.
1716
 */
1717
static void av_update_stream_timings(AVFormatContext *ic)
1718
{
1719
    int64_t start_time, start_time1, end_time, end_time1;
1720
    int64_t duration, duration1;
1721
    int i;
1722
    AVStream *st;
1723

    
1724
    start_time = INT64_MAX;
1725
    end_time = INT64_MIN;
1726
    duration = INT64_MIN;
1727
    for(i = 0;i < ic->nb_streams; i++) {
1728
        st = ic->streams[i];
1729
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1730
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1731
            if (start_time1 < start_time)
1732
                start_time = start_time1;
1733
            if (st->duration != AV_NOPTS_VALUE) {
1734
                end_time1 = start_time1
1735
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1736
                if (end_time1 > end_time)
1737
                    end_time = end_time1;
1738
            }
1739
        }
1740
        if (st->duration != AV_NOPTS_VALUE) {
1741
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1742
            if (duration1 > duration)
1743
                duration = duration1;
1744
        }
1745
    }
1746
    if (start_time != INT64_MAX) {
1747
        ic->start_time = start_time;
1748
        if (end_time != INT64_MIN) {
1749
            if (end_time - start_time > duration)
1750
                duration = end_time - start_time;
1751
        }
1752
    }
1753
    if (duration != INT64_MIN) {
1754
        ic->duration = duration;
1755
        if (ic->file_size > 0) {
1756
            /* compute the bitrate */
1757
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1758
                (double)ic->duration;
1759
        }
1760
    }
1761
}
1762

    
1763
static void fill_all_stream_timings(AVFormatContext *ic)
1764
{
1765
    int i;
1766
    AVStream *st;
1767

    
1768
    av_update_stream_timings(ic);
1769
    for(i = 0;i < ic->nb_streams; i++) {
1770
        st = ic->streams[i];
1771
        if (st->start_time == AV_NOPTS_VALUE) {
1772
            if(ic->start_time != AV_NOPTS_VALUE)
1773
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1774
            if(ic->duration != AV_NOPTS_VALUE)
1775
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1776
        }
1777
    }
1778
}
1779

    
1780
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1781
{
1782
    int64_t filesize, duration;
1783
    int bit_rate, i;
1784
    AVStream *st;
1785

    
1786
    /* if bit_rate is already set, we believe it */
1787
    if (ic->bit_rate == 0) {
1788
        bit_rate = 0;
1789
        for(i=0;i<ic->nb_streams;i++) {
1790
            st = ic->streams[i];
1791
            bit_rate += st->codec->bit_rate;
1792
        }
1793
        ic->bit_rate = bit_rate;
1794
    }
1795

    
1796
    /* if duration is already set, we believe it */
1797
    if (ic->duration == AV_NOPTS_VALUE &&
1798
        ic->bit_rate != 0 &&
1799
        ic->file_size != 0)  {
1800
        filesize = ic->file_size;
1801
        if (filesize > 0) {
1802
            for(i = 0; i < ic->nb_streams; i++) {
1803
                st = ic->streams[i];
1804
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1805
                if (st->duration == AV_NOPTS_VALUE)
1806
                    st->duration = duration;
1807
            }
1808
        }
1809
    }
1810
}
1811

    
1812
#define DURATION_MAX_READ_SIZE 250000
1813
#define DURATION_MAX_RETRY 3
1814

    
1815
/* only usable for MPEG-PS streams */
1816
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1817
{
1818
    AVPacket pkt1, *pkt = &pkt1;
1819
    AVStream *st;
1820
    int read_size, i, ret;
1821
    int64_t end_time, start_time[MAX_STREAMS];
1822
    int64_t filesize, offset, duration;
1823
    int retry=0;
1824

    
1825
    ic->cur_st = NULL;
1826

    
1827
    /* flush packet queue */
1828
    flush_packet_queue(ic);
1829

    
1830
    for(i=0;i<ic->nb_streams;i++) {
1831
        st = ic->streams[i];
1832
        if(st->start_time != AV_NOPTS_VALUE){
1833
            start_time[i]= st->start_time;
1834
        }else if(st->first_dts != AV_NOPTS_VALUE){
1835
            start_time[i]= st->first_dts;
1836
        }else
1837
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1838

    
1839
        if (st->parser) {
1840
            av_parser_close(st->parser);
1841
            st->parser= NULL;
1842
            av_free_packet(&st->cur_pkt);
1843
        }
1844
    }
1845

    
1846
    /* estimate the end time (duration) */
1847
    /* XXX: may need to support wrapping */
1848
    filesize = ic->file_size;
1849
    end_time = AV_NOPTS_VALUE;
1850
    do{
1851
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1852
    if (offset < 0)
1853
        offset = 0;
1854

    
1855
    url_fseek(ic->pb, offset, SEEK_SET);
1856
    read_size = 0;
1857
    for(;;) {
1858
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1859
            break;
1860

    
1861
        do{
1862
            ret = av_read_packet(ic, pkt);
1863
        }while(ret == AVERROR(EAGAIN));
1864
        if (ret != 0)
1865
            break;
1866
        read_size += pkt->size;
1867
        st = ic->streams[pkt->stream_index];
1868
        if (pkt->pts != AV_NOPTS_VALUE &&
1869
            start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1870
            end_time = pkt->pts;
1871
            duration = end_time - start_time[pkt->stream_index];
1872
            if (duration < 0)
1873
                duration += 1LL<<st->pts_wrap_bits;
1874
            if (duration > 0) {
1875
                if (st->duration == AV_NOPTS_VALUE ||
1876
                    st->duration < duration)
1877
                    st->duration = duration;
1878
            }
1879
        }
1880
        av_free_packet(pkt);
1881
    }
1882
    }while(   end_time==AV_NOPTS_VALUE
1883
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1884
           && ++retry <= DURATION_MAX_RETRY);
1885

    
1886
    fill_all_stream_timings(ic);
1887

    
1888
    url_fseek(ic->pb, old_offset, SEEK_SET);
1889
    for(i=0; i<ic->nb_streams; i++){
1890
        st= ic->streams[i];
1891
        st->cur_dts= st->first_dts;
1892
        st->last_IP_pts = AV_NOPTS_VALUE;
1893
    }
1894
}
1895

    
1896
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1897
{
1898
    int64_t file_size;
1899

    
1900
    /* get the file size, if possible */
1901
    if (ic->iformat->flags & AVFMT_NOFILE) {
1902
        file_size = 0;
1903
    } else {
1904
        file_size = url_fsize(ic->pb);
1905
        if (file_size < 0)
1906
            file_size = 0;
1907
    }
1908
    ic->file_size = file_size;
1909

    
1910
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1911
         !strcmp(ic->iformat->name, "mpegts")) &&
1912
        file_size && !url_is_streamed(ic->pb)) {
1913
        /* get accurate estimate from the PTSes */
1914
        av_estimate_timings_from_pts(ic, old_offset);
1915
    } else if (av_has_duration(ic)) {
1916
        /* at least one component has timings - we use them for all
1917
           the components */
1918
        fill_all_stream_timings(ic);
1919
    } else {
1920
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1921
        /* less precise: use bitrate info */
1922
        av_estimate_timings_from_bit_rate(ic);
1923
    }
1924
    av_update_stream_timings(ic);
1925

    
1926
#if 0
1927
    {
1928
        int i;
1929
        AVStream *st;
1930
        for(i = 0;i < ic->nb_streams; i++) {
1931
            st = ic->streams[i];
1932
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1933
               i, (double)st->start_time / AV_TIME_BASE,
1934
               (double)st->duration / AV_TIME_BASE);
1935
        }
1936
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1937
               (double)ic->start_time / AV_TIME_BASE,
1938
               (double)ic->duration / AV_TIME_BASE,
1939
               ic->bit_rate / 1000);
1940
    }
1941
#endif
1942
}
1943

    
1944
static int has_codec_parameters(AVCodecContext *enc)
1945
{
1946
    int val;
1947
    switch(enc->codec_type) {
1948
    case CODEC_TYPE_AUDIO:
1949
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1950
        if(!enc->frame_size &&
1951
           (enc->codec_id == CODEC_ID_VORBIS ||
1952
            enc->codec_id == CODEC_ID_AAC ||
1953
            enc->codec_id == CODEC_ID_MP1 ||
1954
            enc->codec_id == CODEC_ID_MP2 ||
1955
            enc->codec_id == CODEC_ID_MP3 ||
1956
            enc->codec_id == CODEC_ID_SPEEX))
1957
            return 0;
1958
        break;
1959
    case CODEC_TYPE_VIDEO:
1960
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1961
        break;
1962
    default:
1963
        val = 1;
1964
        break;
1965
    }
1966
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1967
}
1968

    
1969
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1970
{
1971
    int16_t *samples;
1972
    AVCodec *codec;
1973
    int got_picture, data_size, ret=0;
1974
    AVFrame picture;
1975

    
1976
    if(!st->codec->codec){
1977
        codec = avcodec_find_decoder(st->codec->codec_id);
1978
        if (!codec)
1979
            return -1;
1980
        ret = avcodec_open(st->codec, codec);
1981
        if (ret < 0)
1982
            return ret;
1983
    }
1984

    
1985
    if(!has_codec_parameters(st->codec)){
1986
        switch(st->codec->codec_type) {
1987
        case CODEC_TYPE_VIDEO:
1988
            avcodec_get_frame_defaults(&picture);
1989
            ret = avcodec_decode_video2(st->codec, &picture,
1990
                                        &got_picture, avpkt);
1991
            break;
1992
        case CODEC_TYPE_AUDIO:
1993
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1994
            samples = av_malloc(data_size);
1995
            if (!samples)
1996
                goto fail;
1997
            ret = avcodec_decode_audio3(st->codec, samples,
1998
                                        &data_size, avpkt);
1999
            av_free(samples);
2000
            break;
2001
        default:
2002
            break;
2003
        }
2004
    }
2005
 fail:
2006
    return ret;
2007
}
2008

    
2009
unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
2010
{
2011
    while (tags->id != CODEC_ID_NONE) {
2012
        if (tags->id == id)
2013
            return tags->tag;
2014
        tags++;
2015
    }
2016
    return 0;
2017
}
2018

    
2019
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2020
{
2021
    int i;
2022
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2023
        if(tag == tags[i].tag)
2024
            return tags[i].id;
2025
    }
2026
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2027
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
2028
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
2029
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
2030
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
2031
            return tags[i].id;
2032
    }
2033
    return CODEC_ID_NONE;
2034
}
2035

    
2036
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2037
{
2038
    int i;
2039
    for(i=0; tags && tags[i]; i++){
2040
        int tag= ff_codec_get_tag(tags[i], id);
2041
        if(tag) return tag;
2042
    }
2043
    return 0;
2044
}
2045

    
2046
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2047
{
2048
    int i;
2049
    for(i=0; tags && tags[i]; i++){
2050
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2051
        if(id!=CODEC_ID_NONE) return id;
2052
    }
2053
    return CODEC_ID_NONE;
2054
}
2055

    
2056
static void compute_chapters_end(AVFormatContext *s)
2057
{
2058
    unsigned int i;
2059

    
2060
    for (i=0; i+1<s->nb_chapters; i++)
2061
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2062
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2063
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2064
            s->chapters[i]->end = s->chapters[i+1]->start;
2065
        }
2066

    
2067
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2068
        assert(s->start_time != AV_NOPTS_VALUE);
2069
        assert(s->duration > 0);
2070
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2071
                                           AV_TIME_BASE_Q,
2072
                                           s->chapters[i]->time_base);
2073
    }
2074
}
2075

    
2076
#define MAX_STD_TIMEBASES (60*12+5)
2077
static int get_std_framerate(int i){
2078
    if(i<60*12) return i*1001;
2079
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2080
}
2081

    
2082
/*
2083
 * Is the time base unreliable.
2084
 * This is a heuristic to balance between quick acceptance of the values in
2085
 * the headers vs. some extra checks.
2086
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2087
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2088
 * And there are "variable" fps files this needs to detect as well.
2089
 */
2090
static int tb_unreliable(AVCodecContext *c){
2091
    if(   c->time_base.den >= 101L*c->time_base.num
2092
       || c->time_base.den <    5L*c->time_base.num
2093
/*       || c->codec_tag == AV_RL32("DIVX")
2094
       || c->codec_tag == AV_RL32("XVID")*/
2095
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2096
       || c->codec_id == CODEC_ID_H264
2097
       )
2098
        return 1;
2099
    return 0;
2100
}
2101

    
2102
int av_find_stream_info(AVFormatContext *ic)
2103
{
2104
    int i, count, ret, read_size, j;
2105
    AVStream *st;
2106
    AVPacket pkt1, *pkt;
2107
    int64_t last_dts[MAX_STREAMS];
2108
    int64_t duration_gcd[MAX_STREAMS]={0};
2109
    int duration_count[MAX_STREAMS]={0};
2110
    double (*duration_error)[MAX_STD_TIMEBASES];
2111
    int64_t old_offset = url_ftell(ic->pb);
2112
    int64_t codec_info_duration[MAX_STREAMS]={0};
2113

    
2114
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2115
    if (!duration_error) return AVERROR(ENOMEM);
2116

    
2117
    for(i=0;i<ic->nb_streams;i++) {
2118
        st = ic->streams[i];
2119
        if (st->codec->codec_id == CODEC_ID_AAC) {
2120
            st->codec->sample_rate = 0;
2121
            st->codec->frame_size = 0;
2122
            st->codec->channels = 0;
2123
        }
2124
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2125
/*            if(!st->time_base.num)
2126
                st->time_base= */
2127
            if(!st->codec->time_base.num)
2128
                st->codec->time_base= st->time_base;
2129
        }
2130
        //only for the split stuff
2131
        if (!st->parser) {
2132
            st->parser = av_parser_init(st->codec->codec_id);
2133
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2134
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2135
            }
2136
        }
2137
        assert(!st->codec->codec);
2138
        //try to just open decoders, in case this is enough to get parameters
2139
        if(!has_codec_parameters(st->codec)){
2140
            AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
2141
            if (codec)
2142
                avcodec_open(st->codec, codec);
2143
        }
2144
    }
2145

    
2146
    for(i=0;i<MAX_STREAMS;i++){
2147
        last_dts[i]= AV_NOPTS_VALUE;
2148
    }
2149

    
2150
    count = 0;
2151
    read_size = 0;
2152
    for(;;) {
2153
        if(url_interrupt_cb()){
2154
            ret= AVERROR(EINTR);
2155
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2156
            break;
2157
        }
2158

    
2159
        /* check if one codec still needs to be handled */
2160
        for(i=0;i<ic->nb_streams;i++) {
2161
            st = ic->streams[i];
2162
            if (!has_codec_parameters(st->codec))
2163
                break;
2164
            /* variable fps and no guess at the real fps */
2165
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2166
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2167
                break;
2168
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2169
                break;
2170
            if(st->first_dts == AV_NOPTS_VALUE)
2171
                break;
2172
        }
2173
        if (i == ic->nb_streams) {
2174
            /* NOTE: if the format has no header, then we need to read
2175
               some packets to get most of the streams, so we cannot
2176
               stop here */
2177
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2178
                /* if we found the info for all the codecs, we can stop */
2179
                ret = count;
2180
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2181
                break;
2182
            }
2183
        }
2184
        /* we did not get all the codec info, but we read too much data */
2185
        if (read_size >= ic->probesize) {
2186
            ret = count;
2187
            av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2188
            break;
2189
        }
2190

    
2191
        /* NOTE: a new stream can be added there if no header in file
2192
           (AVFMTCTX_NOHEADER) */
2193
        ret = av_read_frame_internal(ic, &pkt1);
2194
        if(ret == AVERROR(EAGAIN))
2195
            continue;
2196
        if (ret < 0) {
2197
            /* EOF or error */
2198
            ret = -1; /* we could not have all the codec parameters before EOF */
2199
            for(i=0;i<ic->nb_streams;i++) {
2200
                st = ic->streams[i];
2201
                if (!has_codec_parameters(st->codec)){
2202
                    char buf[256];
2203
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2204
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2205
                } else {
2206
                    ret = 0;
2207
                }
2208
            }
2209
            break;
2210
        }
2211

    
2212
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2213
        if(av_dup_packet(pkt) < 0) {
2214
            av_free(duration_error);
2215
            return AVERROR(ENOMEM);
2216
        }
2217

    
2218
        read_size += pkt->size;
2219

    
2220
        st = ic->streams[pkt->stream_index];
2221
        if(st->codec_info_nb_frames>1) {
2222
            if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
2223
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2224
                break;
2225
            }
2226
            codec_info_duration[st->index] += pkt->duration;
2227
        }
2228
            st->codec_info_nb_frames++;
2229

    
2230
        {
2231
            int index= pkt->stream_index;
2232
            int64_t last= last_dts[index];
2233
            int64_t duration= pkt->dts - last;
2234

    
2235
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2236
                double dur= duration * av_q2d(st->time_base);
2237

    
2238
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2239
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2240
                if(duration_count[index] < 2)
2241
                    memset(duration_error[index], 0, sizeof(*duration_error));
2242
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2243
                    int framerate= get_std_framerate(i);
2244
                    int ticks= lrintf(dur*framerate/(1001*12));
2245
                    double error= dur - ticks*1001*12/(double)framerate;
2246
                    duration_error[index][i] += error*error;
2247
                }
2248
                duration_count[index]++;
2249
                // ignore the first 4 values, they might have some random jitter
2250
                if (duration_count[index] > 3)
2251
                    duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2252
            }
2253
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2254
                last_dts[pkt->stream_index]= pkt->dts;
2255
        }
2256
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2257
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2258
            if(i){
2259
                st->codec->extradata_size= i;
2260
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2261
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2262
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2263
            }
2264
        }
2265

    
2266
        /* if still no information, we try to open the codec and to
2267
           decompress the frame. We try to avoid that in most cases as
2268
           it takes longer and uses more memory. For MPEG-4, we need to
2269
           decompress for QuickTime. */
2270
        if (!has_codec_parameters(st->codec))
2271
            try_decode_frame(st, pkt);
2272

    
2273
        count++;
2274
    }
2275

    
2276
    // close codecs which were opened in try_decode_frame()
2277
    for(i=0;i<ic->nb_streams;i++) {
2278
        st = ic->streams[i];
2279
        if(st->codec->codec)
2280
            avcodec_close(st->codec);
2281
    }
2282
    for(i=0;i<ic->nb_streams;i++) {
2283
        st = ic->streams[i];
2284
        if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
2285
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2286
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2287
                      codec_info_duration[i]    *(int64_t)st->time_base.num, 60000);
2288
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2289
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2290
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2291

    
2292
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2293
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2294
            // ipmovie.c produces.
2295
            if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
2296
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
2297
            if(duration_count[i] && !st->r_frame_rate.num
2298
               && tb_unreliable(st->codec) /*&&
2299
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2300
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2301
                int num = 0;
2302
                double best_error= 2*av_q2d(st->time_base);
2303
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2304

    
2305
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2306
                    double error= duration_error[i][j] * get_std_framerate(j);
2307
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2308
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2309
                    if(error < best_error){
2310
                        best_error= error;
2311
                        num = get_std_framerate(j);
2312
                    }
2313
                }
2314
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2315
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2316
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2317
            }
2318

    
2319
            if (!st->r_frame_rate.num){
2320
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2321
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2322
                    st->r_frame_rate.num = st->codec->time_base.den;
2323
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2324
                }else{
2325
                    st->r_frame_rate.num = st->time_base.den;
2326
                    st->r_frame_rate.den = st->time_base.num;
2327
                }
2328
            }
2329
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2330
            if(!st->codec->bits_per_coded_sample)
2331
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2332
        }
2333
    }
2334

    
2335
    av_estimate_timings(ic, old_offset);
2336

    
2337
    compute_chapters_end(ic);
2338

    
2339
#if 0
2340
    /* correct DTS for B-frame streams with no timestamps */
2341
    for(i=0;i<ic->nb_streams;i++) {
2342
        st = ic->streams[i];
2343
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2344
            if(b-frames){
2345
                ppktl = &ic->packet_buffer;
2346
                while(ppkt1){
2347
                    if(ppkt1->stream_index != i)
2348
                        continue;
2349
                    if(ppkt1->pkt->dts < 0)
2350
                        break;
2351
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2352
                        break;
2353
                    ppkt1->pkt->dts -= delta;
2354
                    ppkt1= ppkt1->next;
2355
                }
2356
                if(ppkt1)
2357
                    continue;
2358
                st->cur_dts -= delta;
2359
            }
2360
        }
2361
    }
2362
#endif
2363

    
2364
    av_free(duration_error);
2365

    
2366
    return ret;
2367
}
2368

    
2369
/*******************************************************/
2370

    
2371
int av_read_play(AVFormatContext *s)
2372
{
2373
    if (s->iformat->read_play)
2374
        return s->iformat->read_play(s);
2375
    if (s->pb)
2376
        return av_url_read_fpause(s->pb, 0);
2377
    return AVERROR(ENOSYS);
2378
}
2379

    
2380
int av_read_pause(AVFormatContext *s)
2381
{
2382
    if (s->iformat->read_pause)
2383
        return s->iformat->read_pause(s);
2384
    if (s->pb)
2385
        return av_url_read_fpause(s->pb, 1);
2386
    return AVERROR(ENOSYS);
2387
}
2388

    
2389
void av_close_input_stream(AVFormatContext *s)
2390
{
2391
    int i;
2392
    AVStream *st;
2393

    
2394
    if (s->iformat->read_close)
2395
        s->iformat->read_close(s);
2396
    for(i=0;i<s->nb_streams;i++) {
2397
        /* free all data in a stream component */
2398
        st = s->streams[i];
2399
        if (st->parser) {
2400
            av_parser_close(st->parser);
2401
            av_free_packet(&st->cur_pkt);
2402
        }
2403
        av_metadata_free(&st->metadata);
2404
        av_free(st->index_entries);
2405
        av_free(st->codec->extradata);
2406
        av_free(st->codec);
2407
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2408
        av_free(st->filename);
2409
#endif
2410
        av_free(st->priv_data);
2411
        av_free(st);
2412
    }
2413
    for(i=s->nb_programs-1; i>=0; i--) {
2414
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2415
        av_freep(&s->programs[i]->provider_name);
2416
        av_freep(&s->programs[i]->name);
2417
#endif
2418
        av_metadata_free(&s->programs[i]->metadata);
2419
        av_freep(&s->programs[i]->stream_index);
2420
        av_freep(&s->programs[i]);
2421
    }
2422
    av_freep(&s->programs);
2423
    flush_packet_queue(s);
2424
    av_freep(&s->priv_data);
2425
    while(s->nb_chapters--) {
2426
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2427
        av_free(s->chapters[s->nb_chapters]->title);
2428
#endif
2429
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2430
        av_free(s->chapters[s->nb_chapters]);
2431
    }
2432
    av_freep(&s->chapters);
2433
    av_metadata_free(&s->metadata);
2434
    av_free(s);
2435
}
2436

    
2437
void av_close_input_file(AVFormatContext *s)
2438
{
2439
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2440
    av_close_input_stream(s);
2441
    if (pb)
2442
        url_fclose(pb);
2443
}
2444

    
2445
AVStream *av_new_stream(AVFormatContext *s, int id)
2446
{
2447
    AVStream *st;
2448
    int i;
2449

    
2450
    if (s->nb_streams >= MAX_STREAMS)
2451
        return NULL;
2452

    
2453
    st = av_mallocz(sizeof(AVStream));
2454
    if (!st)
2455
        return NULL;
2456

    
2457
    st->codec= avcodec_alloc_context();
2458
    if (s->iformat) {
2459
        /* no default bitrate if decoding */
2460
        st->codec->bit_rate = 0;
2461
    }
2462
    st->index = s->nb_streams;
2463
    st->id = id;
2464
    st->start_time = AV_NOPTS_VALUE;
2465
    st->duration = AV_NOPTS_VALUE;
2466
        /* we set the current DTS to 0 so that formats without any timestamps
2467
           but durations get some timestamps, formats with some unknown
2468
           timestamps have their first few packets buffered and the
2469
           timestamps corrected before they are returned to the user */
2470
    st->cur_dts = 0;
2471
    st->first_dts = AV_NOPTS_VALUE;
2472
    st->probe_packets = MAX_PROBE_PACKETS;
2473

    
2474
    /* default pts setting is MPEG-like */
2475
    av_set_pts_info(st, 33, 1, 90000);
2476
    st->last_IP_pts = AV_NOPTS_VALUE;
2477
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2478
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2479
    st->reference_dts = AV_NOPTS_VALUE;
2480

    
2481
    st->sample_aspect_ratio = (AVRational){0,1};
2482

    
2483
    s->streams[s->nb_streams++] = st;
2484
    return st;
2485
}
2486

    
2487
AVProgram *av_new_program(AVFormatContext *ac, int id)
2488
{
2489
    AVProgram *program=NULL;
2490
    int i;
2491

    
2492
#ifdef DEBUG_SI
2493
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2494
#endif
2495

    
2496
    for(i=0; i<ac->nb_programs; i++)
2497
        if(ac->programs[i]->id == id)
2498
            program = ac->programs[i];
2499

    
2500
    if(!program){
2501
        program = av_mallocz(sizeof(AVProgram));
2502
        if (!program)
2503
            return NULL;
2504
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2505
        program->discard = AVDISCARD_NONE;
2506
    }
2507
    program->id = id;
2508

    
2509
    return program;
2510
}
2511

    
2512
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2513
{
2514
    AVChapter *chapter = NULL;
2515
    int i;
2516

    
2517
    for(i=0; i<s->nb_chapters; i++)
2518
        if(s->chapters[i]->id == id)
2519
            chapter = s->chapters[i];
2520

    
2521
    if(!chapter){
2522
        chapter= av_mallocz(sizeof(AVChapter));
2523
        if(!chapter)
2524
            return NULL;
2525
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2526
    }
2527
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2528
    av_free(chapter->title);
2529
#endif
2530
    av_metadata_set(&chapter->metadata, "title", title);
2531
    chapter->id    = id;
2532
    chapter->time_base= time_base;
2533
    chapter->start = start;
2534
    chapter->end   = end;
2535

    
2536
    return chapter;
2537
}
2538

    
2539
/************************************************************/
2540
/* output media file */
2541

    
2542
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2543
{
2544
    int ret;
2545

    
2546
    if (s->oformat->priv_data_size > 0) {
2547
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2548
        if (!s->priv_data)
2549
            return AVERROR(ENOMEM);
2550
    } else
2551
        s->priv_data = NULL;
2552

    
2553
    if (s->oformat->set_parameters) {
2554
        ret = s->oformat->set_parameters(s, ap);
2555
        if (ret < 0)
2556
            return ret;
2557
    }
2558
    return 0;
2559
}
2560

    
2561
int av_write_header(AVFormatContext *s)
2562
{
2563
    int ret, i;
2564
    AVStream *st;
2565

    
2566
    // some sanity checks
2567
    if (s->nb_streams == 0) {
2568
        av_log(s, AV_LOG_ERROR, "no streams\n");
2569
        return -1;
2570
    }
2571

    
2572
    for(i=0;i<s->nb_streams;i++) {
2573
        st = s->streams[i];
2574

    
2575
        switch (st->codec->codec_type) {
2576
        case CODEC_TYPE_AUDIO:
2577
            if(st->codec->sample_rate<=0){
2578
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2579
                return -1;
2580
            }
2581
            if(!st->codec->block_align)
2582
                st->codec->block_align = st->codec->channels *
2583
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2584
            break;
2585
        case CODEC_TYPE_VIDEO:
2586
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2587
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2588
                return -1;
2589
            }
2590
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2591
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2592
                return -1;
2593
            }
2594
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2595
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2596
                return -1;
2597
            }
2598
            break;
2599
        }
2600

    
2601
        if(s->oformat->codec_tag){
2602
            if(st->codec->codec_tag){
2603
                //FIXME
2604
                //check that tag + id is in the table
2605
                //if neither is in the table -> OK
2606
                //if tag is in the table with another id -> FAIL
2607
                //if id is in the table with another tag -> FAIL unless strict < ?
2608
            }else
2609
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2610
        }
2611

    
2612
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2613
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2614
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2615
    }
2616

    
2617
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2618
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2619
        if (!s->priv_data)
2620
            return AVERROR(ENOMEM);
2621
    }
2622

    
2623
#if LIBAVFORMAT_VERSION_MAJOR < 53
2624
    ff_metadata_mux_compat(s);
2625
#endif
2626

    
2627
    /* set muxer identification string */
2628
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2629
        AVMetadata *m;
2630
        AVMetadataTag *t;
2631

    
2632
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2633
            return AVERROR(ENOMEM);
2634
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2635
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2636
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2637
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2638
        av_metadata_free(&m);
2639
    }
2640

    
2641
    if(s->oformat->write_header){
2642
        ret = s->oformat->write_header(s);
2643
        if (ret < 0)
2644
            return ret;
2645
    }
2646

    
2647
    /* init PTS generation */
2648
    for(i=0;i<s->nb_streams;i++) {
2649
        int64_t den = AV_NOPTS_VALUE;
2650
        st = s->streams[i];
2651

    
2652
        switch (st->codec->codec_type) {
2653
        case CODEC_TYPE_AUDIO:
2654
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2655
            break;
2656
        case CODEC_TYPE_VIDEO:
2657
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2658
            break;
2659
        default:
2660
            break;
2661
        }
2662
        if (den != AV_NOPTS_VALUE) {
2663
            if (den <= 0)
2664
                return AVERROR_INVALIDDATA;
2665
            av_frac_init(&st->pts, 0, 0, den);
2666
        }
2667
    }
2668
    return 0;
2669
}
2670

    
2671
//FIXME merge with compute_pkt_fields
2672
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2673
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2674
    int num, den, frame_size, i;
2675

    
2676
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2677

    
2678
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2679
        return -1;*/
2680

    
2681
    /* duration field */
2682
    if (pkt->duration == 0) {
2683
        compute_frame_duration(&num, &den, st, NULL, pkt);
2684
        if (den && num) {
2685
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2686
        }
2687
    }
2688

    
2689
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2690
        pkt->pts= pkt->dts;
2691

    
2692
    //XXX/FIXME this is a temporary hack until all encoders output pts
2693
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2694
        pkt->dts=
2695
//        pkt->pts= st->cur_dts;
2696
        pkt->pts= st->pts.val;
2697
    }
2698

    
2699
    //calculate dts from pts
2700
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2701
        st->pts_buffer[0]= pkt->pts;
2702
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2703
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2704
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2705
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2706

    
2707
        pkt->dts= st->pts_buffer[0];
2708
    }
2709

    
2710
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2711
        av_log(s, AV_LOG_ERROR,
2712
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2713
               st->index, st->cur_dts, pkt->dts);
2714
        return -1;
2715
    }
2716
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2717
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2718
        return -1;
2719
    }
2720

    
2721
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2722
    st->cur_dts= pkt->dts;
2723
    st->pts.val= pkt->dts;
2724

    
2725
    /* update pts */
2726
    switch (st->codec->codec_type) {
2727
    case CODEC_TYPE_AUDIO:
2728
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2729

    
2730
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2731
           likely equal to the encoder delay, but it would be better if we
2732
           had the real timestamps from the encoder */
2733
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2734
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2735
        }
2736
        break;
2737
    case CODEC_TYPE_VIDEO:
2738
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2739
        break;
2740
    default:
2741
        break;
2742
    }
2743
    return 0;
2744
}
2745

    
2746
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2747
{
2748
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2749

    
2750
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2751
        return ret;
2752

    
2753
    ret= s->oformat->write_packet(s, pkt);
2754
    if(!ret)
2755
        ret= url_ferror(s->pb);
2756
    return ret;
2757
}
2758

    
2759
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2760
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2761
{
2762
    AVPacketList **next_point, *this_pktl;
2763

    
2764
    this_pktl = av_mallocz(sizeof(AVPacketList));
2765
    this_pktl->pkt= *pkt;
2766
    pkt->destruct= NULL;             // do not free original but only the copy
2767
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2768

    
2769
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2770
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2771
    }else
2772
        next_point = &s->packet_buffer;
2773

    
2774
    if(*next_point){
2775
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2776
            while(!compare(s, &(*next_point)->pkt, pkt)){
2777
                next_point= &(*next_point)->next;
2778
            }
2779
            goto next_non_null;
2780
        }else{
2781
            next_point = &(s->packet_buffer_end->next);
2782
        }
2783
    }
2784
    assert(!*next_point);
2785

    
2786
    s->packet_buffer_end= this_pktl;
2787
next_non_null:
2788

    
2789
    this_pktl->next= *next_point;
2790

    
2791
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2792
    *next_point= this_pktl;
2793
}
2794

    
2795
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2796
{
2797
    AVStream *st = s->streams[ pkt ->stream_index];
2798
    AVStream *st2= s->streams[ next->stream_index];
2799
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2800
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2801
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2802
}
2803

    
2804
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2805
    AVPacketList *pktl;
2806
    int stream_count=0;
2807
    int i;
2808

    
2809
    if(pkt){
2810
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2811
    }
2812

    
2813
    for(i=0; i < s->nb_streams; i++)
2814
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2815

    
2816
    if(stream_count && (s->nb_streams == stream_count || flush)){
2817
        pktl= s->packet_buffer;
2818
        *out= pktl->pkt;
2819

    
2820
        s->packet_buffer= pktl->next;
2821
        if(!s->packet_buffer)
2822
            s->packet_buffer_end= NULL;
2823

    
2824
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2825
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2826
        av_freep(&pktl);
2827
        return 1;
2828
    }else{
2829
        av_init_packet(out);
2830
        return 0;
2831
    }
2832
}
2833

    
2834
/**
2835
 * Interleaves an AVPacket correctly so it can be muxed.
2836
 * @param out the interleaved packet will be output here
2837
 * @param in the input packet
2838
 * @param flush 1 if no further packets are available as input and all
2839
 *              remaining packets should be output
2840
 * @return 1 if a packet was output, 0 if no packet could be output,
2841
 *         < 0 if an error occurred
2842
 */
2843
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2844
    if(s->oformat->interleave_packet)
2845
        return s->oformat->interleave_packet(s, out, in, flush);
2846
    else
2847
        return av_interleave_packet_per_dts(s, out, in, flush);
2848
}
2849

    
2850
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2851
    AVStream *st= s->streams[ pkt->stream_index];
2852

    
2853
    //FIXME/XXX/HACK drop zero sized packets
2854
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2855
        return 0;
2856

    
2857
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2858
    if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2859
        return -1;
2860

    
2861
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2862
        return -1;
2863

    
2864
    for(;;){
2865
        AVPacket opkt;
2866
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2867
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2868
            return ret;
2869

    
2870
        ret= s->oformat->write_packet(s, &opkt);
2871

    
2872
        av_free_packet(&opkt);
2873
        pkt= NULL;
2874

    
2875
        if(ret<0)
2876
            return ret;
2877
        if(url_ferror(s->pb))
2878
            return url_ferror(s->pb);
2879
    }
2880
}
2881

    
2882
int av_write_trailer(AVFormatContext *s)
2883
{
2884
    int ret, i;
2885

    
2886
    for(;;){
2887
        AVPacket pkt;
2888
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2889
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2890
            goto fail;
2891
        if(!ret)
2892
            break;
2893

    
2894
        ret= s->oformat->write_packet(s, &pkt);
2895

    
2896
        av_free_packet(&pkt);
2897

    
2898
        if(ret<0)
2899
            goto fail;
2900
        if(url_ferror(s->pb))
2901
            goto fail;
2902
    }
2903

    
2904
    if(s->oformat->write_trailer)
2905
        ret = s->oformat->write_trailer(s);
2906
fail:
2907
    if(ret == 0)
2908
       ret=url_ferror(s->pb);
2909
    for(i=0;i<s->nb_streams;i++) {
2910
        av_freep(&s->streams[i]->priv_data);
2911
        av_freep(&s->streams[i]->index_entries);
2912
    }
2913
    av_freep(&s->priv_data);
2914
    return ret;
2915
}
2916

    
2917
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2918
{
2919
    int i, j;
2920
    AVProgram *program=NULL;
2921
    void *tmp;
2922

    
2923
    if (idx >= ac->nb_streams) {
2924
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2925
        return;
2926
    }
2927

    
2928
    for(i=0; i<ac->nb_programs; i++){
2929
        if(ac->programs[i]->id != progid)
2930
            continue;
2931
        program = ac->programs[i];
2932
        for(j=0; j<program->nb_stream_indexes; j++)
2933
            if(program->stream_index[j] == idx)
2934
                return;
2935

    
2936
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2937
        if(!tmp)
2938
            return;
2939
        program->stream_index = tmp;
2940
        program->stream_index[program->nb_stream_indexes++] = idx;
2941
        return;
2942
    }
2943
}
2944

    
2945
static void print_fps(double d, const char *postfix){
2946
    uint64_t v= lrintf(d*100);
2947
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2948
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2949
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2950
}
2951

    
2952
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2953
{
2954
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2955
        AVMetadataTag *tag=NULL;
2956

    
2957
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2958
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2959
            if(strcmp("language", tag->key))
2960
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
2961
        }
2962
    }
2963
}
2964

    
2965
/* "user interface" functions */
2966
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2967
{
2968
    char buf[256];
2969
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2970
    AVStream *st = ic->streams[i];
2971
    int g = av_gcd(st->time_base.num, st->time_base.den);
2972
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2973
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2974
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2975
    /* the pid is an important information, so we display it */
2976
    /* XXX: add a generic system */
2977
    if (flags & AVFMT_SHOW_IDS)
2978
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2979
    if (lang)
2980
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2981
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
2982
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2983
    if (st->sample_aspect_ratio.num && // default
2984
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2985
        AVRational display_aspect_ratio;
2986
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2987
                  st->codec->width*st->sample_aspect_ratio.num,
2988
                  st->codec->height*st->sample_aspect_ratio.den,
2989
                  1024*1024);
2990
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2991
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2992
                 display_aspect_ratio.num, display_aspect_ratio.den);
2993
    }
2994
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2995
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
2996
            print_fps(av_q2d(st->avg_frame_rate), "fps");
2997
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2998
            print_fps(av_q2d(st->r_frame_rate), "tbr");
2999
        if(st->time_base.den && st->time_base.num)
3000
            print_fps(1/av_q2d(st->time_base), "tbn");
3001
        if(st->codec->time_base.den && st->codec->time_base.num)
3002
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3003
    }
3004
    av_log(NULL, AV_LOG_INFO, "\n");
3005
    dump_metadata(NULL, st->metadata, "    ");
3006
}
3007

    
3008
void dump_format(AVFormatContext *ic,
3009
                 int index,
3010
                 const char *url,
3011
                 int is_output)
3012
{
3013
    int i;
3014
    uint8_t *printed = av_mallocz(ic->nb_streams);
3015
    if (ic->nb_streams && !printed)
3016
        return;
3017

    
3018
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3019
            is_output ? "Output" : "Input",
3020
            index,
3021
            is_output ? ic->oformat->name : ic->iformat->name,
3022
            is_output ? "to" : "from", url);
3023
    dump_metadata(NULL, ic->metadata, "  ");
3024
    if (!is_output) {
3025
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3026
        if (ic->duration != AV_NOPTS_VALUE) {
3027
            int hours, mins, secs, us;
3028
            secs = ic->duration / AV_TIME_BASE;
3029
            us = ic->duration % AV_TIME_BASE;
3030
            mins = secs / 60;
3031
            secs %= 60;
3032
            hours = mins / 60;
3033
            mins %= 60;
3034
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3035
                   (100 * us) / AV_TIME_BASE);
3036
        } else {
3037
            av_log(NULL, AV_LOG_INFO, "N/A");
3038
        }
3039
        if (ic->start_time != AV_NOPTS_VALUE) {
3040
            int secs, us;
3041
            av_log(NULL, AV_LOG_INFO, ", start: ");
3042
            secs = ic->start_time / AV_TIME_BASE;
3043
            us = ic->start_time % AV_TIME_BASE;
3044
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3045
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3046
        }
3047
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3048
        if (ic->bit_rate) {
3049
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3050
        } else {
3051
            av_log(NULL, AV_LOG_INFO, "N/A");
3052
        }
3053
        av_log(NULL, AV_LOG_INFO, "\n");
3054
    }
3055
    for (i = 0; i < ic->nb_chapters; i++) {
3056
        AVChapter *ch = ic->chapters[i];
3057
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3058
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3059
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3060

    
3061
        dump_metadata(NULL, ch->metadata, "    ");
3062
    }
3063
    if(ic->nb_programs) {
3064
        int j, k, total = 0;
3065
        for(j=0; j<ic->nb_programs; j++) {
3066
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3067
                                                  "name", NULL, 0);
3068
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3069
                   name ? name->value : "");
3070
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3071
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3072
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3073
                printed[ic->programs[j]->stream_index[k]] = 1;
3074
            }
3075
            total += ic->programs[j]->nb_stream_indexes;
3076
        }
3077
        if (total < ic->nb_streams)
3078
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3079
    }
3080
    for(i=0;i<ic->nb_streams;i++)
3081
        if (!printed[i])
3082
            dump_stream_format(ic, i, index, is_output);
3083

    
3084
    av_free(printed);
3085
}
3086

    
3087
#if LIBAVFORMAT_VERSION_MAJOR < 53
3088
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3089
{
3090
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
3091
}
3092

    
3093
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3094
{
3095
    AVRational frame_rate;
3096
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
3097
    *frame_rate_num= frame_rate.num;
3098
    *frame_rate_den= frame_rate.den;
3099
    return ret;
3100
}
3101
#endif
3102

    
3103
int64_t av_gettime(void)
3104
{
3105
    struct timeval tv;
3106
    gettimeofday(&tv,NULL);
3107
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3108
}
3109

    
3110
int64_t parse_date(const char *datestr, int duration)
3111
{
3112
    const char *p;
3113
    int64_t t;
3114
    struct tm dt;
3115
    int i;
3116
    static const char * const date_fmt[] = {
3117
        "%Y-%m-%d",
3118
        "%Y%m%d",
3119
    };
3120
    static const char * const time_fmt[] = {
3121
        "%H:%M:%S",
3122
        "%H%M%S",
3123
    };
3124
    const char *q;
3125
    int is_utc, len;
3126
    char lastch;
3127
    int negative = 0;
3128

    
3129
#undef time
3130
    time_t now = time(0);
3131

    
3132
    len = strlen(datestr);
3133
    if (len > 0)
3134
        lastch = datestr[len - 1];
3135
    else
3136
        lastch = '\0';
3137
    is_utc = (lastch == 'z' || lastch == 'Z');
3138

    
3139
    memset(&dt, 0, sizeof(dt));
3140

    
3141
    p = datestr;
3142
    q = NULL;
3143
    if (!duration) {
3144
        if (!strncasecmp(datestr, "now", len))
3145
            return (int64_t) now * 1000000;
3146

    
3147
        /* parse the year-month-day part */
3148
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3149
            q = small_strptime(p, date_fmt[i], &dt);
3150
            if (q) {
3151
                break;
3152
            }
3153
        }
3154

    
3155
        /* if the year-month-day part is missing, then take the
3156
         * current year-month-day time */
3157
        if (!q) {
3158
            if (is_utc) {
3159
                dt = *gmtime(&now);
3160
            } else {
3161
                dt = *localtime(&now);
3162
            }
3163
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3164
        } else {
3165
            p = q;
3166
        }
3167

    
3168
        if (*p == 'T' || *p == 't' || *p == ' ')
3169
            p++;
3170

    
3171
        /* parse the hour-minute-second part */
3172
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3173
            q = small_strptime(p, time_fmt[i], &dt);
3174
            if (q) {
3175
                break;
3176
            }
3177
        }
3178
    } else {
3179
        /* parse datestr as a duration */
3180
        if (p[0] == '-') {
3181
            negative = 1;
3182
            ++p;
3183
        }
3184
        /* parse datestr as HH:MM:SS */
3185
        q = small_strptime(p, time_fmt[0], &dt);
3186
        if (!q) {
3187
            /* parse datestr as S+ */
3188
            dt.tm_sec = strtol(p, (char **)&q, 10);
3189
            if (q == p)
3190
                /* the parsing didn't succeed */
3191
                return INT64_MIN;
3192
            dt.tm_min = 0;
3193
            dt.tm_hour = 0;
3194
        }
3195
    }
3196

    
3197
    /* Now we have all the fields that we can get */
3198
    if (!q) {
3199
        return INT64_MIN;
3200
    }
3201

    
3202
    if (duration) {
3203
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3204
    } else {
3205
        dt.tm_isdst = -1;       /* unknown */
3206
        if (is_utc) {
3207
            t = mktimegm(&dt);
3208
        } else {
3209
            t = mktime(&dt);
3210
        }
3211
    }
3212

    
3213
    t *= 1000000;
3214

    
3215
    /* parse the .m... part */
3216
    if (*q == '.') {
3217
        int val, n;
3218
        q++;
3219
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3220
            if (!isdigit(*q))
3221
                break;
3222
            val += n * (*q - '0');
3223
        }
3224
        t += val;
3225
    }
3226
    return negative ? -t : t;
3227
}
3228

    
3229
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3230
{
3231
    const char *p;
3232
    char tag[128], *q;
3233

    
3234
    p = info;
3235
    if (*p == '?')
3236
        p++;
3237
    for(;;) {
3238
        q = tag;
3239
        while (*p != '\0' && *p != '=' && *p != '&') {
3240
            if ((q - tag) < sizeof(tag) - 1)
3241
                *q++ = *p;
3242
            p++;
3243
        }
3244
        *q = '\0';
3245
        q = arg;
3246
        if (*p == '=') {
3247
            p++;
3248
            while (*p != '&' && *p != '\0') {
3249
                if ((q - arg) < arg_size - 1) {
3250
                    if (*p == '+')
3251
                        *q++ = ' ';
3252
                    else
3253
                        *q++ = *p;
3254
                }
3255
                p++;
3256
            }
3257
            *q = '\0';
3258
        }
3259
        if (!strcmp(tag, tag1))
3260
            return 1;
3261
        if (*p != '&')
3262
            break;
3263
        p++;
3264
    }
3265
    return 0;
3266
}
3267

    
3268
int av_get_frame_filename(char *buf, int buf_size,
3269
                          const char *path, int number)
3270
{
3271
    const char *p;
3272
    char *q, buf1[20], c;
3273
    int nd, len, percentd_found;
3274

    
3275
    q = buf;
3276
    p = path;
3277
    percentd_found = 0;
3278
    for(;;) {
3279
        c = *p++;
3280
        if (c == '\0')
3281
            break;
3282
        if (c == '%') {
3283
            do {
3284
                nd = 0;
3285
                while (isdigit(*p)) {
3286
                    nd = nd * 10 + *p++ - '0';
3287
                }
3288
                c = *p++;
3289
            } while (isdigit(c));
3290

    
3291
            switch(c) {
3292
            case '%':
3293
                goto addchar;
3294
            case 'd':
3295
                if (percentd_found)
3296
                    goto fail;
3297
                percentd_found = 1;
3298
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3299
                len = strlen(buf1);
3300
                if ((q - buf + len) > buf_size - 1)
3301
                    goto fail;
3302
                memcpy(q, buf1, len);
3303
                q += len;
3304
                break;
3305
            default:
3306
                goto fail;
3307
            }
3308
        } else {
3309
        addchar:
3310
            if ((q - buf) < buf_size - 1)
3311
                *q++ = c;
3312
        }
3313
    }
3314
    if (!percentd_found)
3315
        goto fail;
3316
    *q = '\0';
3317
    return 0;
3318
 fail:
3319
    *q = '\0';
3320
    return -1;
3321
}
3322

    
3323
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3324
{
3325
    int len, i, j, c;
3326
#undef fprintf
3327
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3328

    
3329
    for(i=0;i<size;i+=16) {
3330
        len = size - i;
3331
        if (len > 16)
3332
            len = 16;
3333
        PRINT("%08x ", i);
3334
        for(j=0;j<16;j++) {
3335
            if (j < len)
3336
                PRINT(" %02x", buf[i+j]);
3337
            else
3338
                PRINT("   ");
3339
        }
3340
        PRINT(" ");
3341
        for(j=0;j<len;j++) {
3342
            c = buf[i+j];
3343
            if (c < ' ' || c > '~')
3344
                c = '.';
3345
            PRINT("%c", c);
3346
        }
3347
        PRINT("\n");
3348
    }
3349
#undef PRINT
3350
}
3351

    
3352
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3353
{
3354
    hex_dump_internal(NULL, f, 0, buf, size);
3355
}
3356

    
3357
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3358
{
3359
    hex_dump_internal(avcl, NULL, level, buf, size);
3360
}
3361

    
3362
 //FIXME needs to know the time_base
3363
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3364
{
3365
#undef fprintf
3366
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3367
    PRINT("stream #%d:\n", pkt->stream_index);
3368
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3369
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3370
    /* DTS is _always_ valid after av_read_frame() */
3371
    PRINT("  dts=");
3372
    if (pkt->dts == AV_NOPTS_VALUE)
3373
        PRINT("N/A");
3374
    else
3375
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3376
    /* PTS may not be known if B-frames are present. */
3377
    PRINT("  pts=");
3378
    if (pkt->pts == AV_NOPTS_VALUE)
3379
        PRINT("N/A");
3380
    else
3381
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3382
    PRINT("\n");
3383
    PRINT("  size=%d\n", pkt->size);
3384
#undef PRINT
3385
    if (dump_payload)
3386
        av_hex_dump(f, pkt->data, pkt->size);
3387
}
3388

    
3389
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3390
{
3391
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3392
}
3393

    
3394
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3395
{
3396
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3397
}
3398

    
3399
void url_split(char *proto, int proto_size,
3400
               char *authorization, int authorization_size,
3401
               char *hostname, int hostname_size,
3402
               int *port_ptr,
3403
               char *path, int path_size,
3404
               const char *url)
3405
{
3406
    const char *p, *ls, *at, *col, *brk;
3407

    
3408
    if (port_ptr)               *port_ptr = -1;
3409
    if (proto_size > 0)         proto[0] = 0;
3410
    if (authorization_size > 0) authorization[0] = 0;
3411
    if (hostname_size > 0)      hostname[0] = 0;
3412
    if (path_size > 0)          path[0] = 0;
3413

    
3414
    /* parse protocol */
3415
    if ((p = strchr(url, ':'))) {
3416
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3417
        p++; /* skip ':' */
3418
        if (*p == '/') p++;
3419
        if (*p == '/') p++;
3420
    } else {
3421
        /* no protocol means plain filename */
3422
        av_strlcpy(path, url, path_size);
3423
        return;
3424
    }
3425

    
3426
    /* separate path from hostname */
3427
    ls = strchr(p, '/');
3428
    if(!ls)
3429
        ls = strchr(p, '?');
3430
    if(ls)
3431
        av_strlcpy(path, ls, path_size);
3432
    else
3433
        ls = &p[strlen(p)]; // XXX
3434

    
3435
    /* the rest is hostname, use that to parse auth/port */
3436
    if (ls != p) {
3437
        /* authorization (user[:pass]@hostname) */
3438
        if ((at = strchr(p, '@')) && at < ls) {
3439
            av_strlcpy(authorization, p,
3440
                       FFMIN(authorization_size, at + 1 - p));
3441
            p = at + 1; /* skip '@' */
3442
        }
3443

    
3444
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3445
            /* [host]:port */
3446
            av_strlcpy(hostname, p + 1,
3447
                       FFMIN(hostname_size, brk - p));
3448
            if (brk[1] == ':' && port_ptr)
3449
                *port_ptr = atoi(brk + 2);
3450
        } else if ((col = strchr(p, ':')) && col < ls) {
3451
            av_strlcpy(hostname, p,
3452
                       FFMIN(col + 1 - p, hostname_size));
3453
            if (port_ptr) *port_ptr = atoi(col + 1);
3454
        } else
3455
            av_strlcpy(hostname, p,
3456
                       FFMIN(ls + 1 - p, hostname_size));
3457
    }
3458
}
3459

    
3460
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3461
{
3462
    int i;
3463
    static const char hex_table[16] = { '0', '1', '2', '3',
3464
                                        '4', '5', '6', '7',
3465
                                        '8', '9', 'A', 'B',
3466
                                        'C', 'D', 'E', 'F' };
3467

    
3468
    for(i = 0; i < s; i++) {
3469
        buff[i * 2]     = hex_table[src[i] >> 4];
3470
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3471
    }
3472

    
3473
    return buff;
3474
}
3475

    
3476
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3477
                     unsigned int pts_num, unsigned int pts_den)
3478
{
3479
    s->pts_wrap_bits = pts_wrap_bits;
3480

    
3481
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3482
        if(s->time_base.num != pts_num)
3483
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3484
    }else
3485
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3486

    
3487
    if(!s->time_base.num || !s->time_base.den)
3488
        s->time_base.num= s->time_base.den= 0;
3489
}
3490

    
3491
int ff_url_join(char *str, int size, const char *proto,
3492
                const char *authorization, const char *hostname,
3493
                int port, const char *fmt, ...)
3494
{
3495
#if CONFIG_NETWORK
3496
    struct addrinfo hints, *ai;
3497
#endif
3498

    
3499
    str[0] = '\0';
3500
    if (proto)
3501
        av_strlcatf(str, size, "%s://", proto);
3502
    if (authorization)
3503
        av_strlcatf(str, size, "%s@", authorization);
3504
#if CONFIG_NETWORK && defined(AF_INET6)
3505
    /* Determine if hostname is a numerical IPv6 address,
3506
     * properly escape it within [] in that case. */
3507
    memset(&hints, 0, sizeof(hints));
3508
    hints.ai_flags = AI_NUMERICHOST;
3509
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3510
        if (ai->ai_family == AF_INET6) {
3511
            av_strlcat(str, "[", size);
3512
            av_strlcat(str, hostname, size);
3513
            av_strlcat(str, "]", size);
3514
        } else {
3515
            av_strlcat(str, hostname, size);
3516
        }
3517
        freeaddrinfo(ai);
3518
    } else
3519
#endif
3520
        /* Not an IPv6 address, just output the plain string. */
3521
        av_strlcat(str, hostname, size);
3522

    
3523
    if (port >= 0)
3524
        av_strlcatf(str, size, ":%d", port);
3525
    if (fmt) {
3526
        va_list vl;
3527
        int len = strlen(str);
3528

    
3529
        va_start(vl, fmt);
3530
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3531
        va_end(vl);
3532
    }
3533
    return strlen(str);
3534
}