Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ c0492097

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_parse(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.pts = AV_NOPTS_VALUE;
963
                st->cur_pkt.dts = AV_NOPTS_VALUE;
964
                /* increment read pointer */
965
                st->cur_ptr += len;
966
                st->cur_len -= len;
967

    
968
                /* return packet if any */
969
                if (pkt->size) {
970
                    pkt->pos = st->cur_pkt.pos;              // Isn't quite accurate but close.
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->destruct = av_destruct_packet_nofree;
977
                    compute_pkt_fields(s, st, st->parser, pkt);
978

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

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

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

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

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

    
1063
    return 0;
1064
}
1065

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

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

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

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

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

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

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

    
1135
/*******************************************************/
1136
/* seek support */
1137

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

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

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

    
1165
    flush_packet_queue(s);
1166

    
1167
    s->cur_st = NULL;
1168

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

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

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

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

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

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

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

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

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

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

    
1228
    st->index_entries= entries;
1229

    
1230
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1231

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

    
1247
    ie->pos = pos;
1248
    ie->timestamp = timestamp;
1249
    ie->min_distance= distance;
1250
    ie->size= size;
1251
    ie->flags = flags;
1252

    
1253
    return index;
1254
}
1255

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

    
1264
    a = - 1;
1265
    b = nb_entries;
1266

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

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

    
1283
    if(m == nb_entries)
1284
        return -1;
1285
    return  m;
1286
}
1287

    
1288
#define DEBUG_SEEK
1289

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

    
1297
    if (stream_index < 0)
1298
        return -1;
1299

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

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

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

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

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

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

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

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

    
1349
    av_update_cur_dts(s, st, ts);
1350

    
1351
    return 0;
1352
}
1353

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

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

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

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

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

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

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

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

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

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

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

1474
    if (stream_index < 0)
1475
        return -1;
1476

1477
    st= s->streams[stream_index];
1478
#endif
1479

    
1480
    pos_min = s->data_offset;
1481
    pos_max = url_fsize(s->pb) - 1;
1482

    
1483
    if     (pos < pos_min) pos= pos_min;
1484
    else if(pos > pos_max) pos= pos_max;
1485

    
1486
    url_fseek(s->pb, pos, SEEK_SET);
1487

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

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

    
1501
    st = s->streams[stream_index];
1502

    
1503
    index = av_index_search_timestamp(st, timestamp, flags);
1504

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

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

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

    
1547
    return 0;
1548
}
1549

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

    
1555
    av_read_frame_flush(s);
1556

    
1557
    if(flags & AVSEEK_FLAG_BYTE)
1558
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1559

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

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

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

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

    
1585
/*******************************************************/
1586

    
1587
/**
1588
 * Returns TRUE if the stream has accurate duration in any stream.
1589
 *
1590
 * @return TRUE if the stream has accurate duration for at least one component.
1591
 */
1592
static int av_has_duration(AVFormatContext *ic)
1593
{
1594
    int i;
1595
    AVStream *st;
1596

    
1597
    for(i = 0;i < ic->nb_streams; i++) {
1598
        st = ic->streams[i];
1599
        if (st->duration != AV_NOPTS_VALUE)
1600
            return 1;
1601
    }
1602
    return 0;
1603
}
1604

    
1605
/**
1606
 * Estimate the stream timings from the one of each components.
1607
 *
1608
 * Also computes the global bitrate if possible.
1609
 */
1610
static void av_update_stream_timings(AVFormatContext *ic)
1611
{
1612
    int64_t start_time, start_time1, end_time, end_time1;
1613
    int64_t duration, duration1;
1614
    int i;
1615
    AVStream *st;
1616

    
1617
    start_time = INT64_MAX;
1618
    end_time = INT64_MIN;
1619
    duration = INT64_MIN;
1620
    for(i = 0;i < ic->nb_streams; i++) {
1621
        st = ic->streams[i];
1622
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1623
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1624
            if (start_time1 < start_time)
1625
                start_time = start_time1;
1626
            if (st->duration != AV_NOPTS_VALUE) {
1627
                end_time1 = start_time1
1628
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1629
                if (end_time1 > end_time)
1630
                    end_time = end_time1;
1631
            }
1632
        }
1633
        if (st->duration != AV_NOPTS_VALUE) {
1634
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1635
            if (duration1 > duration)
1636
                duration = duration1;
1637
        }
1638
    }
1639
    if (start_time != INT64_MAX) {
1640
        ic->start_time = start_time;
1641
        if (end_time != INT64_MIN) {
1642
            if (end_time - start_time > duration)
1643
                duration = end_time - start_time;
1644
        }
1645
    }
1646
    if (duration != INT64_MIN) {
1647
        ic->duration = duration;
1648
        if (ic->file_size > 0) {
1649
            /* compute the bitrate */
1650
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1651
                (double)ic->duration;
1652
        }
1653
    }
