Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 72415b2a

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 AVMediaType type){
258
    if(type == AVMEDIA_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 == AVMEDIA_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 = AVMEDIA_TYPE_AUDIO;
355
        } else if (!strcmp(fmt->name, "ac3")) {
356
            st->codec->codec_id = CODEC_ID_AC3;
357
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
358
        } else if (!strcmp(fmt->name, "eac3")) {
359
            st->codec->codec_id = CODEC_ID_EAC3;
360
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
361
        } else if (!strcmp(fmt->name, "mpegvideo")) {
362
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
363
            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
364
        } else if (!strcmp(fmt->name, "m4v")) {
365
            st->codec->codec_id = CODEC_ID_MPEG4;
366
            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
367
        } else if (!strcmp(fmt->name, "h264")) {
368
            st->codec->codec_id = CODEC_ID_H264;
369
            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
370
        } else if (!strcmp(fmt->name, "dts")) {
371
            st->codec->codec_id = CODEC_ID_DTS;
372
            st->codec->codec_type = AVMEDIA_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;
482
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
483
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
484
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
485

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

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

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

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

    
516
    av_free(buf);
517

    
518
    if (!*fmt) {
519
        return AVERROR_INVALIDDATA;
520
    }
521

    
522
    if (url_fseek(*pb, 0, SEEK_SET) < 0) {
523
        url_fclose(*pb);
524
        if (url_fopen(pb, filename, URL_RDONLY) < 0)
525
            return AVERROR(EIO);
526
    }
527

    
528
    return 0;
529
}
530

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

    
541
    pd->filename = "";
542
    if (filename)
543
        pd->filename = filename;
544
    pd->buf = NULL;
545
    pd->buf_size = 0;
546

    
547
    if (!fmt) {
548
        /* guess format if no file can be opened */
549
        fmt = av_probe_input_format(pd, 0);
550
    }
551

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

    
567
    /* if still no format found, error */
568
    if (!fmt) {
569
        err = AVERROR_INVALIDDATA;
570
        goto fail;
571
    }
572

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

    
593
}
594

    
595
/*******************************************************/
596

    
597
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
598
                               AVPacketList **plast_pktl){
599
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
600
    if (!pktl)
601
        return NULL;
602

    
603
    if (*packet_buffer)
604
        (*plast_pktl)->next = pktl;
605
    else
606
        *packet_buffer = pktl;
607

    
608
    /* add the packet in the buffered packet list */
609
    *plast_pktl = pktl;
610
    pktl->pkt= *pkt;
611
    return &pktl->pkt;
612
}
613

    
614
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
615
{
616
    int ret, i;
617
    AVStream *st;
618

    
619
    for(;;){
620
        AVPacketList *pktl = s->raw_packet_buffer;
621

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

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

    
648
        switch(st->codec->codec_type){
649
        case AVMEDIA_TYPE_VIDEO:
650
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
651
            break;
652
        case AVMEDIA_TYPE_AUDIO:
653
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
654
            break;
655
        case AVMEDIA_TYPE_SUBTITLE:
656
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
657
            break;
658
        }
659

    
660
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
661
                     !st->probe_packets))
662
            return ret;
663

    
664
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
665
        s->raw_packet_buffer_remaining_size -= pkt->size;
666

    
667
        if(st->codec->codec_id == CODEC_ID_PROBE){
668
            AVProbeData *pd = &st->probe_data;
669
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
670
            --st->probe_packets;
671

    
672
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
673
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
674
            pd->buf_size += pkt->size;
675
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
676

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

    
689
/**********************************************************/
690

    
691
/**
692
 * Get the number of samples of an audio frame. Return -1 on error.
693
 */
694
static int get_audio_frame_size(AVCodecContext *enc, int size)
695
{
696
    int frame_size;
697

    
698
    if(enc->codec_id == CODEC_ID_VORBIS)
699
        return -1;
700

    
701
    if (enc->frame_size <= 1) {
702
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
703

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

    
720

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

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

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

    
780
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
781
                                      int64_t dts, int64_t pts)
782
{
783
    AVStream *st= s->streams[stream_index];
784
    AVPacketList *pktl= s->packet_buffer;
785

    
786
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
787
        return;
788

    
789
    st->first_dts= dts - st->cur_dts;
790
    st->cur_dts= dts;
791

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

    
799
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
800
            pktl->pkt.dts += st->first_dts;
801

    
802
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
803
            st->start_time= pktl->pkt.pts;
804
    }
805
    if (st->start_time == AV_NOPTS_VALUE)
806
        st->start_time = pts;
807
}
808

    
809
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
810
{
811
    AVPacketList *pktl= s->packet_buffer;
812
    int64_t cur_dts= 0;
813

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

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

    
845
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
846
                               AVCodecParserContext *pc, AVPacket *pkt)
847
{
848
    int num, den, presentation_delayed, delay, i;
849
    int64_t offset;
850

    
851
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
852
        pkt->dts= AV_NOPTS_VALUE;
853

    
854
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
855
        //FIXME Set low_delay = 0 when has_b_frames = 1
856
        st->codec->has_b_frames = 1;
857

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

    
867
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
868
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
869
        pkt->dts -= 1LL<<st->pts_wrap_bits;
870
    }
871

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

    
880
    if (pkt->duration == 0) {
881
        compute_frame_duration(&num, &den, st, pc, pkt);
882
        if (den && num) {
883
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
884

    
885
            if(pkt->duration != 0 && s->packet_buffer)
886
                update_initial_durations(s, st, pkt);
887
        }
888
    }
889

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

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

    
920
    /* This may be redundant, but it should not hurt. */
921
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
922
        presentation_delayed = 1;
923

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

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

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

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

    
982
//    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);
983

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

    
999

    
1000
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1001
{
1002
    AVStream *st;
1003
    int len, ret, i;
1004

    
1005
    av_init_packet(pkt);
1006

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

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

    
1045
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
1046
                        ff_reduce_index(s, st->index);
1047
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1048
                                           0, 0, AVINDEX_KEYFRAME);
1049
                    }
1050

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

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

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

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

    
1132
    return 0;
