Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 8e2fd8e1

History | View | Annotate | Download (98.3 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
                *pden *= 2;
684
                *pnum = (*pnum) * (2 + pc->repeat_pict);
685
            }
686
        }
687
        break;
688
    case CODEC_TYPE_AUDIO:
689
        frame_size = get_audio_frame_size(st->codec, pkt->size);
690
        if (frame_size < 0)
691
            break;
692
        *pnum = frame_size;
693
        *pden = st->codec->sample_rate;
694
        break;
695
    default:
696
        break;
697
    }
698
}
699

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
838
    /* This may be redundant, but it should not hurt. */
839
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
840
        presentation_delayed = 1;
841

    
842
//    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);
843
    /* interpolate PTS and DTS if they are not present */
844
    if(delay==0 || (delay==1 && pc)){
845
        if (presentation_delayed) {
846
            /* DTS = decompression timestamp */
847
            /* PTS = presentation timestamp */
848
            if (pkt->dts == AV_NOPTS_VALUE)
849
                pkt->dts = st->last_IP_pts;
850
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
851
            if (pkt->dts == AV_NOPTS_VALUE)
852
                pkt->dts = st->cur_dts;
853

    
854
            /* this is tricky: the dts must be incremented by the duration
855
            of the frame we are displaying, i.e. the last I- or P-frame */
856
            if (st->last_IP_duration == 0)
857
                st->last_IP_duration = pkt->duration;
858
            if(pkt->dts != AV_NOPTS_VALUE)
859
                st->cur_dts = pkt->dts + st->last_IP_duration;
860
            st->last_IP_duration  = pkt->duration;
861
            st->last_IP_pts= pkt->pts;
862
            /* cannot compute PTS if not present (we can compute it only
863
            by knowing the future */
864
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
865
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
866
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
867
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
868
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
869
                    pkt->pts += pkt->duration;
870
    //                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);
871
                }
872
            }
873

    
874
            /* presentation is not delayed : PTS and DTS are the same */
875
            if(pkt->pts == AV_NOPTS_VALUE)
876
                pkt->pts = pkt->dts;
877
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
878
            if(pkt->pts == AV_NOPTS_VALUE)
879
                pkt->pts = st->cur_dts;
880
            pkt->dts = pkt->pts;
881
            if(pkt->pts != AV_NOPTS_VALUE)
882
                st->cur_dts = pkt->pts + pkt->duration;
883
        }
884
    }
885

    
886
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
887
        st->pts_buffer[0]= pkt->pts;
888
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
889
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
890
        if(pkt->dts == AV_NOPTS_VALUE)
891
            pkt->dts= st->pts_buffer[0];
892
        if(delay>1){
893
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
894
        }
895
        if(pkt->dts > st->cur_dts)
896
            st->cur_dts = pkt->dts;
897
    }
898

    
899
//    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);
900

    
901
    /* update flags */
902
    if(is_intra_only(st->codec))
903
        pkt->flags |= PKT_FLAG_KEY;
904
    else if (pc) {
905
        pkt->flags = 0;
906
        /* keyframe computation */
907
            if (pc->pict_type == FF_I_TYPE)
908
                pkt->flags |= PKT_FLAG_KEY;
909
    }
910
}
911

    
912
void av_destruct_packet_nofree(AVPacket *pkt)
913
{
914
    pkt->data = NULL; pkt->size = 0;
915
}
916

    
917
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
918
{
919
    AVStream *st;
920
    int len, ret, i;
921

    
922
    av_init_packet(pkt);
923

    
924
    for(;;) {
925
        /* select current input stream component */
926
        st = s->cur_st;
927
        if (st) {
928
            if (!st->need_parsing || !st->parser) {
929
                /* no parsing needed: we just output the packet as is */
930
                /* raw data support */
931
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
932
                compute_pkt_fields(s, st, NULL, pkt);
933
                s->cur_st = NULL;
934
                break;
935
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
936
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
937
                                      st->cur_ptr, st->cur_len,
938
                                      st->cur_pkt.pts, st->cur_pkt.dts);
939
                st->cur_pkt.pts = AV_NOPTS_VALUE;
940
                st->cur_pkt.dts = AV_NOPTS_VALUE;
941
                /* increment read pointer */
942
                st->cur_ptr += len;
943
                st->cur_len -= len;
944

    
945
                /* return packet if any */
946
                if (pkt->size) {
947
                    pkt->pos = st->cur_pkt.pos;              // Isn't quite accurate but close.
948
                got_packet:
949
                    pkt->duration = 0;
950
                    pkt->stream_index = st->index;
951
                    pkt->pts = st->parser->pts;
952
                    pkt->dts = st->parser->dts;
953
                    pkt->destruct = av_destruct_packet_nofree;
954
                    compute_pkt_fields(s, st, st->parser, pkt);
955

    
956
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
957
                        ff_reduce_index(s, st->index);
958
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
959
                                           0, 0, AVINDEX_KEYFRAME);
960
                    }
961

    
962
                    break;
963
                }
964
            } else {
965
                /* free packet */
966
                av_free_packet(&st->cur_pkt);
967
                s->cur_st = NULL;
968
            }
969
        } else {
970
            AVPacket cur_pkt;
971
            /* read next packet */
972
            ret = av_read_packet(s, &cur_pkt);
973
            if (ret < 0) {
974
                if (ret == AVERROR(EAGAIN))
975
                    return ret;
976
                /* return the last frames, if any */
977
                for(i = 0; i < s->nb_streams; i++) {
978
                    st = s->streams[i];
979
                    if (st->parser && st->need_parsing) {
980
                        av_parser_parse(st->parser, st->codec,
981
                                        &pkt->data, &pkt->size,
982
                                        NULL, 0,
983
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
984
                        if (pkt->size)
985
                            goto got_packet;
986
                    }
987
                }
988
                /* no more packets: really terminate parsing */
989
                return ret;
990
            }
991
            st = s->streams[cur_pkt.stream_index];
992
            st->cur_pkt= cur_pkt;
993

    
994
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
995
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
996
               st->cur_pkt.pts < st->cur_pkt.dts){
997
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
998
                    st->cur_pkt.stream_index,
999
                    st->cur_pkt.pts,
1000
                    st->cur_pkt.dts,
1001
                    st->cur_pkt.size);
1002
//                av_free_packet(&st->cur_pkt);
1003
//                return -1;
1004
            }
1005

    
1006
            if(s->debug & FF_FDEBUG_TS)
1007
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
1008
                    st->cur_pkt.stream_index,
1009
                    st->cur_pkt.pts,
1010
                    st->cur_pkt.dts,
1011
                    st->cur_pkt.size,
1012
                    st->cur_pkt.flags);
1013

    
1014
            s->cur_st = st;
1015
            st->cur_ptr = st->cur_pkt.data;
1016
            st->cur_len = st->cur_pkt.size;
1017
            if (st->need_parsing && !st->parser) {
1018
                st->parser = av_parser_init(st->codec->codec_id);
1019
                if (!st->parser) {
1020
                    /* no parser available: just output the raw packets */
1021
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1022
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1023
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1024
                }
1025
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1026
                    st->parser->next_frame_offset=
1027
                    st->parser->cur_offset= st->cur_pkt.pos;
1028
                }
1029
            }
1030
        }
1031
    }
1032
    if(s->debug & FF_FDEBUG_TS)
1033
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1034
            pkt->stream_index,
1035
            pkt->pts,
1036
            pkt->dts,
1037
            pkt->size,
1038
            pkt->flags);
1039

    
1040
    return 0;
1041
}
1042

    
1043
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1044
{
1045
    AVPacketList *pktl;
1046
    int eof=0;
1047
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1048

    
1049
    for(;;){
1050
        pktl = s->packet_buffer;
1051
        if (pktl) {
1052
            AVPacket *next_pkt= &pktl->pkt;
1053

    
1054
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1055
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1056
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1057
                       && next_pkt->dts < pktl->pkt.dts
1058
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1059
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1060
                        next_pkt->pts= pktl->pkt.dts;
1061
                    }
1062
                    pktl= pktl->next;
1063
                }
1064
                pktl = s->packet_buffer;
1065
            }
1066

    
1067
            if(   next_pkt->pts != AV_NOPTS_VALUE
1068
               || next_pkt->dts == AV_NOPTS_VALUE
1069
               || !genpts || eof){
1070
                /* read packet from packet buffer, if there is data */
1071
                *pkt = *next_pkt;
1072
                s->packet_buffer = pktl->next;
1073
                av_free(pktl);
1074
                return 0;
1075
            }
1076
        }
1077
        if(genpts){
1078
            int ret= av_read_frame_internal(s, pkt);
1079
            if(ret<0){
1080
                if(pktl && ret != AVERROR(EAGAIN)){
1081
                    eof=1;
1082
                    continue;
1083
                }else
1084
                    return ret;
1085
            }
1086

    
1087
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1088
                                           &s->packet_buffer_end)) < 0)
1089
                return AVERROR(ENOMEM);
1090
        }else{
1091
            assert(!s->packet_buffer);
1092
            return av_read_frame_internal(s, pkt);
1093
        }
1094
    }