1654
}
1655

    
1656
static void fill_all_stream_timings(AVFormatContext *ic)
1657
{
1658
    int i;
1659
    AVStream *st;
1660

    
1661
    av_update_stream_timings(ic);
1662
    for(i = 0;i < ic->nb_streams; i++) {
1663
        st = ic->streams[i];
1664
        if (st->start_time == AV_NOPTS_VALUE) {
1665
            if(ic->start_time != AV_NOPTS_VALUE)
1666
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1667
            if(ic->duration != AV_NOPTS_VALUE)
1668
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1669
        }
1670
    }
1671
}
1672

    
1673
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1674
{
1675
    int64_t filesize, duration;
1676
    int bit_rate, i;
1677
    AVStream *st;
1678

    
1679
    /* if bit_rate is already set, we believe it */
1680
    if (ic->bit_rate == 0) {
1681
        bit_rate = 0;
1682
        for(i=0;i<ic->nb_streams;i++) {
1683
            st = ic->streams[i];
1684
            bit_rate += st->codec->bit_rate;
1685
        }
1686
        ic->bit_rate = bit_rate;
1687
    }
1688

    
1689
    /* if duration is already set, we believe it */
1690
    if (ic->duration == AV_NOPTS_VALUE &&
1691
        ic->bit_rate != 0 &&
1692
        ic->file_size != 0)  {
1693
        filesize = ic->file_size;
1694
        if (filesize > 0) {
1695
            for(i = 0; i < ic->nb_streams; i++) {
1696
                st = ic->streams[i];
1697
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1698
                if (st->duration == AV_NOPTS_VALUE)
1699
                    st->duration = duration;
1700
            }
1701
        }
1702
    }
1703
}
1704

    
1705
#define DURATION_MAX_READ_SIZE 250000
1706

    
1707
/* only usable for MPEG-PS streams */
1708
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1709
{
1710
    AVPacket pkt1, *pkt = &pkt1;
1711
    AVStream *st;
1712
    int read_size, i, ret;
1713
    int64_t end_time;
1714
    int64_t filesize, offset, duration;
1715

    
1716
    ic->cur_st = NULL;
1717

    
1718
    /* flush packet queue */
1719
    flush_packet_queue(ic);
1720

    
1721
    for(i=0;i<ic->nb_streams;i++) {
1722
        st = ic->streams[i];
1723
        if (st->parser) {
1724
            av_parser_close(st->parser);
1725
            st->parser= NULL;
1726
            av_free_packet(&st->cur_pkt);
1727
        }
1728
    }
1729

    
1730
    /* we read the first packets to get the first PTS (not fully
1731
       accurate, but it is enough now) */
1732
    url_fseek(ic->pb, 0, SEEK_SET);
1733
    read_size = 0;
1734
    for(;;) {
1735
        if (read_size >= DURATION_MAX_READ_SIZE)
1736
            break;
1737
        /* if all info is available, we can stop */
1738
        for(i = 0;i < ic->nb_streams; i++) {
1739
            st = ic->streams[i];
1740
            if (st->start_time == AV_NOPTS_VALUE)
1741
                break;
1742
        }
1743
        if (i == ic->nb_streams)
1744
            break;
1745

    
1746
        do{
1747
            ret = av_read_packet(ic, pkt);
1748
        }while(ret == AVERROR(EAGAIN));
1749
        if (ret != 0)
1750
            break;
1751
        read_size += pkt->size;
1752
        st = ic->streams[pkt->stream_index];
1753
        if (pkt->pts != AV_NOPTS_VALUE) {
1754
            if (st->start_time == AV_NOPTS_VALUE)
1755
                st->start_time = pkt->pts;
1756
        }
1757
        av_free_packet(pkt);
1758
    }
1759

    
1760
    /* estimate the end time (duration) */
1761
    /* XXX: may need to support wrapping */
1762
    filesize = ic->file_size;
1763
    offset = filesize - DURATION_MAX_READ_SIZE;
1764
    if (offset < 0)
1765
        offset = 0;
1766

    
1767
    url_fseek(ic->pb, offset, SEEK_SET);
1768
    read_size = 0;
1769
    for(;;) {
1770
        if (read_size >= DURATION_MAX_READ_SIZE)
1771
            break;
1772

    
1773
        do{
1774
            ret = av_read_packet(ic, pkt);
1775
        }while(ret == AVERROR(EAGAIN));
1776
        if (ret != 0)
1777
            break;
1778
        read_size += pkt->size;
1779
        st = ic->streams[pkt->stream_index];
1780
        if (pkt->pts != AV_NOPTS_VALUE &&
1781
            st->start_time != AV_NOPTS_VALUE) {
1782
            end_time = pkt->pts;
1783
            duration = end_time - st->start_time;
1784
            if (duration > 0) {
1785
                if (st->duration == AV_NOPTS_VALUE ||
1786
                    st->duration < duration)
1787
                    st->duration = duration;
1788
            }
1789
        }
1790
        av_free_packet(pkt);
1791
    }
1792

    
1793
    fill_all_stream_timings(ic);
1794

    
1795
    url_fseek(ic->pb, old_offset, SEEK_SET);
1796
    for(i=0; i<ic->nb_streams; i++){
1797
        st= ic->streams[i];
1798
        st->cur_dts= st->first_dts;
1799
        st->last_IP_pts = AV_NOPTS_VALUE;
1800
    }
1801
}
1802

    
1803
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1804
{
1805
    int64_t file_size;
1806

    
1807
    /* get the file size, if possible */
1808
    if (ic->iformat->flags & AVFMT_NOFILE) {
1809
        file_size = 0;
1810
    } else {
1811
        file_size = url_fsize(ic->pb);
1812
        if (file_size < 0)
1813
            file_size = 0;
1814
    }
1815
    ic->file_size = file_size;
1816

    
1817
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1818
         !strcmp(ic->iformat->name, "mpegts")) &&
1819
        file_size && !url_is_streamed(ic->pb)) {
1820
        /* get accurate estimate from the PTSes */
1821
        av_estimate_timings_from_pts(ic, old_offset);
1822
    } else if (av_has_duration(ic)) {
1823
        /* at least one component has timings - we use them for all
1824
           the components */
1825
        fill_all_stream_timings(ic);
1826
    } else {
1827
        /* less precise: use bitrate info */
1828
        av_estimate_timings_from_bit_rate(ic);
1829
    }
1830
    av_update_stream_timings(ic);
1831

    
1832
#if 0
1833
    {
1834
        int i;
1835
        AVStream *st;
1836
        for(i = 0;i < ic->nb_streams; i++) {
1837
            st = ic->streams[i];
1838
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1839
               i, (double)st->start_time / AV_TIME_BASE,
1840
               (double)st->duration / AV_TIME_BASE);
1841
        }
1842
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1843
               (double)ic->start_time / AV_TIME_BASE,
1844
               (double)ic->duration / AV_TIME_BASE,
1845
               ic->bit_rate / 1000);
1846
    }
1847
#endif
1848
}
1849

    
1850
static int has_codec_parameters(AVCodecContext *enc)
1851
{
1852
    int val;
1853
    switch(enc->codec_type) {
1854
    case CODEC_TYPE_AUDIO:
1855
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1856
        if(!enc->frame_size &&
1857
           (enc->codec_id == CODEC_ID_VORBIS ||
1858
            enc->codec_id == CODEC_ID_AAC))
1859
            return 0;
1860
        break;
1861
    case CODEC_TYPE_VIDEO:
1862
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1863
        break;
1864
    default:
1865
        val = 1;
1866
        break;
1867
    }
1868
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1869
}
1870

    
1871
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1872
{
1873
    int16_t *samples;
1874
    AVCodec *codec;
1875
    int got_picture, data_size, ret=0;
1876
    AVFrame picture;
1877

    
1878
  if(!st->codec->codec){
1879
    codec = avcodec_find_decoder(st->codec->codec_id);
1880
    if (!codec)
1881
        return -1;
1882
    ret = avcodec_open(st->codec, codec);
1883
    if (ret < 0)
1884
        return ret;
1885
  }
1886

    
1887
  if(!has_codec_parameters(st->codec)){
1888
    switch(st->codec->codec_type) {
1889
    case CODEC_TYPE_VIDEO:
1890
        ret = avcodec_decode_video(st->codec, &picture,
1891
                                   &got_picture, data, size);
1892
        break;
1893
    case CODEC_TYPE_AUDIO:
1894
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1895
        samples = av_malloc(data_size);
1896
        if (!samples)
1897
            goto fail;
1898
        ret = avcodec_decode_audio2(st->codec, samples,
1899
                                    &data_size, data, size);
1900
        av_free(samples);
1901
        break;
1902
    default:
1903
        break;
1904
    }
1905
  }
1906
 fail:
1907
    return ret;
1908
}
1909

    
1910
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1911
{
1912
    while (tags->id != CODEC_ID_NONE) {
1913
        if (tags->id == id)
1914
            return tags->tag;
1915
        tags++;
1916
    }
1917
    return 0;
1918
}
1919

    
1920
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1921
{
1922
    int i;
1923
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1924
        if(tag == tags[i].tag)
1925
            return tags[i].id;
1926
    }
