Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ d8f92957

History | View | Annotate | Download (111 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
int av_match_ext(const char *filename, const char *extensions)
146
{
147
    const char *ext, *p;
148
    char ext1[32], *q;
149

    
150
    if(!filename)
151
        return 0;
152

    
153
    ext = strrchr(filename, '.');
154
    if (ext) {
155
        ext++;
156
        p = extensions;
157
        for(;;) {
158
            q = ext1;
159
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
160
                *q++ = *p++;
161
            *q = '\0';
162
            if (!strcasecmp(ext1, ext))
163
                return 1;
164
            if (*p == '\0')
165
                break;
166
            p++;
167
        }
168
    }
169
    return 0;
170
}
171

    
172
static int match_format(const char *name, const char *names)
173
{
174
    const char *p;
175
    int len, namelen;
176

    
177
    if (!name || !names)
178
        return 0;
179

    
180
    namelen = strlen(name);
181
    while ((p = strchr(names, ','))) {
182
        len = FFMAX(p - names, namelen);
183
        if (!strncasecmp(name, names, len))
184
            return 1;
185
        names = p+1;
186
    }
187
    return !strcasecmp(name, names);
188
}
189

    
190
#if LIBAVFORMAT_VERSION_MAJOR < 53
191
AVOutputFormat *guess_format(const char *short_name, const char *filename,
192
                             const char *mime_type)
193
{
194
    return av_guess_format(short_name, filename, mime_type);
195
}
196
#endif
197

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

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

    
235
#if LIBAVFORMAT_VERSION_MAJOR < 53
236
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
237
                             const char *mime_type)
238
{
239
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
240

    
241
    if (fmt) {
242
        AVOutputFormat *stream_fmt;
243
        char stream_format_name[64];
244

    
245
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
246
        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
247

    
248
        if (stream_fmt)
249
            fmt = stream_fmt;
250
    }
251

    
252
    return fmt;
253
}
254
#endif
255

    
256
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
257
                            const char *filename, const char *mime_type, enum CodecType type){
258
    if(type == CODEC_TYPE_VIDEO){
259
        enum CodecID codec_id= CODEC_ID_NONE;
260

    
261
#if CONFIG_IMAGE2_MUXER
262
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
263
            codec_id= av_guess_image2_codec(filename);
264
        }
265
#endif
266
        if(codec_id == CODEC_ID_NONE)
267
            codec_id= fmt->video_codec;
268
        return codec_id;
269
    }else if(type == CODEC_TYPE_AUDIO)
270
        return fmt->audio_codec;
271
    else
272
        return CODEC_ID_NONE;
273
}
274

    
275
AVInputFormat *av_find_input_format(const char *short_name)
276
{
277
    AVInputFormat *fmt;
278
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
279
        if (match_format(short_name, fmt->name))
280
            return fmt;
281
    }
282
    return NULL;
283
}
284

    
285
/* memory handling */
286

    
287

    
288
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
289
{
290
    int ret= av_new_packet(pkt, size);
291

    
292
    if(ret<0)
293
        return ret;
294

    
295
    pkt->pos= url_ftell(s);
296

    
297
    ret= get_buffer(s, pkt->data, size);
298
    if(ret<=0)
299
        av_free_packet(pkt);
300
    else
301
        av_shrink_packet(pkt, ret);
302

    
303
    return ret;
304
}
305

    
306

    
307
int av_filename_number_test(const char *filename)
308
{
309
    char buf[1024];
310
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
311
}
312

    
313
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
314
{
315
    AVInputFormat *fmt1, *fmt;
316
    int score;
317

    
318
    fmt = NULL;
319
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
320
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
321
            continue;
322
        score = 0;
323
        if (fmt1->read_probe) {
324
            score = fmt1->read_probe(pd);
325
        } else if (fmt1->extensions) {
326
            if (av_match_ext(pd->filename, fmt1->extensions)) {
327
                score = 50;
328
            }
329
        }
330
        if (score > *score_max) {
331
            *score_max = score;
332
            fmt = fmt1;
333
        }else if (score == *score_max)
334
            fmt = NULL;
335
    }