1095
}
1096

    
1097
/* XXX: suppress the packet queue */
1098
static void flush_packet_queue(AVFormatContext *s)
1099
{
1100
    AVPacketList *pktl;
1101

    
1102
    for(;;) {
1103
        pktl = s->packet_buffer;
1104
        if (!pktl)
1105
            break;
1106
        s->packet_buffer = pktl->next;
1107
        av_free_packet(&pktl->pkt);
1108
        av_free(pktl);
1109
    }
1110
}
1111

    
1112
/*******************************************************/
1113
/* seek support */
1114

    
1115
int av_find_default_stream_index(AVFormatContext *s)
1116
{
1117
    int first_audio_index = -1;
1118
    int i;
1119
    AVStream *st;
1120

    
1121
    if (s->nb_streams <= 0)
1122
        return -1;
1123
    for(i = 0; i < s->nb_streams; i++) {
1124
        st = s->streams[i];
1125
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1126
            return i;
1127
        }
1128
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1129
            first_audio_index = i;
1130
    }
1131
    return first_audio_index >= 0 ? first_audio_index : 0;
1132
}
1133

    
1134
/**
1135
 * Flush the frame reader.
1136
 */
1137
static void av_read_frame_flush(AVFormatContext *s)
1138
{
1139
    AVStream *st;
1140
    int i;
1141

    
1142
    flush_packet_queue(s);
1143

    
1144
    s->cur_st = NULL;
1145

    
1146
    /* for each stream, reset read state */
1147
    for(i = 0; i < s->nb_streams; i++) {
1148
        st = s->streams[i];
1149

    
1150
        if (st->parser) {
1151
            av_parser_close(st->parser);
1152
            st->parser = NULL;
1153
            av_free_packet(&st->cur_pkt);
1154
        }
1155
        st->last_IP_pts = AV_NOPTS_VALUE;
1156
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1157
        /* fail safe */
1158
        st->cur_ptr = NULL;
1159
        st->cur_len = 0;
1160
    }
1161
}
1162

    
1163
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1164
    int i;
1165

    
1166
    for(i = 0; i < s->nb_streams; i++) {
1167
        AVStream *st = s->streams[i];
1168

    
1169
        st->cur_dts = av_rescale(timestamp,
1170
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1171
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1172
    }
1173
}
1174

    
1175
void ff_reduce_index(AVFormatContext *s, int stream_index)
1176
{
1177
    AVStream *st= s->streams[stream_index];
1178
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1179

    
1180
    if((unsigned)st->nb_index_entries >= max_entries){
1181
        int i;
1182
        for(i=0; 2*i<st->nb_index_entries; i++)
1183
            st->index_entries[i]= st->index_entries[2*i];
1184
        st->nb_index_entries= i;
1185
    }
1186
}
1187

    
1188
int av_add_index_entry(AVStream *st,
1189
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1190
{
1191
    AVIndexEntry *entries, *ie;
1192
    int index;
1193

    
1194
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1195
        return -1;
1196

    
1197
    entries = av_fast_realloc(st->index_entries,
1198
                              &st->index_entries_allocated_size,
1199
                              (st->nb_index_entries + 1) *
1200
                              sizeof(AVIndexEntry));
1201
    if(!entries)
1202
        return -1;
1203

    
1204
    st->index_entries= entries;
1205

    
1206
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1207

    
1208
    if(index<0){
1209
        index= st->nb_index_entries++;
1210
        ie= &entries[index];
1211
        assert(index==0 || ie[-1].timestamp < timestamp);
1212
    }else{
1213
        ie= &entries[index];
1214
        if(ie->timestamp != timestamp){
1215
            if(ie->timestamp <= timestamp)
1216
                return -1;
1217
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1218
            st->nb_index_entries++;
1219
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1220
            distance= ie->min_distance;
1221
    }
1222

    
1223
    ie->pos = pos;
1224
    ie->timestamp = timestamp;
1225
    ie->min_distance= distance;
1226
    ie->size= size;
1227
    ie->flags = flags;
1228

    
1229
    return index;
1230
}
1231

    
1232
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1233
                              int flags)
1234
{
1235
    AVIndexEntry *entries= st->index_entries;
1236
    int nb_entries= st->nb_index_entries;
1237
    int a, b, m;
1238
    int64_t timestamp;
1239

    
1240
    a = - 1;
1241
    b = nb_entries;
1242

    
1243
    while (b - a > 1) {
1244
        m = (a + b) >> 1;
1245
        timestamp = entries[m].timestamp;
1246
        if(timestamp >= wanted_timestamp)
1247
            b = m;
1248
        if(timestamp <= wanted_timestamp)
1249
            a = m;
1250
    }
1251
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1252

    
1253
    if(!(flags & AVSEEK_FLAG_ANY)){
1254
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1255
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1256
        }
1257
    }
1258

    
1259
    if(m == nb_entries)
1260
        return -1;
1261
    return  m;
1262
}
1263

    
1264
#define DEBUG_SEEK
1265

    
1266
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1267
    AVInputFormat *avif= s->iformat;
1268
    int64_t pos_min, pos_max, pos, pos_limit;
1269
    int64_t ts_min, ts_max, ts;
1270
    int index;
1271
    AVStream *st;
1272

    
1273
    if (stream_index < 0)
1274
        return -1;
1275

    
1276
#ifdef DEBUG_SEEK
1277
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1278
#endif
1279

    
1280
    ts_max=
1281
    ts_min= AV_NOPTS_VALUE;
1282
    pos_limit= -1; //gcc falsely says it may be uninitialized
1283

    
1284
    st= s->streams[stream_index];
1285
    if(st->index_entries){
1286
        AVIndexEntry *e;
1287

    
1288
        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()
1289
        index= FFMAX(index, 0);
1290
        e= &st->index_entries[index];
1291

    
1292
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1293
            pos_min= e->pos;
1294
            ts_min= e->timestamp;
1295
#ifdef DEBUG_SEEK
1296
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1297
               pos_min,ts_min);
1298
#endif
1299
        }else{
1300
            assert(index==0);
1301
        }
1302

    
1303
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1304
        assert(index < st->nb_index_entries);
1305
        if(index >= 0){
1306
            e= &st->index_entries[index];
1307
            assert(e->timestamp >= target_ts);
1308
            pos_max= e->pos;
1309
            ts_max= e->timestamp;
1310
            pos_limit= pos_max - e->min_distance;
1311
#ifdef DEBUG_SEEK
1312
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1313
               pos_max,pos_limit, ts_max);
1314
#endif
1315
        }
1316
    }
1317

    
1318
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1319
    if(pos<0)
1320
        return -1;
1321

    
1322
    /* do the seek */
1323
    url_fseek(s->pb, pos, SEEK_SET);
1324

    
1325
    av_update_cur_dts(s, st, ts);
1326

    
1327
    return 0;
1328
}
1329

    
1330
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 )){
1331
    int64_t pos, ts;
1332
    int64_t start_pos, filesize;
1333
    int no_change;
1334

    
1335
#ifdef DEBUG_SEEK
1336
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1337
#endif
1338

    
1339
    if(ts_min == AV_NOPTS_VALUE){
1340
        pos_min = s->data_offset;
1341
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1342
        if (ts_min == AV_NOPTS_VALUE)
1343
            return -1;
1344
    }
1345

    
1346
    if(ts_max == AV_NOPTS_VALUE){
1347
        int step= 1024;
1348
        filesize = url_fsize(s->pb);
1349
        pos_max = filesize - 1;
1350
        do{
1351
            pos_max -= step;
1352
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1353
            step += step;
1354
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1355
        if (ts_max == AV_NOPTS_VALUE)
1356
            return -1;
1357

    
1358
        for(;;){
1359
            int64_t tmp_pos= pos_max + 1;
1360
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1361
            if(tmp_ts == AV_NOPTS_VALUE)
1362
                break;
1363
            ts_max= tmp_ts;
1364
            pos_max= tmp_pos;
1365
            if(tmp_pos >= filesize)
1366
                break;
1367
        }
1368
        pos_limit= pos_max;
1369
    }
1370

    
1371
    if(ts_min > ts_max){
1372
        return -1;
1373
    }else if(ts_min == ts_max){
1374
        pos_limit= pos_min;
1375
    }
1376

    
1377
    no_change=0;
1378
    while (pos_min < pos_limit) {
1379
#ifdef DEBUG_SEEK
1380
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1381
               pos_min, pos_max,
1382
               ts_min, ts_max);
1383
#endif
1384
        assert(pos_limit <= pos_max);
1385

    
1386
        if(no_change==0){
1387
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1388
            // interpolate position (better than dichotomy)
1389
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1390
                + pos_min - approximate_keyframe_distance;
1391
        }else if(no_change==1){
1392
            // bisection, if interpolation failed to change min or max pos last time
1393
            pos = (pos_min + pos_limit)>>1;
1394
        }else{
1395
            /* linear search if bisection failed, can only happen if there
1396
               are very few or no keyframes between min/max */
1397
            pos=pos_min;
1398
        }
1399
        if(pos <= pos_min)
1400
            pos= pos_min + 1;
1401
        else if(pos > pos_limit)
1402
            pos= pos_limit;
1403
        start_pos= pos;
1404

    
1405
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1406
        if(pos == pos_max)
1407
            no_change++;
1408
        else
1409
            no_change=0;
1410
#ifdef DEBUG_SEEK
1411
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);
1412
#endif
1413
        if(ts == AV_NOPTS_VALUE){
1414
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1415
            return -1;
1416
        }
1417
        assert(ts != AV_NOPTS_VALUE);
1418
        if (target_ts <= ts) {
1419
            pos_limit = start_pos - 1;
1420
            pos_max = pos;
1421
            ts_max = ts;
1422
        }
1423
        if (target_ts >= ts) {
1424
            pos_min = pos;
1425
            ts_min = ts;
1426
        }
1427
    }
