Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 8163c870

History | View | Annotate | Download (97.8 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 "libavcodec/opt.h"
23
#include "libavutil/avstring.h"
24
#include "riff.h"
25
#include <sys/time.h>
26
#include <time.h>
27

    
28
#undef NDEBUG
29
#include <assert.h>
30

    
31
/**
32
 * @file libavformat/utils.c
33
 * various utility functions for use within FFmpeg
34
 */
35

    
36
unsigned avformat_version(void)
37
{
38
    return LIBAVFORMAT_VERSION_INT;
39
}
40

    
41
/* fraction handling */
42

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

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

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

    
91
/** head of registered input format linked list */
92
AVInputFormat *first_iformat = NULL;
93
/** head of registered output format linked list */
94
AVOutputFormat *first_oformat = NULL;
95

    
96
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
97
{
98
    if(f) return f->next;
99
    else  return first_iformat;
100
}
101

    
102
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
103
{
104
    if(f) return f->next;
105
    else  return first_oformat;
106
}
107

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

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

    
126
int match_ext(const char *filename, const char *extensions)
127
{
128
    const char *ext, *p;
129
    char ext1[32], *q;
130

    
131
    if(!filename)
132
        return 0;
133

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

    
153
AVOutputFormat *guess_format(const char *short_name, const char *filename,
154
                             const char *mime_type)
155
{
156
    AVOutputFormat *fmt, *fmt_found;
157
    int score_max, score;
158

    
159
    /* specific test for image sequences */
160
#ifdef CONFIG_IMAGE2_MUXER
161
    if (!short_name && filename &&
162
        av_filename_number_test(filename) &&
163
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
164
        return guess_format("image2", NULL, NULL);
165
    }
166
#endif
167
    /* Find the proper file type. */
168
    fmt_found = NULL;
169
    score_max = 0;
170
    fmt = first_oformat;
171
    while (fmt != NULL) {
172
        score = 0;
173
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
174
            score += 100;
175
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
176
            score += 10;
177
        if (filename && fmt->extensions &&
178
            match_ext(filename, fmt->extensions)) {
179
            score += 5;
180
        }
181
        if (score > score_max) {
182
            score_max = score;
183
            fmt_found = fmt;
184
        }
185
        fmt = fmt->next;
186
    }
187
    return fmt_found;
188
}
189

    
190
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
191
                             const char *mime_type)
192
{
193
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
194

    
195
    if (fmt) {
196
        AVOutputFormat *stream_fmt;
197
        char stream_format_name[64];
198

    
199
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
200
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
201

    
202
        if (stream_fmt)
203
            fmt = stream_fmt;
204
    }
205

    
206
    return fmt;
207
}
208

    
209
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
210
                            const char *filename, const char *mime_type, enum CodecType type){
211
    if(type == CODEC_TYPE_VIDEO){
212
        enum CodecID codec_id= CODEC_ID_NONE;
213

    
214
#ifdef CONFIG_IMAGE2_MUXER
215
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
216
            codec_id= av_guess_image2_codec(filename);
217
        }
218
#endif
219
        if(codec_id == CODEC_ID_NONE)
220
            codec_id= fmt->video_codec;
221
        return codec_id;
222
    }else if(type == CODEC_TYPE_AUDIO)
223
        return fmt->audio_codec;
224
    else
225
        return CODEC_ID_NONE;
226
}
227

    
228
AVInputFormat *av_find_input_format(const char *short_name)
229
{
230
    AVInputFormat *fmt;
231
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
232
        if (!strcmp(fmt->name, short_name))
233
            return fmt;
234
    }
235
    return NULL;
236
}
237

    
238
/* memory handling */
239

    
240
void av_destruct_packet(AVPacket *pkt)
241
{
242
    av_free(pkt->data);
243
    pkt->data = NULL; pkt->size = 0;
244
}
245

    
246
void av_init_packet(AVPacket *pkt)
247
{
248
    pkt->pts   = AV_NOPTS_VALUE;
249
    pkt->dts   = AV_NOPTS_VALUE;
250
    pkt->pos   = -1;
251
    pkt->duration = 0;
252
    pkt->flags = 0;
253
    pkt->stream_index = 0;
254
    pkt->destruct= av_destruct_packet_nofree;
255
}
256

    
257
int av_new_packet(AVPacket *pkt, int size)
258
{
259
    uint8_t *data;
260
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
261
        return AVERROR(ENOMEM);
262
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
263
    if (!data)
264
        return AVERROR(ENOMEM);
265
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
266

    
267
    av_init_packet(pkt);
268
    pkt->data = data;
269
    pkt->size = size;
270
    pkt->destruct = av_destruct_packet;
271
    return 0;
272
}
273

    
274
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
275
{
276
    int ret= av_new_packet(pkt, size);
277

    
278
    if(ret<0)
279
        return ret;
280

    
281
    pkt->pos= url_ftell(s);
282

    
283
    ret= get_buffer(s, pkt->data, size);
284
    if(ret<=0)
285
        av_free_packet(pkt);
286
    else
287
        pkt->size= ret;
288

    
289
    return ret;
290
}
291

    
292
int av_dup_packet(AVPacket *pkt)
293
{
294
    if (pkt->destruct != av_destruct_packet) {
295
        uint8_t *data;
296
        /* We duplicate the packet and don't forget to add the padding again. */
297
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
298
            return AVERROR(ENOMEM);
299
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
300
        if (!data) {
301
            return AVERROR(ENOMEM);
302
        }
303
        memcpy(data, pkt->data, pkt->size);
304
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
305
        pkt->data = data;
306
        pkt->destruct = av_destruct_packet;
307
    }
308
    return 0;
309
}
310

    
311
int av_filename_number_test(const char *filename)
312
{
313
    char buf[1024];
314
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
315
}
316

    
317
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
318
{
319
    AVInputFormat *fmt1, *fmt;
320
    int score;
321

    
322
    fmt = NULL;
323
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
324
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
325
            continue;
326
        score = 0;
327
        if (fmt1->read_probe) {
328
            score = fmt1->read_probe(pd);
329
        } else if (fmt1->extensions) {
330
            if (match_ext(pd->filename, fmt1->extensions)) {
331
                score = 50;
332
            }
333
        }
334
        if (score > *score_max) {
335
            *score_max = score;
336
            fmt = fmt1;
337
        }else if (score == *score_max)
338
            fmt = NULL;
339
    }
340
    return fmt;
341
}
342

    
343
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
344
    int score=0;
345
    return av_probe_input_format2(pd, is_opened, &score);
346
}
347

    
348
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
349
{
350
    AVInputFormat *fmt;
351
    fmt = av_probe_input_format2(pd, 1, &score);
352

    
353
    if (fmt) {
354
        if (!strcmp(fmt->name, "mp3"))
355
            st->codec->codec_id = CODEC_ID_MP3;
356
        else if (!strcmp(fmt->name, "ac3"))
357
            st->codec->codec_id = CODEC_ID_AC3;
358
        else if (!strcmp(fmt->name, "mpegvideo"))
359
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
360
        else if (!strcmp(fmt->name, "h264"))
361
            st->codec->codec_id = CODEC_ID_H264;
362
    }
363
    return !!fmt;
364
}
365

    
366
/************************************************************/
367
/* input media file */
368

    
369
/**
370
 * Open a media file from an IO stream. 'fmt' must be specified.
371
 */
