Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 85142724

History | View | Annotate | Download (101 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
    if(delay==0 || (delay==1 && pc)){
863
        if (presentation_delayed) {
864
            /* DTS = decompression timestamp */
865
            /* PTS = presentation timestamp */
866
            if (pkt->dts == AV_NOPTS_VALUE)
867
                pkt->dts = st->last_IP_pts;
868
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
869
            if (pkt->dts == AV_NOPTS_VALUE)
870
                pkt->dts = st->cur_dts;
871

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

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

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

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

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

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

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

    
944
    av_init_packet(pkt);
945

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

    
967
                /* return packet if any */
968
                if (pkt->size) {
969
                    pkt->pos = st->cur_pkt.pos;              // Isn't quite accurate but close.
970
                got_packet:
971
                    pkt->duration = 0;
972
                    pkt->stream_index = st->index;
973
                    pkt->pts = st->parser->pts;
974
                    pkt->dts = st->parser->dts;
975
                    pkt->destruct = av_destruct_packet_nofree;
976
                    compute_pkt_fields(s, st, st->parser, pkt);
977

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

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

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

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

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

    
1062
    return 0;
1063
}
1064

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

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

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

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

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

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

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

    
1134
/*******************************************************/
1135
/* seek support */
1136

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

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

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

    
1164
    flush_packet_queue(s);
1165

    
1166
    s->cur_st = NULL;
1167

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

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

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

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

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

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

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

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

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

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

    
1227
    st->index_entries= entries;
1228

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

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

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

    
1252
    return index;
1253
}
1254

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

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

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

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

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

    
1287
#define DEBUG_SEEK
1288

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

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

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

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

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

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

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

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

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

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

    
1348
    av_update_cur_dts(s, st, ts);
1349

    
1350
    return 0;
1351
}
1352

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

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

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

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

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

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

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

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

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

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

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

1471
    if (stream_index < 0)
1472
        return -1;
1473

1474
    st= s->streams[stream_index];
1475
#endif
1476

    
1477
    pos_min = s->data_offset;
1478
    pos_max = url_fsize(s->pb) - 1;
1479

    
1480
    if     (pos < pos_min) pos= pos_min;
1481
    else if(pos > pos_max) pos= pos_max;
1482

    
1483
    url_fseek(s->pb, pos, SEEK_SET);
1484

    
1485
#if 0
1486
    av_update_cur_dts(s, st, ts);
1487
#endif
1488
    return 0;
1489
}
1490

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

    
1498
    st = s->streams[stream_index];
1499

    
1500
    index = av_index_search_timestamp(st, timestamp, flags);
