Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 2dad0dce

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
        }
499
        pd.buf_size += ret;
500
        pd.buf = &buf[offset];
501

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

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

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

    
521
    return 0;
522
}
523

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

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

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

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

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

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

    
586
}
587

    
588
/*******************************************************/
589

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

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

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

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

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

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

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

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

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

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

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

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

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

    
682
/**********************************************************/
683

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

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

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

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

    
713

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
992

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

    
998
    av_init_packet(pkt);
999

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

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

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

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

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

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

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

    
1125
    return 0;
1126
}
1127

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

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

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

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

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

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

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

    
1206
/*******************************************************/
1207
/* seek support */
1208

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

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

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

    
1236
    flush_packet_queue(s);
1237

    
1238
    s->cur_st = NULL;
1239

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

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

    
1256
        st->probe_packets = MAX_PROBE_PACKETS;
1257

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

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

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

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

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

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

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

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

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

    
1304
    st->index_entries= entries;
1305

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

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

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

    
1329
    return index;
1330
}
1331

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

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

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

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

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

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

    
1368
#define DEBUG_SEEK
1369

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

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

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

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

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

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

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

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

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

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

    
1431
    av_update_cur_dts(s, st, ts);
1432

    
1433
    return 0;
1434
}
1435

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1633
    return 0;
1634
}
1635

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

    
1641
    av_read_frame_flush(s);
1642

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

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

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

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

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

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

    
1676
    av_read_frame_flush(s);
1677

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

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

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

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

    
1693
/*******************************************************/
1694

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

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

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

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

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

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

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

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

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

    
1813
#define DURATION_MAX_READ_SIZE 250000
1814
#define DURATION_MAX_RETRY 3
1815

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

    
1826
    ic->cur_st = NULL;
1827

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

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

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

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

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

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

    
1887
    fill_all_stream_timings(ic);
1888

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2219
        read_size += pkt->size;
2220

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

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

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

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

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

    
2274
        count++;
2275
    }
2276

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

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

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

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

    
2336
    av_estimate_timings(ic, old_offset);
2337

    
2338
    compute_chapters_end(ic);
2339

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

    
2365
    av_free(duration_error);
2366

    
2367
    return ret;
2368
}
2369

    
2370
/*******************************************************/
2371

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2510
    return program;
2511
}
2512

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

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

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

    
2537
    return chapter;
2538
}
2539

    
2540
/************************************************************/
2541
/* output media file */
2542

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2790
    this_pktl->next= *next_point;
2791

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2897
        av_free_packet(&pkt);
2898

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3085
    av_free(printed);
3086
}
3087

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3219
    t *= 1000000;
3220

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3466
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3467
{
3468
    int i;
3469
    static const char hex_table[16] = { '0', '1', '2', '3',
3470
                                        '4', '5', '6', '7',
3471
                                        '8', '9', 'A', 'B',
3472
                                        'C', 'D', 'E', 'F' };
3473

    
3474
    for(i = 0; i < s; i++) {
3475
        buff[i * 2]     = hex_table[src[i] >> 4];
3476
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3477
    }
3478

    
3479
    return buff;
3480
}
3481

    
3482
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3483
                     unsigned int pts_num, unsigned int pts_den)
3484
{
3485
    s->pts_wrap_bits = pts_wrap_bits;
3486

    
3487
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3488
        if(s->time_base.num != pts_num)
3489
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3490
    }else
3491
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3492

    
3493
    if(!s->time_base.num || !s->time_base.den)
3494
        s->time_base.num= s->time_base.den= 0;
3495
}
3496

    
3497
int ff_url_join(char *str, int size, const char *proto,
3498
                const char *authorization, const char *hostname,
3499
                int port, const char *fmt, ...)
3500
{
3501
#if CONFIG_NETWORK
3502
    struct addrinfo hints, *ai;
3503
#endif
3504

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

    
3529
    if (port >= 0)
3530
        av_strlcatf(str, size, ":%d", port);
3531
    if (fmt) {
3532
        va_list vl;
3533
        int len = strlen(str);
3534

    
3535
        va_start(vl, fmt);
3536
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3537
        va_end(vl);
3538
    }
3539
    return strlen(str);
3540
}