372
static const char* format_to_name(void* ptr)
373
{
374
    AVFormatContext* fc = (AVFormatContext*) ptr;
375
    if(fc->iformat) return fc->iformat->name;
376
    else if(fc->oformat) return fc->oformat->name;
377
    else return "NULL";
378
}
379

    
380
#define OFFSET(x) offsetof(AVFormatContext,x)
381
#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
382
//these names are too long to be readable
383
#define E AV_OPT_FLAG_ENCODING_PARAM
384
#define D AV_OPT_FLAG_DECODING_PARAM
385

    
386
static const AVOption options[]={
387
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
388
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
389
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
390
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
391
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
392
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
393
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
394
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
395
{"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
396
{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
397
{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
398
{"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, 3041280, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
399
{"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E|D, "fdebug"},
400
{"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E|D, "fdebug"},
401
{NULL},
402
};
403

    
404
#undef E
405
#undef D
406
#undef DEFAULT
407

    
408
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
409

    
410
static void avformat_get_context_defaults(AVFormatContext *s)
411
{
412
    memset(s, 0, sizeof(AVFormatContext));
413

    
414
    s->av_class = &av_format_context_class;
415

    
416
    av_opt_set_defaults(s);
417
}
418

    
419
AVFormatContext *av_alloc_format_context(void)
420
{
421
    AVFormatContext *ic;
422
    ic = av_malloc(sizeof(AVFormatContext));
423
    if (!ic) return ic;
424
    avformat_get_context_defaults(ic);
425
    ic->av_class = &av_format_context_class;
426
    return ic;
427
}
428

    
429
int av_open_input_stream(AVFormatContext **ic_ptr,
430
                         ByteIOContext *pb, const char *filename,
431
                         AVInputFormat *fmt, AVFormatParameters *ap)
432
{
433
    int err;
434
    AVFormatContext *ic;
435
    AVFormatParameters default_ap;
436

    
437
    if(!ap){
438
        ap=&default_ap;
439
        memset(ap, 0, sizeof(default_ap));
440
    }
441

    
442
    if(!ap->prealloced_context)
443
        ic = av_alloc_format_context();
444
    else
445
        ic = *ic_ptr;
446
    if (!ic) {
447
        err = AVERROR(ENOMEM);
448
        goto fail;
449
    }
450
    ic->iformat = fmt;
451
    ic->pb = pb;
452
    ic->duration = AV_NOPTS_VALUE;
453
    ic->start_time = AV_NOPTS_VALUE;
454
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
455

    
456
    /* allocate private data */
457
    if (fmt->priv_data_size > 0) {
458
        ic->priv_data = av_mallocz(fmt->priv_data_size);
459
        if (!ic->priv_data) {
460
            err = AVERROR(ENOMEM);
461
            goto fail;
462
        }
463
    } else {
464
        ic->priv_data = NULL;
465
    }
466

    
467
    if (ic->iformat->read_header) {
468
        err = ic->iformat->read_header(ic, ap);
469
        if (err < 0)
470
            goto fail;
471
    }
472

    
473
    if (pb && !ic->data_offset)
474
        ic->data_offset = url_ftell(ic->pb);
475

    
476
    *ic_ptr = ic;
477
    return 0;
478
 fail:
479
    if (ic) {
480
        int i;
481
        av_freep(&ic->priv_data);
482
        for(i=0;i<ic->nb_streams;i++) {
483
            AVStream *st = ic->streams[i];
484
            if (st) {
485
                av_free(st->priv_data);
486
                av_free(st->codec->extradata);
487
            }
488
            av_free(st);
489
        }
490
    }
491
    av_free(ic);
492
    *ic_ptr = NULL;
493
    return err;
494
}
495

    
496
/** size of probe buffer, for guessing file type from file contents */
497
#define PROBE_BUF_MIN 2048
498
#define PROBE_BUF_MAX (1<<20)
499

    
500
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
501
                       AVInputFormat *fmt,
502
                       int buf_size,
503
                       AVFormatParameters *ap)
504
{
505
    int err, probe_size;
506
    AVProbeData probe_data, *pd = &probe_data;
507
    ByteIOContext *pb = NULL;
508

    
509
    pd->filename = "";
510
    if (filename)
511
        pd->filename = filename;
512
    pd->buf = NULL;
513
    pd->buf_size = 0;
514

    
515
    if (!fmt) {
516
        /* guess format if no file can be opened */
517
        fmt = av_probe_input_format(pd, 0);
518
    }
519

    
520
    /* Do not open file if the format does not need it. XXX: specific
521
       hack needed to handle RTSP/TCP */
522
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
523
        /* if no file needed do not try to open one */
524
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
525
            goto fail;
526
        }
527
        if (buf_size > 0) {
528
            url_setbufsize(pb, buf_size);
529
        }
530

    
531
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
532
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
533
            /* read probe data */
534
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
535
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
536
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
537
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
538
                url_fclose(pb);
539
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
540
                    pb = NULL;
541
                    err = AVERROR(EIO);
542
                    goto fail;
543
                }
544
            }
545
            /* guess file format */
546
            fmt = av_probe_input_format2(pd, 1, &score);
547
        }
548
        av_freep(&pd->buf);
549
    }
550

    
551
    /* if still no format found, error */
552
    if (!fmt) {
553
        err = AVERROR_NOFMT;
554
        goto fail;
555
    }
556

    
557
    /* check filename in case an image number is expected */
558
    if (fmt->flags & AVFMT_NEEDNUMBER) {
559
        if (!av_filename_number_test(filename)) {
560
            err = AVERROR_NUMEXPECTED;
561
            goto fail;
562
        }
563
    }
564
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
565
    if (err)
566
        goto fail;
567
    return 0;
568
 fail:
569
    av_freep(&pd->buf);
570
    if (pb)
571
        url_fclose(pb);
572
    *ic_ptr = NULL;
573
    return err;
574

    
575
}
576

    
577
/*******************************************************/
578

    
579
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
580
                               AVPacketList **plast_pktl){
581
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
582
    if (!pktl)
583
        return NULL;
584

    
585
    if (*packet_buffer)
586
        (*plast_pktl)->next = pktl;
587
    else
588
        *packet_buffer = pktl;
589

    
590
    /* add the packet in the buffered packet list */
591
    *plast_pktl = pktl;
592
    pktl->pkt= *pkt;
593
    return &pktl->pkt;
594
}
595

    
596
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
597
{
598
    int ret;
599
    AVStream *st;
600

    
601
    for(;;){
602
        AVPacketList *pktl = s->raw_packet_buffer;
603

    
604
        if (pktl) {
605
            *pkt = pktl->pkt;
606
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
607
                s->raw_packet_buffer = pktl->next;
608
                av_free(pktl);
609
                return 0;
610
            }
611
        }
612

    
613
        av_init_packet(pkt);
614
        ret= s->iformat->read_packet(s, pkt);
615
        if (ret < 0)
616
            return ret;
617
        st= s->streams[pkt->stream_index];
618

    
619
        switch(st->codec->codec_type){
620
        case CODEC_TYPE_VIDEO:
621
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
622
            break;
623
        case CODEC_TYPE_AUDIO:
624
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
625
            break;
626
        case CODEC_TYPE_SUBTITLE:
627
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
628
            break;
629
        }
630

    
631
        if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
632
            return ret;
633

    
634
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
635

    
636
        if(st->codec->codec_id == CODEC_ID_PROBE){
637
            AVProbeData *pd = &st->probe_data;
638

    
639
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
640
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
641
            pd->buf_size += pkt->size;
642
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
643

    
644
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
645
                set_codec_from_probe_data(st, pd, 1);
646
                if(st->codec->codec_id != CODEC_ID_PROBE){
647
                    pd->buf_size=0;
648
                    av_freep(&pd->buf);
649
                }
650
            }
651
        }
652
    }
653
}
654

    
655
/**********************************************************/
656

    
657
/**
658
 * Get the number of samples of an audio frame. Return -1 on error.
659
 */
660
static int get_audio_frame_size(AVCodecContext *enc, int size)
661
{
662
    int frame_size;
663

    
664
    if(enc->codec_id == CODEC_ID_VORBIS)
665
        return -1;
666

    
667
    if (enc->frame_size <= 1) {
668
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
669

    
670
        if (bits_per_sample) {
671
            if (enc->channels == 0)
672
                return -1;
673
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
674
        } else {
675
            /* used for example by ADPCM codecs */
676
            if (enc->bit_rate == 0)
677
                return -1;
678
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
679
        }
680
    } else {
681
        frame_size = enc->frame_size;
682
    }
683
    return frame_size;
684
}
685

    
686

    
687
/**
688
 * Return the frame duration in seconds. Return 0 if not available.
689
 */
690
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
691
                                   AVCodecParserContext *pc, AVPacket *pkt)
692
{
693
    int frame_size;
694

    
695
    *pnum = 0;
696
    *pden = 0;
697
    switch(st->codec->codec_type) {
698
    case CODEC_TYPE_VIDEO:
699
        if(st->time_base.num*1000LL > st->time_base.den){
700
            *pnum = st->time_base.num;
701
            *pden = st->time_base.den;
702
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
703
            *pnum = st->codec->time_base.num;
704
            *pden = st->codec->time_base.den;
705
            if (pc && pc->repeat_pict) {
706
                *pden *= 2;
707
                *pnum = (*pnum) * (2 + pc->repeat_pict);
708
            }
709
        }
710
        break;
711
    case CODEC_TYPE_AUDIO:
712
        frame_size = get_audio_frame_size(st->codec, pkt->size);
713
        if (frame_size < 0)
714
            break;
715
        *pnum = frame_size;
716
        *pden = st->codec->sample_rate;
717
        break;
718
    default:
719
        break;
720
    }
721
}
722

    
723
static int is_intra_only(AVCodecContext *enc){
724
    if(enc->codec_type == CODEC_TYPE_AUDIO){
725
        return 1;
726
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
727
        switch(enc->codec_id){
728
        case CODEC_ID_MJPEG:
729
        case CODEC_ID_MJPEGB:
730
        case CODEC_ID_LJPEG:
731
        case CODEC_ID_RAWVIDEO:
732
        case CODEC_ID_DVVIDEO:
733
        case CODEC_ID_HUFFYUV:
734
        case CODEC_ID_FFVHUFF:
735
        case CODEC_ID_ASV1:
736
        case CODEC_ID_ASV2:
737
        case CODEC_ID_VCR1:
738
            return 1;
739
        default: break;
740
        }
741
    }
742
    return 0;
743
}
744

    
745
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
746
                                      int64_t dts, int64_t pts)
747
{
748
    AVStream *st= s->streams[stream_index];
749
    AVPacketList *pktl= s->packet_buffer;
750

    
751
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
752
        return;
753

    
754
    st->first_dts= dts - st->cur_dts;
755
    st->cur_dts= dts;
756

    
757
    for(; pktl; pktl= pktl->next){
758
        if(pktl->pkt.stream_index != stream_index)
759
            continue;
760
        //FIXME think more about this check
761
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
762
            pktl->pkt.pts += st->first_dts;
763

    
764
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
765
            pktl->pkt.dts += st->first_dts;
766

    
767
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
768
            st->start_time= pktl->pkt.pts;
769
    }
770
    if (st->start_time == AV_NOPTS_VALUE)
771
        st->start_time = pts;
772
}
773

    
774
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
775
{
776
    AVPacketList *pktl= s->packet_buffer;
777
    int64_t cur_dts= 0;
778

    
779
    if(st->first_dts != AV_NOPTS_VALUE){
780
        cur_dts= st->first_dts;
781
        for(; pktl; pktl= pktl->next){
782
            if(pktl->pkt.stream_index == pkt->stream_index){
783
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
784
                    break;
785
                cur_dts -= pkt->duration;
786
            }
787
        }
788
        pktl= s->packet_buffer;
789
        st->first_dts = cur_dts;
790
    }else if(st->cur_dts)
791
        return;
792

    
793
    for(; pktl; pktl= pktl->next){
794
        if(pktl->pkt.stream_index != pkt->stream_index)
795
            continue;
796
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
797
           && !pktl->pkt.duration){
798
            pktl->pkt.dts= cur_dts;
799
            if(!st->codec->has_b_frames)
800
                pktl->pkt.pts= cur_dts;
801
            cur_dts += pkt->duration;
802
            pktl->pkt.duration= pkt->duration;
803
        }else
804
            break;
805
    }
806
    if(st->first_dts == AV_NOPTS_VALUE)
807
        st->cur_dts= cur_dts;
808
}
809

    
810
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
811
                               AVCodecParserContext *pc, AVPacket *pkt)
812
{
813
    int num, den, presentation_delayed, delay, i;
814
    int64_t offset;
815

    
816
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
817
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
818
        pkt->dts -= 1LL<<st->pts_wrap_bits;
819
    }