1501

    
1502
    if(index < 0 || index==st->nb_index_entries-1){
1503
        int i;
1504
        AVPacket pkt;
1505

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

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

    
1544
    return 0;
1545
}
1546

    
1547
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1548
{
1549
    int ret;
1550
    AVStream *st;
1551

    
1552
    av_read_frame_flush(s);
1553

    
1554
    if(flags & AVSEEK_FLAG_BYTE)
1555
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1556

    
1557
    if(stream_index < 0){
1558
        stream_index= av_find_default_stream_index(s);
1559
        if(stream_index < 0)
1560
            return -1;
1561

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

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

    
1576
    if(s->iformat->read_timestamp)
1577
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1578
    else
1579
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1580
}
1581

    
1582
/*******************************************************/
1583

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

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

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

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

    
1653
static void fill_all_stream_timings(AVFormatContext *ic)
1654
{
1655
    int i;
1656
    AVStream *st;
1657

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

    
1670
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1671
{
1672
    int64_t filesize, duration;
1673
    int bit_rate, i;
1674
    AVStream *st;
1675

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

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

    
1702
#define DURATION_MAX_READ_SIZE 250000
1703

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

    
1713
    ic->cur_st = NULL;
1714

    
1715
    /* flush packet queue */
1716
    flush_packet_queue(ic);
1717

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

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

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

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

    
1764
    url_fseek(ic->pb, offset, SEEK_SET);
1765
    read_size = 0;
1766
    for(;;) {
1767
        if (read_size >= DURATION_MAX_READ_SIZE)
1768
            break;
1769

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

    
1790
    fill_all_stream_timings(ic);
1791

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

    
1800
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1801
{
1802
    int64_t file_size;
1803

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

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

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

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

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

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

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

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

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

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

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

    
1954
static void compute_chapters_end(AVFormatContext *s)
1955
{
1956
    unsigned int i;
1957

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

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

    
1974
/* absolute maximum size we read until we abort */
1975
#define MAX_READ_SIZE        5000000
1976

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

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

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

    
2016
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2017
    if (!duration_error) return AVERROR(ENOMEM);
2018

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

    
2036
    for(i=0;i<MAX_STREAMS;i++){
2037
        last_dts[i]= AV_NOPTS_VALUE;
2038
    }
2039

    
2040
    count = 0;
2041
    read_size = 0;
2042
    for(;;) {
2043
        if(url_interrupt_cb()){
2044
            ret= AVERROR(EINTR);
2045
            break;
2046
        }
2047

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

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

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

    
2105
        read_size += pkt->size;
2106

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

    
2113
        {
2114
            int index= pkt->stream_index;
2115
            int64_t last= last_dts[index];
2116
            int64_t duration= pkt->dts - last;
2117

    
2118
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2119
                double dur= duration * av_q2d(st->time_base);
2120

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

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

    
2170
        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) {
2171
            break;
2172
        }
2173
        count++;
2174
    }
2175

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

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

    
2200
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2201
                    double error= duration_error[i][j] * get_std_framerate(j);
2202
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2203
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2204
                    if(error < best_error){
2205
                        best_error= error;
2206
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2207
                    }
2208
                }
2209
            }
2210

    
2211
            if (!st->r_frame_rate.num){
2212
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2213
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2214
                    st->r_frame_rate.num = st->codec->time_base.den;
2215
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2216
                }else{
2217
                    st->r_frame_rate.num = st->time_base.den;
2218
                    st->r_frame_rate.den = st->time_base.num;
2219
                }
2220
            }
2221
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2222
            if(!st->codec->bits_per_coded_sample)
2223
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2224
        }
2225
    }
2226

    
2227
    av_estimate_timings(ic, old_offset);
2228

    
2229
    compute_chapters_end(ic);
2230

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

    
2256
    av_free(duration_error);
2257

    
2258
    return ret;
2259
}
2260

    
2261
/*******************************************************/
2262

    
2263
int av_read_play(AVFormatContext *s)
2264
{
2265
    if (s->iformat->read_play)
2266
        return s->iformat->read_play(s);
2267
    if (s->pb)
2268
        return av_url_read_fpause(s->pb, 0);
2269
    return AVERROR(ENOSYS);
2270
}
2271

    
2272
int av_read_pause(AVFormatContext *s)
2273
{
2274
    if (s->iformat->read_pause)
2275
        return s->iformat->read_pause(s);
2276
    if (s->pb)
2277
        return av_url_read_fpause(s->pb, 1);
2278
    return AVERROR(ENOSYS);
2279
}
2280

    
2281
void av_close_input_stream(AVFormatContext *s)
2282
{
2283
    int i;
2284
    AVStream *st;
2285

    
2286
    if (s->iformat->read_close)
2287
        s->iformat->read_close(s);
2288
    for(i=0;i<s->nb_streams;i++) {
2289
        /* free all data in a stream component */
2290
        st = s->streams[i];
2291
        if (st->parser) {
2292
            av_parser_close(st->parser);
2293
            av_free_packet(&st->cur_pkt);
2294
        }
2295
        av_metadata_free(&st->metadata);
2296
        av_free(st->index_entries);
2297
        av_free(st->codec->extradata);
2298
        av_free(st->codec);
2299
        av_free(st->filename);
2300
        av_free(st->priv_data);
2301
        av_free(st);
2302
    }
2303
    for(i=s->nb_programs-1; i>=0; i--) {
2304
        av_freep(&s->programs[i]->provider_name);
2305
        av_freep(&s->programs[i]->name);
2306
        av_metadata_free(&s->programs[i]->metadata);
2307
        av_freep(&s->programs[i]->stream_index);
2308
        av_freep(&s->programs[i]);
2309
    }
2310
    av_freep(&s->programs);
2311
    flush_packet_queue(s);
2312
    av_freep(&s->priv_data);
2313
    while(s->nb_chapters--) {
2314
        av_free(s->chapters[s->nb_chapters]->title);
2315
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2316
        av_free(s->chapters[s->nb_chapters]);
2317
    }
2318
    av_freep(&s->chapters);
2319
    av_metadata_free(&s->metadata);
2320
    av_free(s);
2321
}
2322

    
2323
void av_close_input_file(AVFormatContext *s)
2324
{
2325
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2326
    av_close_input_stream(s);
2327
    if (pb)
2328
        url_fclose(pb);
2329
}
2330

    
2331
AVStream *av_new_stream(AVFormatContext *s, int id)
2332
{
2333
    AVStream *st;
2334
    int i;
2335

    
2336
    if (s->nb_streams >= MAX_STREAMS)
2337
        return NULL;
2338

    
2339
    st = av_mallocz(sizeof(AVStream));
2340
    if (!st)
2341
        return NULL;
2342

    
2343
    st->codec= avcodec_alloc_context();
2344
    if (s->iformat) {
2345
        /* no default bitrate if decoding */
2346
        st->codec->bit_rate = 0;
2347
    }
2348
    st->index = s->nb_streams;
2349
    st->id = id;
2350
    st->start_time = AV_NOPTS_VALUE;
2351
    st->duration = AV_NOPTS_VALUE;
2352
        /* we set the current DTS to 0 so that formats without any timestamps
2353
           but durations get some timestamps, formats with some unknown
2354
           timestamps have their first few packets buffered and the
2355
           timestamps corrected before they are returned to the user */
2356
    st->cur_dts = 0;
2357
    st->first_dts = AV_NOPTS_VALUE;
2358

    
2359
    /* default pts setting is MPEG-like */
2360
    av_set_pts_info(st, 33, 1, 90000);
2361
    st->last_IP_pts = AV_NOPTS_VALUE;
2362
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2363
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2364
    st->reference_dts = AV_NOPTS_VALUE;
2365

    
2366
    st->sample_aspect_ratio = (AVRational){0,1};
2367

    
2368
    s->streams[s->nb_streams++] = st;
2369
    return st;
2370
}
2371

    
2372
AVProgram *av_new_program(AVFormatContext *ac, int id)
2373
{
2374
    AVProgram *program=NULL;
2375
    int i;
2376

    
2377
#ifdef DEBUG_SI
2378
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2379
#endif
2380

    
2381
    for(i=0; i<ac->nb_programs; i++)
2382
        if(ac->programs[i]->id == id)
2383
            program = ac->programs[i];
2384

    
2385
    if(!program){
2386
        program = av_mallocz(sizeof(AVProgram));
2387
        if (!program)
2388
            return NULL;
2389
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2390
        program->discard = AVDISCARD_NONE;
2391
    }
2392
    program->id = id;
2393

    
2394
    return program;
2395
}
2396

    
2397
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2398
{
2399
    AVChapter *chapter = NULL;
2400
    int i;
2401

    
2402
    for(i=0; i<s->nb_chapters; i++)
2403
        if(s->chapters[i]->id == id)
2404
            chapter = s->chapters[i];
2405

    
2406
    if(!chapter){
2407
        chapter= av_mallocz(sizeof(AVChapter));
2408
        if(!chapter)
2409
            return NULL;
2410
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2411
    }
2412
    av_free(chapter->title);
2413
    chapter->title = av_strdup(title);
2414
    chapter->id    = id;
2415
    chapter->time_base= time_base;
2416
    chapter->start = start;
2417
    chapter->end   = end;
2418

    
2419
    return chapter;
2420
}
2421

    
2422
/************************************************************/
2423
/* output media file */
2424

    
2425
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2426
{
2427
    int ret;
2428

    
2429
    if (s->oformat->priv_data_size > 0) {
2430
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2431
        if (!s->priv_data)
2432
            return AVERROR(ENOMEM);
2433
    } else
2434
        s->priv_data = NULL;
2435

    
2436
    if (s->oformat->set_parameters) {
2437
        ret = s->oformat->set_parameters(s, ap);
2438
        if (ret < 0)
2439
            return ret;
2440
    }
2441
    return 0;
2442
}
2443

    
2444
int av_write_header(AVFormatContext *s)
2445
{
2446
    int ret, i;
2447
    AVStream *st;
2448

    
2449
    // some sanity checks
2450
    for(i=0;i<s->nb_streams;i++) {
2451
        st = s->streams[i];
2452

    
2453
        switch (st->codec->codec_type) {
2454
        case CODEC_TYPE_AUDIO:
2455
            if(st->codec->sample_rate<=0){
2456
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2457
                return -1;
2458
            }
2459
            if(!st->codec->block_align)
2460
                st->codec->block_align = st->codec->channels *
2461
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2462
            break;
2463
        case CODEC_TYPE_VIDEO:
2464
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2465
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2466
                return -1;
2467
            }
2468
            if(st->codec->width<=0 || st->codec->height<=0){
2469
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2470
                return -1;
2471
            }
2472
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2473
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2474
                return -1;
2475
            }
2476
            break;
2477
        }