336
    return fmt;
337
}
338

    
339
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
340
    int score=0;
341
    return av_probe_input_format2(pd, is_opened, &score);
342
}
343

    
344
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
345
{
346
    AVInputFormat *fmt;
347
    fmt = av_probe_input_format2(pd, 1, &score);
348

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

    
378
/************************************************************/
379
/* input media file */
380

    
381
/**
382
 * Open a media file from an IO stream. 'fmt' must be specified.
383
 */
384
int av_open_input_stream(AVFormatContext **ic_ptr,
385
                         ByteIOContext *pb, const char *filename,
386
                         AVInputFormat *fmt, AVFormatParameters *ap)
387
{
388
    int err;
389
    AVFormatContext *ic;
390
    AVFormatParameters default_ap;
391

    
392
    if(!ap){
393
        ap=&default_ap;
394
        memset(ap, 0, sizeof(default_ap));
395
    }
396

    
397
    if(!ap->prealloced_context)
398
        ic = avformat_alloc_context();
399
    else
400
        ic = *ic_ptr;
401
    if (!ic) {
402
        err = AVERROR(ENOMEM);
403
        goto fail;
404
    }
405
    ic->iformat = fmt;
406
    ic->pb = pb;
407
    ic->duration = AV_NOPTS_VALUE;
408
    ic->start_time = AV_NOPTS_VALUE;
409
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
410

    
411
    /* allocate private data */
412
    if (fmt->priv_data_size > 0) {
413
        ic->priv_data = av_mallocz(fmt->priv_data_size);
414
        if (!ic->priv_data) {
415
            err = AVERROR(ENOMEM);
416
            goto fail;
417
        }
418
    } else {
419
        ic->priv_data = NULL;
420
    }
421

    
422
    if (ic->iformat->read_header) {
423
        err = ic->iformat->read_header(ic, ap);
424
        if (err < 0)
425
            goto fail;
426
    }
427

    
428
    if (pb && !ic->data_offset)
429
        ic->data_offset = url_ftell(ic->pb);
430

    
431
#if LIBAVFORMAT_VERSION_MAJOR < 53
432
    ff_metadata_demux_compat(ic);
433
#endif
434

    
435
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
436

    
437
    *ic_ptr = ic;
438
    return 0;
439
 fail:
440
    if (ic) {
441
        int i;
442
        av_freep(&ic->priv_data);
443
        for(i=0;i<ic->nb_streams;i++) {
444
            AVStream *st = ic->streams[i];
445
            if (st) {
446
                av_free(st->priv_data);
447
                av_free(st->codec->extradata);
448
            }
449
            av_free(st);
450
        }
451
    }
452
    av_free(ic);
453
    *ic_ptr = NULL;
454
    return err;
455
}
456

    
457
/** size of probe buffer, for guessing file type from file contents */
458
#define PROBE_BUF_MIN 2048
459
#define PROBE_BUF_MAX (1<<20)
460

    
461
int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
462
                          const char *filename, void *logctx,
463
                          unsigned int offset, unsigned int max_probe_size)
464
{
465
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
466
    unsigned char *buf = NULL;
467
    int ret = 0, probe_size;
468

    
469
    if (!max_probe_size) {
470
        max_probe_size = PROBE_BUF_MAX;
471
    } else if (max_probe_size > PROBE_BUF_MAX) {
472
        max_probe_size = PROBE_BUF_MAX;
473
    } else if (max_probe_size < PROBE_BUF_MIN) {
474
        return AVERROR(EINVAL);
475
    }
476

    
477
    if (offset >= max_probe_size) {
478
        return AVERROR(EINVAL);
479
    }
480

    
481
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0; probe_size<<=1){
482
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
483
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
484

    
485
        if (probe_size < offset) {
486
            continue;
487
        }
488

    
489
        /* read probe data */
490
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
491
        if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
492
            /* fail if error was not end of file, otherwise, lower score */
493
            if (ret != AVERROR_EOF) {
494
                av_free(buf);
495
                return ret;
496
            }
497
            score = 0;
498
            ret = 0;            /* error was end of file, nothing read */
499
        }