820

    
821
    if (pkt->duration == 0) {
822
        compute_frame_duration(&num, &den, st, pc, pkt);
823
        if (den && num) {
824
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
825

    
826
            if(pkt->duration != 0 && s->packet_buffer)
827
                update_initial_durations(s, st, pkt);
828
        }
829
    }
830

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

    
842
    /* do we have a video B-frame ? */
843
    delay= st->codec->has_b_frames;
844
    presentation_delayed = 0;
845
    /* XXX: need has_b_frame, but cannot get it if the codec is
846
        not initialized */
847
    if (delay &&
848
        pc && pc->pict_type != FF_B_TYPE)
849
        presentation_delayed = 1;
850
    /* This may be redundant, but it should not hurt. */
851
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
852
        presentation_delayed = 1;
853

    
854
//    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);
855
    /* interpolate PTS and DTS if they are not present */
856
    if(delay==0 || (delay==1 && pc)){
857
        if (presentation_delayed) {
858
            /* DTS = decompression timestamp */
859
            /* PTS = presentation timestamp */
860
            if (pkt->dts == AV_NOPTS_VALUE)
861
                pkt->dts = st->last_IP_pts;
862
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
863
            if (pkt->dts == AV_NOPTS_VALUE)
864
                pkt->dts = st->cur_dts;
865

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

    
886
            /* presentation is not delayed : PTS and DTS are the same */
887
            if(pkt->pts == AV_NOPTS_VALUE)
888
                pkt->pts = pkt->dts;
889
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
890
            if(pkt->pts == AV_NOPTS_VALUE)
891
                pkt->pts = st->cur_dts;
892
            pkt->dts = pkt->pts;
893
            if(pkt->pts != AV_NOPTS_VALUE)
894
                st->cur_dts = pkt->pts + pkt->duration;
895
        }
896
    }
897

    
898
    if(pkt->pts != AV_NOPTS_VALUE){
899
        st->pts_buffer[0]= pkt->pts;
900
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
901
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
902
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
903
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
904
        if(pkt->dts == AV_NOPTS_VALUE)
905
            pkt->dts= st->pts_buffer[0];
906
        if(delay>1){
907
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
908
        }
909
        if(pkt->dts > st->cur_dts)
910
            st->cur_dts = pkt->dts;
911
    }
912

    
913
//    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);
914

    
915
    /* update flags */
916
    if(is_intra_only(st->codec))
917
        pkt->flags |= PKT_FLAG_KEY;
918
    else if (pc) {
919
        pkt->flags = 0;
920
        /* keyframe computation */
921
            if (pc->pict_type == FF_I_TYPE)
922
                pkt->flags |= PKT_FLAG_KEY;
923
    }
924
}
925

    
926
void av_destruct_packet_nofree(AVPacket *pkt)
927
{
928
    pkt->data = NULL; pkt->size = 0;
929
}
930

    
931
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
932
{
933
    AVStream *st;
934
    int len, ret, i;
935

    
936
    av_init_packet(pkt);
937

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

    
959
                /* return packet if any */
960
                if (pkt->size) {
961
                got_packet:
962
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
963
                    pkt->duration = 0;
964
                    pkt->stream_index = st->index;
965
                    pkt->pts = st->parser->pts;
966
                    pkt->dts = st->parser->dts;
967
                    pkt->destruct = av_destruct_packet_nofree;
968
                    compute_pkt_fields(s, st, st->parser, pkt);
969

    
970
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
971
                        ff_reduce_index(s, st->index);
972
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
973
                                           0, 0, AVINDEX_KEYFRAME);
974
                    }
975

    
976
                    break;
977
                }
978
            } else {
979
                /* free packet */
980
                av_free_packet(&s->cur_pkt);
981
                s->cur_st = NULL;
982
            }
983
        } else {
984
            /* read next packet */
985
            ret = av_read_packet(s, &s->cur_pkt);
986
            if (ret < 0) {
987
                if (ret == AVERROR(EAGAIN))
988
                    return ret;
989
                /* return the last frames, if any */
990
                for(i = 0; i < s->nb_streams; i++) {
991
                    st = s->streams[i];
992
                    if (st->parser && st->need_parsing) {
993
                        av_parser_parse(st->parser, st->codec,
994
                                        &pkt->data, &pkt->size,
995
                                        NULL, 0,
996
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
997
                        if (pkt->size)
998
                            goto got_packet;
999
                    }
1000
                }
1001
                /* no more packets: really terminate parsing */
1002
                return ret;
1003
            }
1004

    
1005
            if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
1006
               s->cur_pkt.dts != AV_NOPTS_VALUE &&
1007
               s->cur_pkt.pts < s->cur_pkt.dts){
1008
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1009
                    s->cur_pkt.stream_index,
1010
                    s->cur_pkt.pts,
1011
                    s->cur_pkt.dts,
1012
                    s->cur_pkt.size);
1013
//                av_free_packet(&s->cur_pkt);
1014
//                return -1;
1015
            }
1016

    
1017
            st = s->streams[s->cur_pkt.stream_index];
1018
            if(s->debug & FF_FDEBUG_TS)
1019
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
1020
                    s->cur_pkt.stream_index,
1021
                    s->cur_pkt.pts,
1022
                    s->cur_pkt.dts,
1023
                    s->cur_pkt.size,
1024
                    s->cur_pkt.flags);
1025

    
1026
            s->cur_st = st;
1027
            s->cur_ptr = s->cur_pkt.data;
1028
            s->cur_len = s->cur_pkt.size;
1029
            if (st->need_parsing && !st->parser) {
1030
                st->parser = av_parser_init(st->codec->codec_id);
1031
                if (!st->parser) {
1032
                    /* no parser available: just output the raw packets */
1033
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1034
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1035
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1036
                }
1037
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1038
                    st->parser->next_frame_offset=
1039
                    st->parser->cur_offset= s->cur_pkt.pos;
1040
                }
1041
            }
1042
        }
1043
    }
1044
    if(s->debug & FF_FDEBUG_TS)
1045
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1046
            pkt->stream_index,
1047
            pkt->pts,
1048
            pkt->dts,
1049
            pkt->size,
1050
            pkt->flags);
1051

    
1052
    return 0;
1053
}
1054

    
1055
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1056
{
1057
    AVPacketList *pktl;
1058
    int eof=0;
1059
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1060

    
1061
    for(;;){
1062
        pktl = s->packet_buffer;
1063
        if (pktl) {
1064
            AVPacket *next_pkt= &pktl->pkt;
1065

    
1066
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1067
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1068
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1069
                       && next_pkt->dts < pktl->pkt.dts
1070
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1071
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1072
                        next_pkt->pts= pktl->pkt.dts;
1073
                    }
1074
                    pktl= pktl->next;
1075
                }
1076
                pktl = s->packet_buffer;
1077
            }
1078

    
1079
            if(   next_pkt->pts != AV_NOPTS_VALUE
1080
               || next_pkt->dts == AV_NOPTS_VALUE
1081
               || !genpts || eof){
1082
                /* read packet from packet buffer, if there is data */
1083
                *pkt = *next_pkt;
1084
                s->packet_buffer = pktl->next;
1085
                av_free(pktl);
1086
                return 0;
1087
            }
1088
        }
1089
        if(genpts){
1090
            int ret= av_read_frame_internal(s, pkt);
1091
            if(ret<0){
1092
                if(pktl && ret != AVERROR(EAGAIN)){
1093
                    eof=1;
1094
                    continue;
1095
                }else
1096
                    return ret;
1097
            }
1098

    
1099
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1100
                                           &s->packet_buffer_end)) < 0)
1101
                return AVERROR(ENOMEM);
1102
        }else{
1103
            assert(!s->packet_buffer);
1104
            return av_read_frame_internal(s, pkt);
1105
        }
1106
    }
1107
}
1108

    
1109
/* XXX: suppress the packet queue */
1110
static void flush_packet_queue(AVFormatContext *s)
1111
{
1112
    AVPacketList *pktl;
1113

    
1114
    for(;;) {
1115
        pktl = s->packet_buffer;
1116
        if (!pktl)
1117
            break;
1118
        s->packet_buffer = pktl->next;
1119
        av_free_packet(&pktl->pkt);
1120
        av_free(pktl);
1121
    }
1122
}
1123

    
1124
/*******************************************************/
1125
/* seek support */
1126

    
1127
int av_find_default_stream_index(AVFormatContext *s)
1128
{
1129
    int first_audio_index = -1;
1130
    int i;
1131
    AVStream *st;
1132

    
1133
    if (s->nb_streams <= 0)
1134
        return -1;
1135
    for(i = 0; i < s->nb_streams; i++) {
1136
        st = s->streams[i];
1137
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1138
            return i;
1139
        }
1140
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1141
            first_audio_index = i;
1142
    }
1143
    return first_audio_index >= 0 ? first_audio_index : 0;
1144
}
1145

    
1146
/**
1147
 * Flush the frame reader.
1148
 */
1149
static void av_read_frame_flush(AVFormatContext *s)
1150
{
1151
    AVStream *st;
1152
    int i;
1153

    
1154
    flush_packet_queue(s);
1155

    
1156
    /* free previous packet */
1157
    if (s->cur_st) {
1158
        if (s->cur_st->parser)
1159
            av_free_packet(&s->cur_pkt);
1160
        s->cur_st = NULL;
1161
    }
1162
    /* fail safe */
1163
    s->cur_ptr = NULL;
1164
    s->cur_len = 0;
1165

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

    
1170
        if (st->parser) {
1171
            av_parser_close(st->parser);
1172
            st->parser = NULL;
1173
        }
1174
        st->last_IP_pts = AV_NOPTS_VALUE;
1175
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1176
    }
1177
}
1178

    
1179
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1180
    int i;