2478

    
2479
        if(s->oformat->codec_tag){
2480
            if(st->codec->codec_tag){
2481
                //FIXME
2482
                //check that tag + id is in the table
2483
                //if neither is in the table -> OK
2484
                //if tag is in the table with another id -> FAIL
2485
                //if id is in the table with another tag -> FAIL unless strict < ?
2486
            }else
2487
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2488
        }
2489

    
2490
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2491
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2492
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2493
    }
2494

    
2495
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2496
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2497
        if (!s->priv_data)
2498
            return AVERROR(ENOMEM);
2499
    }
2500

    
2501
#if LIBAVFORMAT_VERSION_MAJOR < 53
2502
    ff_metadata_mux_compat(s);
2503
#endif
2504

    
2505
    if(s->oformat->write_header){
2506
        ret = s->oformat->write_header(s);
2507
        if (ret < 0)
2508
            return ret;
2509
    }
2510

    
2511
    /* init PTS generation */
2512
    for(i=0;i<s->nb_streams;i++) {
2513
        int64_t den = AV_NOPTS_VALUE;
2514
        st = s->streams[i];
2515

    
2516
        switch (st->codec->codec_type) {
2517
        case CODEC_TYPE_AUDIO:
2518
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2519
            break;
2520
        case CODEC_TYPE_VIDEO:
2521
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2522
            break;
2523
        default:
2524
            break;
2525
        }
2526
        if (den != AV_NOPTS_VALUE) {
2527
            if (den <= 0)
2528
                return AVERROR_INVALIDDATA;
2529
            av_frac_init(&st->pts, 0, 0, den);
2530
        }
2531
    }