500
        pd.buf_size += ret;
501
        pd.buf = &buf[offset];
502

    
503
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
504

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

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

    
522
    return 0;
523
}
524

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

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

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

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

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

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

    
587
}
588

    
589
/*******************************************************/
590

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

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

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

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

    
613
    for(;;){
614
        AVPacketList *pktl = s->raw_packet_buffer;
615

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

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

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

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

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

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

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

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

    
683
/**********************************************************/
684

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

    
692
    if(enc->codec_id == CODEC_ID_VORBIS)
693
        return -1;
694

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

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

    
714

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

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

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

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

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

    
783
    st->first_dts= dts - st->cur_dts;
784
    st->cur_dts= dts;
785

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
976
//    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);
977

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

    
993

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

    
999
    av_init_packet(pkt);
1000

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

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

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

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

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

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

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

    
1126
    return 0;
1127
}
1128

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

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

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

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

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

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

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

    
1207
/*******************************************************/
1208
/* seek support */
1209

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

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

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

    
1237
    flush_packet_queue(s);
1238

    
1239
    s->cur_st = NULL;
1240

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

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

    
1257
        st->probe_packets = MAX_PROBE_PACKETS;
1258

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

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

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

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

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

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

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

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

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

    
1305
    st->index_entries= entries;
1306

    
1307
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1308

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

    
1324
    ie->pos = pos;
1325
    ie->timestamp = timestamp;
1326
    ie->min_distance= distance;
1327
    ie->size= size;
1328
    ie->flags = flags;
1329

    
1330
    return index;
1331
}
1332

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

    
1341
    a = - 1;
1342
    b = nb_entries;
1343

    
1344
    //optimize appending index entries at the end
1345
    if(b && entries[b-1].timestamp < wanted_timestamp)
1346
        a= b-1;
1347

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

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

    
1364
    if(m == nb_entries)
1365
        return -1;
1366
    return  m;
1367
}
1368

    
1369
#define DEBUG_SEEK
1370

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

    
1379
    if (stream_index < 0)
1380
        return -1;
1381

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

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

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

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

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

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

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

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

    
1432
    av_update_cur_dts(s, st, ts);
1433

    
1434
    return 0;
1435
}
1436

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

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

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

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

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

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

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

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

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

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

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

1557
    if (stream_index < 0)
1558
        return -1;
1559

1560
    st= s->streams[stream_index];
1561
#endif
1562

    
1563
    pos_min = s->data_offset;
1564
    pos_max = url_fsize(s->pb) - 1;
1565

    
1566
    if     (pos < pos_min) pos= pos_min;
1567
    else if(pos > pos_max) pos= pos_max;
1568

    
1569
    url_fseek(s->pb, pos, SEEK_SET);
1570

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

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

    
1585
    st = s->streams[stream_index];
1586

    
1587
    index = av_index_search_timestamp(st, timestamp, flags);
1588

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

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

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

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

    
1634
    return 0;
1635
}
1636

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

    
1642
    ff_read_frame_flush(s);
1643

    
1644
    if(flags & AVSEEK_FLAG_BYTE)
1645
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1646

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

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

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

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

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

    
1677
    ff_read_frame_flush(s);
1678

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

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

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

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

    
1694
/*******************************************************/
1695

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

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

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

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

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

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

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

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

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

    
1814
#define DURATION_MAX_READ_SIZE 250000
1815
#define DURATION_MAX_RETRY 3
1816

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

    
1827
    ic->cur_st = NULL;
1828

    
1829
    /* flush packet queue */
1830
    flush_packet_queue(ic);
1831

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

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

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

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

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

    
1888
    fill_all_stream_timings(ic);
1889

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2058
static void compute_chapters_end(AVFormatContext *s)
2059
{
2060
    unsigned int i;
2061

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

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

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

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

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

    
2116
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2117
    if (!duration_error) return AVERROR(ENOMEM);
2118

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

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

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

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

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

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

    
2220
        read_size += pkt->size;
2221

    
2222
        st = ic->streams[pkt->stream_index];
2223
        if(st->codec_info_nb_frames>1) {
2224
            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){
2225
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2226
                break;
2227
            }
2228
            codec_info_duration[st->index] += pkt->duration;
2229
        }