1181

    
1182
    for(i = 0; i < s->nb_streams; i++) {
1183
        AVStream *st = s->streams[i];
1184

    
1185
        st->cur_dts = av_rescale(timestamp,
1186
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1187
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1188
    }
1189
}
1190

    
1191
void ff_reduce_index(AVFormatContext *s, int stream_index)
1192
{
1193
    AVStream *st= s->streams[stream_index];
1194
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1195

    
1196
    if((unsigned)st->nb_index_entries >= max_entries){
1197
        int i;
1198
        for(i=0; 2*i<st->nb_index_entries; i++)
1199
            st->index_entries[i]= st->index_entries[2*i];
1200
        st->nb_index_entries= i;
1201
    }
1202
}
1203

    
1204
int av_add_index_entry(AVStream *st,
1205
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1206
{
1207
    AVIndexEntry *entries, *ie;
1208
    int index;
1209

    
1210
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1211
        return -1;
1212

    
1213
    entries = av_fast_realloc(st->index_entries,
1214
                              &st->index_entries_allocated_size,
1215
                              (st->nb_index_entries + 1) *
1216
                              sizeof(AVIndexEntry));
1217
    if(!entries)
1218
        return -1;
1219

    
1220
    st->index_entries= entries;
1221

    
1222
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1223

    
1224
    if(index<0){
1225
        index= st->nb_index_entries++;
1226
        ie= &entries[index];
1227
        assert(index==0 || ie[-1].timestamp < timestamp);
1228
    }else{
1229
        ie= &entries[index];
1230
        if(ie->timestamp != timestamp){
1231
            if(ie->timestamp <= timestamp)
1232
                return -1;
1233
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1234
            st->nb_index_entries++;
1235
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1236
            distance= ie->min_distance;
1237
    }
1238

    
1239
    ie->pos = pos;
1240
    ie->timestamp = timestamp;
1241
    ie->min_distance= distance;
1242
    ie->size= size;
1243
    ie->flags = flags;
1244

    
1245
    return index;
1246
}
1247

    
1248
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1249
                              int flags)
1250
{
1251
    AVIndexEntry *entries= st->index_entries;
1252
    int nb_entries= st->nb_index_entries;
1253
    int a, b, m;
1254
    int64_t timestamp;
1255

    
1256
    a = - 1;
1257
    b = nb_entries;
1258

    
1259
    while (b - a > 1) {
1260
        m = (a + b) >> 1;
1261
        timestamp = entries[m].timestamp;
1262
        if(timestamp >= wanted_timestamp)
1263
            b = m;
1264
        if(timestamp <= wanted_timestamp)
1265
            a = m;
1266
    }
1267
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1268

    
1269
    if(!(flags & AVSEEK_FLAG_ANY)){
1270
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1271
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1272
        }
1273
    }
1274

    
1275
    if(m == nb_entries)
1276
        return -1;
1277
    return  m;
1278
}
1279

    
1280
#define DEBUG_SEEK
1281

    
1282
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1283
    AVInputFormat *avif= s->iformat;
1284
    int64_t pos_min, pos_max, pos, pos_limit;
1285
    int64_t ts_min, ts_max, ts;
1286
    int index;
1287
    AVStream *st;
1288

    
1289
    if (stream_index < 0)
1290
        return -1;
1291

    
1292
#ifdef DEBUG_SEEK
1293
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1294
#endif
1295

    
1296
    ts_max=
1297
    ts_min= AV_NOPTS_VALUE;
1298
    pos_limit= -1; //gcc falsely says it may be uninitialized
1299

    
1300
    st= s->streams[stream_index];
1301
    if(st->index_entries){
1302
        AVIndexEntry *e;
1303

    
1304
        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()
1305
        index= FFMAX(index, 0);
1306
        e= &st->index_entries[index];
1307

    
1308
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1309
            pos_min= e->pos;
1310
            ts_min= e->timestamp;
1311
#ifdef DEBUG_SEEK
1312
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1313
               pos_min,ts_min);
1314
#endif
1315
        }else{
1316
            assert(index==0);
1317
        }
1318

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

    
1334
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1335
    if(pos<0)
1336
        return -1;
1337

    
1338
    /* do the seek */
1339
    url_fseek(s->pb, pos, SEEK_SET);
1340

    
1341
    av_update_cur_dts(s, st, ts);
1342

    
1343
    return 0;
1344
}
1345

    
1346
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 )){
1347
    int64_t pos, ts;
1348
    int64_t start_pos, filesize;
1349
    int no_change;
1350

    
1351
#ifdef DEBUG_SEEK
1352
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1353
#endif
1354

    
1355
    if(ts_min == AV_NOPTS_VALUE){
1356
        pos_min = s->data_offset;
1357
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1358
        if (ts_min == AV_NOPTS_VALUE)
1359
            return -1;
1360
    }
1361

    
1362
    if(ts_max == AV_NOPTS_VALUE){
1363
        int step= 1024;
1364
        filesize = url_fsize(s->pb);
1365
        pos_max = filesize - 1;
1366
        do{
1367
            pos_max -= step;
1368
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1369
            step += step;
1370
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1371
        if (ts_max == AV_NOPTS_VALUE)
1372
            return -1;
1373

    
1374
        for(;;){
1375
            int64_t tmp_pos= pos_max + 1;
1376
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1377
            if(tmp_ts == AV_NOPTS_VALUE)
1378
                break;
1379
            ts_max= tmp_ts;
1380
            pos_max= tmp_pos;
1381
            if(tmp_pos >= filesize)
1382
                break;
1383
        }
1384
        pos_limit= pos_max;
1385
    }
1386

    
1387
    if(ts_min > ts_max){
1388
        return -1;
1389
    }else if(ts_min == ts_max){
1390
        pos_limit= pos_min;
1391
    }
1392

    
1393
    no_change=0;
1394
    while (pos_min < pos_limit) {
1395
#ifdef DEBUG_SEEK
1396
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1397
               pos_min, pos_max,
1398
               ts_min, ts_max);
1399
#endif
1400
        assert(pos_limit <= pos_max);
1401

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

    
1421
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1422
        if(pos == pos_max)
1423
            no_change++;
1424
        else
1425
            no_change=0;
1426
#ifdef DEBUG_SEEK
1427
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);
1428
#endif
1429
        if(ts == AV_NOPTS_VALUE){
1430
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1431
            return -1;
1432
        }
1433
        assert(ts != AV_NOPTS_VALUE);
1434
        if (target_ts <= ts) {
1435
            pos_limit = start_pos - 1;
1436
            pos_max = pos;
1437
            ts_max = ts;
1438
        }
1439
        if (target_ts >= ts) {
1440
            pos_min = pos;
1441
            ts_min = ts;
1442
        }
1443
    }
1444

    
1445
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1446
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1447
#ifdef DEBUG_SEEK
1448
    pos_min = pos;
1449
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1450
    pos_min++;
1451
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1452
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1453
           pos, ts_min, target_ts, ts_max);
1454
#endif
1455
    *ts_ret= ts;
1456
    return pos;
1457
}
1458

    
1459
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1460
    int64_t pos_min, pos_max;
1461
#if 0
1462
    AVStream *st;
1463

1464
    if (stream_index < 0)
1465
        return -1;
1466

1467
    st= s->streams[stream_index];
1468
#endif
1469

    
1470
    pos_min = s->data_offset;
1471
    pos_max = url_fsize(s->pb) - 1;
1472

    
1473
    if     (pos < pos_min) pos= pos_min;
1474
    else if(pos > pos_max) pos= pos_max;
1475

    
1476
    url_fseek(s->pb, pos, SEEK_SET);
1477

    
1478
#if 0
1479
    av_update_cur_dts(s, st, ts);
1480
#endif
1481
    return 0;
1482
}
1483

    
1484
static int av_seek_frame_generic(AVFormatContext *s,
1485
                                 int stream_index, int64_t timestamp, int flags)
1486
{
1487
    int index, ret;
1488
    AVStream *st;
1489
    AVIndexEntry *ie;
1490

    
1491
    st = s->streams[stream_index];
1492

    
1493
    index = av_index_search_timestamp(st, timestamp, flags);
1494

    
1495
    if(index < 0 || index==st->nb_index_entries-1){
1496
        int i;
1497
        AVPacket pkt;
1498

    
1499
        if(st->nb_index_entries){
1500
            assert(st->index_entries);
1501
            ie= &st->index_entries[st->nb_index_entries-1];
1502
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1503
                return ret;
1504
            av_update_cur_dts(s, st, ie->timestamp);
1505
        }else{
1506
            if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1507
                return ret;
1508
        }
1509
        for(i=0;; i++) {
1510
            int ret = av_read_frame(s, &pkt);
1511
            if(ret<0)
1512
                break;
1513
            av_free_packet(&pkt);
1514
            if(stream_index == pkt.stream_index){
1515
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1516
                    break;
1517
            }
1518
        }
1519
        index = av_index_search_timestamp(st, timestamp, flags);
1520
    }
1521
    if (index < 0)
1522
        return -1;
1523

    
1524
    av_read_frame_flush(s);
1525
    if (s->iformat->read_seek){
1526
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1527
            return 0;
1528
    }
1529
    ie = &st->index_entries[index];
1530
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1531
        return ret;
1532
    av_update_cur_dts(s, st, ie->timestamp);
1533

    
1534
    return 0;
1535
}
1536

    
1537
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1538
{
1539
    int ret;
1540
    AVStream *st;
1541

    
1542
    av_read_frame_flush(s);
1543

    
1544
    if(flags & AVSEEK_FLAG_BYTE)
1545
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1546

    
1547
    if(stream_index < 0){
1548
        stream_index= av_find_default_stream_index(s);
1549
        if(stream_index < 0)
1550
            return -1;
1551

    
1552
        st= s->streams[stream_index];
1553
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1554
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1555
    }
1556
    st= s->streams[stream_index];
1557

    
1558
    /* first, we try the format specific seek */
1559
    if (s->iformat->read_seek)
1560
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1561
    else
1562
        ret = -1;
1563
    if (ret >= 0) {
1564
        return 0;
1565
    }
1566

    
1567
    if(s->iformat->read_timestamp)
1568
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1569
    else
1570
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1571
}
1572

    
1573
/*******************************************************/
1574

    
1575
/**
1576
 * Returns TRUE if the stream has accurate duration in any stream.
1577
 *
1578
 * @return TRUE if the stream has accurate duration for at least one component.
1579
 */