2532
    return 0;
2533
}
2534

    
2535
//FIXME merge with compute_pkt_fields
2536
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2537
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2538
    int num, den, frame_size, i;
2539

    
2540
//    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);
2541

    
2542
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2543
        return -1;*/
2544

    
2545
    /* duration field */
2546
    if (pkt->duration == 0) {
2547
        compute_frame_duration(&num, &den, st, NULL, pkt);
2548
        if (den && num) {
2549
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2550
        }
2551
    }
2552

    
2553
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2554
        pkt->pts= pkt->dts;
2555

    
2556
    //XXX/FIXME this is a temporary hack until all encoders output pts
2557
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2558
        pkt->dts=
2559
//        pkt->pts= st->cur_dts;
2560
        pkt->pts= st->pts.val;
2561
    }
2562

    
2563
    //calculate dts from pts
2564
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2565
        st->pts_buffer[0]= pkt->pts;
2566
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2567
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2568
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2569
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2570

    
2571
        pkt->dts= st->pts_buffer[0];
2572
    }
2573

    
2574
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2575
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2576
        return -1;
2577
    }
2578
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2579
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2580
        return -1;
2581
    }
2582

    
2583
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2584
    st->cur_dts= pkt->dts;
2585
    st->pts.val= pkt->dts;
2586

    
2587
    /* update pts */
2588
    switch (st->codec->codec_type) {
2589
    case CODEC_TYPE_AUDIO:
2590
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2591

    
2592
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2593
           likely equal to the encoder delay, but it would be better if we
2594
           had the real timestamps from the encoder */
2595
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2596
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2597
        }
2598
        break;
2599
    case CODEC_TYPE_VIDEO:
2600
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2601
        break;
2602
    default:
2603
        break;
2604
    }
2605
    return 0;
2606
}
2607

    
2608
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2609
{
2610
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2611

    
2612
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2613
        return ret;
2614

    
2615
    ret= s->oformat->write_packet(s, pkt);
2616
    if(!ret)
2617
        ret= url_ferror(s->pb);
2618
    return ret;
2619
}
2620

    
2621
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2622
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2623
{
2624
    AVPacketList **next_point, *this_pktl;
2625

    
2626
    this_pktl = av_mallocz(sizeof(AVPacketList));
2627
    this_pktl->pkt= *pkt;
2628
    if(pkt->destruct == av_destruct_packet)
2629
        pkt->destruct= NULL; // not shared -> must keep original from being freed
2630
    else
2631
        av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2632

    
2633
    next_point = &s->packet_buffer;
2634
    while(*next_point){
2635
        if(compare(s, &(*next_point)->pkt, pkt))
2636
            break;
2637
        next_point= &(*next_point)->next;
2638
    }
2639
    this_pktl->next= *next_point;
2640
    *next_point= this_pktl;
2641
}
2642

    
2643
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2644
{
2645
    AVStream *st = s->streams[ pkt ->stream_index];
2646
    AVStream *st2= s->streams[ next->stream_index];
2647
    int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2648
    int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2649

    
2650
    if (pkt->dts == AV_NOPTS_VALUE)
2651
        return 0;
2652

    
2653
    return next->dts * left > pkt->dts * right; //FIXME this can overflow
2654
}
2655

    
2656
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2657
    AVPacketList *pktl;
2658
    int stream_count=0;
2659
    int streams[MAX_STREAMS];
2660

    
2661
    if(pkt){
2662
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2663
    }
2664

    
2665
    memset(streams, 0, sizeof(streams));
2666
    pktl= s->packet_buffer;
2667
    while(pktl){
2668
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2669
        if(streams[ pktl->pkt.stream_index ] == 0)
2670
            stream_count++;
2671
        streams[ pktl->pkt.stream_index ]++;
2672
        pktl= pktl->next;
2673
    }