1428

    
1429
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1430
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1431
#ifdef DEBUG_SEEK
1432
    pos_min = pos;
1433
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1434
    pos_min++;
1435
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1436
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1437
           pos, ts_min, target_ts, ts_max);
1438
#endif
1439
    *ts_ret= ts;
1440
    return pos;
1441
}
1442

    
1443
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1444
    int64_t pos_min, pos_max;
1445
#if 0
1446
    AVStream *st;
1447

1448
    if (stream_index < 0)
1449
        return -1;
1450

1451
    st= s->streams[stream_index];
1452
#endif
1453

    
1454
    pos_min = s->data_offset;
1455
    pos_max = url_fsize(s->pb) - 1;
1456

    
1457
    if     (pos < pos_min) pos= pos_min;
1458
    else if(pos > pos_max) pos= pos_max;
1459

    
1460
    url_fseek(s->pb, pos, SEEK_SET);
1461

    
1462
#if 0
1463
    av_update_cur_dts(s, st, ts);
1464
#endif
1465
    return 0;
1466
}
1467

    
1468
static int av_seek_frame_generic(AVFormatContext *s,
1469
                                 int stream_index, int64_t timestamp, int flags)
1470
{
1471
    int index, ret;
1472
    AVStream *st;
1473
    AVIndexEntry *ie;
1474

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

    
1477
    index = av_index_search_timestamp(st, timestamp, flags);
1478

    
1479
    if(index < 0 || index==st->nb_index_entries-1){
1480
        int i;
1481
        AVPacket pkt;
1482

    
1483
        if(st->nb_index_entries){
1484
            assert(st->index_entries);
1485
            ie= &st->index_entries[st->nb_index_entries-1];
1486
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1487
                return ret;
1488
            av_update_cur_dts(s, st, ie->timestamp);
1489
        }else{
1490
            if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1491
                return ret;
1492
        }
1493
        for(i=0;; i++) {
1494
            int ret;
1495
            do{
1496
                ret = av_read_frame(s, &pkt);
1497
            }while(ret == AVERROR(EAGAIN));
1498
            if(ret<0)
1499
                break;
1500
            av_free_packet(&pkt);
1501
            if(stream_index == pkt.stream_index){
1502
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1503
                    break;
1504
            }
1505
        }
1506
        index = av_index_search_timestamp(st, timestamp, flags);
1507
    }
1508
    if (index < 0)
1509
        return -1;
1510

    
1511
    av_read_frame_flush(s);
1512
    if (s->iformat->read_seek){
1513
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1514
            return 0;
1515
    }
1516
    ie = &st->index_entries[index];
1517
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1518
        return ret;
1519
    av_update_cur_dts(s, st, ie->timestamp);
1520

    
1521
    return 0;
1522
}
1523

    
1524
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1525
{
1526
    int ret;
1527
    AVStream *st;
1528

    
1529
    av_read_frame_flush(s);
1530

    
1531
    if(flags & AVSEEK_FLAG_BYTE)
1532
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1533

    
1534
    if(stream_index < 0){
1535
        stream_index= av_find_default_stream_index(s);
1536
        if(stream_index < 0)
1537
            return -1;
1538

    
1539
        st= s->streams[stream_index];
1540
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1541
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1542
    }
1543

    
1544
    /* first, we try the format specific seek */
1545
    if (s->iformat->read_seek)
1546
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1547
    else
1548
        ret = -1;
1549
    if (ret >= 0) {
1550
        return 0;
1551
    }
1552

    
1553
    if(s->iformat->read_timestamp)
1554
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1555
    else
1556
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1557
}
1558

    
1559
/*******************************************************/
1560

    
1561
/**
1562
 * Returns TRUE if the stream has accurate duration in any stream.
1563
 *
1564
 * @return TRUE if the stream has accurate duration for at least one component.
1565
 */
1566
static int av_has_duration(AVFormatContext *ic)
1567
{
1568
    int i;
1569
    AVStream *st;
1570

    
1571
    for(i = 0;i < ic->nb_streams; i++) {
1572
        st = ic->streams[i];
1573
        if (st->duration != AV_NOPTS_VALUE)
1574
            return 1;
1575
    }
1576
    return 0;
1577
}
1578

    
1579
/**
1580
 * Estimate the stream timings from the one of each components.
1581
 *
1582
 * Also computes the global bitrate if possible.
1583
 */
1584
static void av_update_stream_timings(AVFormatContext *ic)
1585
{
1586
    int64_t start_time, start_time1, end_time, end_time1;
1587
    int64_t duration, duration1;
1588
    int i;
1589
    AVStream *st;
1590

    
1591
    start_time = INT64_MAX;
1592
    end_time = INT64_MIN;
1593
    duration = INT64_MIN;
1594
    for(i = 0;i < ic->nb_streams; i++) {
1595
        st = ic->streams[i];
1596
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1597
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1598
            if (start_time1 < start_time)
1599
                start_time = start_time1;
1600
            if (st->duration != AV_NOPTS_VALUE) {
1601
                end_time1 = start_time1
1602
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1603
                if (end_time1 > end_time)
1604
                    end_time = end_time1;
1605
            }
1606
        }
1607
        if (st->duration != AV_NOPTS_VALUE) {
1608
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1609
            if (duration1 > duration)
1610
                duration = duration1;
1611
        }
1612
    }
1613
    if (start_time != INT64_MAX) {
1614
        ic->start_time = start_time;
1615
        if (end_time != INT64_MIN) {
1616
            if (end_time - start_time > duration)
1617
                duration = end_time - start_time;
1618
        }
1619
    }
1620
    if (duration != INT64_MIN) {
1621
        ic->duration = duration;
1622
        if (ic->file_size > 0) {
1623
            /* compute the bitrate */
1624
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1625
                (double)ic->duration;
1626
        }
1627
    }
1628
}
1629

    
1630
static void fill_all_stream_timings(AVFormatContext *ic)
1631
{
1632
    int i;
1633
    AVStream *st;
1634

    
1635
    av_update_stream_timings(ic);
1636
    for(i = 0;i < ic->nb_streams; i++) {
1637
        st = ic->streams[i];
1638
        if (st->start_time == AV_NOPTS_VALUE) {
1639
            if(ic->start_time != AV_NOPTS_VALUE)
1640
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1641
            if(ic->duration != AV_NOPTS_VALUE)
1642
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1643
        }
1644
    }
1645
}
1646

    
1647
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1648
{
1649
    int64_t filesize, duration;
1650
    int bit_rate, i;
1651
    AVStream *st;
1652

    
1653
    /* if bit_rate is already set, we believe it */
1654
    if (ic->bit_rate == 0) {
1655
        bit_rate = 0;
1656
        for(i=0;i<ic->nb_streams;i++) {
1657
            st = ic->streams[i];
1658
            bit_rate += st->codec->bit_rate;
1659
        }
1660
        ic->bit_rate = bit_rate;
1661
    }
1662

    
1663
    /* if duration is already set, we believe it */
1664
    if (ic->duration == AV_NOPTS_VALUE &&
1665
        ic->bit_rate != 0 &&
1666
        ic->file_size != 0)  {
1667
        filesize = ic->file_size;
1668
        if (filesize > 0) {
1669
            for(i = 0; i < ic->nb_streams; i++) {
1670
                st = ic->streams[i];
1671
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1672
                if (st->duration == AV_NOPTS_VALUE)
1673
                    st->duration = duration;
1674
            }
1675
        }
1676
    }
1677
}
1678

    
1679
#define DURATION_MAX_READ_SIZE 250000
1680

    
1681
/* only usable for MPEG-PS streams */
1682
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1683
{
1684
    AVPacket pkt1, *pkt = &pkt1;
1685
    AVStream *st;
1686
    int read_size, i, ret;
1687
    int64_t end_time;
1688
    int64_t filesize, offset, duration;
1689

    
1690
    ic->cur_st = NULL;
1691

    
1692
    /* flush packet queue */
1693
    flush_packet_queue(ic);
1694

    
1695
    for(i=0;i<ic->nb_streams;i++) {
1696
        st = ic->streams[i];
1697
        if (st->parser) {
1698
            av_parser_close(st->parser);
1699
            st->parser= NULL;
1700
            av_free_packet(&st->cur_pkt);
1701
        }
1702
    }
1703

    
1704
    /* we read the first packets to get the first PTS (not fully
1705
       accurate, but it is enough now) */
1706
    url_fseek(ic->pb, 0, SEEK_SET);
1707
    read_size = 0;
1708
    for(;;) {
1709
        if (read_size >= DURATION_MAX_READ_SIZE)
1710
            break;
1711
        /* if all info is available, we can stop */
1712
        for(i = 0;i < ic->nb_streams; i++) {
1713
            st = ic->streams[i];
1714
            if (st->start_time == AV_NOPTS_VALUE)
1715
                break;
1716
        }
1717
        if (i == ic->nb_streams)
1718
            break;
1719

    
1720
        do{
1721
            ret = av_read_packet(ic, pkt);
1722
        }while(ret == AVERROR(EAGAIN));
1723
        if (ret != 0)
1724
            break;
1725
        read_size += pkt->size;
1726
        st = ic->streams[pkt->stream_index];
1727
        if (pkt->pts != AV_NOPTS_VALUE) {
1728
            if (st->start_time == AV_NOPTS_VALUE)
1729
                st->start_time = pkt->pts;
1730
        }
1731
        av_free_packet(pkt);
1732
    }
1733

    
1734
    /* estimate the end time (duration) */
1735
    /* XXX: may need to support wrapping */
1736
    filesize = ic->file_size;
1737
    offset = filesize - DURATION_MAX_READ_SIZE;
1738
    if (offset < 0)
1739
        offset = 0;
1740

    
1741
    url_fseek(ic->pb, offset, SEEK_SET);
1742
    read_size = 0;
1743
    for(;;) {
1744
        if (read_size >= DURATION_MAX_READ_SIZE)
1745
            break;
1746

    
1747
        do{
1748
            ret = av_read_packet(ic, pkt);
1749
        }while(ret == AVERROR(EAGAIN));
1750
        if (ret != 0)
1751
            break;
1752
        read_size += pkt->size;
1753
        st = ic->streams[pkt->stream_index];
1754
        if (pkt->pts != AV_NOPTS_VALUE &&
1755
            st->start_time != AV_NOPTS_VALUE) {
1756
            end_time = pkt->pts;
1757
            duration = end_time - st->start_time;
1758
            if (duration > 0) {
1759
                if (st->duration == AV_NOPTS_VALUE ||
1760
                    st->duration < duration)
1761
                    st->duration = duration;
1762
            }
1763
        }
1764
        av_free_packet(pkt);
1765
    }
1766

    
1767
    fill_all_stream_timings(ic);
1768

    
1769
    url_fseek(ic->pb, old_offset, SEEK_SET);
1770
    for(i=0; i<ic->nb_streams; i++){
1771
        st= ic->streams[i];
1772
        st->cur_dts= st->first_dts;
1773
        st->last_IP_pts = AV_NOPTS_VALUE;
1774
    }
1775
}
1776

    
1777
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1778
{
1779
    int64_t file_size;
1780

    
1781
    /* get the file size, if possible */
1782
    if (ic->iformat->flags & AVFMT_NOFILE) {
1783
        file_size = 0;
1784
    } else {
1785
        file_size = url_fsize(ic->pb);
1786
        if (file_size < 0)
1787
            file_size = 0;
1788
    }
1789
    ic->file_size = file_size;
1790

    
1791
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1792
         !strcmp(ic->iformat->name, "mpegts")) &&