1133
}
1134

    
1135
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1136
{
1137
    AVPacketList *pktl;
1138
    int eof=0;
1139
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1140

    
1141
    for(;;){
1142
        pktl = s->packet_buffer;
1143
        if (pktl) {
1144
            AVPacket *next_pkt= &pktl->pkt;
1145

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

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

    
1179
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1180
                                           &s->packet_buffer_end)) < 0)
1181
                return AVERROR(ENOMEM);
1182
        }else{
1183
            assert(!s->packet_buffer);
1184
            return av_read_frame_internal(s, pkt);
1185
        }
1186
    }
1187
}
1188

    
1189
/* XXX: suppress the packet queue */
1190
static void flush_packet_queue(AVFormatContext *s)
1191
{
1192
    AVPacketList *pktl;
1193

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

    
1213
/*******************************************************/
1214
/* seek support */
1215

    
1216
int av_find_default_stream_index(AVFormatContext *s)
1217
{
1218
    int first_audio_index = -1;
1219
    int i;
1220
    AVStream *st;
1221

    
1222
    if (s->nb_streams <= 0)
1223
        return -1;
1224
    for(i = 0; i < s->nb_streams; i++) {
1225
        st = s->streams[i];
1226
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1227
            return i;
1228
        }
1229
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1230
            first_audio_index = i;
1231
    }
1232
    return first_audio_index >= 0 ? first_audio_index : 0;
1233
}
1234

    
1235
/**
1236
 * Flush the frame reader.
1237
 */
1238
void ff_read_frame_flush(AVFormatContext *s)
1239
{
1240
    AVStream *st;
1241
    int i, j;
1242

    
1243
    flush_packet_queue(s);
1244

    
1245
    s->cur_st = NULL;
1246

    
1247
    /* for each stream, reset read state */
1248
    for(i = 0; i < s->nb_streams; i++) {
1249
        st = s->streams[i];
1250

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

    
1263
        st->probe_packets = MAX_PROBE_PACKETS;
1264

    
1265
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1266
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1267
    }
1268
}
1269

    
1270
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1271
    int i;
1272

    
1273
    for(i = 0; i < s->nb_streams; i++) {
1274
        AVStream *st = s->streams[i];
1275

    
1276
        st->cur_dts = av_rescale(timestamp,
1277
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1278
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1279
    }
1280
}
1281

    
1282
void ff_reduce_index(AVFormatContext *s, int stream_index)
1283
{
1284
    AVStream *st= s->streams[stream_index];
1285
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1286

    
1287
    if((unsigned)st->nb_index_entries >= max_entries){
1288
        int i;
1289
        for(i=0; 2*i<st->nb_index_entries; i++)
1290
            st->index_entries[i]= st->index_entries[2*i];
1291
        st->nb_index_entries= i;
1292
    }
1293
}
1294

    
1295
int av_add_index_entry(AVStream *st,
1296
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1297
{
1298
    AVIndexEntry *entries, *ie;
1299
    int index;
1300

    
1301
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1302
        return -1;
1303

    
1304
    entries = av_fast_realloc(st->index_entries,
1305
                              &st->index_entries_allocated_size,
1306
                              (st->nb_index_entries + 1) *
1307
                              sizeof(AVIndexEntry));
1308
    if(!entries)
1309
        return -1;
1310

    
1311
    st->index_entries= entries;
1312

    
1313
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1314

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

    
1330
    ie->pos = pos;
1331
    ie->timestamp = timestamp;
1332
    ie->min_distance= distance;
1333
    ie->size= size;
1334
    ie->flags = flags;
1335

    
1336
    return index;
1337
}
1338

    
1339
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1340
                              int flags)
1341
{
1342
    AVIndexEntry *entries= st->index_entries;
1343
    int nb_entries= st->nb_index_entries;
1344
    int a, b, m;
1345
    int64_t timestamp;
1346

    
1347
    a = - 1;
1348
    b = nb_entries;
1349

    
1350
    //optimize appending index entries at the end
1351
    if(b && entries[b-1].timestamp < wanted_timestamp)
1352
        a= b-1;
1353

    
1354
    while (b - a > 1) {
1355
        m = (a + b) >> 1;
1356
        timestamp = entries[m].timestamp;
1357
        if(timestamp >= wanted_timestamp)
1358
            b = m;
1359
        if(timestamp <= wanted_timestamp)
1360
            a = m;
1361
    }
1362
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1363

    
1364
    if(!(flags & AVSEEK_FLAG_ANY)){
1365
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1366
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1367
        }
1368
    }
1369

    
1370
    if(m == nb_entries)
1371
        return -1;
1372
    return  m;
1373
}
1374

    
1375
#define DEBUG_SEEK
1376

    
1377
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1378
    AVInputFormat *avif= s->iformat;
1379
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1380
    int64_t ts_min, ts_max, ts;
1381
    int index;
1382
    int64_t ret;
1383
    AVStream *st;
1384

    
1385
    if (stream_index < 0)
1386
        return -1;
1387

    
1388
#ifdef DEBUG_SEEK
1389
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1390
#endif
1391

    
1392
    ts_max=
1393
    ts_min= AV_NOPTS_VALUE;
1394
    pos_limit= -1; //gcc falsely says it may be uninitialized
1395

    
1396
    st= s->streams[stream_index];
1397
    if(st->index_entries){
1398
        AVIndexEntry *e;
1399

    
1400
        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()
1401
        index= FFMAX(index, 0);
1402
        e= &st->index_entries[index];
1403

    
1404
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1405
            pos_min= e->pos;
1406
            ts_min= e->timestamp;
1407
#ifdef DEBUG_SEEK
1408
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1409
                   pos_min,ts_min);
1410
#endif
1411
        }else{
1412
            assert(index==0);
1413
        }
1414

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

    
1430
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1431
    if(pos<0)
1432
        return -1;
1433

    
1434
    /* do the seek */
1435
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1436
        return ret;
1437

    
1438
    av_update_cur_dts(s, st, ts);
1439

    
1440
    return 0;
