Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 85b4230f

History | View | Annotate | Download (102 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 <sys/time.h>
28
#include <time.h>
29
#include <strings.h>
30

    
31
#undef NDEBUG
32
#include <assert.h>
33

    
34
/**
35
 * @file libavformat/utils.c
36
 * various utility functions for use within FFmpeg
37
 */
38

    
39
unsigned avformat_version(void)
40
{
41
    return LIBAVFORMAT_VERSION_INT;
42
}
43

    
44
/* fraction handling */
45

    
46
/**
47
 * f = val + (num / den) + 0.5.
48
 *
49
 * 'num' is normalized so that it is such as 0 <= num < den.
50
 *
51
 * @param f fractional number
52
 * @param val integer value
53
 * @param num must be >= 0
54
 * @param den must be >= 1
55
 */
56
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
57
{
58
    num += (den >> 1);
59
    if (num >= den) {
60
        val += num / den;
61
        num = num % den;
62
    }
63
    f->val = val;
64
    f->num = num;
65
    f->den = den;
66
}
67

    
68
/**
69
 * Fractional addition to f: f = f + (incr / f->den).
70
 *
71
 * @param f fractional number
72
 * @param incr increment, can be positive or negative
73
 */
74
static void av_frac_add(AVFrac *f, int64_t incr)
75
{
76
    int64_t num, den;
77

    
78
    num = f->num + incr;
79
    den = f->den;
80
    if (num < 0) {
81
        f->val += num / den;
82
        num = num % den;
83
        if (num < 0) {
84
            num += den;
85
            f->val--;
86
        }
87
    } else if (num >= den) {
88
        f->val += num / den;
89
        num = num % den;
90
    }
91
    f->num = num;
92
}
93

    
94
/** head of registered input format linked list */
95
AVInputFormat *first_iformat = NULL;
96
/** head of registered output format linked list */
97
AVOutputFormat *first_oformat = NULL;
98

    
99
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
100
{
101
    if(f) return f->next;
102
    else  return first_iformat;
103
}
104

    
105
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
106
{
107
    if(f) return f->next;
108
    else  return first_oformat;
109
}
110

    
111
void av_register_input_format(AVInputFormat *format)
112
{
113
    AVInputFormat **p;
114
    p = &first_iformat;
115
    while (*p != NULL) p = &(*p)->next;
116
    *p = format;
117
    format->next = NULL;
118
}
119

    
120
void av_register_output_format(AVOutputFormat *format)
121
{
122
    AVOutputFormat **p;
123
    p = &first_oformat;
124
    while (*p != NULL) p = &(*p)->next;
125
    *p = format;
126
    format->next = NULL;
127
}
128

    
129
int match_ext(const char *filename, const char *extensions)
130
{
131
    const char *ext, *p;
132
    char ext1[32], *q;
133

    
134
    if(!filename)
135
        return 0;
136

    
137
    ext = strrchr(filename, '.');
138
    if (ext) {
139
        ext++;
140
        p = extensions;
141
        for(;;) {
142
            q = ext1;
143
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
144
                *q++ = *p++;
145
            *q = '\0';
146
            if (!strcasecmp(ext1, ext))
147
                return 1;
148
            if (*p == '\0')
149
                break;
150
            p++;
151
        }
152
    }
153
    return 0;
154
}
155

    
156
static int match_format(const char *name, const char *names)
157
{
158
    const char *p;
159
    int len, namelen;
160

    
161
    if (!name || !names)
162
        return 0;
163

    
164
    namelen = strlen(name);
165
    while ((p = strchr(names, ','))) {
166
        len = FFMAX(p - names, namelen);
167
        if (!strncasecmp(name, names, len))
168
            return 1;
169
        names = p+1;
170
    }
171
    return !strcasecmp(name, names);
172
}
173

    
174
AVOutputFormat *guess_format(const char *short_name, const char *filename,
175
                             const char *mime_type)
176
{
177
    AVOutputFormat *fmt, *fmt_found;
178
    int score_max, score;
179

    
180
    /* specific test for image sequences */
181
#if CONFIG_IMAGE2_MUXER
182
    if (!short_name && filename &&
183
        av_filename_number_test(filename) &&
184
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
185
        return guess_format("image2", NULL, NULL);
186
    }
187
#endif
188
    /* Find the proper file type. */
189
    fmt_found = NULL;
190
    score_max = 0;
191
    fmt = first_oformat;
192
    while (fmt != NULL) {
193
        score = 0;
194
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
195
            score += 100;
196
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
197
            score += 10;
198
        if (filename && fmt->extensions &&
199
            match_ext(filename, fmt->extensions)) {
200
            score += 5;
201
        }
202
        if (score > score_max) {
203
            score_max = score;
204
            fmt_found = fmt;
205
        }
206
        fmt = fmt->next;
207
    }
208
    return fmt_found;
209
}
210

    
211
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
212
                             const char *mime_type)
213
{
214
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
215

    
216
    if (fmt) {
217
        AVOutputFormat *stream_fmt;
218
        char stream_format_name[64];
219

    
220
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
221
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
222

    
223
        if (stream_fmt)
224
            fmt = stream_fmt;
225
    }
226

    
227
    return fmt;
228
}
229

    
230
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
231
                            const char *filename, const char *mime_type, enum CodecType type){
232
    if(type == CODEC_TYPE_VIDEO){
233
        enum CodecID codec_id= CODEC_ID_NONE;
234

    
235
#if CONFIG_IMAGE2_MUXER
236
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
237
            codec_id= av_guess_image2_codec(filename);
238
        }
239
#endif
240
        if(codec_id == CODEC_ID_NONE)
241
            codec_id= fmt->video_codec;
242
        return codec_id;
243
    }else if(type == CODEC_TYPE_AUDIO)
244
        return fmt->audio_codec;
245
    else
246
        return CODEC_ID_NONE;
247
}
248

    
249
AVInputFormat *av_find_input_format(const char *short_name)
250
{
251
    AVInputFormat *fmt;
252
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
253
        if (match_format(short_name, fmt->name))
254
            return fmt;
255
    }
256
    return NULL;
257
}
258

    
259
/* memory handling */
260

    
261
void av_destruct_packet(AVPacket *pkt)
262
{
263
    av_free(pkt->data);
264
    pkt->data = NULL; pkt->size = 0;
265
}
266

    
267
void av_init_packet(AVPacket *pkt)
268
{
269
    pkt->pts   = AV_NOPTS_VALUE;
270
    pkt->dts   = AV_NOPTS_VALUE;
271
    pkt->pos   = -1;
272
    pkt->duration = 0;
273
    pkt->convergence_duration = 0;
274
    pkt->flags = 0;
275
    pkt->stream_index = 0;
276
    pkt->destruct= av_destruct_packet_nofree;
277
}
278

    
279
int av_new_packet(AVPacket *pkt, int size)
280
{
281
    uint8_t *data;
282
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
283
        return AVERROR(ENOMEM);
284
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
285
    if (!data)
286
        return AVERROR(ENOMEM);
287
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
288

    
289
    av_init_packet(pkt);
290
    pkt->data = data;
291
    pkt->size = size;
292
    pkt->destruct = av_destruct_packet;
293
    return 0;
294
}
295

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

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

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

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

    
311
    return ret;
312
}
313

    
314
int av_dup_packet(AVPacket *pkt)
315
{
316
    if (((pkt->destruct == av_destruct_packet_nofree) || (pkt->destruct == NULL)) && pkt->data) {
317
        uint8_t *data;
318
        /* We duplicate the packet and don't forget to add the padding again. */
319
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
320
            return AVERROR(ENOMEM);
321
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
322
        if (!data) {
323
            return AVERROR(ENOMEM);
324
        }
325
        memcpy(data, pkt->data, pkt->size);
326
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
327
        pkt->data = data;
328
        pkt->destruct = av_destruct_packet;
329
    }
330
    return 0;
331
}
332

    
333
int av_filename_number_test(const char *filename)
334
{
335
    char buf[1024];
336
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
337
}
338

    
339
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
340
{
341
    AVInputFormat *fmt1, *fmt;
342
    int score;
343

    
344
    fmt = NULL;
345
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
346
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
347
            continue;
348
        score = 0;
349
        if (fmt1->read_probe) {
350
            score = fmt1->read_probe(pd);
351
        } else if (fmt1->extensions) {
352
            if (match_ext(pd->filename, fmt1->extensions)) {
353
                score = 50;
354
            }
355
        }
356
        if (score > *score_max) {
357
            *score_max = score;
358
            fmt = fmt1;
359
        }else if (score == *score_max)
360
            fmt = NULL;
361
    }
362
    return fmt;
363
}
364

    
365
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
366
    int score=0;
367
    return av_probe_input_format2(pd, is_opened, &score);
368
}
369

    
370
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
371
{
372
    AVInputFormat *fmt;
373
    fmt = av_probe_input_format2(pd, 1, &score);
374

    
375
    if (fmt) {
376
        if (!strcmp(fmt->name, "mp3")) {
377
            st->codec->codec_id = CODEC_ID_MP3;
378
            st->codec->codec_type = CODEC_TYPE_AUDIO;
379
        } else if (!strcmp(fmt->name, "ac3")) {
380
            st->codec->codec_id = CODEC_ID_AC3;
381
            st->codec->codec_type = CODEC_TYPE_AUDIO;
382
        } else if (!strcmp(fmt->name, "mpegvideo")) {
383
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
384
            st->codec->codec_type = CODEC_TYPE_VIDEO;
385
        } else if (!strcmp(fmt->name, "m4v")) {
386
            st->codec->codec_id = CODEC_ID_MPEG4;
387
            st->codec->codec_type = CODEC_TYPE_VIDEO;
388
        } else if (!strcmp(fmt->name, "h264")) {
389
            st->codec->codec_id = CODEC_ID_H264;
390
            st->codec->codec_type = CODEC_TYPE_VIDEO;
391
        }
392
    }
393
    return !!fmt;
394
}
395

    
396
/************************************************************/
397
/* input media file */
398

    
399
/**
400
 * Open a media file from an IO stream. 'fmt' must be specified.
401
 */
402
int av_open_input_stream(AVFormatContext **ic_ptr,
403
                         ByteIOContext *pb, const char *filename,
404
                         AVInputFormat *fmt, AVFormatParameters *ap)
405
{
406
    int err;
407
    AVFormatContext *ic;
408
    AVFormatParameters default_ap;
409

    
410
    if(!ap){
411
        ap=&default_ap;
412
        memset(ap, 0, sizeof(default_ap));
413
    }
414

    
415
    if(!ap->prealloced_context)
416
        ic = avformat_alloc_context();
417
    else
418
        ic = *ic_ptr;
419
    if (!ic) {
420
        err = AVERROR(ENOMEM);
421
        goto fail;
422
    }
423
    ic->iformat = fmt;
424
    ic->pb = pb;
425
    ic->duration = AV_NOPTS_VALUE;
426
    ic->start_time = AV_NOPTS_VALUE;
427
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
428

    
429
    /* allocate private data */
430
    if (fmt->priv_data_size > 0) {
431
        ic->priv_data = av_mallocz(fmt->priv_data_size);
432
        if (!ic->priv_data) {
433
            err = AVERROR(ENOMEM);
434
            goto fail;
435
        }
436
    } else {
437
        ic->priv_data = NULL;
438
    }
439

    
440
    if (ic->iformat->read_header) {
441
        err = ic->iformat->read_header(ic, ap);
442
        if (err < 0)
443
            goto fail;
444
    }
445

    
446
    if (pb && !ic->data_offset)
447
        ic->data_offset = url_ftell(ic->pb);
448

    
449
#if LIBAVFORMAT_VERSION_MAJOR < 53
450
    ff_metadata_demux_compat(ic);
451
#endif
452

    
453
    *ic_ptr = ic;
454
    return 0;
455
 fail:
456
    if (ic) {
457
        int i;
458
        av_freep(&ic->priv_data);
459
        for(i=0;i<ic->nb_streams;i++) {
460
            AVStream *st = ic->streams[i];
461
            if (st) {
462
                av_free(st->priv_data);
463
                av_free(st->codec->extradata);
464
            }
465
            av_free(st);
466
        }
467
    }
468
    av_free(ic);
469
    *ic_ptr = NULL;
470
    return err;
471
}
472

    
473
/** size of probe buffer, for guessing file type from file contents */
474
#define PROBE_BUF_MIN 2048
475
#define PROBE_BUF_MAX (1<<20)
476

    
477
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
478
                       AVInputFormat *fmt,