1580
static int av_has_duration(AVFormatContext *ic)
1581
{
1582
    int i;
1583
    AVStream *st;
1584

    
1585
    for(i = 0;i < ic->nb_streams; i++) {
1586
        st = ic->streams[i];
1587
        if (st->duration != AV_NOPTS_VALUE)
1588
            return 1;
1589
    }
1590
    return 0;
1591
}
1592

    
1593
/**
1594
 * Estimate the stream timings from the one of each components.
1595
 *
1596
 * Also computes the global bitrate if possible.
1597
 */
1598
static void av_update_stream_timings(AVFormatContext *ic)
1599
{
1600
    int64_t start_time, start_time1, end_time, end_time1;
1601
    int64_t duration, duration1;
1602
    int i;
1603
    AVStream *st;
1604

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

    
1644
static void fill_all_stream_timings(AVFormatContext *ic)
1645
{
1646
    int i;
1647
    AVStream *st;
1648

    
1649
    av_update_stream_timings(ic);
1650
    for(i = 0;i < ic->nb_streams; i++) {
1651
        st = ic->streams[i];
1652
        if (st->start_time == AV_NOPTS_VALUE) {
1653
            if(ic->start_time != AV_NOPTS_VALUE)
1654
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1655
            if(ic->duration != AV_NOPTS_VALUE)
1656
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1657
        }
1658
    }
1659
}
1660

    
1661
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1662
{
1663
    int64_t filesize, duration;
1664
    int bit_rate, i;
1665
    AVStream *st;
1666

    
1667
    /* if bit_rate is already set, we believe it */
1668
    if (ic->bit_rate == 0) {
1669
        bit_rate = 0;
1670
        for(i=0;i<ic->nb_streams;i++) {
1671
            st = ic->streams[i];
1672
            bit_rate += st->codec->bit_rate;
1673
        }
1674
        ic->bit_rate = bit_rate;
1675
    }
1676

    
1677
    /* if duration is already set, we believe it */
1678
    if (ic->duration == AV_NOPTS_VALUE &&
1679
        ic->bit_rate != 0 &&
1680
        ic->file_size != 0)  {
1681
        filesize = ic->file_size;
1682
        if (filesize > 0) {
1683
            for(i = 0; i < ic->nb_streams; i++) {
1684
                st = ic->streams[i];
1685
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1686
                if (st->duration == AV_NOPTS_VALUE)
1687
                    st->duration = duration;
1688
            }
1689
        }
1690
    }
1691
}
1692

    
1693
#define DURATION_MAX_READ_SIZE 250000
1694

    
1695
/* only usable for MPEG-PS streams */
1696
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1697
{
1698
    AVPacket pkt1, *pkt = &pkt1;
1699
    AVStream *st;
1700
    int read_size, i, ret;
1701
    int64_t end_time;
1702
    int64_t filesize, offset, duration;
1703

    
1704
    /* free previous packet */
1705
    if (ic->cur_st && ic->cur_st->parser)
1706
        av_free_packet(&ic->cur_pkt);
1707
    ic->cur_st = NULL;
1708

    
1709
    /* flush packet queue */
1710
    flush_packet_queue(ic);
1711

    
1712
    for(i=0;i<ic->nb_streams;i++) {
1713
        st = ic->streams[i];
1714
        if (st->parser) {
1715
            av_parser_close(st->parser);
1716
            st->parser= NULL;
1717
        }
1718
    }
1719

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

    
1736
        ret = av_read_packet(ic, pkt);
1737
        if (ret != 0)
1738
            break;
1739
        read_size += pkt->size;
1740
        st = ic->streams[pkt->stream_index];
1741
        if (pkt->pts != AV_NOPTS_VALUE) {
1742
            if (st->start_time == AV_NOPTS_VALUE)
1743
                st->start_time = pkt->pts;
1744
        }
1745
        av_free_packet(pkt);
1746
    }
1747

    
1748
    /* estimate the end time (duration) */
1749
    /* XXX: may need to support wrapping */
1750
    filesize = ic->file_size;
1751
    offset = filesize - DURATION_MAX_READ_SIZE;
1752
    if (offset < 0)
1753
        offset = 0;
1754

    
1755
    url_fseek(ic->pb, offset, SEEK_SET);
1756
    read_size = 0;
1757
    for(;;) {
1758
        if (read_size >= DURATION_MAX_READ_SIZE)
1759
            break;
1760

    
1761
        ret = av_read_packet(ic, pkt);
1762
        if (ret != 0)
1763
            break;
1764
        read_size += pkt->size;
1765
        st = ic->streams[pkt->stream_index];
1766
        if (pkt->pts != AV_NOPTS_VALUE &&
1767
            st->start_time != AV_NOPTS_VALUE) {
1768
            end_time = pkt->pts;
1769
            duration = end_time - st->start_time;
1770
            if (duration > 0) {
1771
                if (st->duration == AV_NOPTS_VALUE ||
1772
                    st->duration < duration)
1773
                    st->duration = duration;
1774
            }
1775
        }
1776
        av_free_packet(pkt);
1777
    }
1778

    
1779
    fill_all_stream_timings(ic);
1780

    
1781
    url_fseek(ic->pb, old_offset, SEEK_SET);
1782
    for(i=0; i<ic->nb_streams; i++){
1783
        st= ic->streams[i];
1784
        st->cur_dts= st->first_dts;
1785
        st->last_IP_pts = AV_NOPTS_VALUE;
1786
    }
1787
}
1788

    
1789
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1790
{
1791
    int64_t file_size;
1792

    
1793
    /* get the file size, if possible */
1794
    if (ic->iformat->flags & AVFMT_NOFILE) {
1795
        file_size = 0;
1796
    } else {
1797
        file_size = url_fsize(ic->pb);
1798
        if (file_size < 0)
1799
            file_size = 0;
1800
    }
1801
    ic->file_size = file_size;
1802

    
1803
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1804
         !strcmp(ic->iformat->name, "mpegts")) &&
1805
        file_size && !url_is_streamed(ic->pb)) {
1806
        /* get accurate estimate from the PTSes */
1807
        av_estimate_timings_from_pts(ic, old_offset);
1808
    } else if (av_has_duration(ic)) {
1809
        /* at least one component has timings - we use them for all
1810
           the components */
1811
        fill_all_stream_timings(ic);
1812
    } else {
1813
        /* less precise: use bitrate info */
1814
        av_estimate_timings_from_bit_rate(ic);
1815
    }
1816
    av_update_stream_timings(ic);
1817

    
1818
#if 0
1819
    {
1820
        int i;
1821
        AVStream *st;
1822
        for(i = 0;i < ic->nb_streams; i++) {
1823
            st = ic->streams[i];
1824
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1825
               i, (double)st->start_time / AV_TIME_BASE,
1826
               (double)st->duration / AV_TIME_BASE);
1827
        }
1828
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1829
               (double)ic->start_time / AV_TIME_BASE,
1830
               (double)ic->duration / AV_TIME_BASE,
1831
               ic->bit_rate / 1000);
1832
    }
1833
#endif
1834
}
1835

    
1836
static int has_codec_parameters(AVCodecContext *enc)
1837
{
1838
    int val;
1839
    switch(enc->codec_type) {
1840
    case CODEC_TYPE_AUDIO:
1841
        val = enc->sample_rate && enc->channels;
1842
        if(!enc->frame_size &&
1843
           (enc->codec_id == CODEC_ID_VORBIS ||
1844
            enc->codec_id == CODEC_ID_AAC))
1845
            return 0;
1846
        break;
1847
    case CODEC_TYPE_VIDEO:
1848
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1849
        break;
1850
    default:
1851
        val = 1;
1852
        break;
1853
    }
1854
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1855
}
1856

    
1857
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1858
{
1859
    int16_t *samples;
1860
    AVCodec *codec;
1861
    int got_picture, data_size, ret=0;
1862
    AVFrame picture;
1863

    
1864
  if(!st->codec->codec){
1865
    codec = avcodec_find_decoder(st->codec->codec_id);
1866
    if (!codec)
1867
        return -1;
1868
    ret = avcodec_open(st->codec, codec);
1869
    if (ret < 0)
1870
        return ret;
1871
  }
1872

    
1873
  if(!has_codec_parameters(st->codec)){
1874
    switch(st->codec->codec_type) {
1875
    case CODEC_TYPE_VIDEO:
1876
        ret = avcodec_decode_video(st->codec, &picture,
1877
                                   &got_picture, data, size);
1878
        break;
1879
    case CODEC_TYPE_AUDIO:
1880
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1881
        samples = av_malloc(data_size);
1882
        if (!samples)
1883
            goto fail;
1884
        ret = avcodec_decode_audio2(st->codec, samples,
1885
                                    &data_size, data, size);
1886
        av_free(samples);
1887
        break;
1888
    default:
1889
        break;
1890
    }
1891
  }
1892
 fail:
1893
    return ret;
1894
}
1895

    
1896
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1897
{
1898
    while (tags->id != CODEC_ID_NONE) {
1899
        if (tags->id == id)
1900
            return tags->tag;
1901
        tags++;
1902
    }
1903
    return 0;
1904
}
1905

    
1906
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1907
{
1908
    int i;
1909
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1910
        if(tag == tags[i].tag)
1911
            return tags[i].id;
1912
    }
1913
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1914
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1915
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1916
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1917
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1918
            return tags[i].id;
1919
    }
1920
    return CODEC_ID_NONE;
1921
}
1922

    
1923
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1924
{
1925
    int i;
1926
    for(i=0; tags && tags[i]; i++){
1927
        int tag= codec_get_tag(tags[i], id);
1928
        if(tag) return tag;
1929
    }
1930
    return 0;
1931
}
1932

    
1933
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1934
{
1935
    int i;
1936
    for(i=0; tags && tags[i]; i++){
1937
        enum CodecID id= codec_get_id(tags[i], tag);
1938
        if(id!=CODEC_ID_NONE) return id;
1939
    }
1940
    return CODEC_ID_NONE;
1941
}
1942

    
1943
static void compute_chapters_end(AVFormatContext *s)
1944
{
1945
    unsigned int i;
1946

    
1947
    for (i=0; i+1<s->nb_chapters; i++)
1948
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1949
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1950
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1951
            s->chapters[i]->end = s->chapters[i+1]->start;
1952
        }