1927
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1928
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1929
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1930
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1931
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1932
            return tags[i].id;
1933
    }
1934
    return CODEC_ID_NONE;
1935
}
1936

    
1937
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1938
{
1939
    int i;
1940
    for(i=0; tags && tags[i]; i++){
1941
        int tag= codec_get_tag(tags[i], id);
1942
        if(tag) return tag;
1943
    }
1944
    return 0;
1945
}
1946

    
1947
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1948
{
1949
    int i;
1950
    for(i=0; tags && tags[i]; i++){
1951
        enum CodecID id= codec_get_id(tags[i], tag);
1952
        if(id!=CODEC_ID_NONE) return id;
1953
    }
1954
    return CODEC_ID_NONE;
1955
}
1956

    
1957
static void compute_chapters_end(AVFormatContext *s)
1958
{
1959
    unsigned int i;
1960

    
1961
    for (i=0; i+1<s->nb_chapters; i++)
1962
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1963
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1964
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1965
            s->chapters[i]->end = s->chapters[i+1]->start;
1966
        }
1967

    
1968
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1969
        assert(s->start_time != AV_NOPTS_VALUE);
1970
        assert(s->duration > 0);
1971
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1972
                                           AV_TIME_BASE_Q,
1973
                                           s->chapters[i]->time_base);
1974
    }
1975
}
1976

    
1977
/* absolute maximum size we read until we abort */
1978
#define MAX_READ_SIZE        5000000
1979

    
1980
#define MAX_STD_TIMEBASES (60*12+5)
1981
static int get_std_framerate(int i){
1982
    if(i<60*12) return i*1001;
1983
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1984
}
1985

    
1986
/*
1987
 * Is the time base unreliable.
1988
 * This is a heuristic to balance between quick acceptance of the values in
1989
 * the headers vs. some extra checks.
1990
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1991
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1992
 * And there are "variable" fps files this needs to detect as well.
1993
 */
1994
static int tb_unreliable(AVCodecContext *c){
1995
    if(   c->time_base.den >= 101L*c->time_base.num
1996
       || c->time_base.den <    5L*c->time_base.num
1997
/*       || c->codec_tag == AV_RL32("DIVX")
1998
       || c->codec_tag == AV_RL32("XVID")*/
1999
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2000
       || c->codec_id == CODEC_ID_H264
2001
       )
2002
        return 1;
2003
    return 0;
2004
}
2005

    
2006
int av_find_stream_info(AVFormatContext *ic)
2007
{
2008
    int i, count, ret, read_size, j;
2009
    AVStream *st;
2010
    AVPacket pkt1, *pkt;
2011
    int64_t last_dts[MAX_STREAMS];
2012
    int64_t duration_gcd[MAX_STREAMS]={0};
2013
    int duration_count[MAX_STREAMS]={0};
2014
    double (*duration_error)[MAX_STD_TIMEBASES];
2015
    int64_t old_offset = url_ftell(ic->pb);
2016
    int64_t codec_info_duration[MAX_STREAMS]={0};
2017
    int codec_info_nb_frames[MAX_STREAMS]={0};
2018

    
2019
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2020
    if (!duration_error) return AVERROR(ENOMEM);
2021

    
2022
    for(i=0;i<ic->nb_streams;i++) {
2023
        st = ic->streams[i];
2024
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2025
/*            if(!st->time_base.num)
2026
                st->time_base= */
2027
            if(!st->codec->time_base.num)
2028
                st->codec->time_base= st->time_base;
2029
        }
2030
        //only for the split stuff
2031
        if (!st->parser) {
2032
            st->parser = av_parser_init(st->codec->codec_id);
2033
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2034
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2035
            }
2036
        }
2037
    }
2038

    
2039
    for(i=0;i<MAX_STREAMS;i++){
2040
        last_dts[i]= AV_NOPTS_VALUE;
2041
    }
2042

    
2043
    count = 0;
2044
    read_size = 0;
2045
    for(;;) {
2046
        if(url_interrupt_cb()){
2047
            ret= AVERROR(EINTR);
2048
            break;
2049
        }
2050

    
2051
        /* check if one codec still needs to be handled */
2052
        for(i=0;i<ic->nb_streams;i++) {
2053
            st = ic->streams[i];
2054
            if (!has_codec_parameters(st->codec))
2055
                break;
2056
            /* variable fps and no guess at the real fps */
2057
            if(   tb_unreliable(st->codec)
2058
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2059
                break;
2060
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2061
                break;
2062
            if(st->first_dts == AV_NOPTS_VALUE)
2063
                break;
2064
        }
2065
        if (i == ic->nb_streams) {
2066
            /* NOTE: if the format has no header, then we need to read
2067
               some packets to get most of the streams, so we cannot
2068
               stop here */
2069
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2070
                /* if we found the info for all the codecs, we can stop */
2071
                ret = count;
2072
                break;
2073
            }
2074
        }
2075
        /* we did not get all the codec info, but we read too much data */
2076
        if (read_size >= MAX_READ_SIZE) {
2077
            ret = count;
2078
            break;
2079
        }
2080

    
2081
        /* NOTE: a new stream can be added there if no header in file
2082
           (AVFMTCTX_NOHEADER) */
2083
        ret = av_read_frame_internal(ic, &pkt1);
2084
        if(ret == AVERROR(EAGAIN))
2085
            continue;
2086
        if (ret < 0) {
2087
            /* EOF or error */
2088
            ret = -1; /* we could not have all the codec parameters before EOF */
2089
            for(i=0;i<ic->nb_streams;i++) {
2090
                st = ic->streams[i];
2091
                if (!has_codec_parameters(st->codec)){
2092
                    char buf[256];
2093
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2094
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2095
                } else {
2096
                    ret = 0;
2097
                }
2098
            }
2099
            break;
2100
        }
2101

    
2102
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2103
        if(av_dup_packet(pkt) < 0) {
2104
            av_free(duration_error);
2105
            return AVERROR(ENOMEM);
2106
        }
2107

    
2108
        read_size += pkt->size;
2109

    
2110
        st = ic->streams[pkt->stream_index];
2111
        if(codec_info_nb_frames[st->index]>1)
2112
            codec_info_duration[st->index] += pkt->duration;
2113
        if (pkt->duration != 0)
2114
            codec_info_nb_frames[st->index]++;
2115

    
2116
        {
2117
            int index= pkt->stream_index;
2118
            int64_t last= last_dts[index];
2119
            int64_t duration= pkt->dts - last;
2120

    
2121
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2122
                double dur= duration * av_q2d(st->time_base);
2123

    
2124
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2125
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2126
                if(duration_count[index] < 2)
2127
                    memset(duration_error[index], 0, sizeof(*duration_error));
2128
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2129
                    int framerate= get_std_framerate(i);
2130
                    int ticks= lrintf(dur*framerate/(1001*12));
2131
                    double error= dur - ticks*1001*12/(double)framerate;
2132
                    duration_error[index][i] += error*error;
2133
                }
2134
                duration_count[index]++;
2135
                // ignore the first 4 values, they might have some random jitter
2136
                if (duration_count[index] > 3)
2137
                    duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2138
            }