479
                       int buf_size,
480
                       AVFormatParameters *ap)
481
{
482
    int err, probe_size;
483
    AVProbeData probe_data, *pd = &probe_data;
484
    ByteIOContext *pb = NULL;
485

    
486
    pd->filename = "";
487
    if (filename)
488
        pd->filename = filename;
489
    pd->buf = NULL;
490
    pd->buf_size = 0;
491

    
492
    if (!fmt) {
493
        /* guess format if no file can be opened */
494
        fmt = av_probe_input_format(pd, 0);
495
    }
496

    
497
    /* Do not open file if the format does not need it. XXX: specific
498
       hack needed to handle RTSP/TCP */
499
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
500
        /* if no file needed do not try to open one */
501
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
502
            goto fail;
503
        }
504
        if (buf_size > 0) {
505
            url_setbufsize(pb, buf_size);
506
        }
507

    
508
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
509
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
510
            /* read probe data */
511
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
512
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
513
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
514
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
515
                url_fclose(pb);
516
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
517
                    pb = NULL;
518
                    err = AVERROR(EIO);
519
                    goto fail;
520
                }
521
            }
522
            /* guess file format */
523
            fmt = av_probe_input_format2(pd, 1, &score);
524
        }
525
        av_freep(&pd->buf);
526
    }
527

    
528
    /* if still no format found, error */
529
    if (!fmt) {
530
        err = AVERROR_NOFMT;
531
        goto fail;
532
    }
533

    
534
    /* check filename in case an image number is expected */
535
    if (fmt->flags & AVFMT_NEEDNUMBER) {
536
        if (!av_filename_number_test(filename)) {
537
            err = AVERROR_NUMEXPECTED;
538
            goto fail;
539
        }
540
    }
541
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
542
    if (err)
543
        goto fail;
544
    return 0;
545
 fail:
546
    av_freep(&pd->buf);
547
    if (pb)
548
        url_fclose(pb);
549
    *ic_ptr = NULL;
550
    return err;
551

    
552
}
553

    
554
/*******************************************************/
555

    
556
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
557
                               AVPacketList **plast_pktl){
558
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
559
    if (!pktl)
560
        return NULL;
561

    
562
    if (*packet_buffer)
563
        (*plast_pktl)->next = pktl;
564
    else
565
        *packet_buffer = pktl;
566

    
567
    /* add the packet in the buffered packet list */
568
    *plast_pktl = pktl;
569
    pktl->pkt= *pkt;
570
    return &pktl->pkt;
571
}
572

    
573
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
574
{
575
    int ret;
576
    AVStream *st;
577

    
578
    for(;;){
579
        AVPacketList *pktl = s->raw_packet_buffer;
580

    
581
        if (pktl) {
582
            *pkt = pktl->pkt;
583
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
584
                s->raw_packet_buffer = pktl->next;
585
                av_free(pktl);
586
                return 0;
587
            }
588
        }
589

    
590
        av_init_packet(pkt);
591
        ret= s->iformat->read_packet(s, pkt);
592
        if (ret < 0)
593
            return ret;
594
        st= s->streams[pkt->stream_index];
595

    
596
        switch(st->codec->codec_type){
597
        case CODEC_TYPE_VIDEO:
598
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
599
            break;
600
        case CODEC_TYPE_AUDIO:
601
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
602
            break;
603
        case CODEC_TYPE_SUBTITLE:
604
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
605
            break;
606
        }
607

    
608
        if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
609
            return ret;
610

    
611
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
612

    
613
        if(st->codec->codec_id == CODEC_ID_PROBE){
614
            AVProbeData *pd = &st->probe_data;
615

    
616
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
617
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
618
            pd->buf_size += pkt->size;
619
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
620

    
621
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
622
                set_codec_from_probe_data(st, pd, 1);
623
                if(st->codec->codec_id != CODEC_ID_PROBE){
624
                    pd->buf_size=0;
625
                    av_freep(&pd->buf);
626
                }
627
            }
628
        }
629
    }
630
}
631

    
632
/**********************************************************/
633

    
634
/**
635
 * Get the number of samples of an audio frame. Return -1 on error.
636
 */
637
static int get_audio_frame_size(AVCodecContext *enc, int size)
638
{
639
    int frame_size;
640

    
641
    if(enc->codec_id == CODEC_ID_VORBIS)
642
        return -1;
643

    
644
    if (enc->frame_size <= 1) {
645
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
646

    
647
        if (bits_per_sample) {
648
            if (enc->channels == 0)
649
                return -1;
650
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
651
        } else {
652
            /* used for example by ADPCM codecs */
653
            if (enc->bit_rate == 0)
654
                return -1;
655
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
656
        }
657
    } else {
658
        frame_size = enc->frame_size;
659
    }
660
    return frame_size;
661
}
662

    
663

    
664
/**
665
 * Return the frame duration in seconds. Return 0 if not available.
666
 */
667
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
668
                                   AVCodecParserContext *pc, AVPacket *pkt)
669
{
670
    int frame_size;
671

    
672
    *pnum = 0;
673
    *pden = 0;
674
    switch(st->codec->codec_type) {
675
    case CODEC_TYPE_VIDEO:
676
        if(st->time_base.num*1000LL > st->time_base.den){
677
            *pnum = st->time_base.num;
678
            *pden = st->time_base.den;
679
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
680
            *pnum = st->codec->time_base.num;
681
            *pden = st->codec->time_base.den;
682
            if (pc && pc->repeat_pict) {
683
                *pnum = (*pnum) * (1 + pc->repeat_pict);
684
            }
685
        }
686
        break;
687
    case CODEC_TYPE_AUDIO:
688
        frame_size = get_audio_frame_size(st->codec, pkt->size);
689
        if (frame_size < 0)
690
            break;
691
        *pnum = frame_size;
692
        *pden = st->codec->sample_rate;
693
        break;
694
    default:
695
        break;
696
    }
697
}
698

    
699
static int is_intra_only(AVCodecContext *enc){
700
    if(enc->codec_type == CODEC_TYPE_AUDIO){
701
        return 1;
702
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
703
        switch(enc->codec_id){
704
        case CODEC_ID_MJPEG:
705
        case CODEC_ID_MJPEGB:
706
        case CODEC_ID_LJPEG:
707
        case CODEC_ID_RAWVIDEO:
708
        case CODEC_ID_DVVIDEO:
709
        case CODEC_ID_HUFFYUV:
710
        case CODEC_ID_FFVHUFF:
711
        case CODEC_ID_ASV1:
712
        case CODEC_ID_ASV2:
713
        case CODEC_ID_VCR1:
714
        case CODEC_ID_DNXHD:
715
        case CODEC_ID_JPEG2000:
716
            return 1;
717
        default: break;
718
        }
719
    }
720
    return 0;
721
}
722

    
723
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
724
                                      int64_t dts, int64_t pts)
725
{
726
    AVStream *st= s->streams[stream_index];
727
    AVPacketList *pktl= s->packet_buffer;
728

    
729
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
730
        return;
731

    
732
    st->first_dts= dts - st->cur_dts;
733
    st->cur_dts= dts;
734

    
735
    for(; pktl; pktl= pktl->next){
736
        if(pktl->pkt.stream_index != stream_index)
737
            continue;
738
        //FIXME think more about this check
739
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
740
            pktl->pkt.pts += st->first_dts;
741

    
742
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
743
            pktl->pkt.dts += st->first_dts;
744

    
745
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
746
            st->start_time= pktl->pkt.pts;
747
    }
748
    if (st->start_time == AV_NOPTS_VALUE)
749
        st->start_time = pts;
750
}
751

    
752
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
753
{
754
    AVPacketList *pktl= s->packet_buffer;
755
    int64_t cur_dts= 0;
756

    
757
    if(st->first_dts != AV_NOPTS_VALUE){
758
        cur_dts= st->first_dts;
759
        for(; pktl; pktl= pktl->next){
760
            if(pktl->pkt.stream_index == pkt->stream_index){
761
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
762
                    break;
763
                cur_dts -= pkt->duration;
764
            }
765
        }
766
        pktl= s->packet_buffer;
767
        st->first_dts = cur_dts;
768
    }else if(st->cur_dts)
769
        return;
770

    
771
    for(; pktl; pktl= pktl->next){
772
        if(pktl->pkt.stream_index != pkt->stream_index)
773
            continue;
774
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
775
           && !pktl->pkt.duration){
776
            pktl->pkt.dts= cur_dts;
777
            if(!st->codec->has_b_frames)
778
                pktl->pkt.pts= cur_dts;
779
            cur_dts += pkt->duration;
780
            pktl->pkt.duration= pkt->duration;
781
        }else
782
            break;
783
    }
784
    if(st->first_dts == AV_NOPTS_VALUE)
785
        st->cur_dts= cur_dts;
786
}
787

    
788
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
789
                               AVCodecParserContext *pc, AVPacket *pkt)
790
{
791
    int num, den, presentation_delayed, delay, i;
792
    int64_t offset;
793

    
794
    /* do we have a video B-frame ? */
795
    delay= st->codec->has_b_frames;
796
    presentation_delayed = 0;
797
    /* XXX: need has_b_frame, but cannot get it if the codec is
798
        not initialized */
799
    if (delay &&
800
        pc && pc->pict_type != FF_B_TYPE)
801
        presentation_delayed = 1;
802

    
803
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
804
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
805
        pkt->dts -= 1LL<<st->pts_wrap_bits;
806
    }
807

    
808
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
809
    // we take the conservative approach and discard both
810
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
811
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
812
        av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
813
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
814
    }
815

    
816
    if (pkt->duration == 0) {
817
        compute_frame_duration(&num, &den, st, pc, pkt);
818
        if (den && num) {
819
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
820

    
821
            if(pkt->duration != 0 && s->packet_buffer)
822
                update_initial_durations(s, st, pkt);
823
        }
824
    }
825

    
826
    /* correct timestamps with byte offset if demuxers only have timestamps
827
       on packet boundaries */
828
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
829
        /* this will estimate bitrate based on this frame's duration and size */
830
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
831
        if(pkt->pts != AV_NOPTS_VALUE)
832
            pkt->pts += offset;
833
        if(pkt->dts != AV_NOPTS_VALUE)
834
            pkt->dts += offset;
835
    }
836

    
837
    if (pc && pc->dts_sync_point >= 0) {
838
        // we have synchronization info from the parser
839
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
840
        if (den > 0) {
841
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
842
            if (pkt->dts != AV_NOPTS_VALUE) {
843
                // got DTS from the stream, update reference timestamp
844
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
845
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
846
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
847
                // compute DTS based on reference timestamp
848
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
849
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
850
            }
851
            if (pc->dts_sync_point > 0)
852
                st->reference_dts = pkt->dts; // new reference
853
        }
854
    }
855

    
856
    /* This may be redundant, but it should not hurt. */
857
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
858
        presentation_delayed = 1;
859

    
860
//    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);
861
    /* interpolate PTS and DTS if they are not present */
862
    //We skip H264 currently because delay and has_b_frames are not reliably set
863
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
864
        if (presentation_delayed) {
865
            /* DTS = decompression timestamp */
866
            /* PTS = presentation timestamp */
867
            if (pkt->dts == AV_NOPTS_VALUE)
868
                pkt->dts = st->last_IP_pts;
869
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
870
            if (pkt->dts == AV_NOPTS_VALUE)
871
                pkt->dts = st->cur_dts;
872

    
873
            /* this is tricky: the dts must be incremented by the duration
874
            of the frame we are displaying, i.e. the last I- or P-frame */
875
            if (st->last_IP_duration == 0)
876
                st->last_IP_duration = pkt->duration;
877
            if(pkt->dts != AV_NOPTS_VALUE)
878
                st->cur_dts = pkt->dts + st->last_IP_duration;
879
            st->last_IP_duration  = pkt->duration;
880
            st->last_IP_pts= pkt->pts;
881
            /* cannot compute PTS if not present (we can compute it only
882
            by knowing the future */
883
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
884
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
885
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
886
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
887
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
888
                    pkt->pts += pkt->duration;
889
    //                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);
890
                }
891
            }
892

    
893
            /* presentation is not delayed : PTS and DTS are the same */
894
            if(pkt->pts == AV_NOPTS_VALUE)
895
                pkt->pts = pkt->dts;