1793
        file_size && !url_is_streamed(ic->pb)) {
1794
        /* get accurate estimate from the PTSes */
1795
        av_estimate_timings_from_pts(ic, old_offset);
1796
    } else if (av_has_duration(ic)) {
1797
        /* at least one component has timings - we use them for all
1798
           the components */
1799
        fill_all_stream_timings(ic);
1800
    } else {
1801
        /* less precise: use bitrate info */
1802
        av_estimate_timings_from_bit_rate(ic);
1803
    }
1804
    av_update_stream_timings(ic);
1805

    
1806
#if 0
1807
    {
1808
        int i;
1809
        AVStream *st;
1810
        for(i = 0;i < ic->nb_streams; i++) {
1811
            st = ic->streams[i];
1812
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1813
               i, (double)st->start_time / AV_TIME_BASE,
1814
               (double)st->duration / AV_TIME_BASE);
1815
        }
1816
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1817
               (double)ic->start_time / AV_TIME_BASE,
1818
               (double)ic->duration / AV_TIME_BASE,
1819
               ic->bit_rate / 1000);
1820
    }
1821
#endif
1822
}
1823

    
1824
static int has_codec_parameters(AVCodecContext *enc)
1825
{
1826
    int val;
1827
    switch(enc->codec_type) {
1828
    case CODEC_TYPE_AUDIO:
1829
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1830
        if(!enc->frame_size &&
1831
           (enc->codec_id == CODEC_ID_VORBIS ||
1832
            enc->codec_id == CODEC_ID_AAC))
1833
            return 0;
1834
        break;
1835
    case CODEC_TYPE_VIDEO:
1836
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1837
        break;
1838
    default:
1839
        val = 1;
1840
        break;
1841
    }
1842
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1843
}
1844

    
1845
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1846
{
1847
    int16_t *samples;
1848
    AVCodec *codec;
1849
    int got_picture, data_size, ret=0;
1850
    AVFrame picture;
1851

    
1852
  if(!st->codec->codec){
1853
    codec = avcodec_find_decoder(st->codec->codec_id);
1854
    if (!codec)
1855
        return -1;
1856
    ret = avcodec_open(st->codec, codec);
1857
    if (ret < 0)
1858
        return ret;
1859
  }
1860

    
1861
  if(!has_codec_parameters(st->codec)){
1862
    switch(st->codec->codec_type) {
1863
    case CODEC_TYPE_VIDEO:
1864
        ret = avcodec_decode_video(st->codec, &picture,
1865
                                   &got_picture, data, size);
1866
        break;
1867
    case CODEC_TYPE_AUDIO:
1868
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1869
        samples = av_malloc(data_size);
1870
        if (!samples)
1871
            goto fail;
1872
        ret = avcodec_decode_audio2(st->codec, samples,
1873
                                    &data_size, data, size);
1874
        av_free(samples);
1875
        break;
1876
    default:
1877
        break;
1878
    }
1879
  }
1880
 fail:
1881
    return ret;
1882
}
1883

    
1884
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1885
{
1886
    while (tags->id != CODEC_ID_NONE) {
1887
        if (tags->id == id)
1888
            return tags->tag;
1889
        tags++;
1890
    }
1891
    return 0;
1892
}
1893

    
1894
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1895
{
1896
    int i;
1897
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1898
        if(tag == tags[i].tag)
1899
            return tags[i].id;
1900
    }
1901
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1902
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1903
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1904
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1905
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1906
            return tags[i].id;
1907
    }
1908
    return CODEC_ID_NONE;
1909
}
1910

    
1911
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1912
{
1913
    int i;
1914
    for(i=0; tags && tags[i]; i++){
1915
        int tag= codec_get_tag(tags[i], id);
1916
        if(tag) return tag;
1917
    }
1918
    return 0;
1919
}
1920

    
1921
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1922
{
1923
    int i;
1924
    for(i=0; tags && tags[i]; i++){
1925
        enum CodecID id= codec_get_id(tags[i], tag);
1926
        if(id!=CODEC_ID_NONE) return id;
1927
    }
1928
    return CODEC_ID_NONE;
1929
}
1930

    
1931
static void compute_chapters_end(AVFormatContext *s)
1932
{
1933
    unsigned int i;
1934

    
1935
    for (i=0; i+1<s->nb_chapters; i++)
1936
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1937
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1938
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1939
            s->chapters[i]->end = s->chapters[i+1]->start;
1940
        }
1941

    
1942
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1943
        assert(s->start_time != AV_NOPTS_VALUE);
1944
        assert(s->duration > 0);
1945
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1946
                                           AV_TIME_BASE_Q,
1947
                                           s->chapters[i]->time_base);
1948
    }
1949
}
1950

    
1951
/* absolute maximum size we read until we abort */
1952
#define MAX_READ_SIZE        5000000
1953

    
1954
#define MAX_STD_TIMEBASES (60*12+5)
1955
static int get_std_framerate(int i){
1956
    if(i<60*12) return i*1001;
1957
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1958
}
1959

    
1960
/*
1961
 * Is the time base unreliable.
1962
 * This is a heuristic to balance between quick acceptance of the values in
1963
 * the headers vs. some extra checks.
1964
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1965
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1966
 * And there are "variable" fps files this needs to detect as well.
1967
 */
1968
static int tb_unreliable(AVCodecContext *c){
1969
    if(   c->time_base.den >= 101L*c->time_base.num
1970
       || c->time_base.den <    5L*c->time_base.num
1971
/*       || c->codec_tag == AV_RL32("DIVX")
1972
       || c->codec_tag == AV_RL32("XVID")*/
1973
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1974
        return 1;
1975
    return 0;
1976
}
1977

    
1978
int av_find_stream_info(AVFormatContext *ic)
1979
{
1980
    int i, count, ret, read_size, j;
1981
    AVStream *st;
1982
    AVPacket pkt1, *pkt;
1983
    int64_t last_dts[MAX_STREAMS];
1984
    int duration_count[MAX_STREAMS]={0};
1985
    double (*duration_error)[MAX_STD_TIMEBASES];
1986
    int64_t old_offset = url_ftell(ic->pb);
1987
    int64_t codec_info_duration[MAX_STREAMS]={0};
1988
    int codec_info_nb_frames[MAX_STREAMS]={0};
1989

    
1990
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1991
    if (!duration_error) return AVERROR(ENOMEM);
1992

    
1993
    for(i=0;i<ic->nb_streams;i++) {
1994
        st = ic->streams[i];
1995
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1996
/*            if(!st->time_base.num)
1997
                st->time_base= */
1998
            if(!st->codec->time_base.num)
1999
                st->codec->time_base= st->time_base;
2000
        }
2001
        //only for the split stuff
2002
        if (!st->parser) {
2003
            st->parser = av_parser_init(st->codec->codec_id);
2004
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2005
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2006
            }
2007
        }
2008
    }
2009

    
2010
    for(i=0;i<MAX_STREAMS;i++){
2011
        last_dts[i]= AV_NOPTS_VALUE;
2012
    }