2139
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2140
                last_dts[pkt->stream_index]= pkt->dts;
2141
        }
2142
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2143
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2144
            if(i){
2145
                st->codec->extradata_size= i;
2146
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2147
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2148
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2149
            }
2150
        }
2151

    
2152
        /* if still no information, we try to open the codec and to
2153
           decompress the frame. We try to avoid that in most cases as
2154
           it takes longer and uses more memory. For MPEG-4, we need to
2155
           decompress for QuickTime. */
2156
        if (!has_codec_parameters(st->codec) /*&&
2157
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2158
             st->codec->codec_id == CODEC_ID_H264 ||
2159
             st->codec->codec_id == CODEC_ID_H263 ||
2160
             st->codec->codec_id == CODEC_ID_H261 ||
2161
             st->codec->codec_id == CODEC_ID_VORBIS ||
2162
             st->codec->codec_id == CODEC_ID_MJPEG ||
2163
             st->codec->codec_id == CODEC_ID_PNG ||
2164
             st->codec->codec_id == CODEC_ID_PAM ||
2165
             st->codec->codec_id == CODEC_ID_PGM ||
2166
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2167
             st->codec->codec_id == CODEC_ID_PBM ||
2168
             st->codec->codec_id == CODEC_ID_PPM ||
2169
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2170
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2171
            try_decode_frame(st, pkt->data, pkt->size);
2172

    
2173
        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) {
2174
            break;
2175
        }
2176
        count++;
2177
    }
2178

    
2179
    // close codecs which were opened in try_decode_frame()
2180
    for(i=0;i<ic->nb_streams;i++) {
2181
        st = ic->streams[i];
2182
        if(st->codec->codec)
2183
            avcodec_close(st->codec);
2184
    }
2185
    for(i=0;i<ic->nb_streams;i++) {
2186
        st = ic->streams[i];
2187
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2188
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2189
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2190

    
2191
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2192
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2193
            // ipmovie.c produces.
2194
            if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
2195
                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);
2196
            if(duration_count[i]
2197
               && tb_unreliable(st->codec) /*&&
2198
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2199
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2200
                int num = 0;
2201
                double best_error= 2*av_q2d(st->time_base);
2202
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2203

    
2204
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2205
                    double error= duration_error[i][j] * get_std_framerate(j);
2206
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2207
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2208
                    if(error < best_error){
2209
                        best_error= error;
2210
                        num = get_std_framerate(j);
2211
                    }
2212
                }
2213
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2214
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2215
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2216
            }
2217

    
2218
            if (!st->r_frame_rate.num){
2219
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2220
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2221
                    st->r_frame_rate.num = st->codec->time_base.den;
2222
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2223
                }else{
2224
                    st->r_frame_rate.num = st->time_base.den;
2225
                    st->r_frame_rate.den = st->time_base.num;
2226
                }
2227
            }
2228
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2229
            if(!st->codec->bits_per_coded_sample)
2230
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2231
        }
2232
    }
2233

    
2234
    av_estimate_timings(ic, old_offset);
2235

    
2236
    compute_chapters_end(ic);
2237

    
2238
#if 0
2239
    /* correct DTS for B-frame streams with no timestamps */
2240
    for(i=0;i<ic->nb_streams;i++) {
2241
        st = ic->streams[i];
2242
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2243
            if(b-frames){
2244
                ppktl = &ic->packet_buffer;
2245
                while(ppkt1){
2246
                    if(ppkt1->stream_index != i)
2247
                        continue;
2248
                    if(ppkt1->pkt->dts < 0)
2249
                        break;
2250
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2251
                        break;
2252
                    ppkt1->pkt->dts -= delta;
2253
                    ppkt1= ppkt1->next;
2254
                }
2255
                if(ppkt1)
2256
                    continue;
2257
                st->cur_dts -= delta;
2258
            }
2259
        }
2260
    }
2261
#endif
2262

    
2263
    av_free(duration_error);
2264

    
2265
    return ret;