2674

    
2675
    if(stream_count && (s->nb_streams == stream_count || flush)){
2676
        pktl= s->packet_buffer;
2677
        *out= pktl->pkt;
2678

    
2679
        s->packet_buffer= pktl->next;
2680
        av_freep(&pktl);
2681
        return 1;
2682
    }else{
2683
        av_init_packet(out);
2684
        return 0;
2685
    }
2686
}
2687

    
2688
/**
2689
 * Interleaves an AVPacket correctly so it can be muxed.
2690
 * @param out the interleaved packet will be output here
2691
 * @param in the input packet
2692
 * @param flush 1 if no further packets are available as input and all
2693
 *              remaining packets should be output
2694
 * @return 1 if a packet was output, 0 if no packet could be output,
2695
 *         < 0 if an error occurred
2696
 */
2697
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2698
    if(s->oformat->interleave_packet)
2699
        return s->oformat->interleave_packet(s, out, in, flush);
2700
    else
2701
        return av_interleave_packet_per_dts(s, out, in, flush);
2702
}
2703

    
2704
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2705
    AVStream *st= s->streams[ pkt->stream_index];
2706

    
2707
    //FIXME/XXX/HACK drop zero sized packets
2708
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2709
        return 0;
2710

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

    
2715
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2716
        return -1;
2717

    
2718
    for(;;){
2719
        AVPacket opkt;
2720
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2721
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2722
            return ret;
2723

    
2724
        ret= s->oformat->write_packet(s, &opkt);
2725

    
2726
        av_free_packet(&opkt);
2727
        pkt= NULL;
2728

    
2729
        if(ret<0)
2730
            return ret;
2731
        if(url_ferror(s->pb))
2732
            return url_ferror(s->pb);
2733
    }
2734
}
2735

    
2736
int av_write_trailer(AVFormatContext *s)
2737
{
2738
    int ret, i;
2739

    
2740
    for(;;){
2741
        AVPacket pkt;
2742
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2743
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2744
            goto fail;
2745
        if(!ret)
2746
            break;
2747

    
2748
        ret= s->oformat->write_packet(s, &pkt);
2749

    
2750
        av_free_packet(&pkt);
2751

    
2752
        if(ret<0)
2753
            goto fail;
2754
        if(url_ferror(s->pb))
2755
            goto fail;
2756
    }
2757

    
2758
    if(s->oformat->write_trailer)
2759
        ret = s->oformat->write_trailer(s);
2760
fail:
2761
    if(ret == 0)
2762
       ret=url_ferror(s->pb);
2763
    for(i=0;i<s->nb_streams;i++)
2764
        av_freep(&s->streams[i]->priv_data);
2765
    av_freep(&s->priv_data);
2766
    return ret;
2767
}
2768

    
2769
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2770
{
2771
    int i, j;
2772
    AVProgram *program=NULL;
2773
    void *tmp;
2774

    
2775
    for(i=0; i<ac->nb_programs; i++){
2776
        if(ac->programs[i]->id != progid)
2777
            continue;
2778
        program = ac->programs[i];
2779
        for(j=0; j<program->nb_stream_indexes; j++)
2780
            if(program->stream_index[j] == idx)
2781
                return;
2782

    
2783
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2784
        if(!tmp)
2785
            return;
2786
        program->stream_index = tmp;
2787
        program->stream_index[program->nb_stream_indexes++] = idx;
2788
        return;
2789
    }
2790
}
2791

    
2792
static void print_fps(double d, const char *postfix){
2793
    uint64_t v= lrintf(d*100);
2794
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2795
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2796
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2797
}
2798

    
2799
/* "user interface" functions */
2800
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2801
{
2802
    char buf[256];
2803
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2804
    AVStream *st = ic->streams[i];
2805
    int g = av_gcd(st->time_base.num, st->time_base.den);
2806
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2807
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2808
    /* the pid is an important information, so we display it */
2809
    /* XXX: add a generic system */
2810
    if (flags & AVFMT_SHOW_IDS)
2811
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2812
    if (strlen(st->language) > 0)
2813
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2814
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2815
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2816
    if (st->sample_aspect_ratio.num && // default
2817
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2818
        AVRational display_aspect_ratio;
2819
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2820
                  st->codec->width*st->sample_aspect_ratio.num,
2821
                  st->codec->height*st->sample_aspect_ratio.den,
2822
                  1024*1024);
2823
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2824
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2825
                 display_aspect_ratio.num, display_aspect_ratio.den);
2826
    }
2827
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2828
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2829
            print_fps(av_q2d(st->r_frame_rate), "tbr");
2830
        if(st->time_base.den && st->time_base.num)