2013

    
2014
    count = 0;
2015
    read_size = 0;
2016
    for(;;) {
2017
        /* check if one codec still needs to be handled */
2018
        for(i=0;i<ic->nb_streams;i++) {
2019
            st = ic->streams[i];
2020
            if (!has_codec_parameters(st->codec))
2021
                break;
2022
            /* variable fps and no guess at the real fps */
2023
            if(   tb_unreliable(st->codec)
2024
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2025
                break;
2026
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2027
                break;
2028
            if(st->first_dts == AV_NOPTS_VALUE)
2029
                break;
2030
        }
2031
        if (i == ic->nb_streams) {
2032
            /* NOTE: if the format has no header, then we need to read
2033
               some packets to get most of the streams, so we cannot
2034
               stop here */
2035
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2036
                /* if we found the info for all the codecs, we can stop */
2037
                ret = count;
2038
                break;
2039
            }
2040
        }
2041
        /* we did not get all the codec info, but we read too much data */
2042
        if (read_size >= MAX_READ_SIZE) {
2043
            ret = count;
2044
            break;
2045
        }
2046

    
2047
        /* NOTE: a new stream can be added there if no header in file
2048
           (AVFMTCTX_NOHEADER) */
2049
        ret = av_read_frame_internal(ic, &pkt1);
2050
        if(ret == AVERROR(EAGAIN))
2051
            continue;
2052
        if (ret < 0) {
2053
            /* EOF or error */
2054
            ret = -1; /* we could not have all the codec parameters before EOF */
2055
            for(i=0;i<ic->nb_streams;i++) {
2056
                st = ic->streams[i];
2057
                if (!has_codec_parameters(st->codec)){
2058
                    char buf[256];
2059
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2060
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2061
                } else {
2062
                    ret = 0;
2063
                }
2064
            }
2065
            break;
2066
        }
2067

    
2068
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2069
        if(av_dup_packet(pkt) < 0) {
2070
            av_free(duration_error);
2071
            return AVERROR(ENOMEM);
2072
        }
2073

    
2074
        read_size += pkt->size;
2075

    
2076
        st = ic->streams[pkt->stream_index];
2077
        if(codec_info_nb_frames[st->index]>1)
2078
            codec_info_duration[st->index] += pkt->duration;
2079
        if (pkt->duration != 0)
2080
            codec_info_nb_frames[st->index]++;
2081

    
2082
        {
2083
            int index= pkt->stream_index;
2084
            int64_t last= last_dts[index];
2085
            int64_t duration= pkt->dts - last;
2086

    
2087
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2088
                double dur= duration * av_q2d(st->time_base);
2089

    
2090
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2091
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2092
                if(duration_count[index] < 2)
2093
                    memset(duration_error[index], 0, sizeof(*duration_error));
2094
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2095
                    int framerate= get_std_framerate(i);
2096
                    int ticks= lrintf(dur*framerate/(1001*12));
2097
                    double error= dur - ticks*1001*12/(double)framerate;
2098
                    duration_error[index][i] += error*error;
2099
                }
2100
                duration_count[index]++;
2101
            }
2102
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2103
                last_dts[pkt->stream_index]= pkt->dts;
2104
        }
2105
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2106
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2107
            if(i){
2108
                st->codec->extradata_size= i;
2109
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2110
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2111
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2112
            }
2113
        }
2114

    
2115
        /* if still no information, we try to open the codec and to
2116
           decompress the frame. We try to avoid that in most cases as
2117
           it takes longer and uses more memory. For MPEG-4, we need to
2118
           decompress for QuickTime. */
2119
        if (!has_codec_parameters(st->codec) /*&&
2120
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2121
             st->codec->codec_id == CODEC_ID_H264 ||
2122
             st->codec->codec_id == CODEC_ID_H263 ||
2123
             st->codec->codec_id == CODEC_ID_H261 ||
2124
             st->codec->codec_id == CODEC_ID_VORBIS ||
2125
             st->codec->codec_id == CODEC_ID_MJPEG ||
2126
             st->codec->codec_id == CODEC_ID_PNG ||
2127
             st->codec->codec_id == CODEC_ID_PAM ||
2128
             st->codec->codec_id == CODEC_ID_PGM ||
2129
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2130
             st->codec->codec_id == CODEC_ID_PBM ||
2131
             st->codec->codec_id == CODEC_ID_PPM ||
2132
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2133
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2134
            try_decode_frame(st, pkt->data, pkt->size);
2135

    
2136
        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) {
2137
            break;
2138
        }
2139
        count++;
2140
    }
2141

    
2142
    // close codecs which were opened in try_decode_frame()
2143
    for(i=0;i<ic->nb_streams;i++) {
2144
        st = ic->streams[i];
2145
        if(st->codec->codec)
2146
            avcodec_close(st->codec);
2147
    }
2148
    for(i=0;i<ic->nb_streams;i++) {
2149
        st = ic->streams[i];
2150
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2151
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2152
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2153

    
2154
            if(duration_count[i]
2155
               && tb_unreliable(st->codec) /*&&
2156
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2157
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2158
                double best_error= 2*av_q2d(st->time_base);
2159
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2160

    
2161
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2162
                    double error= duration_error[i][j] * get_std_framerate(j);
2163
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2164
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2165
                    if(error < best_error){
2166
                        best_error= error;
2167
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2168
                    }
2169
                }
2170
            }
2171

    
2172
            if (!st->r_frame_rate.num){
2173
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2174
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2175
                    st->r_frame_rate.num = st->codec->time_base.den;
2176
                    st->r_frame_rate.den = st->codec->time_base.num;
2177
                }else{
2178
                    st->r_frame_rate.num = st->time_base.den;
2179
                    st->r_frame_rate.den = st->time_base.num;
2180
                }
2181
            }
2182
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2183
            if(!st->codec->bits_per_coded_sample)
2184
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2185
        }
2186
    }
2187

    
2188
    av_estimate_timings(ic, old_offset);
2189

    
2190
    compute_chapters_end(ic);
2191

    
2192
#if 0
2193
    /* correct DTS for B-frame streams with no timestamps */
2194
    for(i=0;i<ic->nb_streams;i++) {
2195
        st = ic->streams[i];
2196
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2197
            if(b-frames){
2198
                ppktl = &ic->packet_buffer;
2199
                while(ppkt1){
2200
                    if(ppkt1->stream_index != i)
2201
                        continue;
2202
                    if(ppkt1->pkt->dts < 0)
2203
                        break;
2204
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2205
                        break;
2206
                    ppkt1->pkt->dts -= delta;
2207
                    ppkt1= ppkt1->next;
2208
                }
2209
                if(ppkt1)
2210
                    continue;
2211
                st->cur_dts -= delta;
2212
            }
2213
        }
2214
    }
2215
#endif
2216

    
2217
    av_free(duration_error);
2218

    
2219
    return ret;