2266
}
2267

    
2268
/*******************************************************/
2269

    
2270
int av_read_play(AVFormatContext *s)
2271
{
2272
    if (s->iformat->read_play)
2273
        return s->iformat->read_play(s);
2274
    if (s->pb)
2275
        return av_url_read_fpause(s->pb, 0);
2276
    return AVERROR(ENOSYS);
2277
}
2278

    
2279
int av_read_pause(AVFormatContext *s)
2280
{
2281
    if (s->iformat->read_pause)
2282
        return s->iformat->read_pause(s);
2283
    if (s->pb)
2284
        return av_url_read_fpause(s->pb, 1);
2285
    return AVERROR(ENOSYS);
2286
}
2287

    
2288
void av_close_input_stream(AVFormatContext *s)
2289
{
2290
    int i;
2291
    AVStream *st;
2292

    
2293
    if (s->iformat->read_close)
2294
        s->iformat->read_close(s);
2295
    for(i=0;i<s->nb_streams;i++) {
2296
        /* free all data in a stream component */
2297
        st = s->streams[i];
2298
        if (st->parser) {
2299
            av_parser_close(st->parser);
2300
            av_free_packet(&st->cur_pkt);
2301
        }
2302
        av_metadata_free(&st->metadata);
2303
        av_free(st->index_entries);
2304
        av_free(st->codec->extradata);
2305
        av_free(st->codec);
2306
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2307
        av_free(st->filename);
2308
#endif
2309
        av_free(st->priv_data);
2310
        av_free(st);
2311
    }
2312
    for(i=s->nb_programs-1; i>=0; i--) {
2313
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2314
        av_freep(&s->programs[i]->provider_name);
2315
        av_freep(&s->programs[i]->name);
2316
#endif
2317
        av_metadata_free(&s->programs[i]->metadata);
2318
        av_freep(&s->programs[i]->stream_index);
2319
        av_freep(&s->programs[i]);
2320
    }
2321
    av_freep(&s->programs);
2322
    flush_packet_queue(s);
2323
    av_freep(&s->priv_data);
2324
    while(s->nb_chapters--) {
2325
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2326
        av_free(s->chapters[s->nb_chapters]->title);
2327
#endif
2328
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2329
        av_free(s->chapters[s->nb_chapters]);
2330
    }
2331
    av_freep(&s->chapters);
2332
    av_metadata_free(&s->metadata);
2333
    av_free(s);
2334
}
2335

    
2336
void av_close_input_file(AVFormatContext *s)
2337
{
2338
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2339
    av_close_input_stream(s);
2340
    if (pb)
2341
        url_fclose(pb);
2342
}
2343

    
2344
AVStream *av_new_stream(AVFormatContext *s, int id)
2345
{
2346
    AVStream *st;
2347
    int i;
2348

    
2349
    if (s->nb_streams >= MAX_STREAMS)
2350
        return NULL;
2351

    
2352
    st = av_mallocz(sizeof(AVStream));
2353
    if (!st)
2354
        return NULL;
2355

    
2356
    st->codec= avcodec_alloc_context();
2357
    if (s->iformat) {
2358
        /* no default bitrate if decoding */
2359
        st->codec->bit_rate = 0;
2360
    }
2361
    st->index = s->nb_streams;
2362
    st->id = id;
2363
    st->start_time = AV_NOPTS_VALUE;
2364
    st->duration = AV_NOPTS_VALUE;
2365
        /* we set the current DTS to 0 so that formats without any timestamps
2366
           but durations get some timestamps, formats with some unknown
2367
           timestamps have their first few packets buffered and the
2368
           timestamps corrected before they are returned to the user */
2369
    st->cur_dts = 0;
2370
    st->first_dts = AV_NOPTS_VALUE;
2371

    
2372
    /* default pts setting is MPEG-like */
2373
    av_set_pts_info(st, 33, 1, 90000);
2374
    st->last_IP_pts = AV_NOPTS_VALUE;
2375
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2376
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2377
    st->reference_dts = AV_NOPTS_VALUE;
2378

    
2379
    st->sample_aspect_ratio = (AVRational){0,1};
2380

    
2381
    s->streams[s->nb_streams++] = st;
2382
    return st;
2383
}
2384

    
2385
AVProgram *av_new_program(AVFormatContext *ac, int id)
2386
{
2387
    AVProgram *program=NULL;
2388
    int i;
2389

    
2390
#ifdef DEBUG_SI
2391
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2392
#endif
2393

    
2394
    for(i=0; i<ac->nb_programs; i++)
2395
        if(ac->programs[i]->id == id)
2396
            program = ac->programs[i];
2397

    
2398
    if(!program){
2399
        program = av_mallocz(sizeof(AVProgram));
2400
        if (!program)
2401
            return NULL;
2402
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2403
        program->discard = AVDISCARD_NONE;
2404
    }
2405
    program->id = id;
2406

    
2407
    return program;
2408
}
2409

    
2410
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2411
{
2412
    AVChapter *chapter = NULL;
2413
    int i;
2414

    
2415
    for(i=0; i<s->nb_chapters; i++)
2416
        if(s->chapters[i]->id == id)
2417
            chapter = s->chapters[i];
2418

    
2419
    if(!chapter){
2420
        chapter= av_mallocz(sizeof(AVChapter));
2421
        if(!chapter)
2422
            return NULL;
2423
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2424
    }
2425
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2426
    av_free(chapter->title);
2427
#endif
2428
    av_metadata_set(&chapter->metadata, "title", title);
2429
    chapter->id    = id;
2430
    chapter->time_base= time_base;
2431
    chapter->start = start;
2432
    chapter->end   = end;
2433

    
2434
    return chapter;
2435
}
2436

    
2437
/************************************************************/
2438
/* output media file */
2439

    
2440
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2441
{
2442
    int ret;
2443

    
2444
    if (s->oformat->priv_data_size > 0) {
2445
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2446
        if (!s->priv_data)
2447
            return AVERROR(ENOMEM);
2448
    } else
2449
        s->priv_data = NULL;
2450

    
2451
    if (s->oformat->set_parameters) {
2452
        ret = s->oformat->set_parameters(s, ap);
2453
        if (ret < 0)
2454
            return ret;
2455
    }
2456
    return 0;
2457
}
2458

    
2459
int av_write_header(AVFormatContext *s)
2460
{
2461
    int ret, i;
2462
    AVStream *st;
2463

    
2464
    // some sanity checks
2465
    for(i=0;i<s->nb_streams;i++) {
2466
        st = s->streams[i];
2467

    
2468
        switch (st->codec->codec_type) {
2469
        case CODEC_TYPE_AUDIO:
2470
            if(st->codec->sample_rate<=0){
2471
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2472
                return -1;
2473
            }
2474
            if(!st->codec->block_align)
2475
                st->codec->block_align = st->codec->channels *
2476
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2477
            break;
2478
        case CODEC_TYPE_VIDEO:
2479
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2480
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2481
                return -1;
2482
            }
2483
            if(st->codec->width<=0 || st->codec->height<=0){
2484
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2485
                return -1;
2486
            }
2487
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2488
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2489
                return -1;
2490
            }
2491
            break;
2492
        }
2493

    
2494
        if(s->oformat->codec_tag){
2495
            if(st->codec->codec_tag){
2496
                //FIXME
2497
                //check that tag + id is in the table
2498
                //if neither is in the table -> OK
2499
                //if tag is in the table with another id -> FAIL
2500
                //if id is in the table with another tag -> FAIL unless strict < ?
2501
            }else
2502
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2503
        }
2504

    
2505
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2506
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2507
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2508
    }
2509

    
2510
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2511
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2512
        if (!s->priv_data)
2513
            return AVERROR(ENOMEM);
2514
    }
2515

    
2516
#if LIBAVFORMAT_VERSION_MAJOR < 53
2517
    ff_metadata_mux_compat(s);
2518
#endif
2519

    
2520
    if(s->oformat->write_header){
2521
        ret = s->oformat->write_header(s);
2522
        if (ret < 0)
2523
            return ret;
2524
    }
2525

    
2526
    /* init PTS generation */
2527
    for(i=0;i<s->nb_streams;i++) {
2528
        int64_t den = AV_NOPTS_VALUE;
2529
        st = s->streams[i];
2530

    
2531
        switch (st->codec->codec_type) {
2532
        case CODEC_TYPE_AUDIO:
2533
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2534
            break;
2535
        case CODEC_TYPE_VIDEO:
2536
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2537
            break;
2538
        default:
2539
            break;
2540
        }
2541
        if (den != AV_NOPTS_VALUE) {
2542
            if (den <= 0)
2543
                return AVERROR_INVALIDDATA;
2544
            av_frac_init(&st->pts, 0, 0, den);
2545
        }
2546
    }
2547
    return 0;
2548
}
2549

    
2550
//FIXME merge with compute_pkt_fields
2551
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2552
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2553
    int num, den, frame_size, i;
2554

    
2555
//    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);
2556

    
2557
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2558
        return -1;*/
2559

    
2560
    /* duration field */
2561
    if (pkt->duration == 0) {
2562
        compute_frame_duration(&num, &den, st, NULL, pkt);
2563
        if (den && num) {
2564
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2565
        }
2566
    }
2567

    
2568
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2569
        pkt->pts= pkt->dts;
2570

    
2571
    //XXX/FIXME this is a temporary hack until all encoders output pts
2572
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2573
        pkt->dts=
2574
//        pkt->pts= st->cur_dts;
2575
        pkt->pts= st->pts.val;
2576
    }
2577

    
2578
    //calculate dts from pts
2579
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2580
        st->pts_buffer[0]= pkt->pts;
2581
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2582
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2583
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2584
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2585

    
2586
        pkt->dts= st->pts_buffer[0];
2587
    }
2588

    
2589
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2590
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2591
        return -1;
2592
    }
2593
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2594
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2595
        return -1;
2596
    }
2597

    
2598
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2599
    st->cur_dts= pkt->dts;
2600
    st->pts.val= pkt->dts;
2601

    
2602
    /* update pts */