896
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
897
            if(pkt->pts == AV_NOPTS_VALUE)
898
                pkt->pts = st->cur_dts;
899
            pkt->dts = pkt->pts;
900
            if(pkt->pts != AV_NOPTS_VALUE)
901
                st->cur_dts = pkt->pts + pkt->duration;
902
        }
903
    }
904

    
905
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
906
        st->pts_buffer[0]= pkt->pts;
907
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
908
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
909
        if(pkt->dts == AV_NOPTS_VALUE)
910
            pkt->dts= st->pts_buffer[0];
911
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
912
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
913
        }
914
        if(pkt->dts > st->cur_dts)
915
            st->cur_dts = pkt->dts;
916
    }
917

    
918
//    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);
919

    
920
    /* update flags */
921
    if(is_intra_only(st->codec))
922
        pkt->flags |= PKT_FLAG_KEY;
923
    else if (pc) {
924
        pkt->flags = 0;
925
        /* keyframe computation */
926
        if (pc->key_frame == 1)
927
            pkt->flags |= PKT_FLAG_KEY;
928
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
929
            pkt->flags |= PKT_FLAG_KEY;
930
    }
931
    if (pc)
932
        pkt->convergence_duration = pc->convergence_duration;
933
}
934

    
935
void av_destruct_packet_nofree(AVPacket *pkt)
936
{
937
    pkt->data = NULL; pkt->size = 0;
938
}
939

    
940
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
941
{
942
    AVStream *st;
943
    int len, ret, i;
944

    
945
    av_init_packet(pkt);
946

    
947
    for(;;) {
948
        /* select current input stream component */
949
        st = s->cur_st;
950
        if (st) {
951
            if (!st->need_parsing || !st->parser) {
952
                /* no parsing needed: we just output the packet as is */
953
                /* raw data support */
954
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
955
                compute_pkt_fields(s, st, NULL, pkt);
956
                s->cur_st = NULL;
957
                break;
958
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
959
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
960
                                       st->cur_ptr, st->cur_len,
961
                                       st->cur_pkt.pts, st->cur_pkt.dts,
962
                                       st->cur_pkt.pos);
963
                st->cur_pkt.pts = AV_NOPTS_VALUE;
964
                st->cur_pkt.dts = AV_NOPTS_VALUE;
965
                /* increment read pointer */
966
                st->cur_ptr += len;
967
                st->cur_len -= len;
968

    
969
                /* return packet if any */
970
                if (pkt->size) {
971
                got_packet:
972
                    pkt->duration = 0;
973
                    pkt->stream_index = st->index;
974
                    pkt->pts = st->parser->pts;
975
                    pkt->dts = st->parser->dts;
976
                    pkt->pos = st->parser->pos;
977
                    pkt->destruct = av_destruct_packet_nofree;
978
                    compute_pkt_fields(s, st, st->parser, pkt);
979

    
980
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
981
                        ff_reduce_index(s, st->index);
982
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
983
                                           0, 0, AVINDEX_KEYFRAME);
984
                    }
985

    
986
                    break;
987
                }
988
            } else {
989
                /* free packet */
990
                av_free_packet(&st->cur_pkt);
991
                s->cur_st = NULL;
992
            }
993
        } else {
994
            AVPacket cur_pkt;
995
            /* read next packet */
996
            ret = av_read_packet(s, &cur_pkt);
997
            if (ret < 0) {
998
                if (ret == AVERROR(EAGAIN))
999
                    return ret;
1000
                /* return the last frames, if any */
1001
                for(i = 0; i < s->nb_streams; i++) {
1002
                    st = s->streams[i];
1003
                    if (st->parser && st->need_parsing) {
1004
                        av_parser_parse2(st->parser, st->codec,
1005
                                        &pkt->data, &pkt->size,
1006
                                        NULL, 0,
1007
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1008
                                        AV_NOPTS_VALUE);
1009
                        if (pkt->size)
1010
                            goto got_packet;
1011
                    }
1012
                }
1013
                /* no more packets: really terminate parsing */
1014
                return ret;
1015
            }
1016
            st = s->streams[cur_pkt.stream_index];
1017
            st->cur_pkt= cur_pkt;
1018

    
1019
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1020
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1021
               st->cur_pkt.pts < st->cur_pkt.dts){
1022
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1023
                    st->cur_pkt.stream_index,
1024
                    st->cur_pkt.pts,
1025
                    st->cur_pkt.dts,
1026
                    st->cur_pkt.size);
1027
//                av_free_packet(&st->cur_pkt);
1028
//                return -1;
1029
            }
1030

    
1031
            if(s->debug & FF_FDEBUG_TS)
1032
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
1033
                    st->cur_pkt.stream_index,
1034
                    st->cur_pkt.pts,
1035
                    st->cur_pkt.dts,
1036
                    st->cur_pkt.size,
1037
                    st->cur_pkt.flags);
1038

    
1039
            s->cur_st = st;
1040
            st->cur_ptr = st->cur_pkt.data;
1041
            st->cur_len = st->cur_pkt.size;
1042
            if (st->need_parsing && !st->parser) {
1043
                st->parser = av_parser_init(st->codec->codec_id);
1044
                if (!st->parser) {
1045
                    /* no parser available: just output the raw packets */
1046
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1047
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1048
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1049
                }
1050
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1051
                    st->parser->next_frame_offset=
1052
                    st->parser->cur_offset= st->cur_pkt.pos;
1053
                }
1054
            }
1055
        }
1056
    }
1057
    if(s->debug & FF_FDEBUG_TS)
1058
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1059
            pkt->stream_index,
1060
            pkt->pts,
1061
            pkt->dts,
1062
            pkt->size,
1063
            pkt->flags);
1064

    
1065
    return 0;
1066
}
1067

    
1068
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1069
{
1070
    AVPacketList *pktl;
1071
    int eof=0;
1072
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1073

    
1074
    for(;;){
1075
        pktl = s->packet_buffer;
1076
        if (pktl) {
1077
            AVPacket *next_pkt= &pktl->pkt;
1078

    
1079
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1080
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1081
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1082
                       && next_pkt->dts < pktl->pkt.dts
1083
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1084
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1085
                        next_pkt->pts= pktl->pkt.dts;
1086
                    }
1087
                    pktl= pktl->next;
1088
                }
1089
                pktl = s->packet_buffer;
1090
            }
1091

    
1092
            if(   next_pkt->pts != AV_NOPTS_VALUE
1093
               || next_pkt->dts == AV_NOPTS_VALUE
1094
               || !genpts || eof){
1095
                /* read packet from packet buffer, if there is data */
1096
                *pkt = *next_pkt;
1097
                s->packet_buffer = pktl->next;
1098
                av_free(pktl);
1099
                return 0;
1100
            }
1101
        }
1102
        if(genpts){
1103
            int ret= av_read_frame_internal(s, pkt);
1104
            if(ret<0){
1105
                if(pktl && ret != AVERROR(EAGAIN)){
1106
                    eof=1;
1107
                    continue;
1108
                }else
1109
                    return ret;
1110
            }
1111

    
1112
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1113
                                           &s->packet_buffer_end)) < 0)
1114
                return AVERROR(ENOMEM);
1115
        }else{
1116
            assert(!s->packet_buffer);
1117
            return av_read_frame_internal(s, pkt);
1118
        }
1119
    }
1120
}
1121

    
1122
/* XXX: suppress the packet queue */
1123
static void flush_packet_queue(AVFormatContext *s)
1124
{
1125
    AVPacketList *pktl;
1126

    
1127
    for(;;) {
1128
        pktl = s->packet_buffer;
1129
        if (!pktl)
1130
            break;
1131
        s->packet_buffer = pktl->next;
1132
        av_free_packet(&pktl->pkt);
1133
        av_free(pktl);
1134
    }
1135
}
1136

    
1137
/*******************************************************/
1138
/* seek support */
1139

    
1140
int av_find_default_stream_index(AVFormatContext *s)
1141
{
1142
    int first_audio_index = -1;
1143
    int i;
1144
    AVStream *st;
1145

    
1146
    if (s->nb_streams <= 0)
1147
        return -1;
1148
    for(i = 0; i < s->nb_streams; i++) {
1149
        st = s->streams[i];
1150
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1151
            return i;
1152
        }
1153
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1154
            first_audio_index = i;
1155
    }
1156
    return first_audio_index >= 0 ? first_audio_index : 0;
1157
}
1158

    
1159
/**
1160
 * Flush the frame reader.
1161
 */
1162
static void av_read_frame_flush(AVFormatContext *s)
1163
{
1164
    AVStream *st;
1165
    int i;
1166

    
1167
    flush_packet_queue(s);
1168

    
1169
    s->cur_st = NULL;
1170

    
1171
    /* for each stream, reset read state */
1172
    for(i = 0; i < s->nb_streams; i++) {
1173
        st = s->streams[i];
1174

    
1175
        if (st->parser) {
1176
            av_parser_close(st->parser);
1177
            st->parser = NULL;
1178
            av_free_packet(&st->cur_pkt);
1179
        }
1180
        st->last_IP_pts = AV_NOPTS_VALUE;
1181
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1182
        st->reference_dts = AV_NOPTS_VALUE;
1183
        /* fail safe */
1184
        st->cur_ptr = NULL;
1185
        st->cur_len = 0;
1186
    }
1187
}
1188

    
1189
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1190
    int i;
1191

    
1192
    for(i = 0; i < s->nb_streams; i++) {
1193
        AVStream *st = s->streams[i];
1194

    
1195
        st->cur_dts = av_rescale(timestamp,
1196
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1197
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1198
    }
1199
}
1200

    
1201
void ff_reduce_index(AVFormatContext *s, int stream_index)
1202
{
1203
    AVStream *st= s->streams[stream_index];
1204
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1205

    
1206
    if((unsigned)st->nb_index_entries >= max_entries){
1207
        int i;
1208
        for(i=0; 2*i<st->nb_index_entries; i++)
1209
            st->index_entries[i]= st->index_entries[2*i];
1210
        st->nb_index_entries= i;
1211
    }
1212
}
1213

    
1214
int av_add_index_entry(AVStream *st,
1215
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1216
{
1217
    AVIndexEntry *entries, *ie;
1218
    int index;
1219

    
1220
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1221
        return -1;
1222

    
1223
    entries = av_fast_realloc(st->index_entries,
1224
                              &st->index_entries_allocated_size,
1225
                              (st->nb_index_entries + 1) *
1226
                              sizeof(AVIndexEntry));
1227
    if(!entries)
1228
        return -1;
1229

    
1230
    st->index_entries= entries;
1231

    
1232
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1233

    
1234
    if(index<0){
1235
        index= st->nb_index_entries++;
1236
        ie= &entries[index];
1237
        assert(index==0 || ie[-1].timestamp < timestamp);
1238
    }else{
1239
        ie= &entries[index];
1240
        if(ie->timestamp != timestamp){
1241
            if(ie->timestamp <= timestamp)
1242
                return -1;
1243
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1244
            st->nb_index_entries++;
1245
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1246
            distance= ie->min_distance;
1247
    }
1248

    
1249
    ie->pos = pos;
1250
    ie->timestamp = timestamp;
1251
    ie->min_distance= distance;
1252
    ie->size= size;
1253
    ie->flags = flags;
1254

    
1255
    return index;
1256
}
1257

    
1258
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1259
                              int flags)
1260
{
1261
    AVIndexEntry *entries= st->index_entries;
1262
    int nb_entries= st->nb_index_entries;
1263
    int a, b, m;
1264
    int64_t timestamp;
1265

    
1266
    a = - 1;
1267
    b = nb_entries;
1268

    
1269
    while (b - a > 1) {
1270
        m = (a + b) >> 1;
1271
        timestamp = entries[m].timestamp;
1272
        if(timestamp >= wanted_timestamp)
1273
            b = m;
1274
        if(timestamp <= wanted_timestamp)
1275
            a = m;
1276
    }
1277
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1278

    
1279
    if(!(flags & AVSEEK_FLAG_ANY)){
1280
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1281
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1282
        }
1283
    }
1284

    
1285
    if(m == nb_entries)
1286
        return -1;
1287
    return  m;
1288
}
1289

    
1290
#define DEBUG_SEEK
1291

    
1292
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1293
    AVInputFormat *avif= s->iformat;
1294
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1295
    int64_t ts_min, ts_max, ts;
1296
    int index;
1297
    AVStream *st;