2230
            st->codec_info_nb_frames++;
2231

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

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

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

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

    
2275
        count++;
2276
    }
2277

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

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

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

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

    
2337
    av_estimate_timings(ic, old_offset);
2338

    
2339
    compute_chapters_end(ic);
2340

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

    
2366
    av_free(duration_error);
2367

    
2368
    return ret;
2369
}
2370

    
2371
/*******************************************************/
2372

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

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

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

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

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

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

    
2452
    if (s->nb_streams >= MAX_STREAMS)
2453
        return NULL;
2454

    
2455
    st = av_mallocz(sizeof(AVStream));
2456
    if (!st)
2457
        return NULL;
2458

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

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

    
2483
    st->sample_aspect_ratio = (AVRational){0,1};
2484

    
2485
    s->streams[s->nb_streams++] = st;
2486
    return st;
2487
}
2488

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

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

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

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

    
2511
    return program;
2512
}
2513

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

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

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

    
2538
    return chapter;
2539
}
2540

    
2541
/************************************************************/
2542
/* output media file */
2543

    
2544
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2545
{
2546
    int ret;
2547

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

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

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

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

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

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

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

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

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

    
2625
#if LIBAVFORMAT_VERSION_MAJOR < 53
2626
    ff_metadata_mux_compat(s);
2627
#endif
2628

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

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

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

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

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

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

    
2678
//    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);
2679

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

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

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

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

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

    
2709
        pkt->dts= st->pts_buffer[0];
2710
    }
2711

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

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

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

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

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

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

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

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

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

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

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

    
2788
    s->packet_buffer_end= this_pktl;
2789
next_non_null:
2790

    
2791
    this_pktl->next= *next_point;
2792

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

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

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

    
2811
    if(pkt){
2812
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2813
    }
2814

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

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

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

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

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

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

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

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

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

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

    
2872
        ret= s->oformat->write_packet(s, &opkt);
2873

    
2874
        av_free_packet(&opkt);
2875
        pkt= NULL;
2876

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

    
2884
int av_write_trailer(AVFormatContext *s)
2885
{
2886
    int ret, i;
2887

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

    
2896
        ret= s->oformat->write_packet(s, &pkt);
2897

    
2898
        av_free_packet(&pkt);
2899

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3086
    av_free(printed);
3087
}
3088

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

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

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

    
3112
uint64_t ff_ntp_time(void)
3113
{
3114
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3115
}
3116

    
3117
int64_t parse_date(const char *datestr, int duration)
3118
{
3119
    const char *p;
3120
    int64_t t;
3121
    struct tm dt;
3122
    int i;
3123
    static const char * const date_fmt[] = {
3124
        "%Y-%m-%d",
3125
        "%Y%m%d",
3126
    };
3127
    static const char * const time_fmt[] = {
3128
        "%H:%M:%S",
3129
        "%H%M%S",
3130
    };
3131
    const char *q;
3132
    int is_utc, len;
3133
    char lastch;
3134
    int negative = 0;
3135

    
3136
#undef time
3137
    time_t now = time(0);
3138

    
3139
    len = strlen(datestr);
3140
    if (len > 0)
3141
        lastch = datestr[len - 1];
3142
    else
3143
        lastch = '\0';
3144
    is_utc = (lastch == 'z' || lastch == 'Z');
3145

    
3146
    memset(&dt, 0, sizeof(dt));
3147

    
3148
    p = datestr;
3149
    q = NULL;
3150
    if (!duration) {
3151
        if (!strncasecmp(datestr, "now", len))
3152
            return (int64_t) now * 1000000;
3153

    
3154
        /* parse the year-month-day part */
3155
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3156
            q = small_strptime(p, date_fmt[i], &dt);
3157
            if (q) {
3158
                break;
3159
            }
3160
        }
3161

    
3162
        /* if the year-month-day part is missing, then take the
3163
         * current year-month-day time */
3164
        if (!q) {
3165
            if (is_utc) {
3166
                dt = *gmtime(&now);
3167
            } else {
3168
                dt = *localtime(&now);
3169
            }
3170
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3171
        } else {
3172
            p = q;
3173
        }
3174

    
3175
        if (*p == 'T' || *p == 't' || *p == ' ')
3176
            p++;
3177

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

    
3204
    /* Now we have all the fields that we can get */
3205
    if (!q) {
3206
        return INT64_MIN;
3207
    }
3208

    
3209
    if (duration) {
3210
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3211
    } else {
3212
        dt.tm_isdst = -1;       /* unknown */
3213
        if (is_utc) {
3214
            t = mktimegm(&dt);
3215
        } else {
3216
            t = mktime(&dt);
3217
        }
3218
    }
3219

    
3220
    t *= 1000000;
3221

    
3222
    /* parse the .m... part */
3223
    if (*q == '.') {
3224
        int val, n;
3225
        q++;
3226
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3227
            if (!isdigit(*q))
3228
                break;
3229
            val += n * (*q - '0');
3230
        }
3231
        t += val;
3232
    }