2603
    switch (st->codec->codec_type) {
2604
    case CODEC_TYPE_AUDIO:
2605
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2606

    
2607
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2608
           likely equal to the encoder delay, but it would be better if we
2609
           had the real timestamps from the encoder */
2610
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2611
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2612
        }
2613
        break;
2614
    case CODEC_TYPE_VIDEO:
2615
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2616
        break;
2617
    default:
2618
        break;
2619
    }
2620
    return 0;
2621
}
2622

    
2623
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2624
{
2625
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2626

    
2627
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2628
        return ret;
2629

    
2630
    ret= s->oformat->write_packet(s, pkt);
2631
    if(!ret)
2632
        ret= url_ferror(s->pb);
2633
    return ret;
2634
}
2635

    
2636
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2637
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2638
{
2639
    AVPacketList **next_point, *this_pktl;
2640

    
2641
    this_pktl = av_mallocz(sizeof(AVPacketList));
2642
    this_pktl->pkt= *pkt;
2643
    if(pkt->destruct == av_destruct_packet)
2644
        pkt->destruct= NULL; // not shared -> must keep original from being freed
2645
    else
2646
        av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2647

    
2648
    next_point = &s->packet_buffer;
2649
    while(*next_point){
2650
        if(compare(s, &(*next_point)->pkt, pkt))
2651
            break;
2652
        next_point= &(*next_point)->next;
2653
    }
2654
    this_pktl->next= *next_point;
2655
    *next_point= this_pktl;
2656
}
2657

    
2658
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2659
{
2660
    AVStream *st = s->streams[ pkt ->stream_index];
2661
    AVStream *st2= s->streams[ next->stream_index];
2662
    int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2663
    int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2664

    
2665
    if (pkt->dts == AV_NOPTS_VALUE)
2666
        return 0;
2667

    
2668
    return next->dts * left > pkt->dts * right; //FIXME this can overflow
2669
}
2670

    
2671
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2672
    AVPacketList *pktl;
2673
    int stream_count=0;
2674
    int streams[MAX_STREAMS];
2675

    
2676
    if(pkt){
2677
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2678
    }
2679

    
2680
    memset(streams, 0, sizeof(streams));
2681
    pktl= s->packet_buffer;
2682
    while(pktl){
2683
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2684
        if(streams[ pktl->pkt.stream_index ] == 0)
2685
            stream_count++;
2686
        streams[ pktl->pkt.stream_index ]++;
2687
        pktl= pktl->next;
2688
    }
2689

    
2690
    if(stream_count && (s->nb_streams == stream_count || flush)){
2691
        pktl= s->packet_buffer;
2692
        *out= pktl->pkt;
2693

    
2694
        s->packet_buffer= pktl->next;
2695
        av_freep(&pktl);
2696
        return 1;
2697
    }else{
2698
        av_init_packet(out);
2699
        return 0;
2700
    }
2701
}
2702

    
2703
/**
2704
 * Interleaves an AVPacket correctly so it can be muxed.
2705
 * @param out the interleaved packet will be output here
2706
 * @param in the input packet
2707
 * @param flush 1 if no further packets are available as input and all
2708
 *              remaining packets should be output
2709
 * @return 1 if a packet was output, 0 if no packet could be output,
2710
 *         < 0 if an error occurred
2711
 */
2712
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2713
    if(s->oformat->interleave_packet)
2714
        return s->oformat->interleave_packet(s, out, in, flush);
2715
    else
2716
        return av_interleave_packet_per_dts(s, out, in, flush);
2717
}
2718

    
2719
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2720
    AVStream *st= s->streams[ pkt->stream_index];
2721

    
2722
    //FIXME/XXX/HACK drop zero sized packets
2723
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2724
        return 0;
2725

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

    
2730
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2731
        return -1;
2732

    
2733
    for(;;){
2734
        AVPacket opkt;
2735
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2736
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2737
            return ret;
2738

    
2739
        ret= s->oformat->write_packet(s, &opkt);
2740

    
2741
        av_free_packet(&opkt);
2742
        pkt= NULL;
2743

    
2744
        if(ret<0)
2745
            return ret;
2746
        if(url_ferror(s->pb))
2747
            return url_ferror(s->pb);
2748
    }
2749
}
2750

    
2751
int av_write_trailer(AVFormatContext *s)
2752
{
2753
    int ret, i;
2754

    
2755
    for(;;){
2756
        AVPacket pkt;
2757
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2758
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2759
            goto fail;
2760
        if(!ret)
2761
            break;
2762

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

    
2765
        av_free_packet(&pkt);
2766

    
2767
        if(ret<0)
2768
            goto fail;
2769
        if(url_ferror(s->pb))
2770
            goto fail;
2771
    }
2772

    
2773
    if(s->oformat->write_trailer)
2774
        ret = s->oformat->write_trailer(s);
2775
fail:
2776
    if(ret == 0)
2777
       ret=url_ferror(s->pb);
2778
    for(i=0;i<s->nb_streams;i++)
2779
        av_freep(&s->streams[i]->priv_data);
2780
    av_freep(&s->priv_data);
2781
    return ret;
2782
}
2783

    
2784
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2785
{
2786
    int i, j;
2787
    AVProgram *program=NULL;
2788
    void *tmp;
2789

    
2790
    for(i=0; i<ac->nb_programs; i++){
2791
        if(ac->programs[i]->id != progid)
2792
            continue;
2793
        program = ac->programs[i];
2794
        for(j=0; j<program->nb_stream_indexes; j++)
2795
            if(program->stream_index[j] == idx)
2796
                return;
2797

    
2798
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2799
        if(!tmp)
2800
            return;
2801
        program->stream_index = tmp;
2802
        program->stream_index[program->nb_stream_indexes++] = idx;
2803
        return;
2804
    }
2805
}
2806

    
2807
static void print_fps(double d, const char *postfix){
2808
    uint64_t v= lrintf(d*100);
2809
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2810
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2811
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2812
}
2813

    
2814
/* "user interface" functions */
2815
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2816
{
2817
    char buf[256];
2818
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2819
    AVStream *st = ic->streams[i];
2820
    int g = av_gcd(st->time_base.num, st->time_base.den);
2821
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2822
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2823
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2824
    /* the pid is an important information, so we display it */
2825
    /* XXX: add a generic system */
2826
    if (flags & AVFMT_SHOW_IDS)
2827
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2828
    if (lang)
2829
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2830
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2831
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2832
    if (st->sample_aspect_ratio.num && // default
2833
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2834
        AVRational display_aspect_ratio;
2835
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2836
                  st->codec->width*st->sample_aspect_ratio.num,
2837
                  st->codec->height*st->sample_aspect_ratio.den,
2838
                  1024*1024);
2839
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2840
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2841
                 display_aspect_ratio.num, display_aspect_ratio.den);
2842
    }
2843
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2844
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2845
            print_fps(av_q2d(st->r_frame_rate), "tbr");
2846
        if(st->time_base.den && st->time_base.num)
2847
            print_fps(1/av_q2d(st->time_base), "tbn");