1298

    
1299
    if (stream_index < 0)
1300
        return -1;
1301

    
1302
#ifdef DEBUG_SEEK
1303
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1304
#endif
1305

    
1306
    ts_max=
1307
    ts_min= AV_NOPTS_VALUE;
1308
    pos_limit= -1; //gcc falsely says it may be uninitialized
1309

    
1310
    st= s->streams[stream_index];
1311
    if(st->index_entries){
1312
        AVIndexEntry *e;
1313

    
1314
        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()
1315
        index= FFMAX(index, 0);
1316
        e= &st->index_entries[index];
1317

    
1318
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1319
            pos_min= e->pos;
1320
            ts_min= e->timestamp;
1321
#ifdef DEBUG_SEEK
1322
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1323
                   pos_min,ts_min);
1324
#endif
1325
        }else{
1326
            assert(index==0);
1327
        }
1328

    
1329
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1330
        assert(index < st->nb_index_entries);
1331
        if(index >= 0){
1332
            e= &st->index_entries[index];
1333
            assert(e->timestamp >= target_ts);
1334
            pos_max= e->pos;
1335
            ts_max= e->timestamp;
1336
            pos_limit= pos_max - e->min_distance;
1337
#ifdef DEBUG_SEEK
1338
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1339
                   pos_max,pos_limit, ts_max);
1340
#endif
1341
        }
1342
    }
1343

    
1344
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1345
    if(pos<0)
1346
        return -1;
1347

    
1348
    /* do the seek */
1349
    url_fseek(s->pb, pos, SEEK_SET);
1350

    
1351
    av_update_cur_dts(s, st, ts);
1352

    
1353
    return 0;
1354
}
1355

    
1356
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 )){
1357
    int64_t pos, ts;
1358
    int64_t start_pos, filesize;
1359
    int no_change;
1360

    
1361
#ifdef DEBUG_SEEK
1362
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1363
#endif
1364

    
1365
    if(ts_min == AV_NOPTS_VALUE){
1366
        pos_min = s->data_offset;
1367
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1368
        if (ts_min == AV_NOPTS_VALUE)
1369
            return -1;
1370
    }
1371

    
1372
    if(ts_max == AV_NOPTS_VALUE){
1373
        int step= 1024;
1374
        filesize = url_fsize(s->pb);
1375
        pos_max = filesize - 1;
1376
        do{
1377
            pos_max -= step;
1378
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1379
            step += step;
1380
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1381
        if (ts_max == AV_NOPTS_VALUE)
1382
            return -1;
1383

    
1384
        for(;;){
1385
            int64_t tmp_pos= pos_max + 1;
1386
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1387
            if(tmp_ts == AV_NOPTS_VALUE)
1388
                break;
1389
            ts_max= tmp_ts;
1390
            pos_max= tmp_pos;
1391
            if(tmp_pos >= filesize)
1392
                break;
1393
        }
1394
        pos_limit= pos_max;
1395
    }
1396

    
1397
    if(ts_min > ts_max){
1398
        return -1;
1399
    }else if(ts_min == ts_max){
1400
        pos_limit= pos_min;
1401
    }
1402

    
1403
    no_change=0;
1404
    while (pos_min < pos_limit) {
1405
#ifdef DEBUG_SEEK
1406
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1407
               pos_min, pos_max,
1408
               ts_min, ts_max);
1409
#endif
1410
        assert(pos_limit <= pos_max);
1411

    
1412
        if(no_change==0){
1413
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1414
            // interpolate position (better than dichotomy)
1415
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1416
                + pos_min - approximate_keyframe_distance;
1417
        }else if(no_change==1){
1418
            // bisection, if interpolation failed to change min or max pos last time
1419
            pos = (pos_min + pos_limit)>>1;
1420
        }else{
1421
            /* linear search if bisection failed, can only happen if there
1422
               are very few or no keyframes between min/max */
1423
            pos=pos_min;
1424
        }
1425
        if(pos <= pos_min)
1426
            pos= pos_min + 1;
1427
        else if(pos > pos_limit)
1428
            pos= pos_limit;
1429
        start_pos= pos;
1430

    
1431
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1432
        if(pos == pos_max)
1433
            no_change++;
1434
        else
1435
            no_change=0;
1436
#ifdef DEBUG_SEEK
1437
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1438
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1439
               start_pos, no_change);
1440
#endif
1441
        if(ts == AV_NOPTS_VALUE){
1442
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1443
            return -1;
1444
        }
1445
        assert(ts != AV_NOPTS_VALUE);
1446
        if (target_ts <= ts) {
1447
            pos_limit = start_pos - 1;
1448
            pos_max = pos;
1449
            ts_max = ts;
1450
        }
1451
        if (target_ts >= ts) {
1452
            pos_min = pos;
1453
            ts_min = ts;
1454
        }
1455
    }
1456

    
1457
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1458
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1459
#ifdef DEBUG_SEEK
1460
    pos_min = pos;
1461
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1462
    pos_min++;
1463
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1464
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1465
           pos, ts_min, target_ts, ts_max);
1466
#endif
1467
    *ts_ret= ts;
1468
    return pos;
1469
}
1470

    
1471
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1472
    int64_t pos_min, pos_max;
1473
#if 0
1474
    AVStream *st;
1475

1476
    if (stream_index < 0)
1477
        return -1;
1478

1479
    st= s->streams[stream_index];
1480
#endif
1481

    
1482
    pos_min = s->data_offset;
1483
    pos_max = url_fsize(s->pb) - 1;
1484

    
1485
    if     (pos < pos_min) pos= pos_min;
1486
    else if(pos > pos_max) pos= pos_max;
1487

    
1488
    url_fseek(s->pb, pos, SEEK_SET);
1489

    
1490
#if 0
1491
    av_update_cur_dts(s, st, ts);
1492
#endif
1493
    return 0;
1494
}
1495

    
1496
static int av_seek_frame_generic(AVFormatContext *s,
1497
                                 int stream_index, int64_t timestamp, int flags)
1498
{
1499
    int index, ret;
1500
    AVStream *st;
1501
    AVIndexEntry *ie;
1502

    
1503
    st = s->streams[stream_index];
1504

    
1505
    index = av_index_search_timestamp(st, timestamp, flags);
1506

    
1507
    if(index < 0 || index==st->nb_index_entries-1){
1508
        int i;
1509
        AVPacket pkt;
1510

    
1511
        if(st->nb_index_entries){
1512
            assert(st->index_entries);
1513
            ie= &st->index_entries[st->nb_index_entries-1];
1514
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1515
                return ret;
1516
            av_update_cur_dts(s, st, ie->timestamp);
1517
        }else{
1518
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1519
                return ret;
1520
        }
1521
        for(i=0;; i++) {
1522
            int ret;
1523
            do{
1524
                ret = av_read_frame(s, &pkt);
1525
            }while(ret == AVERROR(EAGAIN));
1526
            if(ret<0)
1527
                break;
1528
            av_free_packet(&pkt);
1529
            if(stream_index == pkt.stream_index){
1530
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1531
                    break;
1532
            }
1533
        }
1534
        index = av_index_search_timestamp(st, timestamp, flags);
1535
    }
1536
    if (index < 0)
1537
        return -1;
1538

    
1539
    av_read_frame_flush(s);
1540
    if (s->iformat->read_seek){
1541
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1542
            return 0;
1543
    }
1544
    ie = &st->index_entries[index];
1545
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1546
        return ret;
1547
    av_update_cur_dts(s, st, ie->timestamp);
1548

    
1549
    return 0;
1550
}
1551

    
1552
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1553
{
1554
    int ret;
1555
    AVStream *st;
1556

    
1557
    av_read_frame_flush(s);
1558

    
1559
    if(flags & AVSEEK_FLAG_BYTE)
1560
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1561

    
1562
    if(stream_index < 0){
1563
        stream_index= av_find_default_stream_index(s);
1564
        if(stream_index < 0)
1565
            return -1;
1566

    
1567
        st= s->streams[stream_index];
1568
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1569
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1570
    }
1571

    
1572
    /* first, we try the format specific seek */
1573
    if (s->iformat->read_seek)
1574
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1575
    else
1576
        ret = -1;
1577
    if (ret >= 0) {
1578
        return 0;
1579
    }
1580

    
1581
    if(s->iformat->read_timestamp)
1582
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1583
    else
1584
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1585
}
1586

    
1587
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1588
{
1589
    if(min_ts > ts || max_ts < ts)
1590
        return -1;
1591

    
1592
    av_read_frame_flush(s);
1593

    
1594
    if (s->iformat->read_seek2)
1595
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1596

    
1597
    if(s->iformat->read_timestamp){
1598
        //try to seek via read_timestamp()
1599
    }
1600

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

    
1606
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1607
}
1608

    
1609
/*******************************************************/
1610

    
1611
/**
1612
 * Returns TRUE if the stream has accurate duration in any stream.
1613
 *
1614
 * @return TRUE if the stream has accurate duration for at least one component.
1615
 */
1616
static int av_has_duration(AVFormatContext *ic)
1617
{
1618
    int i;
1619
    AVStream *st;
1620

    
1621
    for(i = 0;i < ic->nb_streams; i++) {
1622
        st = ic->streams[i];
1623
        if (st->duration != AV_NOPTS_VALUE)
1624
            return 1;
1625
    }
1626
    return 0;
1627
}
1628

    
1629
/**
1630
 * Estimate the stream timings from the one of each components.
1631
 *
1632
 * Also computes the global bitrate if possible.
1633
 */
1634
static void av_update_stream_timings(AVFormatContext *ic)
1635
{
1636
    int64_t start_time, start_time1, end_time, end_time1;
1637
    int64_t duration, duration1;
1638
    int i;
1639
    AVStream *st;
1640

    
1641
    start_time = INT64_MAX;
1642
    end_time = INT64_MIN;
1643
    duration = INT64_MIN;
1644
    for(i = 0;i < ic->nb_streams; i++) {
1645
        st = ic->streams[i];
1646
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1647
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1648
            if (start_time1 < start_time)
1649
                start_time = start_time1;
1650
            if (st->duration != AV_NOPTS_VALUE) {
1651
                end_time1 = start_time1
1652
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1653
                if (end_time1 > end_time)
1654
                    end_time = end_time1;
1655
            }
1656
        }
1657
        if (st->duration != AV_NOPTS_VALUE) {
1658
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1659
            if (duration1 > duration)
1660
                duration = duration1;
1661
        }
1662
    }
1663
    if (start_time != INT64_MAX) {
1664
        ic->start_time = start_time;
1665
        if (end_time != INT64_MIN) {
1666
            if (end_time - start_time > duration)
1667
                duration = end_time - start_time;
1668
        }
1669
    }
1670
    if (duration != INT64_MIN) {
1671
        ic->duration = duration;
1672
        if (ic->file_size > 0) {
1673
            /* compute the bitrate */
1674
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1675
                (double)ic->duration;
1676
        }
1677
    }