1441
}
1442

    
1443
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 )){
1444
    int64_t pos, ts;
1445
    int64_t start_pos, filesize;
1446
    int no_change;
1447

    
1448
#ifdef DEBUG_SEEK
1449
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1450
#endif
1451

    
1452
    if(ts_min == AV_NOPTS_VALUE){
1453
        pos_min = s->data_offset;
1454
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1455
        if (ts_min == AV_NOPTS_VALUE)
1456
            return -1;
1457
    }
1458

    
1459
    if(ts_max == AV_NOPTS_VALUE){
1460
        int step= 1024;
1461
        filesize = url_fsize(s->pb);
1462
        pos_max = filesize - 1;
1463
        do{
1464
            pos_max -= step;
1465
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1466
            step += step;
1467
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1468
        if (ts_max == AV_NOPTS_VALUE)
1469
            return -1;
1470

    
1471
        for(;;){
1472
            int64_t tmp_pos= pos_max + 1;
1473
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1474
            if(tmp_ts == AV_NOPTS_VALUE)
1475
                break;
1476
            ts_max= tmp_ts;
1477
            pos_max= tmp_pos;
1478
            if(tmp_pos >= filesize)
1479
                break;
1480
        }
1481
        pos_limit= pos_max;
1482
    }
1483

    
1484
    if(ts_min > ts_max){
1485
        return -1;
1486
    }else if(ts_min == ts_max){
1487
        pos_limit= pos_min;
1488
    }
1489

    
1490
    no_change=0;
1491
    while (pos_min < pos_limit) {
1492
#ifdef DEBUG_SEEK
1493
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1494
               pos_min, pos_max,
1495
               ts_min, ts_max);
1496
#endif
1497
        assert(pos_limit <= pos_max);
1498

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

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

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

    
1558
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1559
    int64_t pos_min, pos_max;
1560
#if 0
1561
    AVStream *st;
1562

1563
    if (stream_index < 0)
1564
        return -1;
1565

1566
    st= s->streams[stream_index];
1567
#endif
1568

    
1569
    pos_min = s->data_offset;
1570
    pos_max = url_fsize(s->pb) - 1;
1571

    
1572
    if     (pos < pos_min) pos= pos_min;
1573
    else if(pos > pos_max) pos= pos_max;
1574

    
1575
    url_fseek(s->pb, pos, SEEK_SET);
1576

    
1577
#if 0
1578
    av_update_cur_dts(s, st, ts);
1579
#endif
1580
    return 0;
1581
}
1582

    
1583
static int av_seek_frame_generic(AVFormatContext *s,
1584
                                 int stream_index, int64_t timestamp, int flags)
1585
{
1586
    int index;
1587
    int64_t ret;
1588
    AVStream *st;
1589
    AVIndexEntry *ie;
1590

    
1591
    st = s->streams[stream_index];
1592

    
1593
    index = av_index_search_timestamp(st, timestamp, flags);
1594

    
1595
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1596
        return -1;
1597

    
1598
    if(index < 0 || index==st->nb_index_entries-1){
1599
        int i;
1600
        AVPacket pkt;
1601

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

    
1630
    ff_read_frame_flush(s);
1631
    if (s->iformat->read_seek){
1632
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1633
            return 0;
1634
    }
1635
    ie = &st->index_entries[index];
1636
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1637
        return ret;
1638
    av_update_cur_dts(s, st, ie->timestamp);
1639

    
1640
    return 0;
1641
}
1642

    
1643
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1644
{
1645
    int ret;
1646
    AVStream *st;
1647

    
1648
    ff_read_frame_flush(s);
1649

    
1650
    if(flags & AVSEEK_FLAG_BYTE)
1651
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1652

    
1653
    if(stream_index < 0){
1654
        stream_index= av_find_default_stream_index(s);
1655
        if(stream_index < 0)
1656
            return -1;
1657

    
1658
        st= s->streams[stream_index];
1659
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1660
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1661
    }
1662

    
1663
    /* first, we try the format specific seek */
1664
    if (s->iformat->read_seek)
1665
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1666
    else
1667
        ret = -1;
1668
    if (ret >= 0) {
1669
        return 0;
1670
    }
1671

    
1672
    if(s->iformat->read_timestamp)
1673
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1674
    else
1675
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1676
}
1677

    
1678
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1679
{
1680
    if(min_ts > ts || max_ts < ts)
1681
        return -1;
1682

    
1683
    ff_read_frame_flush(s);
1684

    
1685
    if (s->iformat->read_seek2)
1686
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1687

    
1688
    if(s->iformat->read_timestamp){
1689
        //try to seek via read_timestamp()
1690
    }
1691

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

    
1697
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1698
}
1699

    
1700
/*******************************************************/
1701

    
1702
/**
1703
 * Returns TRUE if the stream has accurate duration in any stream.
1704
 *
1705
 * @return TRUE if the stream has accurate duration for at least one component.
1706
 */
1707
static int av_has_duration(AVFormatContext *ic)
1708
{
1709
    int i;
1710
    AVStream *st;
1711

    
1712
    for(i = 0;i < ic->nb_streams; i++) {
1713
        st = ic->streams[i];
1714
        if (st->duration != AV_NOPTS_VALUE)
1715
            return 1;
1716
    }
1717
    return 0;
1718
}
1719

    
1720
/**
1721
 * Estimate the stream timings from the one of each components.
1722
 *
1723
 * Also computes the global bitrate if possible.
1724
 */
1725
static void av_update_stream_timings(AVFormatContext *ic)
1726
{
1727
    int64_t start_time, start_time1, end_time, end_time1;
1728
    int64_t duration, duration1;
1729
    int i;
1730
    AVStream *st;
1731

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

    
1771
static void fill_all_stream_timings(AVFormatContext *ic)
1772
{
1773
    int i;
1774
    AVStream *st;
1775

    
1776
    av_update_stream_timings(ic);
1777
    for(i = 0;i < ic->nb_streams; i++) {
1778
        st = ic->streams[i];
1779
        if (st->start_time == AV_NOPTS_VALUE) {
1780
            if(ic->start_time != AV_NOPTS_VALUE)
1781
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1782
            if(ic->duration != AV_NOPTS_VALUE)
1783
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1784
        }
1785
    }
1786
}
1787

    
1788
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1789
{
1790
    int64_t filesize, duration;
1791
    int bit_rate, i;
1792
    AVStream *st;
1793

    
1794
    /* if bit_rate is already set, we believe it */
1795
    if (ic->bit_rate == 0) {
1796
        bit_rate = 0;
1797
        for(i=0;i<ic->nb_streams;i++) {
1798
            st = ic->streams[i];
1799
            bit_rate += st->codec->bit_rate;
1800
        }
1801
        ic->bit_rate = bit_rate;
1802
    }
1803

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

    
1820
#define DURATION_MAX_READ_SIZE 250000
1821
#define DURATION_MAX_RETRY 3
1822

    
1823
/* only usable for MPEG-PS streams */
1824
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1825
{
1826
    AVPacket pkt1, *pkt = &pkt1;
1827
    AVStream *st;
1828
    int read_size, i, ret;
1829
    int64_t end_time, start_time[MAX_STREAMS];
1830
    int64_t filesize, offset, duration;
1831
    int retry=0;
1832

    
1833
    ic->cur_st = NULL;
1834

    
1835
    /* flush packet queue */
1836
    flush_packet_queue(ic);
1837

    
1838
    for(i=0;i<ic->nb_streams;i++) {
1839
        st = ic->streams[i];
1840
        if(st->start_time != AV_NOPTS_VALUE){
1841
            start_time[i]= st->start_time;
1842
        }else if(st->first_dts != AV_NOPTS_VALUE){
1843
            start_time[i]= st->first_dts;
1844
        }else
1845
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1846

    
1847
        if (st->parser) {
1848
            av_parser_close(st->parser);
1849
            st->parser= NULL;
1850
            av_free_packet(&st->cur_pkt);
1851
        }
1852
    }
1853

    
1854
    /* estimate the end time (duration) */
1855
    /* XXX: may need to support wrapping */
1856
    filesize = ic->file_size;
1857
    end_time = AV_NOPTS_VALUE;
1858
    do{
1859
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1860
    if (offset < 0)
1861
        offset = 0;
1862

    
1863
    url_fseek(ic->pb, offset, SEEK_SET);
1864
    read_size = 0;
1865
    for(;;) {
1866
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1867
            break;
1868

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

    
1894
    fill_all_stream_timings(ic);
1895

    
1896
    url_fseek(ic->pb, old_offset, SEEK_SET);
1897
    for(i=0; i<ic->nb_streams; i++){
1898
        st= ic->streams[i];
1899
        st->cur_dts= st->first_dts;
1900
        st->last_IP_pts = AV_NOPTS_VALUE;
1901
    }
1902
}
1903

    
1904
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1905
{
1906
    int64_t file_size;
1907

    
1908
    /* get the file size, if possible */
1909
    if (ic->iformat->flags & AVFMT_NOFILE) {
1910
        file_size = 0;
1911
    } else {
1912
        file_size = url_fsize(ic->pb);
1913
        if (file_size < 0)
1914
            file_size = 0;
1915
    }
1916
    ic->file_size = file_size;
1917

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

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

    
1952
static int has_codec_parameters(AVCodecContext *enc)
1953
{
1954
    int val;
1955
    switch(enc->codec_type) {
1956
    case AVMEDIA_TYPE_AUDIO:
1957
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1958
        if(!enc->frame_size &&
1959
           (enc->codec_id == CODEC_ID_VORBIS ||
1960
            enc->codec_id == CODEC_ID_AAC ||
1961
            enc->codec_id == CODEC_ID_MP1 ||
1962
            enc->codec_id == CODEC_ID_MP2 ||
1963
            enc->codec_id == CODEC_ID_MP3 ||
1964
            enc->codec_id == CODEC_ID_SPEEX))
1965
            return 0;
1966
        break;
1967
    case AVMEDIA_TYPE_VIDEO:
1968
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1969
        break;
1970
    default:
1971
        val = 1;
1972
        break;
1973
    }
1974
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1975
}
1976

    
1977
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1978
{
1979
    int16_t *samples;
1980
    AVCodec *codec;
1981
    int got_picture, data_size, ret=0;
1982
    AVFrame picture;
1983

    
1984
    if(!st->codec->codec){
1985
        codec = avcodec_find_decoder(st->codec->codec_id);
1986
        if (!codec)
1987
            return -1;
1988
        ret = avcodec_open(st->codec, codec);
1989
        if (ret < 0)
1990
            return ret;
1991
    }
1992

    
1993
    if(!has_codec_parameters(st->codec)){
1994
        switch(st->codec->codec_type) {
1995
        case AVMEDIA_TYPE_VIDEO:
1996
            avcodec_get_frame_defaults(&picture);
1997
            ret = avcodec_decode_video2(st->codec, &picture,
1998
                                        &got_picture, avpkt);
1999
            break;
2000
        case AVMEDIA_TYPE_AUDIO:
2001
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2002
            samples = av_malloc(data_size);
2003
            if (!samples)
2004
                goto fail;
2005
            ret = avcodec_decode_audio3(st->codec, samples,
2006
                                        &data_size, avpkt);
2007
            av_free(samples);
2008
            break;
2009
        default:
2010
            break;
2011
        }
2012
    }
2013
 fail:
2014
    return ret;
2015
}
2016

    
2017
unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
2018
{
2019
    while (tags->id != CODEC_ID_NONE) {
2020
        if (tags->id == id)
2021
            return tags->tag;
2022
        tags++;
2023
    }
2024
    return 0;
2025
}
2026

    
2027
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2028
{
2029
    int i;
2030
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2031
        if(tag == tags[i].tag)
2032
            return tags[i].id;
2033
    }
2034
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2035
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
2036
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
2037
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
2038
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
2039
            return tags[i].id;
2040
    }
2041
    return CODEC_ID_NONE;
2042
}
2043

    
2044
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2045
{
2046
    int i;
2047
    for(i=0; tags && tags[i]; i++){
2048
        int tag= ff_codec_get_tag(tags[i], id);
2049
        if(tag) return tag;
2050
    }
2051
    return 0;
2052
}
2053

    
2054
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2055
{
2056
    int i;
2057
    for(i=0; tags && tags[i]; i++){
2058
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2059
        if(id!=CODEC_ID_NONE) return id;
2060
    }
2061
    return CODEC_ID_NONE;
2062
}
2063

    
2064
static void compute_chapters_end(AVFormatContext *s)
2065
{
2066
    unsigned int i;
2067

    
2068
    for (i=0; i+1<s->nb_chapters; i++)
2069
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2070
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2071
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2072
            s->chapters[i]->end = s->chapters[i+1]->start;
2073
        }
2074

    
2075
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2076
        assert(s->start_time != AV_NOPTS_VALUE);
2077
        assert(s->duration > 0);
2078
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2079
                                           AV_TIME_BASE_Q,
2080
                                           s->chapters[i]->time_base);
2081
    }
2082
}
2083

    
2084
#define MAX_STD_TIMEBASES (60*12+5)
2085
static int get_std_framerate(int i){
2086
    if(i<60*12) return i*1001;
2087
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2088
}
2089

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

    
2110
int av_find_stream_info(AVFormatContext *ic)
2111
{
2112
    int i, count, ret, read_size, j;
2113
    AVStream *st;
2114
    AVPacket pkt1, *pkt;
2115
    int64_t last_dts[MAX_STREAMS];
2116
    int64_t duration_gcd[MAX_STREAMS]={0};
2117
    int duration_count[MAX_STREAMS]={0};
2118
    double (*duration_error)[MAX_STD_TIMEBASES];
2119
    int64_t old_offset = url_ftell(ic->pb);
2120
    int64_t codec_info_duration[MAX_STREAMS]={0};
2121

    
2122
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2123
    if (!duration_error) return AVERROR(ENOMEM);
2124

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

    
2154
    for(i=0;i<MAX_STREAMS;i++){
2155
        last_dts[i]= AV_NOPTS_VALUE;
2156
    }
2157

    
2158
    count = 0;
2159
    read_size = 0;
2160
    for(;;) {
2161
        if(url_interrupt_cb()){
2162
            ret= AVERROR(EINTR);
2163
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2164
            break;
2165
        }
2166

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

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

    
2220
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2221
        if(av_dup_packet(pkt) < 0) {
2222
            av_free(duration_error);
2223
            return AVERROR(ENOMEM);
2224
        }
2225

    
2226
        read_size += pkt->size;
2227

    
2228
        st = ic->streams[pkt->stream_index];
2229
        if(st->codec_info_nb_frames>1) {
2230
            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){
2231
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2232
                break;
2233
            }
2234
            codec_info_duration[st->index] += pkt->duration;
2235
        }
2236
            st->codec_info_nb_frames++;
2237

    
2238
        {
2239
            int index= pkt->stream_index;
2240
            int64_t last= last_dts[index];
2241
            int64_t duration= pkt->dts - last;
2242

    
2243
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2244
                double dur= duration * av_q2d(st->time_base);
2245

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

    
2274
        /* if still no information, we try to open the codec and to
2275
           decompress the frame. We try to avoid that in most cases as
2276
           it takes longer and uses more memory. For MPEG-4, we need to
2277
           decompress for QuickTime. */
2278
        if (!has_codec_parameters(st->codec))
2279
            try_decode_frame(st, pkt);
2280

    
2281
        count++;
2282
    }
2283

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

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

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

    
2327
            if (!st->r_frame_rate.num){
2328
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2329
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2330
                    st->r_frame_rate.num = st->codec->time_base.den;
2331
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2332
                }else{
2333
                    st->r_frame_rate.num = st->time_base.den;
2334
                    st->r_frame_rate.den = st->time_base.num;
2335
                }
2336
            }
2337
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2338
            if(!st->codec->bits_per_coded_sample)
2339
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2340
        }
2341
    }