2848
        if(st->codec->time_base.den && st->codec->time_base.num)
2849
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
2850
    }
2851
    av_log(NULL, AV_LOG_INFO, "\n");
2852
}
2853

    
2854
void dump_format(AVFormatContext *ic,
2855
                 int index,
2856
                 const char *url,
2857
                 int is_output)
2858
{
2859
    int i;
2860

    
2861
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2862
            is_output ? "Output" : "Input",
2863
            index,
2864
            is_output ? ic->oformat->name : ic->iformat->name,
2865
            is_output ? "to" : "from", url);
2866
    if (!is_output) {
2867
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2868
        if (ic->duration != AV_NOPTS_VALUE) {
2869
            int hours, mins, secs, us;
2870
            secs = ic->duration / AV_TIME_BASE;
2871
            us = ic->duration % AV_TIME_BASE;
2872
            mins = secs / 60;
2873
            secs %= 60;
2874
            hours = mins / 60;
2875
            mins %= 60;
2876
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2877
                   (100 * us) / AV_TIME_BASE);
2878
        } else {
2879
            av_log(NULL, AV_LOG_INFO, "N/A");
2880
        }
2881
        if (ic->start_time != AV_NOPTS_VALUE) {
2882
            int secs, us;
2883
            av_log(NULL, AV_LOG_INFO, ", start: ");
2884
            secs = ic->start_time / AV_TIME_BASE;
2885
            us = ic->start_time % AV_TIME_BASE;
2886
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2887
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2888
        }
2889
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2890
        if (ic->bit_rate) {
2891
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2892
        } else {
2893
            av_log(NULL, AV_LOG_INFO, "N/A");
2894
        }
2895
        av_log(NULL, AV_LOG_INFO, "\n");
2896
    }
2897
    if(ic->nb_programs) {
2898
        int j, k;
2899
        for(j=0; j<ic->nb_programs; j++) {
2900
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
2901
                                                  "name", NULL, 0);
2902
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2903
                   name ? name->value : "");
2904
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2905
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2906
         }
2907
    } else
2908
    for(i=0;i<ic->nb_streams;i++)
2909
        dump_stream_format(ic, i, index, is_output);
2910
}
2911

    
2912
#if LIBAVFORMAT_VERSION_MAJOR < 53
2913
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2914
{
2915
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2916
}
2917

    
2918
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2919
{
2920
    AVRational frame_rate;
2921
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2922
    *frame_rate_num= frame_rate.num;
2923
    *frame_rate_den= frame_rate.den;
2924
    return ret;
2925
}
2926
#endif
2927

    
2928
int64_t av_gettime(void)
2929
{
2930
    struct timeval tv;
2931
    gettimeofday(&tv,NULL);
2932
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2933
}
2934

    
2935
int64_t parse_date(const char *datestr, int duration)
2936
{
2937
    const char *p;
2938
    int64_t t;
2939
    struct tm dt;
2940
    int i;
2941
    static const char * const date_fmt[] = {
2942
        "%Y-%m-%d",
2943
        "%Y%m%d",
2944
    };
2945
    static const char * const time_fmt[] = {
2946
        "%H:%M:%S",
2947
        "%H%M%S",
2948
    };
2949
    const char *q;
2950
    int is_utc, len;
2951
    char lastch;
2952
    int negative = 0;
2953

    
2954
#undef time
2955
    time_t now = time(0);
2956

    
2957
    len = strlen(datestr);
2958
    if (len > 0)
2959
        lastch = datestr[len - 1];
2960
    else
2961
        lastch = '\0';
2962
    is_utc = (lastch == 'z' || lastch == 'Z');
2963

    
2964
    memset(&dt, 0, sizeof(dt));
2965

    
2966
    p = datestr;
2967
    q = NULL;
2968
    if (!duration) {
2969
        if (!strncasecmp(datestr, "now", len))
2970
            return (int64_t) now * 1000000;
2971

    
2972
        /* parse the year-month-day part */
2973
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2974
            q = small_strptime(p, date_fmt[i], &dt);
2975
            if (q) {
2976
                break;
2977
            }
2978
        }
2979

    
2980
        /* if the year-month-day part is missing, then take the
2981
         * current year-month-day time */
2982
        if (!q) {
2983
            if (is_utc) {
2984
                dt = *gmtime(&now);
2985
            } else {
2986
                dt = *localtime(&now);
2987
            }
2988
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2989
        } else {
2990
            p = q;
2991
        }
2992

    
2993
        if (*p == 'T' || *p == 't' || *p == ' ')
2994
            p++;
2995

    
2996
        /* parse the hour-minute-second part */
2997
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2998
            q = small_strptime(p, time_fmt[i], &dt);
2999
            if (q) {
3000
                break;
3001
            }
3002
        }
3003
    } else {
3004
        /* parse datestr as a duration */
3005
        if (p[0] == '-') {
3006
            negative = 1;
3007
            ++p;
3008
        }
3009
        /* parse datestr as HH:MM:SS */
3010
        q = small_strptime(p, time_fmt[0], &dt);
3011
        if (!q) {
3012
            /* parse datestr as S+ */
3013
            dt.tm_sec = strtol(p, (char **)&q, 10);
3014
            if (q == p)
3015
                /* the parsing didn't succeed */
3016
                return INT64_MIN;
3017
            dt.tm_min = 0;
3018
            dt.tm_hour = 0;
3019
        }
3020
    }
3021

    
3022
    /* Now we have all the fields that we can get */
3023
    if (!q) {
3024
        return INT64_MIN;
3025
    }
3026

    
3027
    if (duration) {
3028
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3029
    } else {
3030
        dt.tm_isdst = -1;       /* unknown */
3031
        if (is_utc) {
3032
            t = mktimegm(&dt);
3033
        } else {
3034
            t = mktime(&dt);
3035
        }
3036
    }
3037

    
3038
    t *= 1000000;
3039

    
3040
    /* parse the .m... part */
3041
    if (*q == '.') {
3042
        int val, n;
3043
        q++;
3044
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3045
            if (!isdigit(*q))
3046
                break;
3047
            val += n * (*q - '0');
3048
        }
3049
        t += val;
3050
    }
3051
    return negative ? -t : t;
3052
}
3053

    
3054
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3055
{
3056
    const char *p;
3057
    char tag[128], *q;
3058

    
3059
    p = info;
3060
    if (*p == '?')
3061
        p++;
3062
    for(;;) {
3063
        q = tag;
3064
        while (*p != '\0' && *p != '=' && *p != '&') {
3065
            if ((q - tag) < sizeof(tag) - 1)
3066
                *q++ = *p;
3067
            p++;
3068
        }
3069
        *q = '\0';
3070
        q = arg;
3071
        if (*p == '=') {
3072
            p++;
3073
            while (*p != '&' && *p != '\0') {
3074
                if ((q - arg) < arg_size - 1) {
3075
                    if (*p == '+')
3076
                        *q++ = ' ';
3077
                    else
3078
                        *q++ = *p;
3079
                }
3080
                p++;
3081
            }
3082
            *q = '\0';
3083
        }
3084
        if (!strcmp(tag, tag1))
3085
            return 1;
3086
        if (*p != '&')
3087
            break;
3088
        p++;
3089
    }
3090
    return 0;
3091
}
3092

    
3093
int av_get_frame_filename(char *buf, int buf_size,
3094
                          const char *path, int number)