1953

    
1954
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1955
        assert(s->start_time != AV_NOPTS_VALUE);
1956
        assert(s->duration > 0);
1957
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1958
                                           AV_TIME_BASE_Q,
1959
                                           s->chapters[i]->time_base);
1960
    }
1961
}
1962

    
1963
/* absolute maximum size we read until we abort */
1964
#define MAX_READ_SIZE        5000000
1965

    
1966
#define MAX_STD_TIMEBASES (60*12+5)
1967
static int get_std_framerate(int i){
1968
    if(i<60*12) return i*1001;
1969
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1970
}
1971

    
1972
/*
1973
 * Is the time base unreliable.
1974
 * This is a heuristic to balance between quick acceptance of the values in
1975
 * the headers vs. some extra checks.
1976
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1977
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1978
 * And there are "variable" fps files this needs to detect as well.
1979
 */
1980
static int tb_unreliable(AVCodecContext *c){
1981
    if(   c->time_base.den >= 101L*c->time_base.num
1982
       || c->time_base.den <    5L*c->time_base.num
1983
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1984
       || c->codec_tag == ff_get_fourcc("XVID")*/
1985
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1986
        return 1;
1987
    return 0;
1988
}
1989

    
1990
int av_find_stream_info(AVFormatContext *ic)
1991
{
1992
    int i, count, ret, read_size, j;
1993
    AVStream *st;
1994
    AVPacket pkt1, *pkt;
1995
    int64_t last_dts[MAX_STREAMS];
1996
    int duration_count[MAX_STREAMS]={0};
1997
    double (*duration_error)[MAX_STD_TIMEBASES];
1998
    offset_t old_offset = url_ftell(ic->pb);
1999
    int64_t codec_info_duration[MAX_STREAMS]={0};
2000
    int codec_info_nb_frames[MAX_STREAMS]={0};
2001

    
2002
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2003
    if (!duration_error) return AVERROR(ENOMEM);
2004

    
2005
    for(i=0;i<ic->nb_streams;i++) {
2006
        st = ic->streams[i];
2007
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2008
/*            if(!st->time_base.num)
2009
                st->time_base= */
2010
            if(!st->codec->time_base.num)
2011
                st->codec->time_base= st->time_base;
2012
        }
2013
        //only for the split stuff
2014
        if (!st->parser) {
2015
            st->parser = av_parser_init(st->codec->codec_id);
2016
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2017
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2018
            }
2019
        }
2020
    }
2021

    
2022
    for(i=0;i<MAX_STREAMS;i++){
2023
        last_dts[i]= AV_NOPTS_VALUE;
2024
    }
2025

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

    
2059
        /* NOTE: a new stream can be added there if no header in file
2060
           (AVFMTCTX_NOHEADER) */
2061
        ret = av_read_frame_internal(ic, &pkt1);
2062
        if (ret < 0) {
2063
            /* EOF or error */
2064
            ret = -1; /* we could not have all the codec parameters before EOF */
2065
            for(i=0;i<ic->nb_streams;i++) {
2066
                st = ic->streams[i];
2067
                if (!has_codec_parameters(st->codec)){
2068
                    char buf[256];
2069
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2070
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2071
                } else {
2072
                    ret = 0;
2073
                }
2074
            }
2075
            break;
2076
        }
2077

    
2078
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2079
        if(av_dup_packet(pkt) < 0) {
2080
            av_free(duration_error);
2081
            return AVERROR(ENOMEM);
2082
        }
2083

    
2084
        read_size += pkt->size;
2085

    
2086
        st = ic->streams[pkt->stream_index];
2087
        if(codec_info_nb_frames[st->index]>1)
2088
            codec_info_duration[st->index] += pkt->duration;
2089
        if (pkt->duration != 0)
2090
            codec_info_nb_frames[st->index]++;