2342

    
2343
    av_estimate_timings(ic, old_offset);
2344

    
2345
    compute_chapters_end(ic);
2346

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

    
2372
    av_free(duration_error);
2373

    
2374
    return ret;
2375
}
2376

    
2377
/*******************************************************/
2378

    
2379
int av_read_play(AVFormatContext *s)
2380
{
2381
    if (s->iformat->read_play)
2382
        return s->iformat->read_play(s);
2383
    if (s->pb)
2384
        return av_url_read_fpause(s->pb, 0);
2385
    return AVERROR(ENOSYS);
2386
}
2387

    
2388
int av_read_pause(AVFormatContext *s)
2389
{
2390
    if (s->iformat->read_pause)
2391
        return s->iformat->read_pause(s);
2392
    if (s->pb)
2393
        return av_url_read_fpause(s->pb, 1);
2394
    return AVERROR(ENOSYS);
2395
}
2396

    
2397
void av_close_input_stream(AVFormatContext *s)
2398
{
2399
    int i;
2400
    AVStream *st;
2401

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

    
2445
void av_close_input_file(AVFormatContext *s)
2446
{
2447
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2448
    av_close_input_stream(s);
2449
    if (pb)
2450
        url_fclose(pb);
2451
}
2452

    
2453
AVStream *av_new_stream(AVFormatContext *s, int id)
2454
{
2455
    AVStream *st;
2456
    int i;
2457

    
2458
    if (s->nb_streams >= MAX_STREAMS)
2459
        return NULL;
2460

    
2461
    st = av_mallocz(sizeof(AVStream));
2462
    if (!st)
2463
        return NULL;
2464

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

    
2482
    /* default pts setting is MPEG-like */
2483
    av_set_pts_info(st, 33, 1, 90000);
2484
    st->last_IP_pts = AV_NOPTS_VALUE;
2485
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2486
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2487
    st->reference_dts = AV_NOPTS_VALUE;
2488

    
2489
    st->sample_aspect_ratio = (AVRational){0,1};
2490

    
2491
    s->streams[s->nb_streams++] = st;
2492
    return st;
2493
}
2494

    
2495
AVProgram *av_new_program(AVFormatContext *ac, int id)
2496
{
2497
    AVProgram *program=NULL;
2498
    int i;
2499

    
2500
#ifdef DEBUG_SI
2501
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2502
#endif
2503

    
2504
    for(i=0; i<ac->nb_programs; i++)
2505
        if(ac->programs[i]->id == id)
2506
            program = ac->programs[i];
2507

    
2508
    if(!program){
2509
        program = av_mallocz(sizeof(AVProgram));
2510
        if (!program)
2511
            return NULL;
2512
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2513
        program->discard = AVDISCARD_NONE;
2514
    }
2515
    program->id = id;
2516

    
2517
    return program;
2518
}
2519

    
2520
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2521
{
2522
    AVChapter *chapter = NULL;
2523
    int i;
2524

    
2525
    for(i=0; i<s->nb_chapters; i++)
2526
        if(s->chapters[i]->id == id)
2527
            chapter = s->chapters[i];
2528

    
2529
    if(!chapter){
2530
        chapter= av_mallocz(sizeof(AVChapter));
2531
        if(!chapter)
2532
            return NULL;
2533
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2534
    }
2535
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2536
    av_free(chapter->title);
2537
#endif
2538
    av_metadata_set(&chapter->metadata, "title", title);
2539
    chapter->id    = id;
2540
    chapter->time_base= time_base;
2541
    chapter->start = start;
2542
    chapter->end   = end;
2543

    
2544
    return chapter;
2545
}
2546

    
2547
/************************************************************/
2548
/* output media file */
2549

    
2550
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2551
{
2552
    int ret;
2553

    
2554
    if (s->oformat->priv_data_size > 0) {
2555
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2556
        if (!s->priv_data)
2557
            return AVERROR(ENOMEM);
2558
    } else
2559
        s->priv_data = NULL;
2560

    
2561
    if (s->oformat->set_parameters) {
2562
        ret = s->oformat->set_parameters(s, ap);
2563
        if (ret < 0)
2564
            return ret;
2565
    }
2566
    return 0;
2567
}
2568

    
2569
int av_write_header(AVFormatContext *s)
2570
{
2571
    int ret, i;
2572
    AVStream *st;
2573

    
2574
    // some sanity checks
2575
    if (s->nb_streams == 0) {
2576
        av_log(s, AV_LOG_ERROR, "no streams\n");
2577
        return -1;
2578
    }
2579

    
2580
    for(i=0;i<s->nb_streams;i++) {
2581
        st = s->streams[i];
2582

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

    
2609
        if(s->oformat->codec_tag){
2610
            if(st->codec->codec_tag){
2611
                //FIXME
2612
                //check that tag + id is in the table
2613
                //if neither is in the table -> OK
2614
                //if tag is in the table with another id -> FAIL
2615
                //if id is in the table with another tag -> FAIL unless strict < ?
2616
            }else
2617
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2618
        }
2619

    
2620
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2621
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2622
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2623
    }
2624

    
2625
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2626
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2627
        if (!s->priv_data)
2628
            return AVERROR(ENOMEM);
2629
    }
2630

    
2631
#if LIBAVFORMAT_VERSION_MAJOR < 53
2632
    ff_metadata_mux_compat(s);
2633
#endif
2634

    
2635
    /* set muxer identification string */
2636
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2637
        AVMetadata *m;
2638
        AVMetadataTag *t;
2639

    
2640
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2641
            return AVERROR(ENOMEM);
2642
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2643
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2644
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2645
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2646
        av_metadata_free(&m);
2647
    }