2220
}
2221

    
2222
/*******************************************************/
2223

    
2224
int av_read_play(AVFormatContext *s)
2225
{
2226
    if (s->iformat->read_play)
2227
        return s->iformat->read_play(s);
2228
    if (s->pb)
2229
        return av_url_read_fpause(s->pb, 0);
2230
    return AVERROR(ENOSYS);
2231
}
2232

    
2233
int av_read_pause(AVFormatContext *s)
2234
{
2235
    if (s->iformat->read_pause)
2236
        return s->iformat->read_pause(s);
2237
    if (s->pb)
2238
        return av_url_read_fpause(s->pb, 1);
2239
    return AVERROR(ENOSYS);
2240
}
2241

    
2242
void av_close_input_stream(AVFormatContext *s)
2243
{
2244
    int i;
2245
    AVStream *st;
2246

    
2247
    if (s->iformat->read_close)
2248
        s->iformat->read_close(s);
2249
    for(i=0;i<s->nb_streams;i++) {
2250
        /* free all data in a stream component */
2251
        st = s->streams[i];
2252
        if (st->parser) {
2253
            av_parser_close(st->parser);
2254
            av_free_packet(&st->cur_pkt);
2255
        }
2256
        av_metadata_free(&st->metadata);
2257
        av_free(st->index_entries);
2258
        av_free(st->codec->extradata);
2259
        av_free(st->codec);
2260
        av_free(st->filename);
2261
        av_free(st->priv_data);
2262
        av_free(st);
2263
    }
2264
    for(i=s->nb_programs-1; i>=0; i--) {
2265
        av_freep(&s->programs[i]->provider_name);
2266
        av_freep(&s->programs[i]->name);
2267
        av_metadata_free(&s->programs[i]->metadata);
2268
        av_freep(&s->programs[i]->stream_index);
2269
        av_freep(&s->programs[i]);
2270
    }
2271
    av_freep(&s->programs);
2272
    flush_packet_queue(s);
2273
    av_freep(&s->priv_data);
2274
    while(s->nb_chapters--) {
2275
        av_free(s->chapters[s->nb_chapters]->title);
2276
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2277
        av_free(s->chapters[s->nb_chapters]);
2278
    }
2279
    av_freep(&s->chapters);
2280
    av_metadata_free(&s->metadata);
2281
    av_free(s);
2282
}
2283

    
2284
void av_close_input_file(AVFormatContext *s)
2285
{
2286
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2287
    av_close_input_stream(s);
2288
    if (pb)
2289
        url_fclose(pb);
2290
}
2291

    
2292
AVStream *av_new_stream(AVFormatContext *s, int id)
2293
{
2294
    AVStream *st;
2295
    int i;
2296

    
2297
    if (s->nb_streams >= MAX_STREAMS)
2298
        return NULL;
2299

    
2300
    st = av_mallocz(sizeof(AVStream));
2301
    if (!st)
2302
        return NULL;
2303

    
2304
    st->codec= avcodec_alloc_context();
2305
    if (s->iformat) {
2306
        /* no default bitrate if decoding */
2307
        st->codec->bit_rate = 0;
2308
    }
2309
    st->index = s->nb_streams;
2310
    st->id = id;
2311
    st->start_time = AV_NOPTS_VALUE;
2312
    st->duration = AV_NOPTS_VALUE;
2313
        /* we set the current DTS to 0 so that formats without any timestamps
2314
           but durations get some timestamps, formats with some unknown
2315
           timestamps have their first few packets buffered and the
2316
           timestamps corrected before they are returned to the user */
2317
    st->cur_dts = 0;
2318
    st->first_dts = AV_NOPTS_VALUE;
2319

    
2320
    /* default pts setting is MPEG-like */
2321
    av_set_pts_info(st, 33, 1, 90000);
2322
    st->last_IP_pts = AV_NOPTS_VALUE;
2323
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2324
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2325

    
2326
    st->sample_aspect_ratio = (AVRational){0,1};
2327

    
2328
    s->streams[s->nb_streams++] = st;
2329
    return st;
2330
}
2331

    
2332
AVProgram *av_new_program(AVFormatContext *ac, int id)
2333
{
2334
    AVProgram *program=NULL;
2335
    int i;
2336

    
2337
#ifdef DEBUG_SI
2338
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2339
#endif
2340

    
2341
    for(i=0; i<ac->nb_programs; i++)
2342
        if(ac->programs[i]->id == id)
2343
            program = ac->programs[i];
2344

    
2345
    if(!program){
2346
        program = av_mallocz(sizeof(AVProgram));
2347
        if (!program)
2348
            return NULL;
2349
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2350
        program->discard = AVDISCARD_NONE;
2351
    }
2352
    program->id = id;
2353

    
2354
    return program;
2355
}
2356

    
2357
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2358
{
2359
    assert(!provider_name == !name);
2360
    if(name){
2361
        av_free(program->provider_name);
2362
        av_free(program->         name);
2363
        program->provider_name = av_strdup(provider_name);
2364
        program->         name = av_strdup(         name);
2365
    }
2366
}
2367

    
2368
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2369
{
2370
    AVChapter *chapter = NULL;
2371
    int i;
2372

    
2373
    for(i=0; i<s->nb_chapters; i++)
2374
        if(s->chapters[i]->id == id)
2375
            chapter = s->chapters[i];
2376

    
2377
    if(!chapter){
2378
        chapter= av_mallocz(sizeof(AVChapter));
2379
        if(!chapter)
2380
            return NULL;
2381
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2382
    }
2383
    av_free(chapter->title);
2384
    chapter->title = av_strdup(title);
2385
    chapter->id    = id;
2386
    chapter->time_base= time_base;
2387
    chapter->start = start;
2388
    chapter->end   = end;
2389

    
2390
    return chapter;
2391
}
2392

    
2393
/************************************************************/
2394
/* output media file */
2395

    
2396
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2397
{
2398
    int ret;
2399

    
2400
    if (s->oformat->priv_data_size > 0) {
2401
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2402
        if (!s->priv_data)
2403
            return AVERROR(ENOMEM);
2404
    } else
2405
        s->priv_data = NULL;
2406

    
2407
    if (s->oformat->set_parameters) {
2408
        ret = s->oformat->set_parameters(s, ap);
2409
        if (ret < 0)
2410
            return ret;
2411
    }
2412
    return 0;
2413
}
2414

    
2415
int av_write_header(AVFormatContext *s)
2416
{
2417
    int ret, i;
2418
    AVStream *st;
2419

    
2420
    // some sanity checks
2421
    for(i=0;i<s->nb_streams;i++) {
2422
        st = s->streams[i];
2423

    
2424
        switch (st->codec->codec_type) {
2425
        case CODEC_TYPE_AUDIO:
2426
            if(st->codec->sample_rate<=0){
2427
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2428
                return -1;
2429
            }
2430
            if(!st->codec->block_align)
2431
                st->codec->block_align = st->codec->channels *
2432
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2433
            break;
2434
        case CODEC_TYPE_VIDEO:
2435
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2436
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2437
                return -1;
2438
            }
2439
            if(st->codec->width<=0 || st->codec->height<=0){
2440
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2441
                return -1;
2442
            }
2443
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2444
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2445
                return -1;
2446
            }
2447
            break;
2448
        }
2449

    
2450
        if(s->oformat->codec_tag){
2451
            if(st->codec->codec_tag){
2452
                //FIXME
2453
                //check that tag + id is in the table
2454
                //if neither is in the table -> OK
2455
                //if tag is in the table with another id -> FAIL
2456
                //if id is in the table with another tag -> FAIL unless strict < ?
2457
            }else
2458
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2459
        }
2460
    }
2461

    
2462
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2463
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2464
        if (!s->priv_data)
2465
            return AVERROR(ENOMEM);
2466
    }
2467

    
2468
#if LIBAVFORMAT_VERSION_MAJOR < 53
2469
    ff_metadata_mux_compat(s);
2470
#endif
2471

    
2472
    if(s->oformat->write_header){
2473
        ret = s->oformat->write_header(s);
2474
        if (ret < 0)
2475
            return ret;
2476
    }
2477

    
2478
    /* init PTS generation */
2479
    for(i=0;i<s->nb_streams;i++) {
2480
        int64_t den = AV_NOPTS_VALUE;
2481
        st = s->streams[i];
2482

    
2483
        switch (st->codec->codec_type) {
2484
        case CODEC_TYPE_AUDIO:
2485
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2486
            break;
2487
        case CODEC_TYPE_VIDEO:
2488
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2489
            break;
2490
        default:
2491
            break;
2492
        }
2493
        if (den != AV_NOPTS_VALUE) {
2494
            if (den <= 0)
2495
                return AVERROR_INVALIDDATA;
2496
            av_frac_init(&st->pts, 0, 0, den);
2497
        }
2498
    }
2499
    return 0;
2500
}
2501

    
2502
//FIXME merge with compute_pkt_fields
2503
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2504
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2505
    int num, den, frame_size, i;
2506

    
2507
//    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);
2508

    
2509
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2510
        return -1;*/
2511

    
2512
    /* duration field */
2513
    if (pkt->duration == 0) {
2514
        compute_frame_duration(&num, &den, st, NULL, pkt);
2515
        if (den && num) {
2516
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2517
        }
2518
    }
2519

    
2520
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2521
        pkt->pts= pkt->dts;
2522

    
2523
    //XXX/FIXME this is a temporary hack until all encoders output pts
2524
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2525
        pkt->dts=
2526
//        pkt->pts= st->cur_dts;
2527
        pkt->pts= st->pts.val;
2528
    }
2529

    
2530
    //calculate dts from pts
2531
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2532
        st->pts_buffer[0]= pkt->pts;
2533
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2534
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2535
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2536
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2537

    
2538
        pkt->dts= st->pts_buffer[0];
2539
    }
2540

    
2541
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2542
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2543
        return -1;
2544
    }
2545
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2546
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2547
        return -1;
2548
    }
2549

    
2550
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2551
    st->cur_dts= pkt->dts;
2552
    st->pts.val= pkt->dts;
2553

    
2554
    /* update pts */
2555
    switch (st->codec->codec_type) {
2556
    case CODEC_TYPE_AUDIO:
2557
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2558

    
2559
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2560
           likely equal to the encoder delay, but it would be better if we
2561
           had the real timestamps from the encoder */
2562
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2563
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2564
        }
2565
        break;
2566
    case CODEC_TYPE_VIDEO:
2567
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2568
        break;
2569
    default:
2570
        break;
2571
    }
2572
    return 0;
2573
}
2574

    
2575
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2576
{
2577
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2578

    
2579
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2580
        return ret;
2581

    
2582
    ret= s->oformat->write_packet(s, pkt);
2583
    if(!ret)
2584
        ret= url_ferror(s->pb);
2585
    return ret;
2586
}
2587

    
2588
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2589
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2590
{
2591
    AVPacketList **next_point, *this_pktl;
2592

    
2593
    this_pktl = av_mallocz(sizeof(AVPacketList));
2594
    this_pktl->pkt= *pkt;
2595
    if(pkt->destruct == av_destruct_packet)
2596
        pkt->destruct= NULL; // not shared -> must keep original from being freed
2597
    else
2598
        av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2599

    
2600
    next_point = &s->packet_buffer;
2601
    while(*next_point){
2602
        if(compare(s, &(*next_point)->pkt, pkt))
2603
            break;
2604
        next_point= &(*next_point)->next;
2605
    }
2606
    this_pktl->next= *next_point;
2607
    *next_point= this_pktl;
2608
}
2609

    
2610
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2611
{
2612
    AVStream *st = s->streams[ pkt ->stream_index];
2613
    AVStream *st2= s->streams[ next->stream_index];
2614
    int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2615
    int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2616

    
2617
    if (pkt->dts == AV_NOPTS_VALUE)
2618
        return 0;
2619

    
2620
    return next->dts * left > pkt->dts * right; //FIXME this can overflow
2621
}
2622

    
2623
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2624
    AVPacketList *pktl;