1678
}
1679

    
1680
static void fill_all_stream_timings(AVFormatContext *ic)
1681
{
1682
    int i;
1683
    AVStream *st;
1684

    
1685
    av_update_stream_timings(ic);
1686
    for(i = 0;i < ic->nb_streams; i++) {
1687
        st = ic->streams[i];
1688
        if (st->start_time == AV_NOPTS_VALUE) {
1689
            if(ic->start_time != AV_NOPTS_VALUE)
1690
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1691
            if(ic->duration != AV_NOPTS_VALUE)
1692
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1693
        }
1694
    }
1695
}
1696

    
1697
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1698
{
1699
    int64_t filesize, duration;
1700
    int bit_rate, i;
1701
    AVStream *st;
1702

    
1703
    /* if bit_rate is already set, we believe it */
1704
    if (ic->bit_rate == 0) {
1705
        bit_rate = 0;
1706
        for(i=0;i<ic->nb_streams;i++) {
1707
            st = ic->streams[i];
1708
            bit_rate += st->codec->bit_rate;
1709
        }
1710
        ic->bit_rate = bit_rate;
1711
    }
1712

    
1713
    /* if duration is already set, we believe it */
1714
    if (ic->duration == AV_NOPTS_VALUE &&
1715
        ic->bit_rate != 0 &&
1716
        ic->file_size != 0)  {
1717
        filesize = ic->file_size;
1718
        if (filesize > 0) {
1719
            for(i = 0; i < ic->nb_streams; i++) {
1720
                st = ic->streams[i];
1721
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1722
                if (st->duration == AV_NOPTS_VALUE)
1723
                    st->duration = duration;
1724
            }
1725
        }
1726
    }
1727
}
1728

    
1729
#define DURATION_MAX_READ_SIZE 250000
1730

    
1731
/* only usable for MPEG-PS streams */
1732
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1733
{
1734
    AVPacket pkt1, *pkt = &pkt1;
1735
    AVStream *st;
1736
    int read_size, i, ret;
1737
    int64_t end_time;
1738
    int64_t filesize, offset, duration;
1739

    
1740
    ic->cur_st = NULL;
1741

    
1742
    /* flush packet queue */
1743
    flush_packet_queue(ic);
1744

    
1745
    for(i=0;i<ic->nb_streams;i++) {
1746
        st = ic->streams[i];
1747
        if (st->parser) {
1748
            av_parser_close(st->parser);
1749
            st->parser= NULL;
1750
            av_free_packet(&st->cur_pkt);
1751
        }
1752
    }
1753

    
1754
    /* we read the first packets to get the first PTS (not fully
1755
       accurate, but it is enough now) */
1756
    url_fseek(ic->pb, 0, SEEK_SET);
1757
    read_size = 0;
1758
    for(;;) {
1759
        if (read_size >= DURATION_MAX_READ_SIZE)
1760
            break;
1761
        /* if all info is available, we can stop */
1762
        for(i = 0;i < ic->nb_streams; i++) {
1763
            st = ic->streams[i];
1764
            if (st->start_time == AV_NOPTS_VALUE)
1765
                break;
1766
        }
1767
        if (i == ic->nb_streams)
1768
            break;
1769

    
1770
        do{
1771
            ret = av_read_packet(ic, pkt);
1772
        }while(ret == AVERROR(EAGAIN));
1773
        if (ret != 0)
1774
            break;
1775
        read_size += pkt->size;
1776
        st = ic->streams[pkt->stream_index];
1777
        if (pkt->pts != AV_NOPTS_VALUE) {
1778
            if (st->start_time == AV_NOPTS_VALUE)
1779
                st->start_time = pkt->pts;
1780
        }
1781
        av_free_packet(pkt);
1782
    }
1783

    
1784
    /* estimate the end time (duration) */
1785
    /* XXX: may need to support wrapping */
1786
    filesize = ic->file_size;
1787
    offset = filesize - DURATION_MAX_READ_SIZE;
1788
    if (offset < 0)
1789
        offset = 0;
1790

    
1791
    url_fseek(ic->pb, offset, SEEK_SET);
1792
    read_size = 0;
1793
    for(;;) {
1794
        if (read_size >= DURATION_MAX_READ_SIZE)
1795
            break;
1796

    
1797
        do{
1798
            ret = av_read_packet(ic, pkt);
1799
        }while(ret == AVERROR(EAGAIN));
1800
        if (ret != 0)
1801
            break;
1802
        read_size += pkt->size;
1803
        st = ic->streams[pkt->stream_index];
1804
        if (pkt->pts != AV_NOPTS_VALUE &&
1805
            st->start_time != AV_NOPTS_VALUE) {
1806
            end_time = pkt->pts;
1807
            duration = end_time - st->start_time;
1808
            if (duration > 0) {
1809
                if (st->duration == AV_NOPTS_VALUE ||
1810
                    st->duration < duration)
1811
                    st->duration = duration;
1812
            }
1813
        }
1814
        av_free_packet(pkt);
1815
    }
1816

    
1817
    fill_all_stream_timings(ic);
1818

    
1819
    url_fseek(ic->pb, old_offset, SEEK_SET);
1820
    for(i=0; i<ic->nb_streams; i++){
1821
        st= ic->streams[i];
1822
        st->cur_dts= st->first_dts;
1823
        st->last_IP_pts = AV_NOPTS_VALUE;
1824
    }
1825
}
1826

    
1827
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1828
{
1829
    int64_t file_size;
1830

    
1831
    /* get the file size, if possible */
1832
    if (ic->iformat->flags & AVFMT_NOFILE) {
1833
        file_size = 0;
1834
    } else {
1835
        file_size = url_fsize(ic->pb);
1836
        if (file_size < 0)
1837
            file_size = 0;
1838
    }
1839
    ic->file_size = file_size;
1840

    
1841
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1842
         !strcmp(ic->iformat->name, "mpegts")) &&
1843
        file_size && !url_is_streamed(ic->pb)) {
1844
        /* get accurate estimate from the PTSes */
1845
        av_estimate_timings_from_pts(ic, old_offset);
1846
    } else if (av_has_duration(ic)) {
1847
        /* at least one component has timings - we use them for all
1848
           the components */
1849
        fill_all_stream_timings(ic);
1850
    } else {
1851
        /* less precise: use bitrate info */
1852
        av_estimate_timings_from_bit_rate(ic);
1853
    }
1854
    av_update_stream_timings(ic);
1855

    
1856
#if 0
1857
    {
1858
        int i;
1859
        AVStream *st;
1860
        for(i = 0;i < ic->nb_streams; i++) {
1861
            st = ic->streams[i];
1862
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1863
               i, (double)st->start_time / AV_TIME_BASE,
1864
               (double)st->duration / AV_TIME_BASE);
1865
        }
1866
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1867
               (double)ic->start_time / AV_TIME_BASE,
1868
               (double)ic->duration / AV_TIME_BASE,
1869
               ic->bit_rate / 1000);
1870
    }
1871
#endif
1872
}
1873

    
1874
static int has_codec_parameters(AVCodecContext *enc)
1875
{
1876
    int val;
1877
    switch(enc->codec_type) {
1878
    case CODEC_TYPE_AUDIO:
1879
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1880
        if(!enc->frame_size &&
1881
           (enc->codec_id == CODEC_ID_VORBIS ||
1882
            enc->codec_id == CODEC_ID_AAC))
1883
            return 0;
1884
        break;
1885
    case CODEC_TYPE_VIDEO:
1886
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1887
        break;
1888
    default:
1889
        val = 1;
1890
        break;
1891
    }
1892
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1893
}
1894

    
1895
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1896
{
1897
    int16_t *samples;
1898
    AVCodec *codec;
1899
    int got_picture, data_size, ret=0;
1900
    AVFrame picture;
1901

    
1902
  if(!st->codec->codec){
1903
    codec = avcodec_find_decoder(st->codec->codec_id);
1904
    if (!codec)
1905
        return -1;
1906
    ret = avcodec_open(st->codec, codec);
1907
    if (ret < 0)
1908
        return ret;
1909
  }
1910

    
1911
  if(!has_codec_parameters(st->codec)){
1912
    switch(st->codec->codec_type) {
1913
    case CODEC_TYPE_VIDEO:
1914
        ret = avcodec_decode_video(st->codec, &picture,
1915
                                   &got_picture, data, size);
1916
        break;
1917
    case CODEC_TYPE_AUDIO:
1918
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1919
        samples = av_malloc(data_size);
1920
        if (!samples)
1921
            goto fail;
1922
        ret = avcodec_decode_audio2(st->codec, samples,
1923
                                    &data_size, data, size);
1924
        av_free(samples);
1925
        break;
1926
    default:
1927
        break;
1928
    }
1929
  }
1930
 fail:
1931
    return ret;
1932
}
1933

    
1934
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1935
{
1936
    while (tags->id != CODEC_ID_NONE) {
1937
        if (tags->id == id)
1938
            return tags->tag;
1939
        tags++;
1940
    }
1941
    return 0;
1942
}
1943

    
1944
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1945
{
1946
    int i;
1947
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1948
        if(tag == tags[i].tag)
1949
            return tags[i].id;
1950
    }
1951
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1952
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1953
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1954
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1955
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1956
            return tags[i].id;
1957
    }
1958
    return CODEC_ID_NONE;
1959
}
1960

    
1961
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1962
{
1963
    int i;
1964
    for(i=0; tags && tags[i]; i++){
1965
        int tag= codec_get_tag(tags[i], id);
1966
        if(tag) return tag;
1967
    }
1968
    return 0;
1969
}
1970

    
1971
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1972
{
1973
    int i;
1974
    for(i=0; tags && tags[i]; i++){
1975
        enum CodecID id= codec_get_id(tags[i], tag);
1976
        if(id!=CODEC_ID_NONE) return id;
1977
    }
1978
    return CODEC_ID_NONE;
1979
}
1980

    
1981
static void compute_chapters_end(AVFormatContext *s)
1982
{
1983
    unsigned int i;
1984

    
1985
    for (i=0; i+1<s->nb_chapters; i++)
1986
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1987
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1988
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1989
            s->chapters[i]->end = s->chapters[i+1]->start;
1990
        }
1991

    
1992
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1993
        assert(s->start_time != AV_NOPTS_VALUE);
1994
        assert(s->duration > 0);
1995
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1996
                                           AV_TIME_BASE_Q,
1997
                                           s->chapters[i]->time_base);
1998
    }
1999
}
2000

    
2001
/* absolute maximum size we read until we abort */
2002
#define MAX_READ_SIZE        5000000
2003

    
2004
#define MAX_STD_TIMEBASES (60*12+5)
2005
static int get_std_framerate(int i){
2006
    if(i<60*12) return i*1001;
2007
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2008
}
2009

    
2010
/*
2011
 * Is the time base unreliable.
2012
 * This is a heuristic to balance between quick acceptance of the values in
2013
 * the headers vs. some extra checks.
2014
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2015
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2016
 * And there are "variable" fps files this needs to detect as well.
2017
 */
2018
static int tb_unreliable(AVCodecContext *c){
2019
    if(   c->time_base.den >= 101L*c->time_base.num
2020
       || c->time_base.den <    5L*c->time_base.num
2021
/*       || c->codec_tag == AV_RL32("DIVX")
2022
       || c->codec_tag == AV_RL32("XVID")*/
2023
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2024
       || c->codec_id == CODEC_ID_H264
2025
       )
2026
        return 1;
2027
    return 0;
2028
}
2029

    
2030
int av_find_stream_info(AVFormatContext *ic)
2031
{
2032
    int i, count, ret, read_size, j;
2033
    AVStream *st;
2034
    AVPacket pkt1, *pkt;
2035
    int64_t last_dts[MAX_STREAMS];
2036
    int64_t duration_gcd[MAX_STREAMS]={0};
2037
    int duration_count[MAX_STREAMS]={0};
2038
    double (*duration_error)[MAX_STD_TIMEBASES];
2039
    int64_t old_offset = url_ftell(ic->pb);
2040
    int64_t codec_info_duration[MAX_STREAMS]={0};
2041
    int codec_info_nb_frames[MAX_STREAMS]={0};
2042

    
2043
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2044
    if (!duration_error) return AVERROR(ENOMEM);
2045

    
2046
    for(i=0;i<ic->nb_streams;i++) {
2047
        st = ic->streams[i];
2048
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2049
/*            if(!st->time_base.num)
2050
                st->time_base= */
2051
            if(!st->codec->time_base.num)
2052
                st->codec->time_base= st->time_base;
2053
        }
2054
        //only for the split stuff
2055
        if (!st->parser) {
2056
            st->parser = av_parser_init(st->codec->codec_id);
2057
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2058
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2059
            }
2060
        }
2061
    }
2062

    
2063
    for(i=0;i<MAX_STREAMS;i++){
2064
        last_dts[i]= AV_NOPTS_VALUE;
2065
    }
2066

    
2067
    count = 0;
2068
    read_size = 0;