2648

    
2649
    if(s->oformat->write_header){
2650
        ret = s->oformat->write_header(s);
2651
        if (ret < 0)
2652
            return ret;
2653
    }
2654

    
2655
    /* init PTS generation */
2656
    for(i=0;i<s->nb_streams;i++) {
2657
        int64_t den = AV_NOPTS_VALUE;
2658
        st = s->streams[i];
2659

    
2660
        switch (st->codec->codec_type) {
2661
        case AVMEDIA_TYPE_AUDIO:
2662
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2663
            break;
2664
        case AVMEDIA_TYPE_VIDEO:
2665
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2666
            break;
2667
        default:
2668
            break;
2669
        }
2670
        if (den != AV_NOPTS_VALUE) {
2671
            if (den <= 0)
2672
                return AVERROR_INVALIDDATA;
2673
            av_frac_init(&st->pts, 0, 0, den);
2674
        }
2675
    }
2676
    return 0;
2677
}
2678

    
2679
//FIXME merge with compute_pkt_fields
2680
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2681
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2682
    int num, den, frame_size, i;
2683

    
2684
//    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);
2685

    
2686
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2687
        return -1;*/
2688

    
2689
    /* duration field */
2690
    if (pkt->duration == 0) {
2691
        compute_frame_duration(&num, &den, st, NULL, pkt);
2692
        if (den && num) {
2693
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2694
        }
2695
    }