2625
    int stream_count=0;
2626
    int streams[MAX_STREAMS];
2627

    
2628
    if(pkt){
2629
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2630
    }
2631

    
2632
    memset(streams, 0, sizeof(streams));
2633
    pktl= s->packet_buffer;
2634
    while(pktl){
2635
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2636
        if(streams[ pktl->pkt.stream_index ] == 0)
2637
            stream_count++;
2638
        streams[ pktl->pkt.stream_index ]++;
2639
        pktl= pktl->next;
2640
    }
2641

    
2642
    if(stream_count && (s->nb_streams == stream_count || flush)){
2643
        pktl= s->packet_buffer;
2644
        *out= pktl->pkt;
2645

    
2646
        s->packet_buffer= pktl->next;
2647
        av_freep(&pktl);
2648
        return 1;
2649
    }else{
2650
        av_init_packet(out);
2651
        return 0;
2652
    }
2653
}
2654

    
2655
/**
2656
 * Interleaves an AVPacket correctly so it can be muxed.
2657
 * @param out the interleaved packet will be output here
2658
 * @param in the input packet
2659
 * @param flush 1 if no further packets are available as input and all
2660
 *              remaining packets should be output
2661
 * @return 1 if a packet was output, 0 if no packet could be output,
2662
 *         < 0 if an error occurred
2663
 */
2664
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2665
    if(s->oformat->interleave_packet)
2666
        return s->oformat->interleave_packet(s, out, in, flush);
2667
    else
2668
        return av_interleave_packet_per_dts(s, out, in, flush);
2669
}
2670

    
2671
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2672
    AVStream *st= s->streams[ pkt->stream_index];
2673

    
2674
    //FIXME/XXX/HACK drop zero sized packets
2675
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2676
        return 0;
2677

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

    
2682
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2683
        return -1;
2684

    
2685
    for(;;){
2686
        AVPacket opkt;
2687
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2688
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2689
            return ret;
2690

    
2691
        ret= s->oformat->write_packet(s, &opkt);
2692

    
2693
        av_free_packet(&opkt);
2694
        pkt= NULL;
2695

    
2696
        if(ret<0)
2697
            return ret;
2698
        if(url_ferror(s->pb))
2699
            return url_ferror(s->pb);
2700
    }
2701
}
2702

    
2703
int av_write_trailer(AVFormatContext *s)
2704
{
2705
    int ret, i;
2706

    
2707
    for(;;){
2708
        AVPacket pkt;
2709
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2710
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2711
            goto fail;
2712
        if(!ret)
2713
            break;
2714

    
2715
        ret= s->oformat->write_packet(s, &pkt);
2716

    
2717
        av_free_packet(&pkt);
2718

    
2719
        if(ret<0)
2720
            goto fail;
2721
        if(url_ferror(s->pb))
2722
            goto fail;
2723
    }
2724

    
2725
    if(s->oformat->write_trailer)
2726
        ret = s->oformat->write_trailer(s);
2727
fail:
2728
    if(ret == 0)
2729
       ret=url_ferror(s->pb);
2730
    for(i=0;i<s->nb_streams;i++)
2731
        av_freep(&s->streams[i]->priv_data);
2732
    av_freep(&s->priv_data);
2733
    return ret;
2734
}
2735

    
2736
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2737
{
2738
    int i, j;
2739
    AVProgram *program=NULL;
2740
    void *tmp;
2741

    
2742
    for(i=0; i<ac->nb_programs; i++){
2743
        if(ac->programs[i]->id != progid)
2744
            continue;
2745
        program = ac->programs[i];
2746
        for(j=0; j<program->nb_stream_indexes; j++)
2747
            if(program->stream_index[j] == idx)
2748
                return;
2749

    
2750
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2751
        if(!tmp)
2752
            return;
2753
        program->stream_index = tmp;
2754
        program->stream_index[program->nb_stream_indexes++] = idx;
2755
        return;
2756
    }
2757
}
2758

    
2759
/* "user interface" functions */
2760
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2761
{
2762
    char buf[256];
2763
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2764
    AVStream *st = ic->streams[i];
2765
    int g = av_gcd(st->time_base.num, st->time_base.den);
2766
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2767
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2768
    /* the pid is an important information, so we display it */
2769
    /* XXX: add a generic system */
2770
    if (flags & AVFMT_SHOW_IDS)
2771
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2772
    if (strlen(st->language) > 0)
2773
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2774
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2775
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2776
    if (st->sample_aspect_ratio.num && // default
2777
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2778
        AVRational display_aspect_ratio;
2779
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2780
                  st->codec->width*st->sample_aspect_ratio.num,
2781
                  st->codec->height*st->sample_aspect_ratio.den,
2782
                  1024*1024);
2783
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2784
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2785
                 display_aspect_ratio.num, display_aspect_ratio.den);
2786
    }
2787
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2788
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2789
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2790
/*      else if(st->time_base.den && st->time_base.num)
2791
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2792
        else
2793
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2794
    }
2795
    av_log(NULL, AV_LOG_INFO, "\n");
2796
}
2797

    
2798
void dump_format(AVFormatContext *ic,
2799
                 int index,
2800
                 const char *url,
2801
                 int is_output)
2802
{
2803
    int i;
2804

    
2805
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2806
            is_output ? "Output" : "Input",
2807
            index,
2808
            is_output ? ic->oformat->name : ic->iformat->name,
2809
            is_output ? "to" : "from", url);
2810
    if (!is_output) {
2811
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2812
        if (ic->duration != AV_NOPTS_VALUE) {
2813
            int hours, mins, secs, us;
2814
            secs = ic->duration / AV_TIME_BASE;
2815
            us = ic->duration % AV_TIME_BASE;
2816
            mins = secs / 60;
2817
            secs %= 60;
2818
            hours = mins / 60;
2819
            mins %= 60;
2820
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2821
                   (100 * us) / AV_TIME_BASE);
2822
        } else {
2823
            av_log(NULL, AV_LOG_INFO, "N/A");
2824
        }
2825
        if (ic->start_time != AV_NOPTS_VALUE) {
2826
            int secs, us;
2827
            av_log(NULL, AV_LOG_INFO, ", start: ");
2828
            secs = ic->start_time / AV_TIME_BASE;
2829
            us = ic->start_time % AV_TIME_BASE;
2830
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2831
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2832
        }
2833
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2834
        if (ic->bit_rate) {
2835
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2836
        } else {
2837
            av_log(NULL, AV_LOG_INFO, "N/A");
2838
        }
2839
        av_log(NULL, AV_LOG_INFO, "\n");
2840
    }
2841
    if(ic->nb_programs) {
2842
        int j, k;
2843
        for(j=0; j<ic->nb_programs; j++) {
2844
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2845
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2846
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2847
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2848
         }
2849
    } else
2850
    for(i=0;i<ic->nb_streams;i++)
2851
        dump_stream_format(ic, i, index, is_output);
2852
}
2853

    
2854
#if LIBAVFORMAT_VERSION_MAJOR < 53
2855
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2856
{
2857
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2858
}
2859

    
2860
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2861
{
2862
    AVRational frame_rate;
2863
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2864
    *frame_rate_num= frame_rate.num;
2865
    *frame_rate_den= frame_rate.den;
2866
    return ret;
2867
}
2868
#endif
2869

    
2870
int64_t av_gettime(void)
2871
{
2872
    struct timeval tv;
2873
    gettimeofday(&tv,NULL);
2874
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2875
}
2876

    
2877
int64_t parse_date(const char *datestr, int duration)
2878
{
2879
    const char *p;
2880
    int64_t t;
2881
    struct tm dt;
2882
    int i;
2883
    static const char * const date_fmt[] = {
2884
        "%Y-%m-%d",
2885
        "%Y%m%d",
2886
    };
2887
    static const char * const time_fmt[] = {
2888
        "%H:%M:%S",
2889
        "%H%M%S",
2890
    };
2891
    const char *q;
2892
    int is_utc, len;
2893
    char lastch;
2894
    int negative = 0;
2895

    
2896
#undef time
2897
    time_t now = time(0);
2898

    
2899
    len = strlen(datestr);
2900
    if (len > 0)
2901
        lastch = datestr[len - 1];
2902
    else
2903
        lastch = '\0';
2904
    is_utc = (lastch == 'z' || lastch == 'Z');
2905

    
2906
    memset(&dt, 0, sizeof(dt));
2907

    
2908
    p = datestr;
2909
    q = NULL;
2910
    if (!duration) {
2911
        /* parse the year-month-day part */
2912
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2913
            q = small_strptime(p, date_fmt[i], &dt);
2914
            if (q) {
2915
                break;
2916
            }
2917
        }
2918

    
2919
        /* if the year-month-day part is missing, then take the
2920
         * current year-month-day time */
2921
        if (!q) {
2922
            if (is_utc) {
2923
                dt = *gmtime(&now);
2924
            } else {
2925
                dt = *localtime(&now);
2926
            }
2927
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2928
        } else {
2929
            p = q;
2930
        }
2931

    
2932
        if (*p == 'T' || *p == 't' || *p == ' ')
2933
            p++;
2934

    
2935
        /* parse the hour-minute-second part */
2936
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2937
            q = small_strptime(p, time_fmt[i], &dt);