2069
    for(;;) {
2070
        if(url_interrupt_cb()){
2071
            ret= AVERROR(EINTR);
2072
            break;
2073
        }
2074

    
2075
        /* check if one codec still needs to be handled */
2076
        for(i=0;i<ic->nb_streams;i++) {
2077
            st = ic->streams[i];
2078
            if (!has_codec_parameters(st->codec))
2079
                break;
2080
            /* variable fps and no guess at the real fps */
2081
            if(   tb_unreliable(st->codec)
2082
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2083
                break;
2084
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2085
                break;
2086
            if(st->first_dts == AV_NOPTS_VALUE)
2087
                break;
2088
        }
2089
        if (i == ic->nb_streams) {
2090
            /* NOTE: if the format has no header, then we need to read
2091
               some packets to get most of the streams, so we cannot
2092
               stop here */
2093
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2094
                /* if we found the info for all the codecs, we can stop */
2095
                ret = count;
2096
                break;
2097
            }
2098
        }
2099
        /* we did not get all the codec info, but we read too much data */
2100
        if (read_size >= MAX_READ_SIZE) {
2101
            ret = count;
2102
            break;
2103
        }
2104

    
2105
        /* NOTE: a new stream can be added there if no header in file
2106
           (AVFMTCTX_NOHEADER) */
2107
        ret = av_read_frame_internal(ic, &pkt1);
2108
        if(ret == AVERROR(EAGAIN))
2109
            continue;
2110
        if (ret < 0) {
2111
            /* EOF or error */
2112
            ret = -1; /* we could not have all the codec parameters before EOF */
2113
            for(i=0;i<ic->nb_streams;i++) {
2114
                st = ic->streams[i];
2115
                if (!has_codec_parameters(st->codec)){
2116
                    char buf[256];
2117
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2118
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2119
                } else {
2120
                    ret = 0;
2121
                }
2122
            }
2123
            break;
2124
        }
2125

    
2126
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2127
        if(av_dup_packet(pkt) < 0) {
2128
            av_free(duration_error);
2129
            return AVERROR(ENOMEM);
2130
        }
2131

    
2132
        read_size += pkt->size;
2133

    
2134
        st = ic->streams[pkt->stream_index];
2135
        if(codec_info_nb_frames[st->index]>1)
2136
            codec_info_duration[st->index] += pkt->duration;
2137
        if (pkt->duration != 0)
2138
            codec_info_nb_frames[st->index]++;
2139

    
2140
        {
2141
            int index= pkt->stream_index;
2142
            int64_t last= last_dts[index];
2143
            int64_t duration= pkt->dts - last;
2144

    
2145
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2146
                double dur= duration * av_q2d(st->time_base);
2147

    
2148
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2149
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2150
                if(duration_count[index] < 2)
2151
                    memset(duration_error[index], 0, sizeof(*duration_error));
2152
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2153
                    int framerate= get_std_framerate(i);
2154
                    int ticks= lrintf(dur*framerate/(1001*12));
2155
                    double error= dur - ticks*1001*12/(double)framerate;
2156
                    duration_error[index][i] += error*error;
2157
                }
2158
                duration_count[index]++;
2159
                // ignore the first 4 values, they might have some random jitter
2160
                if (duration_count[index] > 3)
2161
                    duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2162
            }
2163
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2164
                last_dts[pkt->stream_index]= pkt->dts;
2165
        }
2166
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2167
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2168
            if(i){
2169
                st->codec->extradata_size= i;
2170
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2171
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2172
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2173
            }
2174
        }
2175

    
2176
        /* if still no information, we try to open the codec and to
2177
           decompress the frame. We try to avoid that in most cases as
2178
           it takes longer and uses more memory. For MPEG-4, we need to
2179
           decompress for QuickTime. */
2180
        if (!has_codec_parameters(st->codec) /*&&
2181
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2182
             st->codec->codec_id == CODEC_ID_H264 ||
2183
             st->codec->codec_id == CODEC_ID_H263 ||
2184
             st->codec->codec_id == CODEC_ID_H261 ||
2185
             st->codec->codec_id == CODEC_ID_VORBIS ||
2186
             st->codec->codec_id == CODEC_ID_MJPEG ||
2187
             st->codec->codec_id == CODEC_ID_PNG ||
2188
             st->codec->codec_id == CODEC_ID_PAM ||
2189
             st->codec->codec_id == CODEC_ID_PGM ||
2190
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2191
             st->codec->codec_id == CODEC_ID_PBM ||
2192
             st->codec->codec_id == CODEC_ID_PPM ||
2193
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2194
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2195
            try_decode_frame(st, pkt->data, pkt->size);
2196

    
2197
        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) {
2198
            break;
2199
        }
2200
        count++;
2201
    }
2202

    
2203
    // close codecs which were opened in try_decode_frame()
2204
    for(i=0;i<ic->nb_streams;i++) {
2205
        st = ic->streams[i];
2206
        if(st->codec->codec)
2207
            avcodec_close(st->codec);
2208
    }
2209
    for(i=0;i<ic->nb_streams;i++) {
2210
        st = ic->streams[i];
2211
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2212
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2213
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2214

    
2215
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2216
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2217
            // ipmovie.c produces.
2218
            if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
2219
                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);
2220
            if(duration_count[i]
2221
               && tb_unreliable(st->codec) /*&&
2222
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2223
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2224
                int num = 0;
2225
                double best_error= 2*av_q2d(st->time_base);
2226
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2227

    
2228
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2229
                    double error= duration_error[i][j] * get_std_framerate(j);
2230
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2231
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2232
                    if(error < best_error){
2233
                        best_error= error;
2234
                        num = get_std_framerate(j);
2235
                    }
2236
                }
2237
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2238
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2239
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2240
            }
2241

    
2242
            if (!st->r_frame_rate.num){
2243
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2244
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2245
                    st->r_frame_rate.num = st->codec->time_base.den;
2246
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2247
                }else{
2248
                    st->r_frame_rate.num = st->time_base.den;
2249
                    st->r_frame_rate.den = st->time_base.num;
2250
                }
2251
            }
2252
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2253
            if(!st->codec->bits_per_coded_sample)
2254
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2255
        }
2256
    }
2257

    
2258
    av_estimate_timings(ic, old_offset);
2259

    
2260
    compute_chapters_end(ic);
2261

    
2262
#if 0
2263
    /* correct DTS for B-frame streams with no timestamps */
2264
    for(i=0;i<ic->nb_streams;i++) {
2265
        st = ic->streams[i];
2266
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2267
            if(b-frames){
2268
                ppktl = &ic->packet_buffer;
2269
                while(ppkt1){
2270
                    if(ppkt1->stream_index != i)
2271
                        continue;
2272
                    if(ppkt1->pkt->dts < 0)
2273
                        break;
2274
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2275
                        break;
2276
                    ppkt1->pkt->dts -= delta;
2277
                    ppkt1= ppkt1->next;
2278
                }
2279
                if(ppkt1)
2280
                    continue;
2281
                st->cur_dts -= delta;
2282
            }
2283
        }
2284
    }
2285
#endif
2286

    
2287
    av_free(duration_error);
2288

    
2289
    return ret;
2290
}
2291

    
2292
/*******************************************************/
2293

    
2294
int av_read_play(AVFormatContext *s)
2295
{
2296
    if (s->iformat->read_play)
2297
        return s->iformat->read_play(s);
2298
    if (s->pb)
2299
        return av_url_read_fpause(s->pb, 0);
2300
    return AVERROR(ENOSYS);
2301
}
2302

    
2303
int av_read_pause(AVFormatContext *s)
2304
{
2305
    if (s->iformat->read_pause)
2306
        return s->iformat->read_pause(s);
2307
    if (s->pb)
2308
        return av_url_read_fpause(s->pb, 1);
2309
    return AVERROR(ENOSYS);
2310
}
2311

    
2312
void av_close_input_stream(AVFormatContext *s)
2313
{
2314
    int i;
2315
    AVStream *st;
2316

    
2317
    if (s->iformat->read_close)
2318
        s->iformat->read_close(s);
2319
    for(i=0;i<s->nb_streams;i++) {
2320
        /* free all data in a stream component */
2321
        st = s->streams[i];
2322
        if (st->parser) {
2323
            av_parser_close(st->parser);
2324
            av_free_packet(&st->cur_pkt);
2325
        }
2326
        av_metadata_free(&st->metadata);
2327
        av_free(st->index_entries);
2328
        av_free(st->codec->extradata);
2329
        av_free(st->codec);
2330
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2331
        av_free(st->filename);
2332
#endif
2333
        av_free(st->priv_data);
2334
        av_free(st);
2335
    }
2336
    for(i=s->nb_programs-1; i>=0; i--) {
2337
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2338
        av_freep(&s->programs[i]->provider_name);
2339
        av_freep(&s->programs[i]->name);
2340
#endif
2341
        av_metadata_free(&s->programs[i]->metadata);
2342
        av_freep(&s->programs[i]->stream_index);
2343
        av_freep(&s->programs[i]);
2344
    }
2345
    av_freep(&s->programs);
2346
    flush_packet_queue(s);
2347
    av_freep(&s->priv_data);
2348
    while(s->nb_chapters--) {
2349
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2350
        av_free(s->chapters[s->nb_chapters]->title);
2351
#endif
2352
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2353
        av_free(s->chapters[s->nb_chapters]);
2354
    }
2355
    av_freep(&s->chapters);
2356
    av_metadata_free(&s->metadata);
2357
    av_free(s);
2358
}
2359

    
2360
void av_close_input_file(AVFormatContext *s)
2361
{
2362
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2363
    av_close_input_stream(s);
2364
    if (pb)
2365
        url_fclose(pb);
2366
}
2367

    
2368
AVStream *av_new_stream(AVFormatContext *s, int id)
2369
{
2370
    AVStream *st;
2371
    int i;
2372

    
2373
    if (s->nb_streams >= MAX_STREAMS)
2374
        return NULL;
2375

    
2376
    st = av_mallocz(sizeof(AVStream));
2377
    if (!st)
2378
        return NULL;
2379

    
2380
    st->codec= avcodec_alloc_context();
2381
    if (s->iformat) {
2382
        /* no default bitrate if decoding */
2383
        st->codec->bit_rate = 0;
2384
    }
2385
    st->index = s->nb_streams;
2386
    st->id = id;
2387
    st->start_time = AV_NOPTS_VALUE;
2388
    st->duration = AV_NOPTS_VALUE;
2389
        /* we set the current DTS to 0 so that formats without any timestamps
2390
           but durations get some timestamps, formats with some unknown
2391
           timestamps have their first few packets buffered and the
2392
           timestamps corrected before they are returned to the user */
2393
    st->cur_dts = 0;
2394
    st->first_dts = AV_NOPTS_VALUE;
2395

    
2396
    /* default pts setting is MPEG-like */
2397
    av_set_pts_info(st, 33, 1, 90000);
2398
    st->last_IP_pts = AV_NOPTS_VALUE;
2399
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2400
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2401
    st->reference_dts = AV_NOPTS_VALUE;
2402

    
2403
    st->sample_aspect_ratio = (AVRational){0,1};
2404

    
2405
    s->streams[s->nb_streams++] = st;
2406
    return st;
2407
}
2408

    
2409
AVProgram *av_new_program(AVFormatContext *ac, int id)
2410
{
2411
    AVProgram *program=NULL;
2412
    int i;
2413

    
2414
#ifdef DEBUG_SI
2415
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2416
#endif
2417

    
2418
    for(i=0; i<ac->nb_programs; i++)
2419
        if(ac->programs[i]->id == id)
2420
            program = ac->programs[i];
2421

    
2422
    if(!program){
2423
        program = av_mallocz(sizeof(AVProgram));
2424
        if (!program)
2425
            return NULL;
2426
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2427
        program->discard = AVDISCARD_NONE;
2428
    }
2429
    program->id = id;
2430

    
2431
    return program;
2432
}
2433

    
2434
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2435
{
2436
    AVChapter *chapter = NULL;
2437
    int i;
2438

    
2439
    for(i=0; i<s->nb_chapters; i++)
2440
        if(s->chapters[i]->id == id)
2441
            chapter = s->chapters[i];
2442

    
2443
    if(!chapter){
2444
        chapter= av_mallocz(sizeof(AVChapter));
2445
        if(!chapter)
2446
            return NULL;
2447
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2448
    }
2449
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2450
    av_free(chapter->title);
2451
#endif
2452
    av_metadata_set(&chapter->metadata, "title", title);
2453
    chapter->id    = id;
2454
    chapter->time_base= time_base;
2455
    chapter->start = start;
2456
    chapter->end   = end;
2457

    
2458
    return chapter;
2459
}
2460

    
2461
/************************************************************/
2462
/* output media file */
2463

    
2464
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2465
{
2466
    int ret;
2467

    
2468
    if (s->oformat->priv_data_size > 0) {
2469
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2470
        if (!s->priv_data)
2471
            return AVERROR(ENOMEM);
2472
    } else
2473
        s->priv_data = NULL;
2474

    
2475
    if (s->oformat->set_parameters) {
2476
        ret = s->oformat->set_parameters(s, ap);
2477
        if (ret < 0)
2478
            return ret;
2479
    }
2480
    return 0;
2481
}
2482

    
2483
int av_write_header(AVFormatContext *s)
2484
{
2485
    int ret, i;
2486
    AVStream *st;
2487

    
2488
    // some sanity checks
2489
    for(i=0;i<s->nb_streams;i++) {
2490
        st = s->streams[i];
2491

    
2492
        switch (st->codec->codec_type) {
2493
        case CODEC_TYPE_AUDIO:
2494
            if(st->codec->sample_rate<=0){
2495
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2496
                return -1;
2497
            }
2498
            if(!st->codec->block_align)
2499
                st->codec->block_align = st->codec->channels *
2500
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2501
            break;
2502
        case CODEC_TYPE_VIDEO:
2503
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2504
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2505
                return -1;
2506
            }
2507
            if(st->codec->width<=0 || st->codec->height<=0){
2508
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2509
                return -1;
2510
            }
2511
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2512
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2513
                return -1;
2514
            }
2515
            break;
2516
        }