2696

    
2697
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2698
        pkt->pts= pkt->dts;
2699

    
2700
    //XXX/FIXME this is a temporary hack until all encoders output pts
2701
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2702
        pkt->dts=
2703
//        pkt->pts= st->cur_dts;
2704
        pkt->pts= st->pts.val;
2705
    }
2706

    
2707
    //calculate dts from pts
2708
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2709
        st->pts_buffer[0]= pkt->pts;
2710
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2711
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2712
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2713
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2714

    
2715
        pkt->dts= st->pts_buffer[0];
2716
    }
2717

    
2718
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2719
        av_log(s, AV_LOG_ERROR,
2720
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2721
               st->index, st->cur_dts, pkt->dts);
2722
        return -1;
2723
    }
2724
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2725
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2726
        return -1;
2727
    }
2728

    
2729
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2730
    st->cur_dts= pkt->dts;
2731
    st->pts.val= pkt->dts;
2732

    
2733
    /* update pts */
2734
    switch (st->codec->codec_type) {
2735
    case AVMEDIA_TYPE_AUDIO:
2736
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2737

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

    
2754
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2755
{
2756
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2757

    
2758
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2759
        return ret;
2760

    
2761
    ret= s->oformat->write_packet(s, pkt);
2762
    if(!ret)
2763
        ret= url_ferror(s->pb);
2764
    return ret;
2765
}
2766

    
2767
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2768
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2769
{
2770
    AVPacketList **next_point, *this_pktl;
2771

    
2772
    this_pktl = av_mallocz(sizeof(AVPacketList));
2773
    this_pktl->pkt= *pkt;
2774
    pkt->destruct= NULL;             // do not free original but only the copy
2775
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2776

    
2777
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2778
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2779
    }else
2780
        next_point = &s->packet_buffer;
2781

    
2782
    if(*next_point){
2783
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2784
            while(!compare(s, &(*next_point)->pkt, pkt)){
2785
                next_point= &(*next_point)->next;
2786
            }
2787
            goto next_non_null;
2788
        }else{
2789
            next_point = &(s->packet_buffer_end->next);
2790
        }
2791
    }