2831
            print_fps(1/av_q2d(st->time_base), "tbn");
2832
        if(st->codec->time_base.den && st->codec->time_base.num)
2833
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
2834
    }
2835
    av_log(NULL, AV_LOG_INFO, "\n");
2836
}
2837

    
2838
void dump_format(AVFormatContext *ic,
2839
                 int index,
2840
                 const char *url,
2841
                 int is_output)
2842
{
2843
    int i;
2844

    
2845
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2846
            is_output ? "Output" : "Input",
2847
            index,
2848
            is_output ? ic->oformat->name : ic->iformat->name,
2849
            is_output ? "to" : "from", url);
2850
    if (!is_output) {
2851
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2852
        if (ic->duration != AV_NOPTS_VALUE) {
2853
            int hours, mins, secs, us;
2854
            secs = ic->duration / AV_TIME_BASE;
2855
            us = ic->duration % AV_TIME_BASE;
2856
            mins = secs / 60;
2857
            secs %= 60;
2858
            hours = mins / 60;
2859
            mins %= 60;
2860
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2861
                   (100 * us) / AV_TIME_BASE);
2862
        } else {
2863
            av_log(NULL, AV_LOG_INFO, "N/A");
2864
        }
2865
        if (ic->start_time != AV_NOPTS_VALUE) {
2866
            int secs, us;
2867
            av_log(NULL, AV_LOG_INFO, ", start: ");
2868
            secs = ic->start_time / AV_TIME_BASE;
2869
            us = ic->start_time % AV_TIME_BASE;
2870
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2871
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2872
        }
2873
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2874
        if (ic->bit_rate) {
2875
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2876
        } else {
2877
            av_log(NULL, AV_LOG_INFO, "N/A");
2878
        }
2879
        av_log(NULL, AV_LOG_INFO, "\n");
2880
    }
2881
    if(ic->nb_programs) {
2882
        int j, k;
2883
        for(j=0; j<ic->nb_programs; j++) {
2884
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2885
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2886
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2887
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2888
         }
2889
    } else
2890
    for(i=0;i<ic->nb_streams;i++)
2891
        dump_stream_format(ic, i, index, is_output);
2892
}
2893

    
2894
#if LIBAVFORMAT_VERSION_MAJOR < 53
2895
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2896
{
2897
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2898
}
2899

    
2900
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2901
{
2902
    AVRational frame_rate;
2903
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2904
    *frame_rate_num= frame_rate.num;
2905
    *frame_rate_den= frame_rate.den;
2906
    return ret;
2907
}
2908
#endif
2909

    
2910
int64_t av_gettime(void)
2911
{
2912
    struct timeval tv;
2913
    gettimeofday(&tv,NULL);
2914
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2915
}
2916

    
2917
int64_t parse_date(const char *datestr, int duration)
2918
{
2919
    const char *p;
2920
    int64_t t;
2921
    struct tm dt;
2922
    int i;
2923
    static const char * const date_fmt[] = {
2924
        "%Y-%m-%d",
2925
        "%Y%m%d",
2926
    };
2927
    static const char * const time_fmt[] = {
2928
        "%H:%M:%S",
2929
        "%H%M%S",
2930
    };
2931
    const char *q;
2932
    int is_utc, len;
2933
    char lastch;
2934
    int negative = 0;
2935

    
2936
#undef time
2937
    time_t now = time(0);
2938

    
2939
    len = strlen(datestr);
2940
    if (len > 0)
2941
        lastch = datestr[len - 1];
2942
    else
2943
        lastch = '\0';
2944
    is_utc = (lastch == 'z' || lastch == 'Z');
2945

    
2946
    memset(&dt, 0, sizeof(dt));
2947

    
2948
    p = datestr;
2949
    q = NULL;
2950
    if (!duration) {
2951
        if (!strncasecmp(datestr, "now", len))
2952
            return (int64_t) now * 1000000;
2953

    
2954
        /* parse the year-month-day part */
2955
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2956
            q = small_strptime(p, date_fmt[i], &dt);
2957
            if (q) {
2958
                break;
2959
            }
2960
        }
2961

    
2962
        /* if the year-month-day part is missing, then take the
2963
         * current year-month-day time */
2964
        if (!q) {
2965
            if (is_utc) {
2966
                dt = *gmtime(&now);
2967
            } else {
2968
                dt = *localtime(&now);
2969
            }
2970
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2971
        } else {
2972
            p = q;
2973
        }
2974

    
2975
        if (*p == 'T' || *p == 't' || *p == ' ')
2976
            p++;
2977

    
2978
        /* parse the hour-minute-second part */
2979
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2980
            q = small_strptime(p, time_fmt[i], &dt);
2981
            if (q) {
2982
                break;
2983
            }
2984
        }