2517

    
2518
        if(s->oformat->codec_tag){
2519
            if(st->codec->codec_tag){
2520
                //FIXME
2521
                //check that tag + id is in the table
2522
                //if neither is in the table -> OK
2523
                //if tag is in the table with another id -> FAIL
2524
                //if id is in the table with another tag -> FAIL unless strict < ?
2525
            }else
2526
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2527
        }
2528

    
2529
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2530
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2531
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2532
    }
2533

    
2534
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2535
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2536
        if (!s->priv_data)
2537
            return AVERROR(ENOMEM);
2538
    }
2539

    
2540
#if LIBAVFORMAT_VERSION_MAJOR < 53
2541
    ff_metadata_mux_compat(s);
2542
#endif
2543

    
2544
    if(s->oformat->write_header){
2545
        ret = s->oformat->write_header(s);
2546
        if (ret < 0)
2547
            return ret;
2548
    }
2549

    
2550
    /* init PTS generation */
2551
    for(i=0;i<s->nb_streams;i++) {
2552
        int64_t den = AV_NOPTS_VALUE;
2553
        st = s->streams[i];
2554

    
2555
        switch (st->codec->codec_type) {
2556
        case CODEC_TYPE_AUDIO:
2557
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2558
            break;
2559
        case CODEC_TYPE_VIDEO:
2560
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2561
            break;
2562
        default:
2563
            break;
2564
        }
2565
        if (den != AV_NOPTS_VALUE) {
2566
            if (den <= 0)
2567
                return AVERROR_INVALIDDATA;
2568
            av_frac_init(&st->pts, 0, 0, den);
2569
        }
2570
    }
2571
    return 0;
2572
}
2573

    
2574
//FIXME merge with compute_pkt_fields
2575
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2576
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2577
    int num, den, frame_size, i;
2578

    
2579
//    av_log(st->codec, 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);
2580

    
2581
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2582
        return -1;*/
2583

    
2584
    /* duration field */
2585
    if (pkt->duration == 0) {
2586
        compute_frame_duration(&num, &den, st, NULL, pkt);
2587
        if (den && num) {
2588
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2589
        }
2590
    }
2591

    
2592
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2593
        pkt->pts= pkt->dts;
2594

    
2595
    //XXX/FIXME this is a temporary hack until all encoders output pts
2596
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2597
        pkt->dts=
2598
//        pkt->pts= st->cur_dts;
2599
        pkt->pts= st->pts.val;
2600
    }
2601

    
2602
    //calculate dts from pts
2603
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2604
        st->pts_buffer[0]= pkt->pts;
2605
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2606
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2607
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2608
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2609

    
2610
        pkt->dts= st->pts_buffer[0];
2611
    }
2612

    
2613
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2614
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2615
        return -1;
2616
    }
2617
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2618
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2619
        return -1;
2620
    }
2621

    
2622
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2623
    st->cur_dts= pkt->dts;
2624
    st->pts.val= pkt->dts;
2625

    
2626
    /* update pts */
2627
    switch (st->codec->codec_type) {
2628
    case CODEC_TYPE_AUDIO:
2629
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2630

    
2631
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2632
           likely equal to the encoder delay, but it would be better if we
2633
           had the real timestamps from the encoder */
2634
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2635
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2636
        }
2637
        break;
2638
    case CODEC_TYPE_VIDEO:
2639
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2640
        break;
2641
    default:
2642
        break;
2643
    }
2644
    return 0;
2645
}
2646

    
2647
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2648
{
2649
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2650

    
2651
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2652
        return ret;
2653

    
2654
    ret= s->oformat->write_packet(s, pkt);
2655
    if(!ret)
2656
        ret= url_ferror(s->pb);
2657
    return ret;
2658
}
2659

    
2660
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2661
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2662
{
2663
    AVPacketList **next_point, *this_pktl;
2664

    
2665
    this_pktl = av_mallocz(sizeof(AVPacketList));
2666
    this_pktl->pkt= *pkt;
2667
    if(pkt->destruct == av_destruct_packet)
2668
        pkt->destruct= NULL; // not shared -> must keep original from being freed
2669
    else
2670
        av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2671

    
2672
    next_point = &s->packet_buffer;
2673
    while(*next_point){
2674
        if(compare(s, &(*next_point)->pkt, pkt))
2675
            break;
2676
        next_point= &(*next_point)->next;
2677
    }
2678
    this_pktl->next= *next_point;
2679
    *next_point= this_pktl;
2680
}
2681

    
2682
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2683
{
2684
    AVStream *st = s->streams[ pkt ->stream_index];
2685
    AVStream *st2= s->streams[ next->stream_index];
2686
    int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2687
    int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2688

    
2689
    if (pkt->dts == AV_NOPTS_VALUE)
2690
        return 0;
2691

    
2692
    return next->dts * left > pkt->dts * right; //FIXME this can overflow
2693
}
2694

    
2695
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2696
    AVPacketList *pktl;
2697
    int stream_count=0;
2698
    int streams[MAX_STREAMS];
2699

    
2700
    if(pkt){
2701
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2702
    }
2703

    
2704
    memset(streams, 0, sizeof(streams));
2705
    pktl= s->packet_buffer;
2706
    while(pktl){
2707
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2708
        if(streams[ pktl->pkt.stream_index ] == 0)
2709
            stream_count++;
2710
        streams[ pktl->pkt.stream_index ]++;
2711
        pktl= pktl->next;
2712
    }
2713

    
2714
    if(stream_count && (s->nb_streams == stream_count || flush)){
2715
        pktl= s->packet_buffer;
2716
        *out= pktl->pkt;
2717

    
2718
        s->packet_buffer= pktl->next;
2719
        av_freep(&pktl);
2720
        return 1;
2721
    }else{
2722
        av_init_packet(out);
2723
        return 0;
2724
    }
2725
}
2726

    
2727
/**
2728
 * Interleaves an AVPacket correctly so it can be muxed.
2729
 * @param out the interleaved packet will be output here
2730
 * @param in the input packet
2731
 * @param flush 1 if no further packets are available as input and all
2732
 *              remaining packets should be output
2733
 * @return 1 if a packet was output, 0 if no packet could be output,
2734
 *         < 0 if an error occurred
2735
 */
2736
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2737
    if(s->oformat->interleave_packet)
2738
        return s->oformat->interleave_packet(s, out, in, flush);
2739
    else
2740
        return av_interleave_packet_per_dts(s, out, in, flush);
2741
}
2742

    
2743
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2744
    AVStream *st= s->streams[ pkt->stream_index];
2745

    
2746
    //FIXME/XXX/HACK drop zero sized packets
2747
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2748
        return 0;
2749

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

    
2754
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2755
        return -1;
2756

    
2757
    for(;;){
2758
        AVPacket opkt;
2759
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2760
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2761
            return ret;
2762

    
2763
        ret= s->oformat->write_packet(s, &opkt);
2764

    
2765
        av_free_packet(&opkt);
2766
        pkt= NULL;
2767

    
2768
        if(ret<0)
2769
            return ret;
2770
        if(url_ferror(s->pb))
2771
            return url_ferror(s->pb);
2772
    }
2773
}
2774

    
2775
int av_write_trailer(AVFormatContext *s)
2776
{
2777
    int ret, i;
2778

    
2779
    for(;;){
2780
        AVPacket pkt;
2781
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2782
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2783
            goto fail;
2784
        if(!ret)
2785
            break;
2786

    
2787
        ret= s->oformat->write_packet(s, &pkt);
2788

    
2789
        av_free_packet(&pkt);
2790

    
2791
        if(ret<0)
2792
            goto fail;
2793
        if(url_ferror(s->pb))
2794
            goto fail;
2795
    }
2796

    
2797
    if(s->oformat->write_trailer)
2798
        ret = s->oformat->write_trailer(s);
2799
fail:
2800
    if(ret == 0)
2801
       ret=url_ferror(s->pb);
2802
    for(i=0;i<s->nb_streams;i++)
2803
        av_freep(&s->streams[i]->priv_data);
2804
    av_freep(&s->priv_data);
2805
    return ret;
2806
}
2807

    
2808
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2809
{
2810
    int i, j;
2811
    AVProgram *program=NULL;
2812
    void *tmp;
2813

    
2814
    for(i=0; i<ac->nb_programs; i++){
2815
        if(ac->programs[i]->id != progid)
2816
            continue;
2817
        program = ac->programs[i];
2818
        for(j=0; j<program->nb_stream_indexes; j++)
2819
            if(program->stream_index[j] == idx)
2820
                return;
2821

    
2822
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2823
        if(!tmp)
2824
            return;
2825
        program->stream_index = tmp;
2826
        program->stream_index[program->nb_stream_indexes++] = idx;
2827
        return;
2828
    }
2829
}
2830

    
2831
static void print_fps(double d, const char *postfix){
2832
    uint64_t v= lrintf(d*100);
2833
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2834
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2835
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2836
}
2837

    
2838
/* "user interface" functions */
2839
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2840
{
2841
    char buf[256];
2842
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2843
    AVStream *st = ic->streams[i];
2844
    int g = av_gcd(st->time_base.num, st->time_base.den);
2845
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2846
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2847
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2848
    /* the pid is an important information, so we display it */
2849
    /* XXX: add a generic system */
2850
    if (flags & AVFMT_SHOW_IDS)
2851
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2852
    if (lang)
2853
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2854
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2855
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2856
    if (st->sample_aspect_ratio.num && // default
2857
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2858
        AVRational display_aspect_ratio;
2859
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2860
                  st->codec->width*st->sample_aspect_ratio.num,
2861
                  st->codec->height*st->sample_aspect_ratio.den,
2862
                  1024*1024);
2863
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2864
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2865
                 display_aspect_ratio.num, display_aspect_ratio.den);
2866
    }
2867
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2868
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2869
            print_fps(av_q2d(st->r_frame_rate), "tbr");
2870
        if(st->time_base.den && st->time_base.num)
2871
            print_fps(1/av_q2d(st->time_base), "tbn");
2872
        if(st->codec->time_base.den && st->codec->time_base.num)
2873
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
2874
    }
2875
    av_log(NULL, AV_LOG_INFO, "\n");
2876
}
2877

    
2878
void dump_format(AVFormatContext *ic,
2879
                 int index,
2880
                 const char *url,
2881
                 int is_output)
2882
{
2883
    int i;
2884

    
2885
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2886
            is_output ? "Output" : "Input",
2887
            index,
2888
            is_output ? ic->oformat->name : ic->iformat->name,
2889
            is_output ? "to" : "from", url);
2890
    if (!is_output) {
2891
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2892
        if (ic->duration != AV_NOPTS_VALUE) {
2893
            int hours, mins, secs, us;
2894
            secs = ic->duration / AV_TIME_BASE;
2895
            us = ic->duration % AV_TIME_BASE;
2896
            mins = secs / 60;
2897
            secs %= 60;
2898
            hours = mins / 60;
2899
            mins %= 60;
2900
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2901
                   (100 * us) / AV_TIME_BASE);
2902
        } else {
2903
            av_log(NULL, AV_LOG_INFO, "N/A");
2904
        }
2905
        if (ic->start_time != AV_NOPTS_VALUE) {
2906
            int secs, us;
2907
            av_log(NULL, AV_LOG_INFO, ", start: ");
2908
            secs = ic->start_time / AV_TIME_BASE;
2909
            us = ic->start_time % AV_TIME_BASE;
2910
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2911
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2912
        }
2913
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2914
        if (ic->bit_rate) {
2915
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2916
        } else {
2917
            av_log(NULL, AV_LOG_INFO, "N/A");
2918
        }