2792
    assert(!*next_point);
2793

    
2794
    s->packet_buffer_end= this_pktl;
2795
next_non_null:
2796

    
2797
    this_pktl->next= *next_point;
2798

    
2799
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2800
    *next_point= this_pktl;
2801
}
2802

    
2803
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2804
{
2805
    AVStream *st = s->streams[ pkt ->stream_index];
2806
    AVStream *st2= s->streams[ next->stream_index];
2807
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2808
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2809
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2810
}
2811

    
2812
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2813
    AVPacketList *pktl;
2814
    int stream_count=0;
2815
    int i;
2816

    
2817
    if(pkt){
2818
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2819
    }
2820

    
2821
    for(i=0; i < s->nb_streams; i++)
2822
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2823

    
2824
    if(stream_count && (s->nb_streams == stream_count || flush)){
2825
        pktl= s->packet_buffer;
2826
        *out= pktl->pkt;
2827

    
2828
        s->packet_buffer= pktl->next;
2829
        if(!s->packet_buffer)
2830
            s->packet_buffer_end= NULL;
2831

    
2832
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2833
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2834
        av_freep(&pktl);
2835
        return 1;
2836
    }else{
2837
        av_init_packet(out);
2838
        return 0;
2839
    }
2840
}
2841

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

    
2858
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2859
    AVStream *st= s->streams[ pkt->stream_index];
2860

    
2861
    //FIXME/XXX/HACK drop zero sized packets
2862
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2863
        return 0;
2864

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

    
2869
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2870
        return -1;
2871

    
2872
    for(;;){
2873
        AVPacket opkt;
2874
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2875
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2876
            return ret;
2877

    
2878
        ret= s->oformat->write_packet(s, &opkt);
2879

    
2880
        av_free_packet(&opkt);
2881
        pkt= NULL;
2882

    
2883
        if(ret<0)
2884
            return ret;
2885
        if(url_ferror(s->pb))
2886
            return url_ferror(s->pb);
2887
    }
2888
}
2889

    
2890
int av_write_trailer(AVFormatContext *s)
2891
{
2892
    int ret, i;
2893

    
2894
    for(;;){
2895
        AVPacket pkt;
2896
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2897
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2898
            goto fail;
2899
        if(!ret)
2900
            break;
2901

    
2902
        ret= s->oformat->write_packet(s, &pkt);
2903

    
2904
        av_free_packet(&pkt);
2905

    
2906
        if(ret<0)
2907
            goto fail;
2908
        if(url_ferror(s->pb))
2909
            goto fail;
2910
    }
2911

    
2912
    if(s->oformat->write_trailer)
2913
        ret = s->oformat->write_trailer(s);
2914
fail:
2915
    if(ret == 0)
2916
       ret=url_ferror(s->pb);
2917
    for(i=0;i<s->nb_streams;i++) {
2918
        av_freep(&s->streams[i]->priv_data);
2919
        av_freep(&s->streams[i]->index_entries);
2920
    }
2921
    av_freep(&s->priv_data);
2922
    return ret;
2923
}
2924

    
2925
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2926
{
2927
    int i, j;
2928
    AVProgram *program=NULL;
2929
    void *tmp;
2930

    
2931
    if (idx >= ac->nb_streams) {
2932
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2933
        return;
2934
    }
2935

    
2936
    for(i=0; i<ac->nb_programs; i++){
2937
        if(ac->programs[i]->id != progid)
2938
            continue;
2939
        program = ac->programs[i];
2940
        for(j=0; j<program->nb_stream_indexes; j++)
2941
            if(program->stream_index[j] == idx)
2942
                return;
2943

    
2944
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2945
        if(!tmp)
2946
            return;
2947
        program->stream_index = tmp;
2948
        program->stream_index[program->nb_stream_indexes++] = idx;
2949
        return;
2950
    }
2951
}
2952

    
2953
static void print_fps(double d, const char *postfix){
2954
    uint64_t v= lrintf(d*100);
2955
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2956
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2957
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2958
}
2959

    
2960
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2961
{
2962
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2963
        AVMetadataTag *tag=NULL;
2964

    
2965
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2966
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2967
            if(strcmp("language", tag->key))
2968
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
2969
        }
2970
    }
2971
}
2972

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

    
3016
void dump_format(AVFormatContext *ic,
3017
                 int index,
3018
                 const char *url,
3019
                 int is_output)
3020
{
3021
    int i;
3022
    uint8_t *printed = av_mallocz(ic->nb_streams);
3023
    if (ic->nb_streams && !printed)
3024
        return;
3025

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

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

    
3092
    av_free(printed);
3093
}
3094

    
3095
#if LIBAVFORMAT_VERSION_MAJOR < 53
3096
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3097
{
3098
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
3099
}
3100

    
3101
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3102
{
3103
    AVRational frame_rate;
3104
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
3105
    *frame_rate_num= frame_rate.num;
3106
    *frame_rate_den= frame_rate.den;
3107
    return ret;
3108
}
3109
#endif
3110

    
3111
int64_t av_gettime(void)
3112
{
3113
    struct timeval tv;
3114
    gettimeofday(&tv,NULL);
3115
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3116
}
3117

    
3118
uint64_t ff_ntp_time(void)
3119
{
3120
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3121
}
3122

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

    
3142
#undef time
3143
    time_t now = time(0);
3144

    
3145
    len = strlen(datestr);
3146
    if (len > 0)
3147
        lastch = datestr[len - 1];
3148
    else
3149
        lastch = '\0';
3150
    is_utc = (lastch == 'z' || lastch == 'Z');
3151

    
3152
    memset(&dt, 0, sizeof(dt));
3153

    
3154
    p = datestr;
3155
    q = NULL;
3156
    if (!duration) {
3157
        if (!strncasecmp(datestr, "now", len))
3158
            return (int64_t) now * 1000000;
3159

    
3160
        /* parse the year-month-day part */
3161
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3162
            q = small_strptime(p, date_fmt[i], &dt);
3163
            if (q) {
3164
                break;
3165
            }
3166
        }
3167

    
3168
        /* if the year-month-day part is missing, then take the
3169
         * current year-month-day time */