3233
    return negative ? -t : t;
3234
}
3235

    
3236
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3237
{
3238
    const char *p;
3239
    char tag[128], *q;
3240

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

    
3275
int av_get_frame_filename(char *buf, int buf_size,
3276
                          const char *path, int number)
3277
{
3278
    const char *p;
3279
    char *q, buf1[20], c;
3280
    int nd, len, percentd_found;
3281

    
3282
    q = buf;
3283
    p = path;
3284
    percentd_found = 0;
3285
    for(;;) {
3286
        c = *p++;
3287
        if (c == '\0')
3288
            break;
3289
        if (c == '%') {
3290
            do {
3291
                nd = 0;
3292
                while (isdigit(*p)) {
3293
                    nd = nd * 10 + *p++ - '0';
3294
                }
3295
                c = *p++;
3296
            } while (isdigit(c));
3297

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

    
3330
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3331
{
3332
    int len, i, j, c;
3333
#undef fprintf
3334
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3335

    
3336
    for(i=0;i<size;i+=16) {
3337
        len = size - i;
3338
        if (len > 16)
3339
            len = 16;
3340
        PRINT("%08x ", i);
3341
        for(j=0;j<16;j++) {
3342
            if (j < len)
3343
                PRINT(" %02x", buf[i+j]);
3344
            else
3345
                PRINT("   ");
3346
        }
3347
        PRINT(" ");
3348
        for(j=0;j<len;j++) {
3349
            c = buf[i+j];
3350
            if (c < ' ' || c > '~')
3351
                c = '.';
3352
            PRINT("%c", c);
3353
        }
3354
        PRINT("\n");
3355
    }
3356
#undef PRINT
3357
}
3358

    
3359
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3360
{
3361
    hex_dump_internal(NULL, f, 0, buf, size);
3362
}
3363

    
3364
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3365
{
3366
    hex_dump_internal(avcl, NULL, level, buf, size);
3367
}
3368

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

    
3396
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3397
{
3398
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3399
}
3400

    
3401
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3402
{
3403
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3404
}
3405

    
3406
void ff_url_split(char *proto, int proto_size,
3407
                  char *authorization, int authorization_size,
3408
                  char *hostname, int hostname_size,
3409
                  int *port_ptr,
3410
                  char *path, int path_size,
3411
                  const char *url)
3412
{
3413
    const char *p, *ls, *at, *col, *brk;
3414

    
3415
    if (port_ptr)               *port_ptr = -1;
3416
    if (proto_size > 0)         proto[0] = 0;
3417
    if (authorization_size > 0) authorization[0] = 0;
3418
    if (hostname_size > 0)      hostname[0] = 0;
3419
    if (path_size > 0)          path[0] = 0;
3420

    
3421
    /* parse protocol */
3422
    if ((p = strchr(url, ':'))) {
3423
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3424
        p++; /* skip ':' */
3425
        if (*p == '/') p++;
3426
        if (*p == '/') p++;
3427
    } else {
3428
        /* no protocol means plain filename */
3429
        av_strlcpy(path, url, path_size);
3430
        return;
3431
    }
3432

    
3433
    /* separate path from hostname */
3434
    ls = strchr(p, '/');
3435
    if(!ls)
3436
        ls = strchr(p, '?');
3437
    if(ls)
3438
        av_strlcpy(path, ls, path_size);
3439
    else
3440
        ls = &p[strlen(p)]; // XXX
3441

    
3442
    /* the rest is hostname, use that to parse auth/port */
3443
    if (ls != p) {
3444
        /* authorization (user[:pass]@hostname) */
3445
        if ((at = strchr(p, '@')) && at < ls) {
3446
            av_strlcpy(authorization, p,
3447
                       FFMIN(authorization_size, at + 1 - p));
3448
            p = at + 1; /* skip '@' */
3449
        }
3450

    
3451
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3452
            /* [host]:port */
3453
            av_strlcpy(hostname, p + 1,
3454
                       FFMIN(hostname_size, brk - p));
3455
            if (brk[1] == ':' && port_ptr)
3456
                *port_ptr = atoi(brk + 2);
3457
        } else if ((col = strchr(p, ':')) && col < ls) {
3458
            av_strlcpy(hostname, p,
3459
                       FFMIN(col + 1 - p, hostname_size));
3460
            if (port_ptr) *port_ptr = atoi(col + 1);
3461
        } else
3462
            av_strlcpy(hostname, p,
3463
                       FFMIN(ls + 1 - p, hostname_size));
3464
    }
3465
}
3466

    
3467
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3468
{
3469
    int i;
3470
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3471
                                           '4', '5', '6', '7',
3472
                                           '8', '9', 'A', 'B',
3473
                                           'C', 'D', 'E', 'F' };
3474
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3475
                                           '4', '5', '6', '7',
3476
                                           '8', '9', 'a', 'b',
3477
                                           'c', 'd', 'e', 'f' };
3478
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3479

    
3480
    for(i = 0; i < s; i++) {
3481
        buff[i * 2]     = hex_table[src[i] >> 4];
3482
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3483
    }
3484

    
3485
    return buff;
3486
}
3487

    
3488
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3489
                     unsigned int pts_num, unsigned int pts_den)