2985
    } else {
2986
        /* parse datestr as a duration */
2987
        if (p[0] == '-') {
2988
            negative = 1;
2989
            ++p;
2990
        }
2991
        /* parse datestr as HH:MM:SS */
2992
        q = small_strptime(p, time_fmt[0], &dt);
2993
        if (!q) {
2994
            /* parse datestr as S+ */
2995
            dt.tm_sec = strtol(p, (char **)&q, 10);
2996
            if (q == p)
2997
                /* the parsing didn't succeed */
2998
                return INT64_MIN;
2999
            dt.tm_min = 0;
3000
            dt.tm_hour = 0;
3001
        }
3002
    }
3003

    
3004
    /* Now we have all the fields that we can get */
3005
    if (!q) {
3006
        return INT64_MIN;
3007
    }
3008

    
3009
    if (duration) {
3010
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3011
    } else {
3012
        dt.tm_isdst = -1;       /* unknown */
3013
        if (is_utc) {
3014
            t = mktimegm(&dt);
3015
        } else {
3016
            t = mktime(&dt);
3017
        }
3018
    }
3019

    
3020
    t *= 1000000;
3021

    
3022
    /* parse the .m... part */
3023
    if (*q == '.') {
3024
        int val, n;
3025
        q++;
3026
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3027
            if (!isdigit(*q))
3028
                break;
3029
            val += n * (*q - '0');
3030
        }
3031
        t += val;
3032
    }
3033
    return negative ? -t : t;
3034
}
3035

    
3036
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3037
{
3038
    const char *p;
3039
    char tag[128], *q;
3040

    
3041
    p = info;
3042
    if (*p == '?')
3043
        p++;
3044
    for(;;) {
3045
        q = tag;
3046
        while (*p != '\0' && *p != '=' && *p != '&') {
3047
            if ((q - tag) < sizeof(tag) - 1)
3048
                *q++ = *p;
3049
            p++;
3050
        }
3051
        *q = '\0';
3052
        q = arg;
3053
        if (*p == '=') {
3054
            p++;
3055
            while (*p != '&' && *p != '\0') {
3056
                if ((q - arg) < arg_size - 1) {
3057
                    if (*p == '+')
3058
                        *q++ = ' ';
3059
                    else
3060
                        *q++ = *p;
3061
                }
3062
                p++;
3063
            }
3064
            *q = '\0';
3065
        }
3066
        if (!strcmp(tag, tag1))
3067
            return 1;
3068
        if (*p != '&')
3069
            break;
3070
        p++;
3071
    }
3072
    return 0;
3073
}
3074

    
3075
int av_get_frame_filename(char *buf, int buf_size,
3076
                          const char *path, int number)
3077
{
3078
    const char *p;
3079
    char *q, buf1[20], c;
3080
    int nd, len, percentd_found;
3081

    
3082
    q = buf;
3083
    p = path;
3084
    percentd_found = 0;
3085
    for(;;) {
3086
        c = *p++;
3087
        if (c == '\0')
3088
            break;
3089
        if (c == '%') {
3090
            do {
3091
                nd = 0;
3092
                while (isdigit(*p)) {
3093
                    nd = nd * 10 + *p++ - '0';
3094
                }
3095
                c = *p++;
3096
            } while (isdigit(c));
3097

    
3098
            switch(c) {
3099
            case '%':
3100
                goto addchar;
3101
            case 'd':
3102
                if (percentd_found)
3103
                    goto fail;
3104
                percentd_found = 1;
3105
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3106
                len = strlen(buf1);
3107
                if ((q - buf + len) > buf_size - 1)
3108
                    goto fail;
3109
                memcpy(q, buf1, len);
3110
                q += len;
3111
                break;
3112
            default:
3113
                goto fail;
3114
            }
3115
        } else {
3116
        addchar:
3117
            if ((q - buf) < buf_size - 1)
3118
                *q++ = c;
3119
        }
3120
    }
3121
    if (!percentd_found)
3122
        goto fail;
3123
    *q = '\0';
3124
    return 0;
3125
 fail:
3126
    *q = '\0';
3127
    return -1;
3128
}
3129

    
3130
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3131
{
3132
    int len, i, j, c;
3133
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3134

    
3135
    for(i=0;i<size;i+=16) {
3136
        len = size - i;
3137
        if (len > 16)
3138
            len = 16;
3139
        PRINT("%08x ", i);
3140
        for(j=0;j<16;j++) {
3141
            if (j < len)
3142
                PRINT(" %02x", buf[i+j]);
3143
            else
3144
                PRINT("   ");
3145
        }
3146
        PRINT(" ");
3147
        for(j=0;j<len;j++) {
3148
            c = buf[i+j];
3149
            if (c < ' ' || c > '~')
3150
                c = '.';
3151
            PRINT("%c", c);
3152
        }
3153
        PRINT("\n");
3154
    }
3155
#undef PRINT
3156
}
3157

    
3158
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3159
{
3160
    hex_dump_internal(NULL, f, 0, buf, size);
3161
}
3162

    
3163
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3164
{
3165
    hex_dump_internal(avcl, NULL, level, buf, size);
3166
}
3167

    
3168
 //FIXME needs to know the time_base