3170
        if (!q) {
3171
            if (is_utc) {
3172
                dt = *gmtime(&now);
3173
            } else {
3174
                dt = *localtime(&now);
3175
            }
3176
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3177
        } else {
3178
            p = q;
3179
        }
3180

    
3181
        if (*p == 'T' || *p == 't' || *p == ' ')
3182
            p++;
3183

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

    
3210
    /* Now we have all the fields that we can get */
3211
    if (!q) {
3212
        return INT64_MIN;
3213
    }
3214

    
3215
    if (duration) {
3216
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3217
    } else {
3218
        dt.tm_isdst = -1;       /* unknown */
3219
        if (is_utc) {
3220
            t = mktimegm(&dt);
3221
        } else {
3222
            t = mktime(&dt);
3223
        }
3224
    }
3225

    
3226
    t *= 1000000;
3227

    
3228
    /* parse the .m... part */
3229
    if (*q == '.') {
3230
        int val, n;
3231
        q++;
3232
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3233
            if (!isdigit(*q))
3234
                break;
3235
            val += n * (*q - '0');
3236
        }
3237
        t += val;
3238
    }
3239
    return negative ? -t : t;
3240
}
3241

    
3242
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3243
{
3244
    const char *p;
3245
    char tag[128], *q;
3246

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

    
3281
int av_get_frame_filename(char *buf, int buf_size,
3282
                          const char *path, int number)
3283
{
3284
    const char *p;
3285
    char *q, buf1[20], c;
3286
    int nd, len, percentd_found;
3287

    
3288
    q = buf;
3289
    p = path;
3290
    percentd_found = 0;
3291
    for(;;) {
3292
        c = *p++;
3293
        if (c == '\0')
3294
            break;
3295
        if (c == '%') {
3296
            do {
3297
                nd = 0;
3298
                while (isdigit(*p)) {
3299
                    nd = nd * 10 + *p++ - '0';
3300
                }
3301
                c = *p++;
3302
            } while (isdigit(c));
3303

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

    
3336
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3337
{
3338
    int len, i, j, c;
3339
#undef fprintf
3340
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3341

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

    
3365
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3366
{
3367
    hex_dump_internal(NULL, f, 0, buf, size);
3368
}
3369

    
3370
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3371
{
3372
    hex_dump_internal(avcl, NULL, level, buf, size);
3373
}
3374

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

    
3402
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3403
{
3404
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3405
}
3406

    
3407
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3408
{
3409
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3410
}
3411

    
3412
void ff_url_split(char *proto, int proto_size,
3413
                  char *authorization, int authorization_size,
3414
                  char *hostname, int hostname_size,
3415
                  int *port_ptr,
3416
                  char *path, int path_size,
3417
                  const char *url)
3418
{
3419
    const char *p, *ls, *at, *col, *brk;
3420

    
3421
    if (port_ptr)               *port_ptr = -1;
3422
    if (proto_size > 0)         proto[0] = 0;
3423
    if (authorization_size > 0) authorization[0] = 0;
3424
    if (hostname_size > 0)      hostname[0] = 0;
3425
    if (path_size > 0)          path[0] = 0;
3426

    
3427
    /* parse protocol */
3428
    if ((p = strchr(url, ':'))) {
3429
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3430
        p++; /* skip ':' */
3431
        if (*p == '/') p++;
3432
        if (*p == '/') p++;
3433
    } else {
3434
        /* no protocol means plain filename */
3435
        av_strlcpy(path, url, path_size);
3436
        return;
3437
    }
3438

    
3439
    /* separate path from hostname */
3440
    ls = strchr(p, '/');
3441
    if(!ls)
3442
        ls = strchr(p, '?');
3443
    if(ls)
3444
        av_strlcpy(path, ls, path_size);
3445
    else
3446
        ls = &p[strlen(p)]; // XXX
3447

    
3448
    /* the rest is hostname, use that to parse auth/port */
3449
    if (ls != p) {
3450
        /* authorization (user[:pass]@hostname) */
3451
        if ((at = strchr(p, '@')) && at < ls) {
3452
            av_strlcpy(authorization, p,
3453
                       FFMIN(authorization_size, at + 1 - p));
3454
            p = at + 1; /* skip '@' */
3455
        }
3456

    
3457
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3458
            /* [host]:port */
3459
            av_strlcpy(hostname, p + 1,
3460
                       FFMIN(hostname_size, brk - p));
3461
            if (brk[1] == ':' && port_ptr)
3462
                *port_ptr = atoi(brk + 2);
3463
        } else if ((col = strchr(p, ':')) && col < ls) {
3464
            av_strlcpy(hostname, p,
3465
                       FFMIN(col + 1 - p, hostname_size));
3466
            if (port_ptr) *port_ptr = atoi(col + 1);
3467
        } else
3468
            av_strlcpy(hostname, p,
3469
                       FFMIN(ls + 1 - p, hostname_size));
3470
    }
3471
}
3472

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

    
3486
    for(i = 0; i < s; i++) {
3487
        buff[i * 2]     = hex_table[src[i] >> 4];
3488
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3489
    }
3490

    
3491
    return buff;
3492
}
3493

    
3494
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3495
                     unsigned int pts_num, unsigned int pts_den)
3496
{
3497
    s->pts_wrap_bits = pts_wrap_bits;
3498

    
3499
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3500
        if(s->time_base.num != pts_num)
3501
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3502
    }else
3503
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3504

    
3505
    if(!s->time_base.num || !s->time_base.den)
3506
        s->time_base.num= s->time_base.den= 0;
3507
}
3508

    
3509
int ff_url_join(char *str, int size, const char *proto,
3510
                const char *authorization, const char *hostname,
3511
                int port, const char *fmt, ...)
3512
{
3513
#if CONFIG_NETWORK
3514
    struct addrinfo hints, *ai;
3515
#endif
3516

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

    
3541
    if (port >= 0)
3542
        av_strlcatf(str, size, ":%d", port);
3543
    if (fmt) {
3544
        va_list vl;
3545
        int len = strlen(str);
3546

    
3547
        va_start(vl, fmt);
3548
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3549
        va_end(vl);
3550
    }
3551
    return strlen(str);
3552
}