2938
            if (q) {
2939
                break;
2940
            }
2941
        }
2942
    } else {
2943
        /* parse datestr as a duration */
2944
        if (p[0] == '-') {
2945
            negative = 1;
2946
            ++p;
2947
        }
2948
        /* parse datestr as HH:MM:SS */
2949
        q = small_strptime(p, time_fmt[0], &dt);
2950
        if (!q) {
2951
            /* parse datestr as S+ */
2952
            dt.tm_sec = strtol(p, (char **)&q, 10);
2953
            if (q == p)
2954
                /* the parsing didn't succeed */
2955
                return INT64_MIN;
2956
            dt.tm_min = 0;
2957
            dt.tm_hour = 0;
2958
        }
2959
    }
2960

    
2961
    /* Now we have all the fields that we can get */
2962
    if (!q) {
2963
        return INT64_MIN;
2964
    }
2965

    
2966
    if (duration) {
2967
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2968
    } else {
2969
        dt.tm_isdst = -1;       /* unknown */
2970
        if (is_utc) {
2971
            t = mktimegm(&dt);
2972
        } else {
2973
            t = mktime(&dt);
2974
        }
2975
    }
2976

    
2977
    t *= 1000000;
2978

    
2979
    /* parse the .m... part */
2980
    if (*q == '.') {
2981
        int val, n;
2982
        q++;
2983
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2984
            if (!isdigit(*q))
2985
                break;
2986
            val += n * (*q - '0');
2987
        }
2988
        t += val;
2989
    }
2990
    return negative ? -t : t;
2991
}
2992

    
2993
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2994
{
2995
    const char *p;
2996
    char tag[128], *q;
2997

    
2998
    p = info;
2999
    if (*p == '?')
3000
        p++;
3001
    for(;;) {
3002
        q = tag;
3003
        while (*p != '\0' && *p != '=' && *p != '&') {
3004
            if ((q - tag) < sizeof(tag) - 1)
3005
                *q++ = *p;
3006
            p++;
3007
        }
3008
        *q = '\0';
3009
        q = arg;
3010
        if (*p == '=') {
3011
            p++;
3012
            while (*p != '&' && *p != '\0') {
3013
                if ((q - arg) < arg_size - 1) {
3014
                    if (*p == '+')
3015
                        *q++ = ' ';
3016
                    else
3017
                        *q++ = *p;
3018
                }
3019
                p++;
3020
            }
3021
            *q = '\0';
3022
        }
3023
        if (!strcmp(tag, tag1))
3024
            return 1;
3025
        if (*p != '&')
3026
            break;
3027
        p++;
3028
    }
3029
    return 0;
3030
}
3031

    
3032
int av_get_frame_filename(char *buf, int buf_size,
3033
                          const char *path, int number)
3034
{
3035
    const char *p;
3036
    char *q, buf1[20], c;
3037
    int nd, len, percentd_found;
3038

    
3039
    q = buf;
3040
    p = path;
3041
    percentd_found = 0;
3042
    for(;;) {
3043
        c = *p++;
3044
        if (c == '\0')
3045
            break;
3046
        if (c == '%') {
3047
            do {
3048
                nd = 0;
3049
                while (isdigit(*p)) {
3050
                    nd = nd * 10 + *p++ - '0';
3051
                }
3052
                c = *p++;
3053
            } while (isdigit(c));
3054

    
3055
            switch(c) {
3056
            case '%':
3057
                goto addchar;
3058
            case 'd':
3059
                if (percentd_found)
3060
                    goto fail;
3061
                percentd_found = 1;
3062
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3063
                len = strlen(buf1);
3064
                if ((q - buf + len) > buf_size - 1)
3065
                    goto fail;
3066
                memcpy(q, buf1, len);
3067
                q += len;
3068
                break;
3069
            default:
3070
                goto fail;
3071
            }
3072
        } else {
3073
        addchar:
3074
            if ((q - buf) < buf_size - 1)
3075
                *q++ = c;
3076
        }
3077
    }
3078
    if (!percentd_found)
3079
        goto fail;
3080
    *q = '\0';
3081
    return 0;
3082
 fail:
3083
    *q = '\0';
3084
    return -1;
3085
}
3086

    
3087
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3088
{
3089
    int len, i, j, c;
3090
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3091

    
3092
    for(i=0;i<size;i+=16) {
3093
        len = size - i;
3094
        if (len > 16)
3095
            len = 16;
3096
        PRINT("%08x ", i);
3097
        for(j=0;j<16;j++) {
3098
            if (j < len)
3099
                PRINT(" %02x", buf[i+j]);
3100
            else
3101
                PRINT("   ");
3102
        }
3103
        PRINT(" ");
3104
        for(j=0;j<len;j++) {
3105
            c = buf[i+j];
3106
            if (c < ' ' || c > '~')
3107
                c = '.';
3108
            PRINT("%c", c);
3109
        }
3110
        PRINT("\n");
3111
    }
3112
#undef PRINT
3113
}
3114

    
3115
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3116
{
3117
    hex_dump_internal(NULL, f, 0, buf, size);
3118
}
3119

    
3120
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3121
{
3122
    hex_dump_internal(avcl, NULL, level, buf, size);
3123
}
3124

    
3125
 //FIXME needs to know the time_base
3126
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3127
{
3128
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3129
    PRINT("stream #%d:\n", pkt->stream_index);
3130
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3131
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3132
    /* DTS is _always_ valid after av_read_frame() */
3133
    PRINT("  dts=");
3134
    if (pkt->dts == AV_NOPTS_VALUE)
3135
        PRINT("N/A");
3136
    else
3137
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3138
    /* PTS may not be known if B-frames are present. */
3139
    PRINT("  pts=");
3140
    if (pkt->pts == AV_NOPTS_VALUE)
3141
        PRINT("N/A");
3142
    else
3143
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3144
    PRINT("\n");
3145
    PRINT("  size=%d\n", pkt->size);
3146
#undef PRINT
3147
    if (dump_payload)
3148
        av_hex_dump(f, pkt->data, pkt->size);
3149
}
3150

    
3151
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3152
{
3153
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3154
}
3155

    
3156
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3157
{
3158
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3159
}
3160

    
3161
void url_split(char *proto, int proto_size,
3162
               char *authorization, int authorization_size,
3163
               char *hostname, int hostname_size,
3164
               int *port_ptr,
3165
               char *path, int path_size,
3166
               const char *url)
3167
{
3168
    const char *p, *ls, *at, *col, *brk;
3169

    
3170
    if (port_ptr)               *port_ptr = -1;
3171
    if (proto_size > 0)         proto[0] = 0;
3172
    if (authorization_size > 0) authorization[0] = 0;
3173
    if (hostname_size > 0)      hostname[0] = 0;
3174
    if (path_size > 0)          path[0] = 0;
3175

    
3176
    /* parse protocol */
3177
    if ((p = strchr(url, ':'))) {
3178
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3179
        p++; /* skip ':' */
3180
        if (*p == '/') p++;
3181
        if (*p == '/') p++;
3182
    } else {
3183
        /* no protocol means plain filename */
3184
        av_strlcpy(path, url, path_size);
3185
        return;
3186
    }
3187

    
3188
    /* separate path from hostname */
3189
    ls = strchr(p, '/');
3190
    if(!ls)
3191
        ls = strchr(p, '?');
3192
    if(ls)
3193
        av_strlcpy(path, ls, path_size);
3194
    else
3195
        ls = &p[strlen(p)]; // XXX
3196

    
3197
    /* the rest is hostname, use that to parse auth/port */
3198
    if (ls != p) {
3199
        /* authorization (user[:pass]@hostname) */
3200
        if ((at = strchr(p, '@')) && at < ls) {
3201
            av_strlcpy(authorization, p,
3202
                       FFMIN(authorization_size, at + 1 - p));
3203
            p = at + 1; /* skip '@' */
3204
        }
3205

    
3206
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3207
            /* [host]:port */
3208
            av_strlcpy(hostname, p + 1,
3209
                       FFMIN(hostname_size, brk - p));
3210
            if (brk[1] == ':' && port_ptr)
3211
                *port_ptr = atoi(brk + 2);
3212
        } else if ((col = strchr(p, ':')) && col < ls) {
3213
            av_strlcpy(hostname, p,
3214
                       FFMIN(col + 1 - p, hostname_size));
3215
            if (port_ptr) *port_ptr = atoi(col + 1);
3216
        } else
3217
            av_strlcpy(hostname, p,
3218
                       FFMIN(ls + 1 - p, hostname_size));
3219
    }
3220
}
3221

    
3222
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3223
{
3224
    int i;
3225
    static const char hex_table[16] = { '0', '1', '2', '3',
3226
                                        '4', '5', '6', '7',
3227
                                        '8', '9', 'A', 'B',
3228
                                        'C', 'D', 'E', 'F' };
3229

    
3230
    for(i = 0; i < s; i++) {
3231
        buff[i * 2]     = hex_table[src[i] >> 4];
3232
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3233
    }
3234

    
3235
    return buff;
3236
}
3237

    
3238
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3239
                     int pts_num, int pts_den)
3240
{
3241
    unsigned int gcd= av_gcd(pts_num, pts_den);
3242
    s->pts_wrap_bits = pts_wrap_bits;
3243
    s->time_base.num = pts_num/gcd;
3244
    s->time_base.den = pts_den/gcd;
3245

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