3169
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3170
{
3171
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3172
    PRINT("stream #%d:\n", pkt->stream_index);
3173
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3174
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3175
    /* DTS is _always_ valid after av_read_frame() */
3176
    PRINT("  dts=");
3177
    if (pkt->dts == AV_NOPTS_VALUE)
3178
        PRINT("N/A");
3179
    else
3180
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3181
    /* PTS may not be known if B-frames are present. */
3182
    PRINT("  pts=");
3183
    if (pkt->pts == AV_NOPTS_VALUE)
3184
        PRINT("N/A");
3185
    else
3186
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3187
    PRINT("\n");
3188
    PRINT("  size=%d\n", pkt->size);
3189
#undef PRINT
3190
    if (dump_payload)
3191
        av_hex_dump(f, pkt->data, pkt->size);
3192
}
3193

    
3194
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3195
{
3196
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3197
}
3198

    
3199
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3200
{
3201
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3202
}
3203

    
3204
void url_split(char *proto, int proto_size,
3205
               char *authorization, int authorization_size,
3206
               char *hostname, int hostname_size,
3207
               int *port_ptr,
3208
               char *path, int path_size,
3209
               const char *url)
3210
{
3211
    const char *p, *ls, *at, *col, *brk;
3212

    
3213
    if (port_ptr)               *port_ptr = -1;
3214
    if (proto_size > 0)         proto[0] = 0;
3215
    if (authorization_size > 0) authorization[0] = 0;
3216
    if (hostname_size > 0)      hostname[0] = 0;
3217
    if (path_size > 0)          path[0] = 0;
3218

    
3219
    /* parse protocol */
3220
    if ((p = strchr(url, ':'))) {
3221
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3222
        p++; /* skip ':' */
3223
        if (*p == '/') p++;
3224
        if (*p == '/') p++;
3225
    } else {
3226
        /* no protocol means plain filename */
3227
        av_strlcpy(path, url, path_size);
3228
        return;
3229
    }
3230

    
3231
    /* separate path from hostname */
3232
    ls = strchr(p, '/');
3233
    if(!ls)
3234
        ls = strchr(p, '?');
3235
    if(ls)
3236
        av_strlcpy(path, ls, path_size);
3237
    else
3238
        ls = &p[strlen(p)]; // XXX
3239

    
3240
    /* the rest is hostname, use that to parse auth/port */
3241
    if (ls != p) {
3242
        /* authorization (user[:pass]@hostname) */
3243
        if ((at = strchr(p, '@')) && at < ls) {
3244
            av_strlcpy(authorization, p,
3245
                       FFMIN(authorization_size, at + 1 - p));
3246
            p = at + 1; /* skip '@' */
3247
        }
3248

    
3249
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3250
            /* [host]:port */
3251
            av_strlcpy(hostname, p + 1,
3252
                       FFMIN(hostname_size, brk - p));
3253
            if (brk[1] == ':' && port_ptr)
3254
                *port_ptr = atoi(brk + 2);
3255
        } else if ((col = strchr(p, ':')) && col < ls) {
3256
            av_strlcpy(hostname, p,
3257
                       FFMIN(col + 1 - p, hostname_size));
3258
            if (port_ptr) *port_ptr = atoi(col + 1);
3259
        } else
3260
            av_strlcpy(hostname, p,
3261
                       FFMIN(ls + 1 - p, hostname_size));
3262
    }
3263
}
3264

    
3265
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3266
{
3267
    int i;
3268
    static const char hex_table[16] = { '0', '1', '2', '3',
3269
                                        '4', '5', '6', '7',
3270
                                        '8', '9', 'A', 'B',
3271
                                        'C', 'D', 'E', 'F' };
3272

    
3273
    for(i = 0; i < s; i++) {
3274
        buff[i * 2]     = hex_table[src[i] >> 4];
3275
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3276
    }
3277

    
3278
    return buff;
3279
}
3280

    
3281
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3282
                     int pts_num, int pts_den)
3283
{
3284
    unsigned int gcd= av_gcd(pts_num, pts_den);
3285
    s->pts_wrap_bits = pts_wrap_bits;
3286
    s->time_base.num = pts_num/gcd;
3287
    s->time_base.den = pts_den/gcd;
3288

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