3490
{
3491
    s->pts_wrap_bits = pts_wrap_bits;
3492

    
3493
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3494
        if(s->time_base.num != pts_num)
3495
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3496
    }else
3497
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3498

    
3499
    if(!s->time_base.num || !s->time_base.den)
3500
        s->time_base.num= s->time_base.den= 0;
3501
}
3502

    
3503
int ff_url_join(char *str, int size, const char *proto,
3504
                const char *authorization, const char *hostname,
3505
                int port, const char *fmt, ...)
3506
{
3507
#if CONFIG_NETWORK
3508
    struct addrinfo hints, *ai;
3509
#endif
3510

    
3511
    str[0] = '\0';
3512
    if (proto)
3513
        av_strlcatf(str, size, "%s://", proto);
3514
    if (authorization)
3515
        av_strlcatf(str, size, "%s@", authorization);
3516
#if CONFIG_NETWORK && defined(AF_INET6)
3517
    /* Determine if hostname is a numerical IPv6 address,
3518
     * properly escape it within [] in that case. */
3519
    memset(&hints, 0, sizeof(hints));
3520
    hints.ai_flags = AI_NUMERICHOST;
3521
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3522
        if (ai->ai_family == AF_INET6) {
3523
            av_strlcat(str, "[", size);
3524
            av_strlcat(str, hostname, size);
3525
            av_strlcat(str, "]", size);
3526
        } else {
3527
            av_strlcat(str, hostname, size);
3528
        }
3529
        freeaddrinfo(ai);
3530
    } else
3531
#endif
3532
        /* Not an IPv6 address, just output the plain string. */
3533
        av_strlcat(str, hostname, size);
3534

    
3535
    if (port >= 0)
3536
        av_strlcatf(str, size, ":%d", port);
3537
    if (fmt) {
3538
        va_list vl;
3539
        int len = strlen(str);
3540

    
3541
        va_start(vl, fmt);
3542
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3543
        va_end(vl);
3544
    }
3545
    return strlen(str);
3546
}