2919
        av_log(NULL, AV_LOG_INFO, "\n");
2920
    }
2921
    if(ic->nb_programs) {
2922
        int j, k;
2923
        for(j=0; j<ic->nb_programs; j++) {
2924
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
2925
                                                  "name", NULL, 0);
2926
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2927
                   name ? name->value : "");
2928
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2929
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2930
         }
2931
    } else
2932
    for(i=0;i<ic->nb_streams;i++)
2933
        dump_stream_format(ic, i, index, is_output);
2934
}
2935

    
2936
#if LIBAVFORMAT_VERSION_MAJOR < 53
2937
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2938
{
2939
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2940
}
2941

    
2942
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2943
{
2944
    AVRational frame_rate;
2945
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2946
    *frame_rate_num= frame_rate.num;
2947
    *frame_rate_den= frame_rate.den;
2948
    return ret;
2949
}
2950
#endif
2951

    
2952
int64_t av_gettime(void)
2953
{
2954
    struct timeval tv;
2955
    gettimeofday(&tv,NULL);
2956
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2957
}
2958

    
2959
int64_t parse_date(const char *datestr, int duration)
2960
{
2961
    const char *p;
2962
    int64_t t;
2963
    struct tm dt;
2964
    int i;
2965
    static const char * const date_fmt[] = {
2966
        "%Y-%m-%d",
2967
        "%Y%m%d",
2968
    };
2969
    static const char * const time_fmt[] = {
2970
        "%H:%M:%S",
2971
        "%H%M%S",
2972
    };
2973
    const char *q;
2974
    int is_utc, len;
2975
    char lastch;
2976
    int negative = 0;
2977

    
2978
#undef time
2979
    time_t now = time(0);
2980

    
2981
    len = strlen(datestr);
2982
    if (len > 0)
2983
        lastch = datestr[len - 1];
2984
    else
2985
        lastch = '\0';
2986
    is_utc = (lastch == 'z' || lastch == 'Z');
2987

    
2988
    memset(&dt, 0, sizeof(dt));
2989

    
2990
    p = datestr;
2991
    q = NULL;
2992
    if (!duration) {
2993
        if (!strncasecmp(datestr, "now", len))
2994
            return (int64_t) now * 1000000;
2995

    
2996
        /* parse the year-month-day part */
2997
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2998
            q = small_strptime(p, date_fmt[i], &dt);
2999
            if (q) {
3000
                break;
3001
            }
3002
        }
3003

    
3004
        /* if the year-month-day part is missing, then take the
3005
         * current year-month-day time */
3006
        if (!q) {
3007
            if (is_utc) {
3008
                dt = *gmtime(&now);
3009
            } else {
3010
                dt = *localtime(&now);
3011
            }
3012
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3013
        } else {
3014
            p = q;
3015
        }
3016

    
3017
        if (*p == 'T' || *p == 't' || *p == ' ')
3018
            p++;
3019

    
3020
        /* parse the hour-minute-second part */
3021
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3022
            q = small_strptime(p, time_fmt[i], &dt);
3023
            if (q) {
3024
                break;
3025
            }
3026
        }
3027
    } else {
3028
        /* parse datestr as a duration */
3029
        if (p[0] == '-') {
3030
            negative = 1;
3031
            ++p;
3032
        }
3033
        /* parse datestr as HH:MM:SS */
3034
        q = small_strptime(p, time_fmt[0], &dt);
3035
        if (!q) {
3036
            /* parse datestr as S+ */
3037
            dt.tm_sec = strtol(p, (char **)&q, 10);
3038
            if (q == p)
3039
                /* the parsing didn't succeed */
3040
                return INT64_MIN;
3041
            dt.tm_min = 0;
3042
            dt.tm_hour = 0;
3043
        }
3044
    }
3045

    
3046
    /* Now we have all the fields that we can get */
3047
    if (!q) {
3048
        return INT64_MIN;
3049
    }
3050

    
3051
    if (duration) {
3052
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3053
    } else {
3054
        dt.tm_isdst = -1;       /* unknown */
3055
        if (is_utc) {
3056
            t = mktimegm(&dt);
3057
        } else {
3058
            t = mktime(&dt);
3059
        }
3060
    }
3061

    
3062
    t *= 1000000;
3063

    
3064
    /* parse the .m... part */
3065
    if (*q == '.') {
3066
        int val, n;
3067
        q++;
3068
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3069
            if (!isdigit(*q))
3070
                break;
3071
            val += n * (*q - '0');
3072
        }
3073
        t += val;
3074
    }
3075
    return negative ? -t : t;
3076
}
3077

    
3078
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3079
{
3080
    const char *p;
3081
    char tag[128], *q;
3082

    
3083
    p = info;
3084
    if (*p == '?')
3085
        p++;
3086
    for(;;) {
3087
        q = tag;
3088
        while (*p != '\0' && *p != '=' && *p != '&') {
3089
            if ((q - tag) < sizeof(tag) - 1)
3090
                *q++ = *p;
3091
            p++;
3092
        }
3093
        *q = '\0';
3094
        q = arg;
3095
        if (*p == '=') {
3096
            p++;
3097
            while (*p != '&' && *p != '\0') {
3098
                if ((q - arg) < arg_size - 1) {
3099
                    if (*p == '+')
3100
                        *q++ = ' ';
3101
                    else
3102
                        *q++ = *p;
3103
                }
3104
                p++;
3105
            }
3106
            *q = '\0';
3107
        }
3108
        if (!strcmp(tag, tag1))
3109
            return 1;
3110
        if (*p != '&')
3111
            break;
3112
        p++;
3113
    }
3114
    return 0;
3115
}
3116

    
3117
int av_get_frame_filename(char *buf, int buf_size,
3118
                          const char *path, int number)
3119
{
3120
    const char *p;
3121
    char *q, buf1[20], c;
3122
    int nd, len, percentd_found;
3123

    
3124
    q = buf;
3125
    p = path;
3126
    percentd_found = 0;
3127
    for(;;) {
3128
        c = *p++;
3129
        if (c == '\0')
3130
            break;
3131
        if (c == '%') {
3132
            do {
3133
                nd = 0;
3134
                while (isdigit(*p)) {
3135
                    nd = nd * 10 + *p++ - '0';
3136
                }
3137
                c = *p++;
3138
            } while (isdigit(c));
3139

    
3140
            switch(c) {
3141
            case '%':
3142
                goto addchar;
3143
            case 'd':
3144
                if (percentd_found)
3145
                    goto fail;
3146
                percentd_found = 1;
3147
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3148
                len = strlen(buf1);
3149
                if ((q - buf + len) > buf_size - 1)
3150
                    goto fail;
3151
                memcpy(q, buf1, len);
3152
                q += len;
3153
                break;
3154
            default:
3155
                goto fail;
3156
            }
3157
        } else {
3158
        addchar:
3159
            if ((q - buf) < buf_size - 1)
3160
                *q++ = c;
3161
        }
3162
    }
3163
    if (!percentd_found)
3164
        goto fail;
3165
    *q = '\0';
3166
    return 0;
3167
 fail:
3168
    *q = '\0';
3169
    return -1;
3170
}
3171

    
3172
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3173
{
3174
    int len, i, j, c;
3175
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3176

    
3177
    for(i=0;i<size;i+=16) {
3178
        len = size - i;
3179
        if (len > 16)
3180
            len = 16;
3181
        PRINT("%08x ", i);
3182
        for(j=0;j<16;j++) {
3183
            if (j < len)
3184
                PRINT(" %02x", buf[i+j]);
3185
            else
3186
                PRINT("   ");
3187
        }
3188
        PRINT(" ");
3189
        for(j=0;j<len;j++) {
3190
            c = buf[i+j];
3191
            if (c < ' ' || c > '~')
3192
                c = '.';
3193
            PRINT("%c", c);
3194
        }
3195
        PRINT("\n");
3196
    }
3197
#undef PRINT
3198
}
3199

    
3200
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3201
{
3202
    hex_dump_internal(NULL, f, 0, buf, size);
3203
}
3204

    
3205
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3206
{
3207
    hex_dump_internal(avcl, NULL, level, buf, size);
3208
}
3209

    
3210
 //FIXME needs to know the time_base
3211
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3212
{
3213
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3214
    PRINT("stream #%d:\n", pkt->stream_index);
3215
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3216
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3217
    /* DTS is _always_ valid after av_read_frame() */
3218
    PRINT("  dts=");
3219
    if (pkt->dts == AV_NOPTS_VALUE)
3220
        PRINT("N/A");
3221
    else
3222
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3223
    /* PTS may not be known if B-frames are present. */
3224
    PRINT("  pts=");
3225
    if (pkt->pts == AV_NOPTS_VALUE)
3226
        PRINT("N/A");
3227
    else
3228
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3229
    PRINT("\n");
3230
    PRINT("  size=%d\n", pkt->size);
3231
#undef PRINT
3232
    if (dump_payload)
3233
        av_hex_dump(f, pkt->data, pkt->size);
3234
}
3235

    
3236
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3237
{
3238
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3239
}
3240

    
3241
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3242
{
3243
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3244
}
3245

    
3246
void url_split(char *proto, int proto_size,
3247
               char *authorization, int authorization_size,
3248
               char *hostname, int hostname_size,
3249
               int *port_ptr,
3250
               char *path, int path_size,
3251
               const char *url)
3252
{
3253
    const char *p, *ls, *at, *col, *brk;
3254

    
3255
    if (port_ptr)               *port_ptr = -1;
3256
    if (proto_size > 0)         proto[0] = 0;
3257
    if (authorization_size > 0) authorization[0] = 0;
3258
    if (hostname_size > 0)      hostname[0] = 0;
3259
    if (path_size > 0)          path[0] = 0;
3260

    
3261
    /* parse protocol */
3262
    if ((p = strchr(url, ':'))) {
3263
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3264
        p++; /* skip ':' */
3265
        if (*p == '/') p++;
3266
        if (*p == '/') p++;
3267
    } else {
3268
        /* no protocol means plain filename */
3269
        av_strlcpy(path, url, path_size);
3270
        return;
3271
    }
3272

    
3273
    /* separate path from hostname */
3274
    ls = strchr(p, '/');
3275
    if(!ls)
3276
        ls = strchr(p, '?');
3277
    if(ls)
3278
        av_strlcpy(path, ls, path_size);
3279
    else
3280
        ls = &p[strlen(p)]; // XXX
3281

    
3282
    /* the rest is hostname, use that to parse auth/port */
3283
    if (ls != p) {
3284
        /* authorization (user[:pass]@hostname) */
3285
        if ((at = strchr(p, '@')) && at < ls) {
3286
            av_strlcpy(authorization, p,
3287
                       FFMIN(authorization_size, at + 1 - p));
3288
            p = at + 1; /* skip '@' */
3289
        }
3290

    
3291
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3292
            /* [host]:port */
3293
            av_strlcpy(hostname, p + 1,
3294
                       FFMIN(hostname_size, brk - p));
3295
            if (brk[1] == ':' && port_ptr)
3296
                *port_ptr = atoi(brk + 2);
3297
        } else if ((col = strchr(p, ':')) && col < ls) {
3298
            av_strlcpy(hostname, p,
3299
                       FFMIN(col + 1 - p, hostname_size));
3300
            if (port_ptr) *port_ptr = atoi(col + 1);
3301
        } else
3302
            av_strlcpy(hostname, p,
3303
                       FFMIN(ls + 1 - p, hostname_size));
3304
    }
3305
}
3306

    
3307
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3308
{
3309
    int i;
3310
    static const char hex_table[16] = { '0', '1', '2', '3',
3311
                                        '4', '5', '6', '7',
3312
                                        '8', '9', 'A', 'B',
3313
                                        'C', 'D', 'E', 'F' };
3314

    
3315
    for(i = 0; i < s; i++) {
3316
        buff[i * 2]     = hex_table[src[i] >> 4];
3317
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3318
    }
3319

    
3320
    return buff;
3321
}
3322

    
3323
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3324
                     int pts_num, int pts_den)
3325
{
3326
    unsigned int gcd= av_gcd(pts_num, pts_den);
3327
    s->pts_wrap_bits = pts_wrap_bits;
3328
    s->time_base.num = pts_num/gcd;
3329
    s->time_base.den = pts_den/gcd;
3330

    
3331
    if(gcd>1)
3332
        av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);
3333
}