3095
{
3096
    const char *p;
3097
    char *q, buf1[20], c;
3098
    int nd, len, percentd_found;
3099

    
3100
    q = buf;
3101
    p = path;
3102
    percentd_found = 0;
3103
    for(;;) {
3104
        c = *p++;
3105
        if (c == '\0')
3106
            break;
3107
        if (c == '%') {
3108
            do {
3109
                nd = 0;
3110
                while (isdigit(*p)) {
3111
                    nd = nd * 10 + *p++ - '0';
3112
                }
3113
                c = *p++;
3114
            } while (isdigit(c));
3115

    
3116
            switch(c) {
3117
            case '%':
3118
                goto addchar;
3119
            case 'd':
3120
                if (percentd_found)
3121
                    goto fail;
3122
                percentd_found = 1;
3123
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3124
                len = strlen(buf1);
3125
                if ((q - buf + len) > buf_size - 1)
3126
                    goto fail;
3127
                memcpy(q, buf1, len);
3128
                q += len;
3129
                break;
3130
            default:
3131
                goto fail;
3132
            }
3133
        } else {
3134
        addchar:
3135
            if ((q - buf) < buf_size - 1)
3136
                *q++ = c;
3137
        }
3138
    }
3139
    if (!percentd_found)
3140
        goto fail;
3141
    *q = '\0';
3142
    return 0;
3143
 fail:
3144
    *q = '\0';
3145
    return -1;
3146
}
3147

    
3148
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3149
{
3150
    int len, i, j, c;
3151
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3152

    
3153
    for(i=0;i<size;i+=16) {
3154
        len = size - i;
3155
        if (len > 16)
3156
            len = 16;
3157
        PRINT("%08x ", i);
3158
        for(j=0;j<16;j++) {
3159
            if (j < len)
3160
                PRINT(" %02x", buf[i+j]);
3161
            else
3162
                PRINT("   ");
3163
        }
3164
        PRINT(" ");
3165
        for(j=0;j<len;j++) {
3166
            c = buf[i+j];
3167
            if (c < ' ' || c > '~')
3168
                c = '.';
3169
            PRINT("%c", c);
3170
        }
3171
        PRINT("\n");
3172
    }
3173
#undef PRINT
3174
}
3175

    
3176
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3177
{
3178
    hex_dump_internal(NULL, f, 0, buf, size);
3179
}
3180

    
3181
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3182
{
3183
    hex_dump_internal(avcl, NULL, level, buf, size);
3184
}
3185

    
3186
 //FIXME needs to know the time_base
3187
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3188
{
3189
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3190
    PRINT("stream #%d:\n", pkt->stream_index);
3191
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3192
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3193
    /* DTS is _always_ valid after av_read_frame() */
3194
    PRINT("  dts=");
3195
    if (pkt->dts == AV_NOPTS_VALUE)
3196
        PRINT("N/A");
3197
    else
3198
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3199
    /* PTS may not be known if B-frames are present. */
3200
    PRINT("  pts=");
3201
    if (pkt->pts == AV_NOPTS_VALUE)
3202
        PRINT("N/A");
3203
    else
3204
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3205
    PRINT("\n");
3206
    PRINT("  size=%d\n", pkt->size);
3207
#undef PRINT
3208
    if (dump_payload)
3209
        av_hex_dump(f, pkt->data, pkt->size);
3210
}
3211

    
3212
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3213
{
3214
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3215
}
3216

    
3217
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3218
{
3219
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3220
}
3221

    
3222
void url_split(char *proto, int proto_size,
3223
               char *authorization, int authorization_size,
3224
               char *hostname, int hostname_size,
3225
               int *port_ptr,
3226
               char *path, int path_size,
3227
               const char *url)
3228
{
3229
    const char *p, *ls, *at, *col, *brk;
3230

    
3231
    if (port_ptr)               *port_ptr = -1;
3232
    if (proto_size > 0)         proto[0] = 0;
3233
    if (authorization_size > 0) authorization[0] = 0;
3234
    if (hostname_size > 0)      hostname[0] = 0;
3235
    if (path_size > 0)          path[0] = 0;
3236

    
3237
    /* parse protocol */
3238
    if ((p = strchr(url, ':'))) {
3239
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3240
        p++; /* skip ':' */
3241
        if (*p == '/') p++;
3242
        if (*p == '/') p++;
3243
    } else {
3244
        /* no protocol means plain filename */
3245
        av_strlcpy(path, url, path_size);
3246
        return;
3247
    }
3248

    
3249
    /* separate path from hostname */
3250
    ls = strchr(p, '/');
3251
    if(!ls)
3252
        ls = strchr(p, '?');
3253
    if(ls)
3254
        av_strlcpy(path, ls, path_size);
3255
    else
3256
        ls = &p[strlen(p)]; // XXX
3257

    
3258
    /* the rest is hostname, use that to parse auth/port */
3259
    if (ls != p) {
3260
        /* authorization (user[:pass]@hostname) */
3261
        if ((at = strchr(p, '@')) && at < ls) {
3262
            av_strlcpy(authorization, p,
3263
                       FFMIN(authorization_size, at + 1 - p));
3264
            p = at + 1; /* skip '@' */
3265
        }
3266

    
3267
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3268
            /* [host]:port */
3269
            av_strlcpy(hostname, p + 1,
3270
                       FFMIN(hostname_size, brk - p));
3271
            if (brk[1] == ':' && port_ptr)
3272
                *port_ptr = atoi(brk + 2);
3273
        } else if ((col = strchr(p, ':')) && col < ls) {
3274
            av_strlcpy(hostname, p,
3275
                       FFMIN(col + 1 - p, hostname_size));
3276
            if (port_ptr) *port_ptr = atoi(col + 1);
3277
        } else
3278
            av_strlcpy(hostname, p,
3279
                       FFMIN(ls + 1 - p, hostname_size));
3280
    }
3281
}
3282

    
3283
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3284
{
3285
    int i;
3286
    static const char hex_table[16] = { '0', '1', '2', '3',
3287
                                        '4', '5', '6', '7',
3288
                                        '8', '9', 'A', 'B',
3289
                                        'C', 'D', 'E', 'F' };
3290

    
3291
    for(i = 0; i < s; i++) {
3292
        buff[i * 2]     = hex_table[src[i] >> 4];
3293
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3294
    }
3295

    
3296
    return buff;
3297
}
3298

    
3299
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3300
                     int pts_num, int pts_den)
3301
{
3302
    unsigned int gcd= av_gcd(pts_num, pts_den);
3303
    s->pts_wrap_bits = pts_wrap_bits;
3304
    s->time_base.num = pts_num/gcd;
3305
    s->time_base.den = pts_den/gcd;
3306

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