2091

    
2092
        {
2093
            int index= pkt->stream_index;
2094
            int64_t last= last_dts[index];
2095
            int64_t duration= pkt->dts - last;
2096

    
2097
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2098
                double dur= duration * av_q2d(st->time_base);
2099

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

    
2125
        /* if still no information, we try to open the codec and to
2126
           decompress the frame. We try to avoid that in most cases as
2127
           it takes longer and uses more memory. For MPEG-4, we need to
2128
           decompress for QuickTime. */
2129
        if (!has_codec_parameters(st->codec) /*&&
2130
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2131
             st->codec->codec_id == CODEC_ID_H264 ||
2132
             st->codec->codec_id == CODEC_ID_H263 ||
2133
             st->codec->codec_id == CODEC_ID_H261 ||
2134
             st->codec->codec_id == CODEC_ID_VORBIS ||
2135
             st->codec->codec_id == CODEC_ID_MJPEG ||
2136
             st->codec->codec_id == CODEC_ID_PNG ||
2137
             st->codec->codec_id == CODEC_ID_PAM ||
2138
             st->codec->codec_id == CODEC_ID_PGM ||
2139
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2140
             st->codec->codec_id == CODEC_ID_PBM ||
2141
             st->codec->codec_id == CODEC_ID_PPM ||
2142
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2143
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2144
            try_decode_frame(st, pkt->data, pkt->size);
2145

    
2146
        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) {
2147
            break;
2148
        }
2149
        count++;
2150
    }
2151

    
2152
    // close codecs which were opened in try_decode_frame()
2153
    for(i=0;i<ic->nb_streams;i++) {
2154
        st = ic->streams[i];
2155
        if(st->codec->codec)
2156
            avcodec_close(st->codec);
2157
    }
2158
    for(i=0;i<ic->nb_streams;i++) {
2159
        st = ic->streams[i];
2160
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2161
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2162
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2163

    
2164
            if(duration_count[i]
2165
               && tb_unreliable(st->codec) /*&&
2166
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2167
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2168
                double best_error= 2*av_q2d(st->time_base);
2169
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2170

    
2171
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2172
                    double error= duration_error[i][j] * get_std_framerate(j);
2173
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2174
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2175
                    if(error < best_error){
2176
                        best_error= error;
2177
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2178
                    }
2179
                }
2180
            }
2181

    
2182
            if (!st->r_frame_rate.num){
2183
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2184
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2185
                    st->r_frame_rate.num = st->codec->time_base.den;
2186
                    st->r_frame_rate.den = st->codec->time_base.num;
2187
                }else{
2188
                    st->r_frame_rate.num = st->time_base.den;
2189
                    st->r_frame_rate.den = st->time_base.num;
2190
                }
2191
            }
2192
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2193
            if(!st->codec->bits_per_sample)
2194
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2195
        }
2196
    }
2197

    
2198
    av_estimate_timings(ic, old_offset);
2199

    
2200
    compute_chapters_end(ic);
2201

    
2202
#if 0
2203
    /* correct DTS for B-frame streams with no timestamps */
2204
    for(i=0;i<ic->nb_streams;i++) {
2205
        st = ic->streams[i];
2206
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2207
            if(b-frames){
2208
                ppktl = &ic->packet_buffer;
2209
                while(ppkt1){
2210
                    if(ppkt1->stream_index != i)
2211
                        continue;
2212
                    if(ppkt1->pkt->dts < 0)
2213
                        break;
2214
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2215
                        break;
2216
                    ppkt1->pkt->dts -= delta;
2217
                    ppkt1= ppkt1->next;
2218
                }
2219
                if(ppkt1)
2220
                    continue;
2221
                st->cur_dts -= delta;
2222
            }
2223
        }
2224
    }
2225
#endif
2226

    
2227
    av_free(duration_error);
2228

    
2229
    return ret;
2230
}
2231

    
2232
/*******************************************************/
2233

    
2234
int av_read_play(AVFormatContext *s)
2235
{
2236
    if (s->iformat->read_play)
2237
        return s->iformat->read_play(s);
2238
    if (s->pb)
2239
        return av_url_read_fpause(s->pb, 0);
2240
    return AVERROR(ENOSYS);
2241
}
2242

    
2243
int av_read_pause(AVFormatContext *s)
2244
{
2245
    if (s->iformat->read_pause)
2246
        return s->iformat->read_pause(s);
2247
    if (s->pb)
2248
        return av_url_read_fpause(s->pb, 1);
2249
    return AVERROR(ENOSYS);
2250
}
2251

    
2252
void av_close_input_stream(AVFormatContext *s)
2253
{
2254
    int i;
2255
    AVStream *st;
2256

    
2257
    /* free previous packet */
2258
    if (s->cur_st && s->cur_st->parser)
2259
        av_free_packet(&s->cur_pkt);
2260

    
2261
    if (s->iformat->read_close)
2262
        s->iformat->read_close(s);
2263
    for(i=0;i<s->nb_streams;i++) {
2264
        /* free all data in a stream component */
2265
        st = s->streams[i];
2266
        if (st->parser) {
2267
            av_parser_close(st->parser);
2268
        }
2269
        av_free(st->index_entries);
2270
        av_free(st->codec->extradata);
2271
        av_free(st->codec);
2272
        av_free(st->filename);
2273
        av_free(st->priv_data);
2274
        av_free(st);
2275
    }
2276
    for(i=s->nb_programs-1; i>=0; i--) {
2277
        av_freep(&s->programs[i]->provider_name);
2278
        av_freep(&s->programs[i]->name);
2279
        av_freep(&s->programs[i]->stream_index);
2280
        av_freep(&s->programs[i]);
2281
    }
2282
    av_freep(&s->programs);
2283
    flush_packet_queue(s);
2284
    av_freep(&s->priv_data);
2285
    while(s->nb_chapters--) {
2286
        av_free(s->chapters[s->nb_chapters]->title);
2287
        av_free(s->chapters[s->nb_chapters]);
2288
    }
2289
    av_freep(&s->chapters);
2290
    av_free(s);
2291
}
2292

    
2293
void av_close_input_file(AVFormatContext *s)
2294
{
2295
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2296
    av_close_input_stream(s);
2297
    if (pb)
2298
        url_fclose(pb);
2299
}
2300

    
2301
AVStream *av_new_stream(AVFormatContext *s, int id)
2302
{
2303
    AVStream *st;
2304
    int i;
2305

    
2306
    if (s->nb_streams >= MAX_STREAMS)
2307
        return NULL;
2308

    
2309
    st = av_mallocz(sizeof(AVStream));
2310
    if (!st)
2311
        return NULL;
2312

    
2313
    st->codec= avcodec_alloc_context();
2314
    if (s->iformat) {
2315
        /* no default bitrate if decoding */
2316
        st->codec->bit_rate = 0;
2317
    }
2318
    st->index = s->nb_streams;
2319
    st->id = id;
2320
    st->start_time = AV_NOPTS_VALUE;
2321
    st->duration = AV_NOPTS_VALUE;
2322
        /* we set the current DTS to 0 so that formats without any timestamps
2323
           but durations get some timestamps, formats with some unknown
2324
           timestamps have their first few packets buffered and the
2325
           timestamps corrected before they are returned to the user */
2326
    st->cur_dts = 0;
2327
    st->first_dts = AV_NOPTS_VALUE;
2328

    
2329
    /* default pts setting is MPEG-like */
2330
    av_set_pts_info(st, 33, 1, 90000);
2331
    st->last_IP_pts = AV_NOPTS_VALUE;
2332
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2333
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2334

    
2335
    s->streams[s->nb_streams++] = st;
2336
    return st;
2337
}
2338

    
2339
AVProgram *av_new_program(AVFormatContext *ac, int id)
2340
{
2341
    AVProgram *program=NULL;
2342
    int i;
2343

    
2344
#ifdef DEBUG_SI
2345
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2346
#endif
2347

    
2348
    for(i=0; i<ac->nb_programs; i++)
2349
        if(ac->programs[i]->id == id)
2350
            program = ac->programs[i];
2351

    
2352
    if(!program){
2353
        program = av_mallocz(sizeof(AVProgram));
2354
        if (!program)
2355
            return NULL;
2356
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2357
        program->discard = AVDISCARD_NONE;
2358
    }
2359
    program->id = id;
2360

    
2361
    return program;
2362
}
2363

    
2364
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2365
{
2366
    assert(!provider_name == !name);
2367
    if(name){
2368
        av_free(program->provider_name);
2369
        av_free(program->         name);
2370
        program->provider_name = av_strdup(provider_name);
2371
        program->         name = av_strdup(         name);
2372
    }
2373
}
2374

    
2375
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2376
{
2377
    AVChapter *chapter = NULL;
2378
    int i;
2379

    
2380
    for(i=0; i<s->nb_chapters; i++)
2381
        if(s->chapters[i]->id == id)
2382
            chapter = s->chapters[i];
2383

    
2384
    if(!chapter){
2385
        chapter= av_mallocz(sizeof(AVChapter));
2386
        if(!chapter)
2387
            return NULL;
2388
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2389
    }
2390
    av_free(chapter->title);
2391
    chapter->title = av_strdup(title);
2392
    chapter->id    = id;
2393
    chapter->time_base= time_base;
2394
    chapter->start = start;
2395
    chapter->end   = end;
2396

    
2397
    return chapter;
2398
}
2399

    
2400
/************************************************************/
2401
/* output media file */
2402

    
2403
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2404
{
2405
    int ret;
2406

    
2407
    if (s->oformat->priv_data_size > 0) {
2408
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2409
        if (!s->priv_data)
2410
            return AVERROR(ENOMEM);
2411
    } else
2412
        s->priv_data = NULL;
2413

    
2414
    if (s->oformat->set_parameters) {
2415
        ret = s->oformat->set_parameters(s, ap);
2416
        if (ret < 0)
2417
            return ret;
2418
    }
2419
    return 0;
2420
}
2421

    
2422
int av_write_header(AVFormatContext *s)
2423
{
2424
    int ret, i;
2425
    AVStream *st;
2426

    
2427
    // some sanity checks
2428
    for(i=0;i<s->nb_streams;i++) {
2429
        st = s->streams[i];
2430

    
2431
        switch (st->codec->codec_type) {
2432
        case CODEC_TYPE_AUDIO:
2433
            if(st->codec->sample_rate<=0){
2434
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2435
                return -1;
2436
            }
2437
            break;
2438
        case CODEC_TYPE_VIDEO:
2439
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2440
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2441
                return -1;
2442
            }
2443
            if(st->codec->width<=0 || st->codec->height<=0){
2444
                av_log(s, AV_LOG_ERROR, "dimensions not set\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(s->oformat->write_header){
2469
        ret = s->oformat->write_header(s);
2470
        if (ret < 0)
2471
            return ret;
2472
    }
2473

    
2474
    /* init PTS generation */
2475
    for(i=0;i<s->nb_streams;i++) {
2476
        int64_t den = AV_NOPTS_VALUE;
2477
        st = s->streams[i];
2478

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

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

    
2503
//    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);
2504

    
2505
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2506
        return -1;*/
2507

    
2508
    /* duration field */
2509
    if (pkt->duration == 0) {
2510
        compute_frame_duration(&num, &den, st, NULL, pkt);
2511
        if (den && num) {
2512
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2513
        }
2514
    }
2515

    
2516
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2517
        pkt->pts= pkt->dts;
2518

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

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

    
2534
        pkt->dts= st->pts_buffer[0];
2535
    }
2536

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

    
2546
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2547
    st->cur_dts= pkt->dts;
2548
    st->pts.val= pkt->dts;
2549

    
2550
    /* update pts */
2551
    switch (st->codec->codec_type) {
2552
    case CODEC_TYPE_AUDIO:
2553
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2554

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

    
2571
static void truncate_ts(AVStream *st, AVPacket *pkt){
2572
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2573

    
2574
//    if(pkt->dts < 0)
2575
//        pkt->dts= 0;  //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
2576

    
2577
    if (pkt->pts != AV_NOPTS_VALUE)
2578
        pkt->pts &= pts_mask;
2579
    if (pkt->dts != AV_NOPTS_VALUE)
2580
        pkt->dts &= pts_mask;
2581
}
2582

    
2583
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2584
{
2585
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2586

    
2587
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2588
        return ret;
2589

    
2590
    truncate_ts(s->streams[pkt->stream_index], pkt);
2591

    
2592
    ret= s->oformat->write_packet(s, pkt);
2593
    if(!ret)
2594
        ret= url_ferror(s->pb);
2595
    return ret;
2596
}
2597

    
2598
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2599
    AVPacketList *pktl, **next_point, *this_pktl;
2600
    int stream_count=0;
2601
    int streams[MAX_STREAMS];
2602

    
2603
    if(pkt){
2604
        AVStream *st= s->streams[ pkt->stream_index];
2605

    
2606
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2607

    
2608
        this_pktl = av_mallocz(sizeof(AVPacketList));
2609
        this_pktl->pkt= *pkt;
2610
        if(pkt->destruct == av_destruct_packet)
2611
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2612
        else
2613
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2614

    
2615
        next_point = &s->packet_buffer;
2616
        while(*next_point){
2617
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2618
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2619
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2620
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2621
                break;
2622
            next_point= &(*next_point)->next;
2623
        }
2624
        this_pktl->next= *next_point;
2625
        *next_point= this_pktl;
2626
    }
2627

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

    
2638
    if(stream_count && (s->nb_streams == stream_count || flush)){
2639
        pktl= s->packet_buffer;
2640
        *out= pktl->pkt;
2641

    
2642
        s->packet_buffer= pktl->next;
2643
        av_freep(&pktl);
2644
        return 1;
2645
    }else{
2646
        av_init_packet(out);
2647
        return 0;
2648
    }
2649
}
2650

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

    
2667
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2668
    AVStream *st= s->streams[ pkt->stream_index];
2669

    
2670
    //FIXME/XXX/HACK drop zero sized packets
2671
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2672
        return 0;
2673

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

    
2678
    if(pkt->dts == AV_NOPTS_VALUE)
2679
        return -1;
2680

    
2681
    for(;;){
2682
        AVPacket opkt;
2683
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2684
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2685
            return ret;
2686

    
2687
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2688
        ret= s->oformat->write_packet(s, &opkt);
2689

    
2690
        av_free_packet(&opkt);
2691
        pkt= NULL;
2692

    
2693
        if(ret<0)
2694
            return ret;
2695
        if(url_ferror(s->pb))
2696
            return url_ferror(s->pb);
2697
    }
2698
}
2699

    
2700
int av_write_trailer(AVFormatContext *s)
2701
{
2702
    int ret, i;
2703

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

    
2712
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2713
        ret= s->oformat->write_packet(s, &pkt);
2714

    
2715
        av_free_packet(&pkt);
2716

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

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

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

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

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

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

    
2785
void dump_format(AVFormatContext *ic,
2786
                 int index,
2787
                 const char *url,
2788
                 int is_output)
2789
{
2790
    int i;
2791

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

    
2841
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2842
{
2843
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2844
}
2845

    
2846
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2847
{
2848
    AVRational frame_rate;
2849
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2850
    *frame_rate_num= frame_rate.num;
2851
    *frame_rate_den= frame_rate.den;
2852
    return ret;
2853
}
2854

    
2855
/**
2856
 * Gets the current time in microseconds.
2857
 */
2858
int64_t av_gettime(void)
2859
{
2860
    struct timeval tv;
2861
    gettimeofday(&tv,NULL);
2862
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2863
}
2864

    
2865
int64_t parse_date(const char *datestr, int duration)
2866
{
2867
    const char *p;
2868
    int64_t t;
2869
    struct tm dt;
2870
    int i;
2871
    static const char *date_fmt[] = {
2872
        "%Y-%m-%d",
2873
        "%Y%m%d",
2874
    };
2875
    static const char *time_fmt[] = {
2876
        "%H:%M:%S",
2877
        "%H%M%S",
2878
    };
2879
    const char *q;
2880
    int is_utc, len;
2881
    char lastch;
2882
    int negative = 0;
2883

    
2884
#undef time
2885
    time_t now = time(0);
2886

    
2887
    len = strlen(datestr);
2888
    if (len > 0)
2889
        lastch = datestr[len - 1];
2890
    else
2891
        lastch = '\0';
2892
    is_utc = (lastch == 'z' || lastch == 'Z');
2893

    
2894
    memset(&dt, 0, sizeof(dt));
2895

    
2896
    p = datestr;
2897
    q = NULL;
2898
    if (!duration) {
2899
        /* parse the year-month-day part */
2900
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2901
            q = small_strptime(p, date_fmt[i], &dt);
2902
            if (q) {
2903
                break;
2904
            }
2905
        }
2906

    
2907
        /* if the year-month-day part is missing, then take the
2908
         * current year-month-day time */
2909
        if (!q) {
2910
            if (is_utc) {
2911
                dt = *gmtime(&now);
2912
            } else {
2913
                dt = *localtime(&now);
2914
            }
2915
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2916
        } else {
2917
            p = q;
2918
        }
2919

    
2920
        if (*p == 'T' || *p == 't' || *p == ' ')
2921
            p++;
2922

    
2923
        /* parse the hour-minute-second part */
2924
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2925
            q = small_strptime(p, time_fmt[i], &dt);
2926
            if (q) {
2927
                break;
2928
            }
2929
        }
2930
    } else {
2931
        /* parse datestr as a duration */
2932
        if (p[0] == '-') {
2933
            negative = 1;
2934
            ++p;
2935
        }
2936
        /* parse datestr as HH:MM:SS */
2937
        q = small_strptime(p, time_fmt[0], &dt);
2938
        if (!q) {
2939
            /* parse datestr as S+ */
2940
            dt.tm_sec = strtol(p, (char **)&q, 10);
2941
            if (q == p)
2942
                /* the parsing didn't succeed */
2943
                return INT64_MIN;
2944
            dt.tm_min = 0;
2945
            dt.tm_hour = 0;
2946
        }
2947
    }
2948

    
2949
    /* Now we have all the fields that we can get */
2950
    if (!q) {
2951
        return INT64_MIN;
2952
    }
2953

    
2954
    if (duration) {
2955
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2956
    } else {
2957
        dt.tm_isdst = -1;       /* unknown */
2958
        if (is_utc) {
2959
            t = mktimegm(&dt);
2960
        } else {
2961
            t = mktime(&dt);
2962
        }
2963
    }
2964

    
2965
    t *= 1000000;
2966

    
2967
    /* parse the .m... part */
2968
    if (*q == '.') {
2969
        int val, n;
2970
        q++;
2971
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2972
            if (!isdigit(*q))
2973
                break;
2974
            val += n * (*q - '0');
2975
        }
2976
        t += val;
2977
    }
2978
    return negative ? -t : t;
2979
}
2980

    
2981
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2982
{
2983
    const char *p;
2984
    char tag[128], *q;
2985

    
2986
    p = info;
2987
    if (*p == '?')
2988
        p++;
2989
    for(;;) {
2990
        q = tag;
2991
        while (*p != '\0' && *p != '=' && *p != '&') {
2992
            if ((q - tag) < sizeof(tag) - 1)
2993
                *q++ = *p;
2994
            p++;
2995
        }
2996
        *q = '\0';
2997
        q = arg;
2998
        if (*p == '=') {
2999
            p++;
3000
            while (*p != '&' && *p != '\0') {
3001
                if ((q - arg) < arg_size - 1) {
3002
                    if (*p == '+')
3003
                        *q++ = ' ';
3004
                    else
3005
                        *q++ = *p;
3006
                }
3007
                p++;
3008
            }
3009
            *q = '\0';
3010
        }
3011
        if (!strcmp(tag, tag1))
3012
            return 1;
3013
        if (*p != '&')
3014
            break;
3015
        p++;
3016
    }
3017
    return 0;
3018
}
3019

    
3020
int av_get_frame_filename(char *buf, int buf_size,
3021
                          const char *path, int number)
3022
{
3023
    const char *p;
3024
    char *q, buf1[20], c;
3025
    int nd, len, percentd_found;
3026

    
3027
    q = buf;
3028
    p = path;
3029
    percentd_found = 0;
3030
    for(;;) {
3031
        c = *p++;
3032
        if (c == '\0')
3033
            break;
3034
        if (c == '%') {
3035
            do {
3036
                nd = 0;
3037
                while (isdigit(*p)) {
3038
                    nd = nd * 10 + *p++ - '0';
3039
                }
3040
                c = *p++;
3041
            } while (isdigit(c));
3042

    
3043
            switch(c) {
3044
            case '%':
3045
                goto addchar;
3046
            case 'd':
3047
                if (percentd_found)
3048
                    goto fail;
3049
                percentd_found = 1;
3050
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3051
                len = strlen(buf1);
3052
                if ((q - buf + len) > buf_size - 1)
3053
                    goto fail;
3054
                memcpy(q, buf1, len);
3055
                q += len;
3056
                break;
3057
            default:
3058
                goto fail;
3059
            }
3060
        } else {
3061
        addchar:
3062
            if ((q - buf) < buf_size - 1)
3063
                *q++ = c;
3064
        }
3065
    }
3066
    if (!percentd_found)
3067
        goto fail;
3068
    *q = '\0';
3069
    return 0;
3070
 fail:
3071
    *q = '\0';
3072
    return -1;
3073
}
3074

    
3075
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3076
{
3077
    int len, i, j, c;
3078
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3079

    
3080
    for(i=0;i<size;i+=16) {
3081
        len = size - i;
3082
        if (len > 16)
3083
            len = 16;
3084
        PRINT("%08x ", i);
3085
        for(j=0;j<16;j++) {
3086
            if (j < len)
3087
                PRINT(" %02x", buf[i+j]);
3088
            else
3089
                PRINT("   ");
3090
        }
3091
        PRINT(" ");
3092
        for(j=0;j<len;j++) {
3093
            c = buf[i+j];
3094
            if (c < ' ' || c > '~')
3095
                c = '.';
3096
            PRINT("%c", c);
3097
        }
3098
        PRINT("\n");
3099
    }
3100
#undef PRINT
3101
}
3102

    
3103
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3104
{
3105
    hex_dump_internal(NULL, f, 0, buf, size);
3106
}
3107

    
3108
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3109
{
3110
    hex_dump_internal(avcl, NULL, level, buf, size);
3111
}
3112

    
3113
 //FIXME needs to know the time_base
3114
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3115
{
3116
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3117
    PRINT("stream #%d:\n", pkt->stream_index);
3118
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3119
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3120
    /* DTS is _always_ valid after av_read_frame() */
3121
    PRINT("  dts=");
3122
    if (pkt->dts == AV_NOPTS_VALUE)
3123
        PRINT("N/A");
3124
    else
3125
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3126
    /* PTS may not be known if B-frames are present. */
3127
    PRINT("  pts=");
3128
    if (pkt->pts == AV_NOPTS_VALUE)
3129
        PRINT("N/A");
3130
    else
3131
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3132
    PRINT("\n");
3133
    PRINT("  size=%d\n", pkt->size);
3134
#undef PRINT
3135
    if (dump_payload)
3136
        av_hex_dump(f, pkt->data, pkt->size);
3137
}
3138

    
3139
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3140
{
3141
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3142
}
3143

    
3144
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3145
{
3146
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3147
}
3148

    
3149
void url_split(char *proto, int proto_size,
3150
               char *authorization, int authorization_size,
3151
               char *hostname, int hostname_size,
3152
               int *port_ptr,
3153
               char *path, int path_size,
3154
               const char *url)
3155
{
3156
    const char *p, *ls, *at, *col, *brk;
3157

    
3158
    if (port_ptr)               *port_ptr = -1;
3159
    if (proto_size > 0)         proto[0] = 0;
3160
    if (authorization_size > 0) authorization[0] = 0;
3161
    if (hostname_size > 0)      hostname[0] = 0;
3162
    if (path_size > 0)          path[0] = 0;
3163

    
3164
    /* parse protocol */
3165
    if ((p = strchr(url, ':'))) {
3166
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3167
        p++; /* skip ':' */
3168
        if (*p == '/') p++;
3169
        if (*p == '/') p++;
3170
    } else {
3171
        /* no protocol means plain filename */
3172
        av_strlcpy(path, url, path_size);
3173
        return;
3174
    }
3175

    
3176
    /* separate path from hostname */
3177
    ls = strchr(p, '/');
3178
    if(!ls)
3179
        ls = strchr(p, '?');
3180
    if(ls)
3181
        av_strlcpy(path, ls, path_size);
3182
    else
3183
        ls = &p[strlen(p)]; // XXX
3184

    
3185
    /* the rest is hostname, use that to parse auth/port */
3186
    if (ls != p) {
3187
        /* authorization (user[:pass]@hostname) */
3188
        if ((at = strchr(p, '@')) && at < ls) {
3189
            av_strlcpy(authorization, p,
3190
                       FFMIN(authorization_size, at + 1 - p));
3191
            p = at + 1; /* skip '@' */
3192
        }
3193

    
3194
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3195
            /* [host]:port */
3196
            av_strlcpy(hostname, p + 1,
3197
                       FFMIN(hostname_size, brk - p));
3198
            if (brk[1] == ':' && port_ptr)
3199
                *port_ptr = atoi(brk + 2);
3200
        } else if ((col = strchr(p, ':')) && col < ls) {
3201
            av_strlcpy(hostname, p,
3202
                       FFMIN(col + 1 - p, hostname_size));
3203
            if (port_ptr) *port_ptr = atoi(col + 1);
3204
        } else
3205
            av_strlcpy(hostname, p,
3206
                       FFMIN(ls + 1 - p, hostname_size));
3207
    }
3208
}
3209

    
3210
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3211
                     int pts_num, int pts_den)
3212
{
3213
    unsigned int gcd= ff_gcd(pts_num, pts_den);
3214
    s->pts_wrap_bits = pts_wrap_bits;
3215
    s->time_base.num = pts_num/gcd;
3216
    s->time_base.den = pts_den/gcd;
3217

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