Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 25d3fb73

History | View | Annotate | Download (98.9 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
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
37
static void av_frac_add(AVFrac *f, int64_t incr);
38

    
39
/** head of registered input format linked list */
40
AVInputFormat *first_iformat = NULL;
41
/** head of registered output format linked list */
42
AVOutputFormat *first_oformat = NULL;
43

    
44
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
45
{
46
    if(f) return f->next;
47
    else  return first_iformat;
48
}
49

    
50
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
51
{
52
    if(f) return f->next;
53
    else  return first_oformat;
54
}
55

    
56
void av_register_input_format(AVInputFormat *format)
57
{
58
    AVInputFormat **p;
59
    p = &first_iformat;
60
    while (*p != NULL) p = &(*p)->next;
61
    *p = format;
62
    format->next = NULL;
63
}
64

    
65
void av_register_output_format(AVOutputFormat *format)
66
{
67
    AVOutputFormat **p;
68
    p = &first_oformat;
69
    while (*p != NULL) p = &(*p)->next;
70
    *p = format;
71
    format->next = NULL;
72
}
73

    
74
int match_ext(const char *filename, const char *extensions)
75
{
76
    const char *ext, *p;
77
    char ext1[32], *q;
78

    
79
    if(!filename)
80
        return 0;
81

    
82
    ext = strrchr(filename, '.');
83
    if (ext) {
84
        ext++;
85
        p = extensions;
86
        for(;;) {
87
            q = ext1;
88
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
89
                *q++ = *p++;
90
            *q = '\0';
91
            if (!strcasecmp(ext1, ext))
92
                return 1;
93
            if (*p == '\0')
94
                break;
95
            p++;
96
        }
97
    }
98
    return 0;
99
}
100

    
101
AVOutputFormat *guess_format(const char *short_name, const char *filename,
102
                             const char *mime_type)
103
{
104
    AVOutputFormat *fmt, *fmt_found;
105
    int score_max, score;
106

    
107
    /* specific test for image sequences */
108
#ifdef CONFIG_IMAGE2_MUXER
109
    if (!short_name && filename &&
110
        av_filename_number_test(filename) &&
111
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
112
        return guess_format("image2", NULL, NULL);
113
    }
114
#endif
115
    /* Find the proper file type. */
116
    fmt_found = NULL;
117
    score_max = 0;
118
    fmt = first_oformat;
119
    while (fmt != NULL) {
120
        score = 0;
121
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
122
            score += 100;
123
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
124
            score += 10;
125
        if (filename && fmt->extensions &&
126
            match_ext(filename, fmt->extensions)) {
127
            score += 5;
128
        }
129
        if (score > score_max) {
130
            score_max = score;
131
            fmt_found = fmt;
132
        }
133
        fmt = fmt->next;
134
    }
135
    return fmt_found;
136
}
137

    
138
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
139
                             const char *mime_type)
140
{
141
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
142

    
143
    if (fmt) {
144
        AVOutputFormat *stream_fmt;
145
        char stream_format_name[64];
146

    
147
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
148
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
149

    
150
        if (stream_fmt)
151
            fmt = stream_fmt;
152
    }
153

    
154
    return fmt;
155
}
156

    
157
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
158
                            const char *filename, const char *mime_type, enum CodecType type){
159
    if(type == CODEC_TYPE_VIDEO){
160
        enum CodecID codec_id= CODEC_ID_NONE;
161

    
162
#ifdef CONFIG_IMAGE2_MUXER
163
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
164
            codec_id= av_guess_image2_codec(filename);
165
        }
166
#endif
167
        if(codec_id == CODEC_ID_NONE)
168
            codec_id= fmt->video_codec;
169
        return codec_id;
170
    }else if(type == CODEC_TYPE_AUDIO)
171
        return fmt->audio_codec;
172
    else
173
        return CODEC_ID_NONE;
174
}
175

    
176
AVInputFormat *av_find_input_format(const char *short_name)
177
{
178
    AVInputFormat *fmt;
179
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
180
        if (!strcmp(fmt->name, short_name))
181
            return fmt;
182
    }
183
    return NULL;
184
}
185

    
186
/* memory handling */
187

    
188
void av_destruct_packet(AVPacket *pkt)
189
{
190
    av_free(pkt->data);
191
    pkt->data = NULL; pkt->size = 0;
192
}
193

    
194
void av_init_packet(AVPacket *pkt)
195
{
196
    pkt->pts   = AV_NOPTS_VALUE;
197
    pkt->dts   = AV_NOPTS_VALUE;
198
    pkt->pos   = -1;
199
    pkt->duration = 0;
200
    pkt->flags = 0;
201
    pkt->stream_index = 0;
202
    pkt->destruct= av_destruct_packet_nofree;
203
}
204

    
205
int av_new_packet(AVPacket *pkt, int size)
206
{
207
    uint8_t *data;
208
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
209
        return AVERROR(ENOMEM);
210
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
211
    if (!data)
212
        return AVERROR(ENOMEM);
213
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
214

    
215
    av_init_packet(pkt);
216
    pkt->data = data;
217
    pkt->size = size;
218
    pkt->destruct = av_destruct_packet;
219
    return 0;
220
}
221

    
222
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
223
{
224
    int ret= av_new_packet(pkt, size);
225

    
226
    if(ret<0)
227
        return ret;
228

    
229
    pkt->pos= url_ftell(s);
230

    
231
    ret= get_buffer(s, pkt->data, size);
232
    if(ret<=0)
233
        av_free_packet(pkt);
234
    else
235
        pkt->size= ret;
236

    
237
    return ret;
238
}
239

    
240
int av_dup_packet(AVPacket *pkt)
241
{
242
    if (pkt->destruct != av_destruct_packet) {
243
        uint8_t *data;
244
        /* We duplicate the packet and don't forget to add the padding again. */
245
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
246
            return AVERROR(ENOMEM);
247
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
248
        if (!data) {
249
            return AVERROR(ENOMEM);
250
        }
251
        memcpy(data, pkt->data, pkt->size);
252
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
253
        pkt->data = data;
254
        pkt->destruct = av_destruct_packet;
255
    }
256
    return 0;
257
}
258

    
259
int av_filename_number_test(const char *filename)
260
{
261
    char buf[1024];
262
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
263
}
264

    
265
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
266
{
267
    AVInputFormat *fmt1, *fmt;
268
    int score;
269

    
270
    fmt = NULL;
271
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
272
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
273
            continue;
274
        score = 0;
275
        if (fmt1->read_probe) {
276
            score = fmt1->read_probe(pd);
277
        } else if (fmt1->extensions) {
278
            if (match_ext(pd->filename, fmt1->extensions)) {
279
                score = 50;
280
            }
281
        }
282
        if (score > *score_max) {
283
            *score_max = score;
284
            fmt = fmt1;
285
        }else if (score == *score_max)
286
            fmt = NULL;
287
    }
288
    return fmt;
289
}
290

    
291
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
292
    int score=0;
293
    return av_probe_input_format2(pd, is_opened, &score);
294
}
295

    
296
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
297
{
298
    AVInputFormat *fmt;
299
    fmt = av_probe_input_format2(pd, 1, &score);
300

    
301
    if (fmt) {
302
        if (strncmp(fmt->name, "mp3", 3) == 0)
303
            st->codec->codec_id = CODEC_ID_MP3;
304
        else if (strncmp(fmt->name, "ac3", 3) == 0)
305
            st->codec->codec_id = CODEC_ID_AC3;
306
        else if (!strcmp(fmt->name, "mpegvideo"))
307
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
308
        else if (!strcmp(fmt->name, "h264"))
309
            st->codec->codec_id = CODEC_ID_H264;
310
    }
311
    return !!fmt;
312
}
313

    
314
/************************************************************/
315
/* input media file */
316

    
317
/**
318
 * Open a media file from an IO stream. 'fmt' must be specified.
319
 */
320
static const char* format_to_name(void* ptr)
321
{
322
    AVFormatContext* fc = (AVFormatContext*) ptr;
323
    if(fc->iformat) return fc->iformat->name;
324
    else if(fc->oformat) return fc->oformat->name;
325
    else return "NULL";
326
}
327

    
328
#define OFFSET(x) offsetof(AVFormatContext,x)
329
#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
330
//these names are too long to be readable
331
#define E AV_OPT_FLAG_ENCODING_PARAM
332
#define D AV_OPT_FLAG_DECODING_PARAM
333

    
334
static const AVOption options[]={
335
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
336
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
337
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
338
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
339
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
340
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
341
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
342
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
343
{"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},
344
{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
345
{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
346
{"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 */
347
{"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E|D, "fdebug"},
348
{"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E|D, "fdebug"},
349
{NULL},
350
};
351

    
352
#undef E
353
#undef D
354
#undef DEFAULT
355

    
356
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
357

    
358
static void avformat_get_context_defaults(AVFormatContext *s)
359
{
360
    memset(s, 0, sizeof(AVFormatContext));
361

    
362
    s->av_class = &av_format_context_class;
363

    
364
    av_opt_set_defaults(s);
365
}
366

    
367
AVFormatContext *av_alloc_format_context(void)
368
{
369
    AVFormatContext *ic;
370
    ic = av_malloc(sizeof(AVFormatContext));
371
    if (!ic) return ic;
372
    avformat_get_context_defaults(ic);
373
    ic->av_class = &av_format_context_class;
374
    return ic;
375
}
376

    
377
int av_open_input_stream(AVFormatContext **ic_ptr,
378
                         ByteIOContext *pb, const char *filename,
379
                         AVInputFormat *fmt, AVFormatParameters *ap)
380
{
381
    int err;
382
    AVFormatContext *ic;
383
    AVFormatParameters default_ap;
384

    
385
    if(!ap){
386
        ap=&default_ap;
387
        memset(ap, 0, sizeof(default_ap));
388
    }
389

    
390
    if(!ap->prealloced_context)
391
        ic = av_alloc_format_context();
392
    else
393
        ic = *ic_ptr;
394
    if (!ic) {
395
        err = AVERROR(ENOMEM);
396
        goto fail;
397
    }
398
    ic->iformat = fmt;
399
    ic->pb = pb;
400
    ic->duration = AV_NOPTS_VALUE;
401
    ic->start_time = AV_NOPTS_VALUE;
402
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
403

    
404
    /* allocate private data */
405
    if (fmt->priv_data_size > 0) {
406
        ic->priv_data = av_mallocz(fmt->priv_data_size);
407
        if (!ic->priv_data) {
408
            err = AVERROR(ENOMEM);
409
            goto fail;
410
        }
411
    } else {
412
        ic->priv_data = NULL;
413
    }
414

    
415
    if (ic->iformat->read_header) {
416
        err = ic->iformat->read_header(ic, ap);
417
        if (err < 0)
418
            goto fail;
419
    }
420

    
421
    if (pb && !ic->data_offset)
422
        ic->data_offset = url_ftell(ic->pb);
423

    
424
    *ic_ptr = ic;
425
    return 0;
426
 fail:
427
    if (ic) {
428
        int i;
429
        av_freep(&ic->priv_data);
430
        for(i=0;i<ic->nb_streams;i++) {
431
            AVStream *st = ic->streams[i];
432
            if (st) {
433
                av_free(st->priv_data);
434
                av_free(st->codec->extradata);
435
            }
436
            av_free(st);
437
        }
438
    }
439
    av_free(ic);
440
    *ic_ptr = NULL;
441
    return err;
442
}
443

    
444
/** size of probe buffer, for guessing file type from file contents */
445
#define PROBE_BUF_MIN 2048
446
#define PROBE_BUF_MAX (1<<20)
447

    
448
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
449
                       AVInputFormat *fmt,
450
                       int buf_size,
451
                       AVFormatParameters *ap)
452
{
453
    int err, probe_size;
454
    AVProbeData probe_data, *pd = &probe_data;
455
    ByteIOContext *pb = NULL;
456

    
457
    pd->filename = "";
458
    if (filename)
459
        pd->filename = filename;
460
    pd->buf = NULL;
461
    pd->buf_size = 0;
462

    
463
    if (!fmt) {
464
        /* guess format if no file can be opened */
465
        fmt = av_probe_input_format(pd, 0);
466
    }
467

    
468
    /* Do not open file if the format does not need it. XXX: specific
469
       hack needed to handle RTSP/TCP */
470
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
471
        /* if no file needed do not try to open one */
472
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
473
            goto fail;
474
        }
475
        if (buf_size > 0) {
476
            url_setbufsize(pb, buf_size);
477
        }
478

    
479
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
480
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
481
            /* read probe data */
482
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
483
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
484
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
485
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
486
                url_fclose(pb);
487
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
488
                    pb = NULL;
489
                    err = AVERROR(EIO);
490
                    goto fail;
491
                }
492
            }
493
            /* guess file format */
494
            fmt = av_probe_input_format2(pd, 1, &score);
495
        }
496
        av_freep(&pd->buf);
497
    }
498

    
499
    /* if still no format found, error */
500
    if (!fmt) {
501
        err = AVERROR_NOFMT;
502
        goto fail;
503
    }
504

    
505
    /* check filename in case an image number is expected */
506
    if (fmt->flags & AVFMT_NEEDNUMBER) {
507
        if (!av_filename_number_test(filename)) {
508
            err = AVERROR_NUMEXPECTED;
509
            goto fail;
510
        }
511
    }
512
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
513
    if (err)
514
        goto fail;
515
    return 0;
516
 fail:
517
    av_freep(&pd->buf);
518
    if (pb)
519
        url_fclose(pb);
520
    *ic_ptr = NULL;
521
    return err;
522

    
523
}
524

    
525
/*******************************************************/
526

    
527
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt){
528
    AVPacketList *pktl;
529
    AVPacketList **plast_pktl= packet_buffer;
530

    
531
    while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
532

    
533
    pktl = av_mallocz(sizeof(AVPacketList));
534
    if (!pktl)
535
        return NULL;
536

    
537
    /* add the packet in the buffered packet list */
538
    *plast_pktl = pktl;
539
    pktl->pkt= *pkt;
540
    return &pktl->pkt;
541
}
542

    
543
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
544
{
545
    int ret;
546
    AVStream *st;
547

    
548
    for(;;){
549
        AVPacketList *pktl = s->raw_packet_buffer;
550

    
551
        if (pktl) {
552
            *pkt = pktl->pkt;
553
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
554
                s->raw_packet_buffer = pktl->next;
555
                av_free(pktl);
556
                return 0;
557
            }
558
        }
559

    
560
        av_init_packet(pkt);
561
        ret= s->iformat->read_packet(s, pkt);
562
        if (ret < 0)
563
            return ret;
564
        st= s->streams[pkt->stream_index];
565

    
566
        if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
567
            return ret;
568

    
569
        add_to_pktbuf(&s->raw_packet_buffer, pkt);
570

    
571
        switch(st->codec->codec_type){
572
        case CODEC_TYPE_VIDEO:
573
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
574
            break;
575
        case CODEC_TYPE_AUDIO:
576
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
577
            break;
578
        case CODEC_TYPE_SUBTITLE:
579
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
580
            break;
581
        }
582

    
583
        if(st->codec->codec_id == CODEC_ID_PROBE){
584
            AVProbeData *pd = &st->probe_data;
585

    
586
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
587
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
588
            pd->buf_size += pkt->size;
589
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
590

    
591
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
592
                set_codec_from_probe_data(st, pd, 1);
593
                if(st->codec->codec_id != CODEC_ID_PROBE){
594
                    pd->buf_size=0;
595
                    av_freep(&pd->buf);
596
                }
597
            }
598
        }
599
    }
600
}
601

    
602
/**********************************************************/
603

    
604
/**
605
 * Get the number of samples of an audio frame. Return -1 on error.
606
 */
607
static int get_audio_frame_size(AVCodecContext *enc, int size)
608
{
609
    int frame_size;
610

    
611
    if(enc->codec_id == CODEC_ID_VORBIS)
612
        return -1;
613

    
614
    if (enc->frame_size <= 1) {
615
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
616

    
617
        if (bits_per_sample) {
618
            if (enc->channels == 0)
619
                return -1;
620
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
621
        } else {
622
            /* used for example by ADPCM codecs */
623
            if (enc->bit_rate == 0)
624
                return -1;
625
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
626
        }
627
    } else {
628
        frame_size = enc->frame_size;
629
    }
630
    return frame_size;
631
}
632

    
633

    
634
/**
635
 * Return the frame duration in seconds. Return 0 if not available.
636
 */
637
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
638
                                   AVCodecParserContext *pc, AVPacket *pkt)
639
{
640
    int frame_size;
641

    
642
    *pnum = 0;
643
    *pden = 0;
644
    switch(st->codec->codec_type) {
645
    case CODEC_TYPE_VIDEO:
646
        if(st->time_base.num*1000LL > st->time_base.den){
647
            *pnum = st->time_base.num;
648
            *pden = st->time_base.den;
649
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
650
            *pnum = st->codec->time_base.num;
651
            *pden = st->codec->time_base.den;
652
            if (pc && pc->repeat_pict) {
653
                *pden *= 2;
654
                *pnum = (*pnum) * (2 + pc->repeat_pict);
655
            }
656
        }
657
        break;
658
    case CODEC_TYPE_AUDIO:
659
        frame_size = get_audio_frame_size(st->codec, pkt->size);
660
        if (frame_size < 0)
661
            break;
662
        *pnum = frame_size;
663
        *pden = st->codec->sample_rate;
664
        break;
665
    default:
666
        break;
667
    }
668
}
669

    
670
static int is_intra_only(AVCodecContext *enc){
671
    if(enc->codec_type == CODEC_TYPE_AUDIO){
672
        return 1;
673
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
674
        switch(enc->codec_id){
675
        case CODEC_ID_MJPEG:
676
        case CODEC_ID_MJPEGB:
677
        case CODEC_ID_LJPEG:
678
        case CODEC_ID_RAWVIDEO:
679
        case CODEC_ID_DVVIDEO:
680
        case CODEC_ID_HUFFYUV:
681
        case CODEC_ID_FFVHUFF:
682
        case CODEC_ID_ASV1:
683
        case CODEC_ID_ASV2:
684
        case CODEC_ID_VCR1:
685
            return 1;
686
        default: break;
687
        }
688
    }
689
    return 0;
690
}
691

    
692
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
693
                                      int64_t dts, int64_t pts)
694
{
695
    AVStream *st= s->streams[stream_index];
696
    AVPacketList *pktl= s->packet_buffer;
697

    
698
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
699
        return;
700

    
701
    st->first_dts= dts - st->cur_dts;
702
    st->cur_dts= dts;
703

    
704
    for(; pktl; pktl= pktl->next){
705
        if(pktl->pkt.stream_index != stream_index)
706
            continue;
707
        //FIXME think more about this check
708
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
709
            pktl->pkt.pts += st->first_dts;
710

    
711
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
712
            pktl->pkt.dts += st->first_dts;
713

    
714
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
715
            st->start_time= pktl->pkt.pts;
716
    }
717
    if (st->start_time == AV_NOPTS_VALUE)
718
        st->start_time = pts;
719
}
720

    
721
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
722
{
723
    AVPacketList *pktl= s->packet_buffer;
724
    int64_t cur_dts= 0;
725

    
726
    if(st->first_dts != AV_NOPTS_VALUE){
727
        cur_dts= st->first_dts;
728
        for(; pktl; pktl= pktl->next){
729
            if(pktl->pkt.stream_index == pkt->stream_index){
730
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
731
                    break;
732
                cur_dts -= pkt->duration;
733
            }
734
        }
735
        pktl= s->packet_buffer;
736
        st->first_dts = cur_dts;
737
    }else if(st->cur_dts)
738
        return;
739

    
740
    for(; pktl; pktl= pktl->next){
741
        if(pktl->pkt.stream_index != pkt->stream_index)
742
            continue;
743
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
744
           && !pktl->pkt.duration){
745
            pktl->pkt.dts= cur_dts;
746
            if(!st->codec->has_b_frames)
747
                pktl->pkt.pts= cur_dts;
748
            cur_dts += pkt->duration;
749
            pktl->pkt.duration= pkt->duration;
750
        }else
751
            break;
752
    }
753
    if(st->first_dts == AV_NOPTS_VALUE)
754
        st->cur_dts= cur_dts;
755
}
756

    
757
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
758
                               AVCodecParserContext *pc, AVPacket *pkt)
759
{
760
    int num, den, presentation_delayed, delay, i;
761
    int64_t offset;
762

    
763
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
764
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
765
        pkt->dts -= 1LL<<st->pts_wrap_bits;
766
    }
767

    
768
    if (pkt->duration == 0) {
769
        compute_frame_duration(&num, &den, st, pc, pkt);
770
        if (den && num) {
771
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
772

    
773
            if(pkt->duration != 0 && s->packet_buffer)
774
                update_initial_durations(s, st, pkt);
775
        }
776
    }
777

    
778
    /* correct timestamps with byte offset if demuxers only have timestamps
779
       on packet boundaries */
780
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
781
        /* this will estimate bitrate based on this frame's duration and size */
782
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
783
        if(pkt->pts != AV_NOPTS_VALUE)
784
            pkt->pts += offset;
785
        if(pkt->dts != AV_NOPTS_VALUE)
786
            pkt->dts += offset;
787
    }
788

    
789
    /* do we have a video B-frame ? */
790
    delay= st->codec->has_b_frames;
791
    presentation_delayed = 0;
792
    /* XXX: need has_b_frame, but cannot get it if the codec is
793
        not initialized */
794
    if (delay &&
795
        pc && pc->pict_type != FF_B_TYPE)
796
        presentation_delayed = 1;
797
    /* This may be redundant, but it should not hurt. */
798
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
799
        presentation_delayed = 1;
800

    
801
//    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);
802
    /* interpolate PTS and DTS if they are not present */
803
    if(delay==0 || (delay==1 && pc)){
804
        if (presentation_delayed) {
805
            /* DTS = decompression timestamp */
806
            /* PTS = presentation timestamp */
807
            if (pkt->dts == AV_NOPTS_VALUE)
808
                pkt->dts = st->last_IP_pts;
809
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
810
            if (pkt->dts == AV_NOPTS_VALUE)
811
                pkt->dts = st->cur_dts;
812

    
813
            /* this is tricky: the dts must be incremented by the duration
814
            of the frame we are displaying, i.e. the last I- or P-frame */
815
            if (st->last_IP_duration == 0)
816
                st->last_IP_duration = pkt->duration;
817
            if(pkt->dts != AV_NOPTS_VALUE)
818
                st->cur_dts = pkt->dts + st->last_IP_duration;
819
            st->last_IP_duration  = pkt->duration;
820
            st->last_IP_pts= pkt->pts;
821
            /* cannot compute PTS if not present (we can compute it only
822
            by knowing the future */
823
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
824
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
825
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
826
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
827
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
828
                    pkt->pts += pkt->duration;
829
    //                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);
830
                }
831
            }
832

    
833
            /* presentation is not delayed : PTS and DTS are the same */
834
            if(pkt->pts == AV_NOPTS_VALUE)
835
                pkt->pts = pkt->dts;
836
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
837
            if(pkt->pts == AV_NOPTS_VALUE)
838
                pkt->pts = st->cur_dts;
839
            pkt->dts = pkt->pts;
840
            if(pkt->pts != AV_NOPTS_VALUE)
841
                st->cur_dts = pkt->pts + pkt->duration;
842
        }
843
    }
844

    
845
    if(pkt->pts != AV_NOPTS_VALUE){
846
        st->pts_buffer[0]= pkt->pts;
847
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
848
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
849
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
850
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
851
        if(pkt->dts == AV_NOPTS_VALUE)
852
            pkt->dts= st->pts_buffer[0];
853
        if(delay>1){
854
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
855
        }
856
        if(pkt->dts > st->cur_dts)
857
            st->cur_dts = pkt->dts;
858
    }
859

    
860
//    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);
861

    
862
    /* update flags */
863
    if(is_intra_only(st->codec))
864
        pkt->flags |= PKT_FLAG_KEY;
865
    else if (pc) {
866
        pkt->flags = 0;
867
        /* keyframe computation */
868
            if (pc->pict_type == FF_I_TYPE)
869
                pkt->flags |= PKT_FLAG_KEY;
870
    }
871
}
872

    
873
void av_destruct_packet_nofree(AVPacket *pkt)
874
{
875
    pkt->data = NULL; pkt->size = 0;
876
}
877

    
878
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
879
{
880
    AVStream *st;
881
    int len, ret, i;
882

    
883
    av_init_packet(pkt);
884

    
885
    for(;;) {
886
        /* select current input stream component */
887
        st = s->cur_st;
888
        if (st) {
889
            if (!st->need_parsing || !st->parser) {
890
                /* no parsing needed: we just output the packet as is */
891
                /* raw data support */
892
                *pkt = s->cur_pkt;
893
                compute_pkt_fields(s, st, NULL, pkt);
894
                s->cur_st = NULL;
895
                break;
896
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
897
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
898
                                      s->cur_ptr, s->cur_len,
899
                                      s->cur_pkt.pts, s->cur_pkt.dts);
900
                s->cur_pkt.pts = AV_NOPTS_VALUE;
901
                s->cur_pkt.dts = AV_NOPTS_VALUE;
902
                /* increment read pointer */
903
                s->cur_ptr += len;
904
                s->cur_len -= len;
905

    
906
                /* return packet if any */
907
                if (pkt->size) {
908
                got_packet:
909
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
910
                    pkt->duration = 0;
911
                    pkt->stream_index = st->index;
912
                    pkt->pts = st->parser->pts;
913
                    pkt->dts = st->parser->dts;
914
                    pkt->destruct = av_destruct_packet_nofree;
915
                    compute_pkt_fields(s, st, st->parser, pkt);
916

    
917
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
918
                        ff_reduce_index(s, st->index);
919
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
920
                                           0, 0, AVINDEX_KEYFRAME);
921
                    }
922

    
923
                    break;
924
                }
925
            } else {
926
                /* free packet */
927
                av_free_packet(&s->cur_pkt);
928
                s->cur_st = NULL;
929
            }
930
        } else {
931
            /* read next packet */
932
            ret = av_read_packet(s, &s->cur_pkt);
933
            if (ret < 0) {
934
                if (ret == AVERROR(EAGAIN))
935
                    return ret;
936
                /* return the last frames, if any */
937
                for(i = 0; i < s->nb_streams; i++) {
938
                    st = s->streams[i];
939
                    if (st->parser && st->need_parsing) {
940
                        av_parser_parse(st->parser, st->codec,
941
                                        &pkt->data, &pkt->size,
942
                                        NULL, 0,
943
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
944
                        if (pkt->size)
945
                            goto got_packet;
946
                    }
947
                }
948
                /* no more packets: really terminate parsing */
949
                return ret;
950
            }
951

    
952
            if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
953
               s->cur_pkt.dts != AV_NOPTS_VALUE &&
954
               s->cur_pkt.pts < s->cur_pkt.dts){
955
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
956
                    s->cur_pkt.stream_index,
957
                    s->cur_pkt.pts,
958
                    s->cur_pkt.dts,
959
                    s->cur_pkt.size);
960
//                av_free_packet(&s->cur_pkt);
961
//                return -1;
962
            }
963

    
964
            st = s->streams[s->cur_pkt.stream_index];
965
            if(s->debug & FF_FDEBUG_TS)
966
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
967
                    s->cur_pkt.stream_index,
968
                    s->cur_pkt.pts,
969
                    s->cur_pkt.dts,
970
                    s->cur_pkt.size,
971
                    s->cur_pkt.flags);
972

    
973
            s->cur_st = st;
974
            s->cur_ptr = s->cur_pkt.data;
975
            s->cur_len = s->cur_pkt.size;
976
            if (st->need_parsing && !st->parser) {
977
                st->parser = av_parser_init(st->codec->codec_id);
978
                if (!st->parser) {
979
                    /* no parser available: just output the raw packets */
980
                    st->need_parsing = AVSTREAM_PARSE_NONE;
981
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
982
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
983
                }
984
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
985
                    st->parser->next_frame_offset=
986
                    st->parser->cur_offset= s->cur_pkt.pos;
987
                }
988
            }
989
        }
990
    }
991
    if(s->debug & FF_FDEBUG_TS)
992
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
993
            pkt->stream_index,
994
            pkt->pts,
995
            pkt->dts,
996
            pkt->size,
997
            pkt->flags);
998

    
999
    return 0;
1000
}
1001

    
1002
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1003
{
1004
    AVPacketList *pktl;
1005
    int eof=0;
1006
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1007

    
1008
    for(;;){
1009
        pktl = s->packet_buffer;
1010
        if (pktl) {
1011
            AVPacket *next_pkt= &pktl->pkt;
1012

    
1013
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1014
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1015
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1016
                       && next_pkt->dts < pktl->pkt.dts
1017
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1018
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1019
                        next_pkt->pts= pktl->pkt.dts;
1020
                    }
1021
                    pktl= pktl->next;
1022
                }
1023
                pktl = s->packet_buffer;
1024
            }
1025

    
1026
            if(   next_pkt->pts != AV_NOPTS_VALUE
1027
               || next_pkt->dts == AV_NOPTS_VALUE
1028
               || !genpts || eof){
1029
                /* read packet from packet buffer, if there is data */
1030
                *pkt = *next_pkt;
1031
                s->packet_buffer = pktl->next;
1032
                av_free(pktl);
1033
                return 0;
1034
            }
1035
        }
1036
        if(genpts){
1037
            int ret= av_read_frame_internal(s, pkt);
1038
            if(ret<0){
1039
                if(pktl && ret != AVERROR(EAGAIN)){
1040
                    eof=1;
1041
                    continue;
1042
                }else
1043
                    return ret;
1044
            }
1045

    
1046
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt)) < 0)
1047
                return AVERROR(ENOMEM);
1048
        }else{
1049
            assert(!s->packet_buffer);
1050
            return av_read_frame_internal(s, pkt);
1051
        }
1052
    }
1053
}
1054

    
1055
/* XXX: suppress the packet queue */
1056
static void flush_packet_queue(AVFormatContext *s)
1057
{
1058
    AVPacketList *pktl;
1059

    
1060
    for(;;) {
1061
        pktl = s->packet_buffer;
1062
        if (!pktl)
1063
            break;
1064
        s->packet_buffer = pktl->next;
1065
        av_free_packet(&pktl->pkt);
1066
        av_free(pktl);
1067
    }
1068
}
1069

    
1070
/*******************************************************/
1071
/* seek support */
1072

    
1073
int av_find_default_stream_index(AVFormatContext *s)
1074
{
1075
    int first_audio_index = -1;
1076
    int i;
1077
    AVStream *st;
1078

    
1079
    if (s->nb_streams <= 0)
1080
        return -1;
1081
    for(i = 0; i < s->nb_streams; i++) {
1082
        st = s->streams[i];
1083
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1084
            return i;
1085
        }
1086
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1087
            first_audio_index = i;
1088
    }
1089
    return first_audio_index >= 0 ? first_audio_index : 0;
1090
}
1091

    
1092
/**
1093
 * Flush the frame reader.
1094
 */
1095
static void av_read_frame_flush(AVFormatContext *s)
1096
{
1097
    AVStream *st;
1098
    int i;
1099

    
1100
    flush_packet_queue(s);
1101

    
1102
    /* free previous packet */
1103
    if (s->cur_st) {
1104
        if (s->cur_st->parser)
1105
            av_free_packet(&s->cur_pkt);
1106
        s->cur_st = NULL;
1107
    }
1108
    /* fail safe */
1109
    s->cur_ptr = NULL;
1110
    s->cur_len = 0;
1111

    
1112
    /* for each stream, reset read state */
1113
    for(i = 0; i < s->nb_streams; i++) {
1114
        st = s->streams[i];
1115

    
1116
        if (st->parser) {
1117
            av_parser_close(st->parser);
1118
            st->parser = NULL;
1119
        }
1120
        st->last_IP_pts = AV_NOPTS_VALUE;
1121
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1122
    }
1123
}
1124

    
1125
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1126
    int i;
1127

    
1128
    for(i = 0; i < s->nb_streams; i++) {
1129
        AVStream *st = s->streams[i];
1130

    
1131
        st->cur_dts = av_rescale(timestamp,
1132
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1133
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1134
    }
1135
}
1136

    
1137
void ff_reduce_index(AVFormatContext *s, int stream_index)
1138
{
1139
    AVStream *st= s->streams[stream_index];
1140
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1141

    
1142
    if((unsigned)st->nb_index_entries >= max_entries){
1143
        int i;
1144
        for(i=0; 2*i<st->nb_index_entries; i++)
1145
            st->index_entries[i]= st->index_entries[2*i];
1146
        st->nb_index_entries= i;
1147
    }
1148
}
1149

    
1150
int av_add_index_entry(AVStream *st,
1151
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1152
{
1153
    AVIndexEntry *entries, *ie;
1154
    int index;
1155

    
1156
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1157
        return -1;
1158

    
1159
    entries = av_fast_realloc(st->index_entries,
1160
                              &st->index_entries_allocated_size,
1161
                              (st->nb_index_entries + 1) *
1162
                              sizeof(AVIndexEntry));
1163
    if(!entries)
1164
        return -1;
1165

    
1166
    st->index_entries= entries;
1167

    
1168
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1169

    
1170
    if(index<0){
1171
        index= st->nb_index_entries++;
1172
        ie= &entries[index];
1173
        assert(index==0 || ie[-1].timestamp < timestamp);
1174
    }else{
1175
        ie= &entries[index];
1176
        if(ie->timestamp != timestamp){
1177
            if(ie->timestamp <= timestamp)
1178
                return -1;
1179
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1180
            st->nb_index_entries++;
1181
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1182
            distance= ie->min_distance;
1183
    }
1184

    
1185
    ie->pos = pos;
1186
    ie->timestamp = timestamp;
1187
    ie->min_distance= distance;
1188
    ie->size= size;
1189
    ie->flags = flags;
1190

    
1191
    return index;
1192
}
1193

    
1194
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1195
                              int flags)
1196
{
1197
    AVIndexEntry *entries= st->index_entries;
1198
    int nb_entries= st->nb_index_entries;
1199
    int a, b, m;
1200
    int64_t timestamp;
1201

    
1202
    a = - 1;
1203
    b = nb_entries;
1204

    
1205
    while (b - a > 1) {
1206
        m = (a + b) >> 1;
1207
        timestamp = entries[m].timestamp;
1208
        if(timestamp >= wanted_timestamp)
1209
            b = m;
1210
        if(timestamp <= wanted_timestamp)
1211
            a = m;
1212
    }
1213
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1214

    
1215
    if(!(flags & AVSEEK_FLAG_ANY)){
1216
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1217
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1218
        }
1219
    }
1220

    
1221
    if(m == nb_entries)
1222
        return -1;
1223
    return  m;
1224
}
1225

    
1226
#define DEBUG_SEEK
1227

    
1228
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1229
    AVInputFormat *avif= s->iformat;
1230
    int64_t pos_min, pos_max, pos, pos_limit;
1231
    int64_t ts_min, ts_max, ts;
1232
    int index;
1233
    AVStream *st;
1234

    
1235
    if (stream_index < 0)
1236
        return -1;
1237

    
1238
#ifdef DEBUG_SEEK
1239
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1240
#endif
1241

    
1242
    ts_max=
1243
    ts_min= AV_NOPTS_VALUE;
1244
    pos_limit= -1; //gcc falsely says it may be uninitialized
1245

    
1246
    st= s->streams[stream_index];
1247
    if(st->index_entries){
1248
        AVIndexEntry *e;
1249

    
1250
        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()
1251
        index= FFMAX(index, 0);
1252
        e= &st->index_entries[index];
1253

    
1254
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1255
            pos_min= e->pos;
1256
            ts_min= e->timestamp;
1257
#ifdef DEBUG_SEEK
1258
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1259
               pos_min,ts_min);
1260
#endif
1261
        }else{
1262
            assert(index==0);
1263
        }
1264

    
1265
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1266
        assert(index < st->nb_index_entries);
1267
        if(index >= 0){
1268
            e= &st->index_entries[index];
1269
            assert(e->timestamp >= target_ts);
1270
            pos_max= e->pos;
1271
            ts_max= e->timestamp;
1272
            pos_limit= pos_max - e->min_distance;
1273
#ifdef DEBUG_SEEK
1274
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1275
               pos_max,pos_limit, ts_max);
1276
#endif
1277
        }
1278
    }
1279

    
1280
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1281
    if(pos<0)
1282
        return -1;
1283

    
1284
    /* do the seek */
1285
    url_fseek(s->pb, pos, SEEK_SET);
1286

    
1287
    av_update_cur_dts(s, st, ts);
1288

    
1289
    return 0;
1290
}
1291

    
1292
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 )){
1293
    int64_t pos, ts;
1294
    int64_t start_pos, filesize;
1295
    int no_change;
1296

    
1297
#ifdef DEBUG_SEEK
1298
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1299
#endif
1300

    
1301
    if(ts_min == AV_NOPTS_VALUE){
1302
        pos_min = s->data_offset;
1303
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1304
        if (ts_min == AV_NOPTS_VALUE)
1305
            return -1;
1306
    }
1307

    
1308
    if(ts_max == AV_NOPTS_VALUE){
1309
        int step= 1024;
1310
        filesize = url_fsize(s->pb);
1311
        pos_max = filesize - 1;
1312
        do{
1313
            pos_max -= step;
1314
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1315
            step += step;
1316
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1317
        if (ts_max == AV_NOPTS_VALUE)
1318
            return -1;
1319

    
1320
        for(;;){
1321
            int64_t tmp_pos= pos_max + 1;
1322
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1323
            if(tmp_ts == AV_NOPTS_VALUE)
1324
                break;
1325
            ts_max= tmp_ts;
1326
            pos_max= tmp_pos;
1327
            if(tmp_pos >= filesize)
1328
                break;
1329
        }
1330
        pos_limit= pos_max;
1331
    }
1332

    
1333
    if(ts_min > ts_max){
1334
        return -1;
1335
    }else if(ts_min == ts_max){
1336
        pos_limit= pos_min;
1337
    }
1338

    
1339
    no_change=0;
1340
    while (pos_min < pos_limit) {
1341
#ifdef DEBUG_SEEK
1342
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1343
               pos_min, pos_max,
1344
               ts_min, ts_max);
1345
#endif
1346
        assert(pos_limit <= pos_max);
1347

    
1348
        if(no_change==0){
1349
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1350
            // interpolate position (better than dichotomy)
1351
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1352
                + pos_min - approximate_keyframe_distance;
1353
        }else if(no_change==1){
1354
            // bisection, if interpolation failed to change min or max pos last time
1355
            pos = (pos_min + pos_limit)>>1;
1356
        }else{
1357
            /* linear search if bisection failed, can only happen if there
1358
               are very few or no keyframes between min/max */
1359
            pos=pos_min;
1360
        }
1361
        if(pos <= pos_min)
1362
            pos= pos_min + 1;
1363
        else if(pos > pos_limit)
1364
            pos= pos_limit;
1365
        start_pos= pos;
1366

    
1367
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1368
        if(pos == pos_max)
1369
            no_change++;
1370
        else
1371
            no_change=0;
1372
#ifdef DEBUG_SEEK
1373
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);
1374
#endif
1375
        if(ts == AV_NOPTS_VALUE){
1376
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1377
            return -1;
1378
        }
1379
        assert(ts != AV_NOPTS_VALUE);
1380
        if (target_ts <= ts) {
1381
            pos_limit = start_pos - 1;
1382
            pos_max = pos;
1383
            ts_max = ts;
1384
        }
1385
        if (target_ts >= ts) {
1386
            pos_min = pos;
1387
            ts_min = ts;
1388
        }
1389
    }
1390

    
1391
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1392
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1393
#ifdef DEBUG_SEEK
1394
    pos_min = pos;
1395
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1396
    pos_min++;
1397
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1398
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1399
           pos, ts_min, target_ts, ts_max);
1400
#endif
1401
    *ts_ret= ts;
1402
    return pos;
1403
}
1404

    
1405
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1406
    int64_t pos_min, pos_max;
1407
#if 0
1408
    AVStream *st;
1409

1410
    if (stream_index < 0)
1411
        return -1;
1412

1413
    st= s->streams[stream_index];
1414
#endif
1415

    
1416
    pos_min = s->data_offset;
1417
    pos_max = url_fsize(s->pb) - 1;
1418

    
1419
    if     (pos < pos_min) pos= pos_min;
1420
    else if(pos > pos_max) pos= pos_max;
1421

    
1422
    url_fseek(s->pb, pos, SEEK_SET);
1423

    
1424
#if 0
1425
    av_update_cur_dts(s, st, ts);
1426
#endif
1427
    return 0;
1428
}
1429

    
1430
static int av_seek_frame_generic(AVFormatContext *s,
1431
                                 int stream_index, int64_t timestamp, int flags)
1432
{
1433
    int index;
1434
    AVStream *st;
1435
    AVIndexEntry *ie;
1436

    
1437
    st = s->streams[stream_index];
1438

    
1439
    index = av_index_search_timestamp(st, timestamp, flags);
1440

    
1441
    if(index < 0 || index==st->nb_index_entries-1){
1442
        int i;
1443
        AVPacket pkt;
1444

    
1445
        if(st->nb_index_entries){
1446
            assert(st->index_entries);
1447
            ie= &st->index_entries[st->nb_index_entries-1];
1448
            url_fseek(s->pb, ie->pos, SEEK_SET);
1449
            av_update_cur_dts(s, st, ie->timestamp);
1450
        }else
1451
            url_fseek(s->pb, 0, SEEK_SET);
1452

    
1453
        for(i=0;; i++) {
1454
            int ret = av_read_frame(s, &pkt);
1455
            if(ret<0)
1456
                break;
1457
            av_free_packet(&pkt);
1458
            if(stream_index == pkt.stream_index){
1459
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1460
                    break;
1461
            }
1462
        }
1463
        index = av_index_search_timestamp(st, timestamp, flags);
1464
    }
1465
    if (index < 0)
1466
        return -1;
1467

    
1468
    av_read_frame_flush(s);
1469
    if (s->iformat->read_seek){
1470
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1471
            return 0;
1472
    }
1473
    ie = &st->index_entries[index];
1474
    url_fseek(s->pb, ie->pos, SEEK_SET);
1475

    
1476
    av_update_cur_dts(s, st, ie->timestamp);
1477

    
1478
    return 0;
1479
}
1480

    
1481
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1482
{
1483
    int ret;
1484
    AVStream *st;
1485

    
1486
    av_read_frame_flush(s);
1487

    
1488
    if(flags & AVSEEK_FLAG_BYTE)
1489
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1490

    
1491
    if(stream_index < 0){
1492
        stream_index= av_find_default_stream_index(s);
1493
        if(stream_index < 0)
1494
            return -1;
1495

    
1496
        st= s->streams[stream_index];
1497
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1498
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1499
    }
1500
    st= s->streams[stream_index];
1501

    
1502
    /* first, we try the format specific seek */
1503
    if (s->iformat->read_seek)
1504
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1505
    else
1506
        ret = -1;
1507
    if (ret >= 0) {
1508
        return 0;
1509
    }
1510

    
1511
    if(s->iformat->read_timestamp)
1512
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1513
    else
1514
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1515
}
1516

    
1517
/*******************************************************/
1518

    
1519
/**
1520
 * Returns TRUE if the stream has accurate duration in any stream.
1521
 *
1522
 * @return TRUE if the stream has accurate duration for at least one component.
1523
 */
1524
static int av_has_duration(AVFormatContext *ic)
1525
{
1526
    int i;
1527
    AVStream *st;
1528

    
1529
    for(i = 0;i < ic->nb_streams; i++) {
1530
        st = ic->streams[i];
1531
        if (st->duration != AV_NOPTS_VALUE)
1532
            return 1;
1533
    }
1534
    return 0;
1535
}
1536

    
1537
/**
1538
 * Estimate the stream timings from the one of each components.
1539
 *
1540
 * Also computes the global bitrate if possible.
1541
 */
1542
static void av_update_stream_timings(AVFormatContext *ic)
1543
{
1544
    int64_t start_time, start_time1, end_time, end_time1;
1545
    int64_t duration, duration1;
1546
    int i;
1547
    AVStream *st;
1548

    
1549
    start_time = INT64_MAX;
1550
    end_time = INT64_MIN;
1551
    duration = INT64_MIN;
1552
    for(i = 0;i < ic->nb_streams; i++) {
1553
        st = ic->streams[i];
1554
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1555
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1556
            if (start_time1 < start_time)
1557
                start_time = start_time1;
1558
            if (st->duration != AV_NOPTS_VALUE) {
1559
                end_time1 = start_time1
1560
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1561
                if (end_time1 > end_time)
1562
                    end_time = end_time1;
1563
            }
1564
        }
1565
        if (st->duration != AV_NOPTS_VALUE) {
1566
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1567
            if (duration1 > duration)
1568
                duration = duration1;
1569
        }
1570
    }
1571
    if (start_time != INT64_MAX) {
1572
        ic->start_time = start_time;
1573
        if (end_time != INT64_MIN) {
1574
            if (end_time - start_time > duration)
1575
                duration = end_time - start_time;
1576
        }
1577
    }
1578
    if (duration != INT64_MIN) {
1579
        ic->duration = duration;
1580
        if (ic->file_size > 0) {
1581
            /* compute the bitrate */
1582
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1583
                (double)ic->duration;
1584
        }
1585
    }
1586
}
1587

    
1588
static void fill_all_stream_timings(AVFormatContext *ic)
1589
{
1590
    int i;
1591
    AVStream *st;
1592

    
1593
    av_update_stream_timings(ic);
1594
    for(i = 0;i < ic->nb_streams; i++) {
1595
        st = ic->streams[i];
1596
        if (st->start_time == AV_NOPTS_VALUE) {
1597
            if(ic->start_time != AV_NOPTS_VALUE)
1598
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1599
            if(ic->duration != AV_NOPTS_VALUE)
1600
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1601
        }
1602
    }
1603
}
1604

    
1605
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1606
{
1607
    int64_t filesize, duration;
1608
    int bit_rate, i;
1609
    AVStream *st;
1610

    
1611
    /* if bit_rate is already set, we believe it */
1612
    if (ic->bit_rate == 0) {
1613
        bit_rate = 0;
1614
        for(i=0;i<ic->nb_streams;i++) {
1615
            st = ic->streams[i];
1616
            bit_rate += st->codec->bit_rate;
1617
        }
1618
        ic->bit_rate = bit_rate;
1619
    }
1620

    
1621
    /* if duration is already set, we believe it */
1622
    if (ic->duration == AV_NOPTS_VALUE &&
1623
        ic->bit_rate != 0 &&
1624
        ic->file_size != 0)  {
1625
        filesize = ic->file_size;
1626
        if (filesize > 0) {
1627
            for(i = 0; i < ic->nb_streams; i++) {
1628
                st = ic->streams[i];
1629
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1630
                if (st->duration == AV_NOPTS_VALUE)
1631
                    st->duration = duration;
1632
            }
1633
        }
1634
    }
1635
}
1636

    
1637
#define DURATION_MAX_READ_SIZE 250000
1638

    
1639
/* only usable for MPEG-PS streams */
1640
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1641
{
1642
    AVPacket pkt1, *pkt = &pkt1;
1643
    AVStream *st;
1644
    int read_size, i, ret;
1645
    int64_t end_time;
1646
    int64_t filesize, offset, duration;
1647

    
1648
    /* free previous packet */
1649
    if (ic->cur_st && ic->cur_st->parser)
1650
        av_free_packet(&ic->cur_pkt);
1651
    ic->cur_st = NULL;
1652

    
1653
    /* flush packet queue */
1654
    flush_packet_queue(ic);
1655

    
1656
    for(i=0;i<ic->nb_streams;i++) {
1657
        st = ic->streams[i];
1658
        if (st->parser) {
1659
            av_parser_close(st->parser);
1660
            st->parser= NULL;
1661
        }
1662
    }
1663

    
1664
    /* we read the first packets to get the first PTS (not fully
1665
       accurate, but it is enough now) */
1666
    url_fseek(ic->pb, 0, SEEK_SET);
1667
    read_size = 0;
1668
    for(;;) {
1669
        if (read_size >= DURATION_MAX_READ_SIZE)
1670
            break;
1671
        /* if all info is available, we can stop */
1672
        for(i = 0;i < ic->nb_streams; i++) {
1673
            st = ic->streams[i];
1674
            if (st->start_time == AV_NOPTS_VALUE)
1675
                break;
1676
        }
1677
        if (i == ic->nb_streams)
1678
            break;
1679

    
1680
        ret = av_read_packet(ic, pkt);
1681
        if (ret != 0)
1682
            break;
1683
        read_size += pkt->size;
1684
        st = ic->streams[pkt->stream_index];
1685
        if (pkt->pts != AV_NOPTS_VALUE) {
1686
            if (st->start_time == AV_NOPTS_VALUE)
1687
                st->start_time = pkt->pts;
1688
        }
1689
        av_free_packet(pkt);
1690
    }
1691

    
1692
    /* estimate the end time (duration) */
1693
    /* XXX: may need to support wrapping */
1694
    filesize = ic->file_size;
1695
    offset = filesize - DURATION_MAX_READ_SIZE;
1696
    if (offset < 0)
1697
        offset = 0;
1698

    
1699
    url_fseek(ic->pb, offset, SEEK_SET);
1700
    read_size = 0;
1701
    for(;;) {
1702
        if (read_size >= DURATION_MAX_READ_SIZE)
1703
            break;
1704

    
1705
        ret = av_read_packet(ic, pkt);
1706
        if (ret != 0)
1707
            break;
1708
        read_size += pkt->size;
1709
        st = ic->streams[pkt->stream_index];
1710
        if (pkt->pts != AV_NOPTS_VALUE &&
1711
            st->start_time != AV_NOPTS_VALUE) {
1712
            end_time = pkt->pts;
1713
            duration = end_time - st->start_time;
1714
            if (duration > 0) {
1715
                if (st->duration == AV_NOPTS_VALUE ||
1716
                    st->duration < duration)
1717
                    st->duration = duration;
1718
            }
1719
        }
1720
        av_free_packet(pkt);
1721
    }
1722

    
1723
    fill_all_stream_timings(ic);
1724

    
1725
    url_fseek(ic->pb, old_offset, SEEK_SET);
1726
    for(i=0; i<ic->nb_streams; i++){
1727
        st= ic->streams[i];
1728
        st->cur_dts= st->first_dts;
1729
        st->last_IP_pts = AV_NOPTS_VALUE;
1730
    }
1731
}
1732

    
1733
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1734
{
1735
    int64_t file_size;
1736

    
1737
    /* get the file size, if possible */
1738
    if (ic->iformat->flags & AVFMT_NOFILE) {
1739
        file_size = 0;
1740
    } else {
1741
        file_size = url_fsize(ic->pb);
1742
        if (file_size < 0)
1743
            file_size = 0;
1744
    }
1745
    ic->file_size = file_size;
1746

    
1747
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1748
         !strcmp(ic->iformat->name, "mpegts")) &&
1749
        file_size && !url_is_streamed(ic->pb)) {
1750
        /* get accurate estimate from the PTSes */
1751
        av_estimate_timings_from_pts(ic, old_offset);
1752
    } else if (av_has_duration(ic)) {
1753
        /* at least one component has timings - we use them for all
1754
           the components */
1755
        fill_all_stream_timings(ic);
1756
    } else {
1757
        /* less precise: use bitrate info */
1758
        av_estimate_timings_from_bit_rate(ic);
1759
    }
1760
    av_update_stream_timings(ic);
1761

    
1762
#if 0
1763
    {
1764
        int i;
1765
        AVStream *st;
1766
        for(i = 0;i < ic->nb_streams; i++) {
1767
            st = ic->streams[i];
1768
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1769
               i, (double)st->start_time / AV_TIME_BASE,
1770
               (double)st->duration / AV_TIME_BASE);
1771
        }
1772
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1773
               (double)ic->start_time / AV_TIME_BASE,
1774
               (double)ic->duration / AV_TIME_BASE,
1775
               ic->bit_rate / 1000);
1776
    }
1777
#endif
1778
}
1779

    
1780
static int has_codec_parameters(AVCodecContext *enc)
1781
{
1782
    int val;
1783
    switch(enc->codec_type) {
1784
    case CODEC_TYPE_AUDIO:
1785
        val = enc->sample_rate && enc->channels;
1786
        if(!enc->frame_size &&
1787
           (enc->codec_id == CODEC_ID_VORBIS ||
1788
            enc->codec_id == CODEC_ID_AAC))
1789
            return 0;
1790
        break;
1791
    case CODEC_TYPE_VIDEO:
1792
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1793
        break;
1794
    default:
1795
        val = 1;
1796
        break;
1797
    }
1798
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1799
}
1800

    
1801
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1802
{
1803
    int16_t *samples;
1804
    AVCodec *codec;
1805
    int got_picture, data_size, ret=0;
1806
    AVFrame picture;
1807

    
1808
  if(!st->codec->codec){
1809
    codec = avcodec_find_decoder(st->codec->codec_id);
1810
    if (!codec)
1811
        return -1;
1812
    ret = avcodec_open(st->codec, codec);
1813
    if (ret < 0)
1814
        return ret;
1815
  }
1816

    
1817
  if(!has_codec_parameters(st->codec)){
1818
    switch(st->codec->codec_type) {
1819
    case CODEC_TYPE_VIDEO:
1820
        ret = avcodec_decode_video(st->codec, &picture,
1821
                                   &got_picture, data, size);
1822
        break;
1823
    case CODEC_TYPE_AUDIO:
1824
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1825
        samples = av_malloc(data_size);
1826
        if (!samples)
1827
            goto fail;
1828
        ret = avcodec_decode_audio2(st->codec, samples,
1829
                                    &data_size, data, size);
1830
        av_free(samples);
1831
        break;
1832
    default:
1833
        break;
1834
    }
1835
  }
1836
 fail:
1837
    return ret;
1838
}
1839

    
1840
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1841
{
1842
    while (tags->id != CODEC_ID_NONE) {
1843
        if (tags->id == id)
1844
            return tags->tag;
1845
        tags++;
1846
    }
1847
    return 0;
1848
}
1849

    
1850
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1851
{
1852
    int i;
1853
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1854
        if(tag == tags[i].tag)
1855
            return tags[i].id;
1856
    }
1857
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1858
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1859
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1860
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1861
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1862
            return tags[i].id;
1863
    }
1864
    return CODEC_ID_NONE;
1865
}
1866

    
1867
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1868
{
1869
    int i;
1870
    for(i=0; tags && tags[i]; i++){
1871
        int tag= codec_get_tag(tags[i], id);
1872
        if(tag) return tag;
1873
    }
1874
    return 0;
1875
}
1876

    
1877
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1878
{
1879
    int i;
1880
    for(i=0; tags && tags[i]; i++){
1881
        enum CodecID id= codec_get_id(tags[i], tag);
1882
        if(id!=CODEC_ID_NONE) return id;
1883
    }
1884
    return CODEC_ID_NONE;
1885
}
1886

    
1887
static void compute_chapters_end(AVFormatContext *s)
1888
{
1889
    unsigned int i;
1890

    
1891
    for (i=0; i+1<s->nb_chapters; i++)
1892
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1893
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1894
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1895
            s->chapters[i]->end = s->chapters[i+1]->start;
1896
        }
1897

    
1898
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1899
        assert(s->start_time != AV_NOPTS_VALUE);
1900
        assert(s->duration > 0);
1901
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1902
                                           AV_TIME_BASE_Q,
1903
                                           s->chapters[i]->time_base);
1904
    }
1905
}
1906

    
1907
/* absolute maximum size we read until we abort */
1908
#define MAX_READ_SIZE        5000000
1909

    
1910
#define MAX_STD_TIMEBASES (60*12+5)
1911
static int get_std_framerate(int i){
1912
    if(i<60*12) return i*1001;
1913
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1914
}
1915

    
1916
/*
1917
 * Is the time base unreliable.
1918
 * This is a heuristic to balance between quick acceptance of the values in
1919
 * the headers vs. some extra checks.
1920
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1921
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1922
 * And there are "variable" fps files this needs to detect as well.
1923
 */
1924
static int tb_unreliable(AVCodecContext *c){
1925
    if(   c->time_base.den >= 101L*c->time_base.num
1926
       || c->time_base.den <    5L*c->time_base.num
1927
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1928
       || c->codec_tag == ff_get_fourcc("XVID")*/
1929
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1930
        return 1;
1931
    return 0;
1932
}
1933

    
1934
int av_find_stream_info(AVFormatContext *ic)
1935
{
1936
    int i, count, ret, read_size, j;
1937
    AVStream *st;
1938
    AVPacket pkt1, *pkt;
1939
    int64_t last_dts[MAX_STREAMS];
1940
    int duration_count[MAX_STREAMS]={0};
1941
    double (*duration_error)[MAX_STD_TIMEBASES];
1942
    offset_t old_offset = url_ftell(ic->pb);
1943
    int64_t codec_info_duration[MAX_STREAMS]={0};
1944
    int codec_info_nb_frames[MAX_STREAMS]={0};
1945
    AVProbeData probe_data[MAX_STREAMS];
1946
    int codec_identified[MAX_STREAMS]={0};
1947

    
1948
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1949
    if (!duration_error) return AVERROR(ENOMEM);
1950

    
1951
    for(i=0;i<ic->nb_streams;i++) {
1952
        st = ic->streams[i];
1953
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1954
/*            if(!st->time_base.num)
1955
                st->time_base= */
1956
            if(!st->codec->time_base.num)
1957
                st->codec->time_base= st->time_base;
1958
        }
1959
        //only for the split stuff
1960
        if (!st->parser) {
1961
            st->parser = av_parser_init(st->codec->codec_id);
1962
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1963
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1964
            }
1965
        }
1966
    }
1967

    
1968
    for(i=0;i<MAX_STREAMS;i++){
1969
        last_dts[i]= AV_NOPTS_VALUE;
1970
    }
1971

    
1972
    memset(probe_data, 0, sizeof(probe_data));
1973
    count = 0;
1974
    read_size = 0;
1975
    for(;;) {
1976
        /* check if one codec still needs to be handled */
1977
        for(i=0;i<ic->nb_streams;i++) {
1978
            st = ic->streams[i];
1979
            if (!has_codec_parameters(st->codec))
1980
                break;
1981
            /* variable fps and no guess at the real fps */
1982
            if(   tb_unreliable(st->codec)
1983
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1984
                break;
1985
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1986
                break;
1987
            if(st->first_dts == AV_NOPTS_VALUE)
1988
                break;
1989
        }
1990
        if (i == ic->nb_streams) {
1991
            /* NOTE: if the format has no header, then we need to read
1992
               some packets to get most of the streams, so we cannot
1993
               stop here */
1994
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1995
                /* if we found the info for all the codecs, we can stop */
1996
                ret = count;
1997
                break;
1998
            }
1999
        }
2000
        /* we did not get all the codec info, but we read too much data */
2001
        if (read_size >= MAX_READ_SIZE) {
2002
            ret = count;
2003
            break;
2004
        }
2005

    
2006
        /* NOTE: a new stream can be added there if no header in file
2007
           (AVFMTCTX_NOHEADER) */
2008
        ret = av_read_frame_internal(ic, &pkt1);
2009
        if (ret < 0) {
2010
            /* EOF or error */
2011
            ret = -1; /* we could not have all the codec parameters before EOF */
2012
            for(i=0;i<ic->nb_streams;i++) {
2013
                st = ic->streams[i];
2014
                if (!has_codec_parameters(st->codec)){
2015
                    char buf[256];
2016
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2017
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2018
                } else {
2019
                    ret = 0;
2020
                }
2021
            }
2022
            break;
2023
        }
2024

    
2025
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1);
2026
        if(av_dup_packet(pkt) < 0)
2027
            return AVERROR(ENOMEM);
2028

    
2029
        read_size += pkt->size;
2030

    
2031
        st = ic->streams[pkt->stream_index];
2032
        if(codec_info_nb_frames[st->index]>1)
2033
            codec_info_duration[st->index] += pkt->duration;
2034
        if (pkt->duration != 0)
2035
            codec_info_nb_frames[st->index]++;
2036

    
2037
        {
2038
            int index= pkt->stream_index;
2039
            int64_t last= last_dts[index];
2040
            int64_t duration= pkt->dts - last;
2041

    
2042
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2043
                double dur= duration * av_q2d(st->time_base);
2044

    
2045
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2046
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2047
                if(duration_count[index] < 2)
2048
                    memset(duration_error[index], 0, sizeof(*duration_error));
2049
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2050
                    int framerate= get_std_framerate(i);
2051
                    int ticks= lrintf(dur*framerate/(1001*12));
2052
                    double error= dur - ticks*1001*12/(double)framerate;
2053
                    duration_error[index][i] += error*error;
2054
                }
2055
                duration_count[index]++;
2056
            }
2057
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2058
                last_dts[pkt->stream_index]= pkt->dts;
2059

    
2060
            if (st->codec->codec_id == CODEC_ID_NONE) {
2061
                AVProbeData *pd = &(probe_data[st->index]);
2062
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
2063
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
2064
                pd->buf_size += pkt->size;
2065
                memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
2066
            }
2067
        }
2068
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2069
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2070
            if(i){
2071
                st->codec->extradata_size= i;
2072
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2073
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2074
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2075
            }
2076
        }
2077

    
2078
        /* if still no information, we try to open the codec and to
2079
           decompress the frame. We try to avoid that in most cases as
2080
           it takes longer and uses more memory. For MPEG-4, we need to
2081
           decompress for QuickTime. */
2082
        if (!has_codec_parameters(st->codec) /*&&
2083
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2084
             st->codec->codec_id == CODEC_ID_H264 ||
2085
             st->codec->codec_id == CODEC_ID_H263 ||
2086
             st->codec->codec_id == CODEC_ID_H261 ||
2087
             st->codec->codec_id == CODEC_ID_VORBIS ||
2088
             st->codec->codec_id == CODEC_ID_MJPEG ||
2089
             st->codec->codec_id == CODEC_ID_PNG ||
2090
             st->codec->codec_id == CODEC_ID_PAM ||
2091
             st->codec->codec_id == CODEC_ID_PGM ||
2092
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2093
             st->codec->codec_id == CODEC_ID_PBM ||
2094
             st->codec->codec_id == CODEC_ID_PPM ||
2095
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2096
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2097
            try_decode_frame(st, pkt->data, pkt->size);
2098

    
2099
        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) {
2100
            break;
2101
        }
2102
        count++;
2103
    }
2104

    
2105
    // close codecs which were opened in try_decode_frame()
2106
    for(i=0;i<ic->nb_streams;i++) {
2107
        st = ic->streams[i];
2108
        if(st->codec->codec)
2109
            avcodec_close(st->codec);
2110
    }
2111
    for(i=0;i<ic->nb_streams;i++) {
2112
        st = ic->streams[i];
2113
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2114
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2115
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2116

    
2117
            if(duration_count[i]
2118
               && tb_unreliable(st->codec) /*&&
2119
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2120
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2121
                double best_error= 2*av_q2d(st->time_base);
2122
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2123

    
2124
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2125
                    double error= duration_error[i][j] * get_std_framerate(j);
2126
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2127
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2128
                    if(error < best_error){
2129
                        best_error= error;
2130
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2131
                    }
2132
                }
2133
            }
2134

    
2135
            if (!st->r_frame_rate.num){
2136
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2137
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2138
                    st->r_frame_rate.num = st->codec->time_base.den;
2139
                    st->r_frame_rate.den = st->codec->time_base.num;
2140
                }else{
2141
                    st->r_frame_rate.num = st->time_base.den;
2142
                    st->r_frame_rate.den = st->time_base.num;
2143
                }
2144
            }
2145
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2146
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
2147
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
2148
                if (codec_identified[st->index]) {
2149
                    st->need_parsing = AVSTREAM_PARSE_FULL;
2150
                }
2151
            }
2152
            if(!st->codec->bits_per_sample)
2153
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2154
        }
2155
    }
2156

    
2157
    av_estimate_timings(ic, old_offset);
2158

    
2159
    for(i=0;i<ic->nb_streams;i++) {
2160
        st = ic->streams[i];
2161
        if (codec_identified[st->index])
2162
            break;
2163
    }
2164
    //FIXME this is a mess
2165
    if(i!=ic->nb_streams){
2166
        av_read_frame_flush(ic);
2167
        for(i=0;i<ic->nb_streams;i++) {
2168
            st = ic->streams[i];
2169
            if (codec_identified[st->index]) {
2170
                av_seek_frame(ic, st->index, 0.0, 0);
2171
            }
2172
            st->cur_dts= st->first_dts;
2173
        }
2174
        url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2175
    }
2176

    
2177
    compute_chapters_end(ic);
2178

    
2179
#if 0
2180
    /* correct DTS for B-frame streams with no timestamps */
2181
    for(i=0;i<ic->nb_streams;i++) {
2182
        st = ic->streams[i];
2183
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2184
            if(b-frames){
2185
                ppktl = &ic->packet_buffer;
2186
                while(ppkt1){
2187
                    if(ppkt1->stream_index != i)
2188
                        continue;
2189
                    if(ppkt1->pkt->dts < 0)
2190
                        break;
2191
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2192
                        break;
2193
                    ppkt1->pkt->dts -= delta;
2194
                    ppkt1= ppkt1->next;
2195
                }
2196
                if(ppkt1)
2197
                    continue;
2198
                st->cur_dts -= delta;
2199
            }
2200
        }
2201
    }
2202
#endif
2203

    
2204
    av_free(duration_error);
2205
    for(i=0;i<MAX_STREAMS;i++){
2206
        av_freep(&(probe_data[i].buf));
2207
    }
2208

    
2209
    return ret;
2210
}
2211

    
2212
/*******************************************************/
2213

    
2214
int av_read_play(AVFormatContext *s)
2215
{
2216
    if (s->iformat->read_play)
2217
        return s->iformat->read_play(s);
2218
    if (s->pb)
2219
        return av_url_read_fpause(s->pb, 0);
2220
    return AVERROR(ENOSYS);
2221
}
2222

    
2223
int av_read_pause(AVFormatContext *s)
2224
{
2225
    if (s->iformat->read_pause)
2226
        return s->iformat->read_pause(s);
2227
    if (s->pb)
2228
        return av_url_read_fpause(s->pb, 1);
2229
    return AVERROR(ENOSYS);
2230
}
2231

    
2232
void av_close_input_stream(AVFormatContext *s)
2233
{
2234
    int i;
2235
    AVStream *st;
2236

    
2237
    /* free previous packet */
2238
    if (s->cur_st && s->cur_st->parser)
2239
        av_free_packet(&s->cur_pkt);
2240

    
2241
    if (s->iformat->read_close)
2242
        s->iformat->read_close(s);
2243
    for(i=0;i<s->nb_streams;i++) {
2244
        /* free all data in a stream component */
2245
        st = s->streams[i];
2246
        if (st->parser) {
2247
            av_parser_close(st->parser);
2248
        }
2249
        av_free(st->index_entries);
2250
        av_free(st->codec->extradata);
2251
        av_free(st->codec);
2252
        av_free(st->filename);
2253
        av_free(st->priv_data);
2254
        av_free(st);
2255
    }
2256
    for(i=s->nb_programs-1; i>=0; i--) {
2257
        av_freep(&s->programs[i]->provider_name);
2258
        av_freep(&s->programs[i]->name);
2259
        av_freep(&s->programs[i]->stream_index);
2260
        av_freep(&s->programs[i]);
2261
    }
2262
    av_freep(&s->programs);
2263
    flush_packet_queue(s);
2264
    av_freep(&s->priv_data);
2265
    while(s->nb_chapters--) {
2266
        av_free(s->chapters[s->nb_chapters]->title);
2267
        av_free(s->chapters[s->nb_chapters]);
2268
    }
2269
    av_freep(&s->chapters);
2270
    av_free(s);
2271
}
2272

    
2273
void av_close_input_file(AVFormatContext *s)
2274
{
2275
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2276
    av_close_input_stream(s);
2277
    if (pb)
2278
        url_fclose(pb);
2279
}
2280

    
2281
AVStream *av_new_stream(AVFormatContext *s, int id)
2282
{
2283
    AVStream *st;
2284
    int i;
2285

    
2286
    if (s->nb_streams >= MAX_STREAMS)
2287
        return NULL;
2288

    
2289
    st = av_mallocz(sizeof(AVStream));
2290
    if (!st)
2291
        return NULL;
2292

    
2293
    st->codec= avcodec_alloc_context();
2294
    if (s->iformat) {
2295
        /* no default bitrate if decoding */
2296
        st->codec->bit_rate = 0;
2297
    }
2298
    st->index = s->nb_streams;
2299
    st->id = id;
2300
    st->start_time = AV_NOPTS_VALUE;
2301
    st->duration = AV_NOPTS_VALUE;
2302
        /* we set the current DTS to 0 so that formats without any timestamps
2303
           but durations get some timestamps, formats with some unknown
2304
           timestamps have their first few packets buffered and the
2305
           timestamps corrected before they are returned to the user */
2306
    st->cur_dts = 0;
2307
    st->first_dts = AV_NOPTS_VALUE;
2308

    
2309
    /* default pts setting is MPEG-like */
2310
    av_set_pts_info(st, 33, 1, 90000);
2311
    st->last_IP_pts = AV_NOPTS_VALUE;
2312
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2313
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2314

    
2315
    s->streams[s->nb_streams++] = st;
2316
    return st;
2317
}
2318

    
2319
AVProgram *av_new_program(AVFormatContext *ac, int id)
2320
{
2321
    AVProgram *program=NULL;
2322
    int i;
2323

    
2324
#ifdef DEBUG_SI
2325
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2326
#endif
2327

    
2328
    for(i=0; i<ac->nb_programs; i++)
2329
        if(ac->programs[i]->id == id)
2330
            program = ac->programs[i];
2331

    
2332
    if(!program){
2333
        program = av_mallocz(sizeof(AVProgram));
2334
        if (!program)
2335
            return NULL;
2336
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2337
        program->discard = AVDISCARD_NONE;
2338
    }
2339
    program->id = id;
2340

    
2341
    return program;
2342
}
2343

    
2344
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2345
{
2346
    assert(!provider_name == !name);
2347
    if(name){
2348
        av_free(program->provider_name);
2349
        av_free(program->         name);
2350
        program->provider_name = av_strdup(provider_name);
2351
        program->         name = av_strdup(         name);
2352
    }
2353
}
2354

    
2355
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2356
{
2357
    AVChapter *chapter = NULL;
2358
    int i;
2359

    
2360
    for(i=0; i<s->nb_chapters; i++)
2361
        if(s->chapters[i]->id == id)
2362
            chapter = s->chapters[i];
2363

    
2364
    if(!chapter){
2365
        chapter= av_mallocz(sizeof(AVChapter));
2366
        if(!chapter)
2367
            return NULL;
2368
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2369
    }
2370
    av_free(chapter->title);
2371
    chapter->title = av_strdup(title);
2372
    chapter->id    = id;
2373
    chapter->time_base= time_base;
2374
    chapter->start = start;
2375
    chapter->end   = end;
2376

    
2377
    return chapter;
2378
}
2379

    
2380
/************************************************************/
2381
/* output media file */
2382

    
2383
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2384
{
2385
    int ret;
2386

    
2387
    if (s->oformat->priv_data_size > 0) {
2388
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2389
        if (!s->priv_data)
2390
            return AVERROR(ENOMEM);
2391
    } else
2392
        s->priv_data = NULL;
2393

    
2394
    if (s->oformat->set_parameters) {
2395
        ret = s->oformat->set_parameters(s, ap);
2396
        if (ret < 0)
2397
            return ret;
2398
    }
2399
    return 0;
2400
}
2401

    
2402
int av_write_header(AVFormatContext *s)
2403
{
2404
    int ret, i;
2405
    AVStream *st;
2406

    
2407
    // some sanity checks
2408
    for(i=0;i<s->nb_streams;i++) {
2409
        st = s->streams[i];
2410

    
2411
        switch (st->codec->codec_type) {
2412
        case CODEC_TYPE_AUDIO:
2413
            if(st->codec->sample_rate<=0){
2414
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2415
                return -1;
2416
            }
2417
            break;
2418
        case CODEC_TYPE_VIDEO:
2419
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2420
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2421
                return -1;
2422
            }
2423
            if(st->codec->width<=0 || st->codec->height<=0){
2424
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2425
                return -1;
2426
            }
2427
            break;
2428
        }
2429

    
2430
        if(s->oformat->codec_tag){
2431
            if(st->codec->codec_tag){
2432
                //FIXME
2433
                //check that tag + id is in the table
2434
                //if neither is in the table -> OK
2435
                //if tag is in the table with another id -> FAIL
2436
                //if id is in the table with another tag -> FAIL unless strict < ?
2437
            }else
2438
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2439
        }
2440
    }
2441

    
2442
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2443
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2444
        if (!s->priv_data)
2445
            return AVERROR(ENOMEM);
2446
    }
2447

    
2448
    if(s->oformat->write_header){
2449
        ret = s->oformat->write_header(s);
2450
        if (ret < 0)
2451
            return ret;
2452
    }
2453

    
2454
    /* init PTS generation */
2455
    for(i=0;i<s->nb_streams;i++) {
2456
        int64_t den = AV_NOPTS_VALUE;
2457
        st = s->streams[i];
2458

    
2459
        switch (st->codec->codec_type) {
2460
        case CODEC_TYPE_AUDIO:
2461
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2462
            break;
2463
        case CODEC_TYPE_VIDEO:
2464
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2465
            break;
2466
        default:
2467
            break;
2468
        }
2469
        if (den != AV_NOPTS_VALUE) {
2470
            if (den <= 0)
2471
                return AVERROR_INVALIDDATA;
2472
            av_frac_init(&st->pts, 0, 0, den);
2473
        }
2474
    }
2475
    return 0;
2476
}
2477

    
2478
//FIXME merge with compute_pkt_fields
2479
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2480
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2481
    int num, den, frame_size, i;
2482

    
2483
//    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);
2484

    
2485
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2486
        return -1;*/
2487

    
2488
    /* duration field */
2489
    if (pkt->duration == 0) {
2490
        compute_frame_duration(&num, &den, st, NULL, pkt);
2491
        if (den && num) {
2492
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2493
        }
2494
    }
2495

    
2496
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2497
        pkt->pts= pkt->dts;
2498

    
2499
    //XXX/FIXME this is a temporary hack until all encoders output pts
2500
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2501
        pkt->dts=
2502
//        pkt->pts= st->cur_dts;
2503
        pkt->pts= st->pts.val;
2504
    }
2505

    
2506
    //calculate dts from pts
2507
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2508
        st->pts_buffer[0]= pkt->pts;
2509
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2510
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2511
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2512
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2513

    
2514
        pkt->dts= st->pts_buffer[0];
2515
    }
2516

    
2517
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2518
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2519
        return -1;
2520
    }
2521
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2522
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2523
        return -1;
2524
    }
2525

    
2526
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2527
    st->cur_dts= pkt->dts;
2528
    st->pts.val= pkt->dts;
2529

    
2530
    /* update pts */
2531
    switch (st->codec->codec_type) {
2532
    case CODEC_TYPE_AUDIO:
2533
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2534

    
2535
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2536
           likely equal to the encoder delay, but it would be better if we
2537
           had the real timestamps from the encoder */
2538
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2539
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2540
        }
2541
        break;
2542
    case CODEC_TYPE_VIDEO:
2543
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2544
        break;
2545
    default:
2546
        break;
2547
    }
2548
    return 0;
2549
}
2550

    
2551
static void truncate_ts(AVStream *st, AVPacket *pkt){
2552
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2553

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

    
2557
    if (pkt->pts != AV_NOPTS_VALUE)
2558
        pkt->pts &= pts_mask;
2559
    if (pkt->dts != AV_NOPTS_VALUE)
2560
        pkt->dts &= pts_mask;
2561
}
2562

    
2563
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2564
{
2565
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2566

    
2567
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2568
        return ret;
2569

    
2570
    truncate_ts(s->streams[pkt->stream_index], pkt);
2571

    
2572
    ret= s->oformat->write_packet(s, pkt);
2573
    if(!ret)
2574
        ret= url_ferror(s->pb);
2575
    return ret;
2576
}
2577

    
2578
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2579
    AVPacketList *pktl, **next_point, *this_pktl;
2580
    int stream_count=0;
2581
    int streams[MAX_STREAMS];
2582

    
2583
    if(pkt){
2584
        AVStream *st= s->streams[ pkt->stream_index];
2585

    
2586
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2587

    
2588
        this_pktl = av_mallocz(sizeof(AVPacketList));
2589
        this_pktl->pkt= *pkt;
2590
        if(pkt->destruct == av_destruct_packet)
2591
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2592
        else
2593
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2594

    
2595
        next_point = &s->packet_buffer;
2596
        while(*next_point){
2597
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2598
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2599
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2600
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2601
                break;
2602
            next_point= &(*next_point)->next;
2603
        }
2604
        this_pktl->next= *next_point;
2605
        *next_point= this_pktl;
2606
    }
2607

    
2608
    memset(streams, 0, sizeof(streams));
2609
    pktl= s->packet_buffer;
2610
    while(pktl){
2611
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2612
        if(streams[ pktl->pkt.stream_index ] == 0)
2613
            stream_count++;
2614
        streams[ pktl->pkt.stream_index ]++;
2615
        pktl= pktl->next;
2616
    }
2617

    
2618
    if(stream_count && (s->nb_streams == stream_count || flush)){
2619
        pktl= s->packet_buffer;
2620
        *out= pktl->pkt;
2621

    
2622
        s->packet_buffer= pktl->next;
2623
        av_freep(&pktl);
2624
        return 1;
2625
    }else{
2626
        av_init_packet(out);
2627
        return 0;
2628
    }
2629
}
2630

    
2631
/**
2632
 * Interleaves an AVPacket correctly so it can be muxed.
2633
 * @param out the interleaved packet will be output here
2634
 * @param in the input packet
2635
 * @param flush 1 if no further packets are available as input and all
2636
 *              remaining packets should be output
2637
 * @return 1 if a packet was output, 0 if no packet could be output,
2638
 *         < 0 if an error occurred
2639
 */
2640
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2641
    if(s->oformat->interleave_packet)
2642
        return s->oformat->interleave_packet(s, out, in, flush);
2643
    else
2644
        return av_interleave_packet_per_dts(s, out, in, flush);
2645
}
2646

    
2647
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2648
    AVStream *st= s->streams[ pkt->stream_index];
2649

    
2650
    //FIXME/XXX/HACK drop zero sized packets
2651
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2652
        return 0;
2653

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

    
2658
    if(pkt->dts == AV_NOPTS_VALUE)
2659
        return -1;
2660

    
2661
    for(;;){
2662
        AVPacket opkt;
2663
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2664
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2665
            return ret;
2666

    
2667
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2668
        ret= s->oformat->write_packet(s, &opkt);
2669

    
2670
        av_free_packet(&opkt);
2671
        pkt= NULL;
2672

    
2673
        if(ret<0)
2674
            return ret;
2675
        if(url_ferror(s->pb))
2676
            return url_ferror(s->pb);
2677
    }
2678
}
2679

    
2680
int av_write_trailer(AVFormatContext *s)
2681
{
2682
    int ret, i;
2683

    
2684
    for(;;){
2685
        AVPacket pkt;
2686
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2687
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2688
            goto fail;
2689
        if(!ret)
2690
            break;
2691

    
2692
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2693
        ret= s->oformat->write_packet(s, &pkt);
2694

    
2695
        av_free_packet(&pkt);
2696

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

    
2703
    if(s->oformat->write_trailer)
2704
        ret = s->oformat->write_trailer(s);
2705
fail:
2706
    if(ret == 0)
2707
       ret=url_ferror(s->pb);
2708
    for(i=0;i<s->nb_streams;i++)
2709
        av_freep(&s->streams[i]->priv_data);
2710
    av_freep(&s->priv_data);
2711
    return ret;
2712
}
2713

    
2714
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2715
{
2716
    int i, j;
2717
    AVProgram *program=NULL;
2718
    void *tmp;
2719

    
2720
    for(i=0; i<ac->nb_programs; i++){
2721
        if(ac->programs[i]->id != progid)
2722
            continue;
2723
        program = ac->programs[i];
2724
        for(j=0; j<program->nb_stream_indexes; j++)
2725
            if(program->stream_index[j] == idx)
2726
                return;
2727

    
2728
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2729
        if(!tmp)
2730
            return;
2731
        program->stream_index = tmp;
2732
        program->stream_index[program->nb_stream_indexes++] = idx;
2733
        return;
2734
    }
2735
}
2736

    
2737
/* "user interface" functions */
2738
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2739
{
2740
    char buf[256];
2741
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2742
    AVStream *st = ic->streams[i];
2743
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2744
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2745
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2746
    /* the pid is an important information, so we display it */
2747
    /* XXX: add a generic system */
2748
    if (flags & AVFMT_SHOW_IDS)
2749
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2750
    if (strlen(st->language) > 0)
2751
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2752
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2753
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2754
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2755
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2756
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2757
/*      else if(st->time_base.den && st->time_base.num)
2758
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2759
        else
2760
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2761
    }
2762
    av_log(NULL, AV_LOG_INFO, "\n");
2763
}
2764

    
2765
void dump_format(AVFormatContext *ic,
2766
                 int index,
2767
                 const char *url,
2768
                 int is_output)
2769
{
2770
    int i;
2771

    
2772
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2773
            is_output ? "Output" : "Input",
2774
            index,
2775
            is_output ? ic->oformat->name : ic->iformat->name,
2776
            is_output ? "to" : "from", url);
2777
    if (!is_output) {
2778
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2779
        if (ic->duration != AV_NOPTS_VALUE) {
2780
            int hours, mins, secs, us;
2781
            secs = ic->duration / AV_TIME_BASE;
2782
            us = ic->duration % AV_TIME_BASE;
2783
            mins = secs / 60;
2784
            secs %= 60;
2785
            hours = mins / 60;
2786
            mins %= 60;
2787
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2788
                   (100 * us) / AV_TIME_BASE);
2789
        } else {
2790
            av_log(NULL, AV_LOG_INFO, "N/A");
2791
        }
2792
        if (ic->start_time != AV_NOPTS_VALUE) {
2793
            int secs, us;
2794
            av_log(NULL, AV_LOG_INFO, ", start: ");
2795
            secs = ic->start_time / AV_TIME_BASE;
2796
            us = ic->start_time % AV_TIME_BASE;
2797
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2798
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2799
        }
2800
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2801
        if (ic->bit_rate) {
2802
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2803
        } else {
2804
            av_log(NULL, AV_LOG_INFO, "N/A");
2805
        }
2806
        av_log(NULL, AV_LOG_INFO, "\n");
2807
    }
2808
    if(ic->nb_programs) {
2809
        int j, k;
2810
        for(j=0; j<ic->nb_programs; j++) {
2811
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2812
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2813
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2814
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2815
         }
2816
    } else
2817
    for(i=0;i<ic->nb_streams;i++)
2818
        dump_stream_format(ic, i, index, is_output);
2819
}
2820

    
2821
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2822
{
2823
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2824
}
2825

    
2826
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2827
{
2828
    AVRational frame_rate;
2829
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2830
    *frame_rate_num= frame_rate.num;
2831
    *frame_rate_den= frame_rate.den;
2832
    return ret;
2833
}
2834

    
2835
/**
2836
 * Gets the current time in microseconds.
2837
 */
2838
int64_t av_gettime(void)
2839
{
2840
    struct timeval tv;
2841
    gettimeofday(&tv,NULL);
2842
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2843
}
2844

    
2845
int64_t parse_date(const char *datestr, int duration)
2846
{
2847
    const char *p;
2848
    int64_t t;
2849
    struct tm dt;
2850
    int i;
2851
    static const char *date_fmt[] = {
2852
        "%Y-%m-%d",
2853
        "%Y%m%d",
2854
    };
2855
    static const char *time_fmt[] = {
2856
        "%H:%M:%S",
2857
        "%H%M%S",
2858
    };
2859
    const char *q;
2860
    int is_utc, len;
2861
    char lastch;
2862
    int negative = 0;
2863

    
2864
#undef time
2865
    time_t now = time(0);
2866

    
2867
    len = strlen(datestr);
2868
    if (len > 0)
2869
        lastch = datestr[len - 1];
2870
    else
2871
        lastch = '\0';
2872
    is_utc = (lastch == 'z' || lastch == 'Z');
2873

    
2874
    memset(&dt, 0, sizeof(dt));
2875

    
2876
    p = datestr;
2877
    q = NULL;
2878
    if (!duration) {
2879
        /* parse the year-month-day part */
2880
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2881
            q = small_strptime(p, date_fmt[i], &dt);
2882
            if (q) {
2883
                break;
2884
            }
2885
        }
2886

    
2887
        /* if the year-month-day part is missing, then take the
2888
         * current year-month-day time */
2889
        if (!q) {
2890
            if (is_utc) {
2891
                dt = *gmtime(&now);
2892
            } else {
2893
                dt = *localtime(&now);
2894
            }
2895
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2896
        } else {
2897
            p = q;
2898
        }
2899

    
2900
        if (*p == 'T' || *p == 't' || *p == ' ')
2901
            p++;
2902

    
2903
        /* parse the hour-minute-second part */
2904
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2905
            q = small_strptime(p, time_fmt[i], &dt);
2906
            if (q) {
2907
                break;
2908
            }
2909
        }
2910
    } else {
2911
        /* parse datestr as a duration */
2912
        if (p[0] == '-') {
2913
            negative = 1;
2914
            ++p;
2915
        }
2916
        /* parse datestr as HH:MM:SS */
2917
        q = small_strptime(p, time_fmt[0], &dt);
2918
        if (!q) {
2919
            /* parse datestr as S+ */
2920
            dt.tm_sec = strtol(p, (char **)&q, 10);
2921
            if (q == p)
2922
                /* the parsing didn't succeed */
2923
                return INT64_MIN;
2924
            dt.tm_min = 0;
2925
            dt.tm_hour = 0;
2926
        }
2927
    }
2928

    
2929
    /* Now we have all the fields that we can get */
2930
    if (!q) {
2931
        return INT64_MIN;
2932
    }
2933

    
2934
    if (duration) {
2935
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2936
    } else {
2937
        dt.tm_isdst = -1;       /* unknown */
2938
        if (is_utc) {
2939
            t = mktimegm(&dt);
2940
        } else {
2941
            t = mktime(&dt);
2942
        }
2943
    }
2944

    
2945
    t *= 1000000;
2946

    
2947
    /* parse the .m... part */
2948
    if (*q == '.') {
2949
        int val, n;
2950
        q++;
2951
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2952
            if (!isdigit(*q))
2953
                break;
2954
            val += n * (*q - '0');
2955
        }
2956
        t += val;
2957
    }
2958
    return negative ? -t : t;
2959
}
2960

    
2961
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2962
{
2963
    const char *p;
2964
    char tag[128], *q;
2965

    
2966
    p = info;
2967
    if (*p == '?')
2968
        p++;
2969
    for(;;) {
2970
        q = tag;
2971
        while (*p != '\0' && *p != '=' && *p != '&') {
2972
            if ((q - tag) < sizeof(tag) - 1)
2973
                *q++ = *p;
2974
            p++;
2975
        }
2976
        *q = '\0';
2977
        q = arg;
2978
        if (*p == '=') {
2979
            p++;
2980
            while (*p != '&' && *p != '\0') {
2981
                if ((q - arg) < arg_size - 1) {
2982
                    if (*p == '+')
2983
                        *q++ = ' ';
2984
                    else
2985
                        *q++ = *p;
2986
                }
2987
                p++;
2988
            }
2989
            *q = '\0';
2990
        }
2991
        if (!strcmp(tag, tag1))
2992
            return 1;
2993
        if (*p != '&')
2994
            break;
2995
        p++;
2996
    }
2997
    return 0;
2998
}
2999

    
3000
int av_get_frame_filename(char *buf, int buf_size,
3001
                          const char *path, int number)
3002
{
3003
    const char *p;
3004
    char *q, buf1[20], c;
3005
    int nd, len, percentd_found;
3006

    
3007
    q = buf;
3008
    p = path;
3009
    percentd_found = 0;
3010
    for(;;) {
3011
        c = *p++;
3012
        if (c == '\0')
3013
            break;
3014
        if (c == '%') {
3015
            do {
3016
                nd = 0;
3017
                while (isdigit(*p)) {
3018
                    nd = nd * 10 + *p++ - '0';
3019
                }
3020
                c = *p++;
3021
            } while (isdigit(c));
3022

    
3023
            switch(c) {
3024
            case '%':
3025
                goto addchar;
3026
            case 'd':
3027
                if (percentd_found)
3028
                    goto fail;
3029
                percentd_found = 1;
3030
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3031
                len = strlen(buf1);
3032
                if ((q - buf + len) > buf_size - 1)
3033
                    goto fail;
3034
                memcpy(q, buf1, len);
3035
                q += len;
3036
                break;
3037
            default:
3038
                goto fail;
3039
            }
3040
        } else {
3041
        addchar:
3042
            if ((q - buf) < buf_size - 1)
3043
                *q++ = c;
3044
        }
3045
    }
3046
    if (!percentd_found)
3047
        goto fail;
3048
    *q = '\0';
3049
    return 0;
3050
 fail:
3051
    *q = '\0';
3052
    return -1;
3053
}
3054

    
3055
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3056
{
3057
    int len, i, j, c;
3058
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3059

    
3060
    for(i=0;i<size;i+=16) {
3061
        len = size - i;
3062
        if (len > 16)
3063
            len = 16;
3064
        PRINT("%08x ", i);
3065
        for(j=0;j<16;j++) {
3066
            if (j < len)
3067
                PRINT(" %02x", buf[i+j]);
3068
            else
3069
                PRINT("   ");
3070
        }
3071
        PRINT(" ");
3072
        for(j=0;j<len;j++) {
3073
            c = buf[i+j];
3074
            if (c < ' ' || c > '~')
3075
                c = '.';
3076
            PRINT("%c", c);
3077
        }
3078
        PRINT("\n");
3079
    }
3080
#undef PRINT
3081
}
3082

    
3083
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3084
{
3085
    hex_dump_internal(NULL, f, 0, buf, size);
3086
}
3087

    
3088
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3089
{
3090
    hex_dump_internal(avcl, NULL, level, buf, size);
3091
}
3092

    
3093
 //FIXME needs to know the time_base
3094
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3095
{
3096
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3097
    PRINT("stream #%d:\n", pkt->stream_index);
3098
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3099
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3100
    /* DTS is _always_ valid after av_read_frame() */
3101
    PRINT("  dts=");
3102
    if (pkt->dts == AV_NOPTS_VALUE)
3103
        PRINT("N/A");
3104
    else
3105
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3106
    /* PTS may not be known if B-frames are present. */
3107
    PRINT("  pts=");
3108
    if (pkt->pts == AV_NOPTS_VALUE)
3109
        PRINT("N/A");
3110
    else
3111
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3112
    PRINT("\n");
3113
    PRINT("  size=%d\n", pkt->size);
3114
#undef PRINT
3115
    if (dump_payload)
3116
        av_hex_dump(f, pkt->data, pkt->size);
3117
}
3118

    
3119
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3120
{
3121
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3122
}
3123

    
3124
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3125
{
3126
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3127
}
3128

    
3129
void url_split(char *proto, int proto_size,
3130
               char *authorization, int authorization_size,
3131
               char *hostname, int hostname_size,
3132
               int *port_ptr,
3133
               char *path, int path_size,
3134
               const char *url)
3135
{
3136
    const char *p, *ls, *at, *col, *brk;
3137

    
3138
    if (port_ptr)               *port_ptr = -1;
3139
    if (proto_size > 0)         proto[0] = 0;
3140
    if (authorization_size > 0) authorization[0] = 0;
3141
    if (hostname_size > 0)      hostname[0] = 0;
3142
    if (path_size > 0)          path[0] = 0;
3143

    
3144
    /* parse protocol */
3145
    if ((p = strchr(url, ':'))) {
3146
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3147
        p++; /* skip ':' */
3148
        if (*p == '/') p++;
3149
        if (*p == '/') p++;
3150
    } else {
3151
        /* no protocol means plain filename */
3152
        av_strlcpy(path, url, path_size);
3153
        return;
3154
    }
3155

    
3156
    /* separate path from hostname */
3157
    ls = strchr(p, '/');
3158
    if(!ls)
3159
        ls = strchr(p, '?');
3160
    if(ls)
3161
        av_strlcpy(path, ls, path_size);
3162
    else
3163
        ls = &p[strlen(p)]; // XXX
3164

    
3165
    /* the rest is hostname, use that to parse auth/port */
3166
    if (ls != p) {
3167
        /* authorization (user[:pass]@hostname) */
3168
        if ((at = strchr(p, '@')) && at < ls) {
3169
            av_strlcpy(authorization, p,
3170
                       FFMIN(authorization_size, at + 1 - p));
3171
            p = at + 1; /* skip '@' */
3172
        }
3173

    
3174
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3175
            /* [host]:port */
3176
            av_strlcpy(hostname, p + 1,
3177
                       FFMIN(hostname_size, brk - p));
3178
            if (brk[1] == ':' && port_ptr)
3179
                *port_ptr = atoi(brk + 2);
3180
        } else if ((col = strchr(p, ':')) && col < ls) {
3181
            av_strlcpy(hostname, p,
3182
                       FFMIN(col + 1 - p, hostname_size));
3183
            if (port_ptr) *port_ptr = atoi(col + 1);
3184
        } else
3185
            av_strlcpy(hostname, p,
3186
                       FFMIN(ls + 1 - p, hostname_size));
3187
    }
3188
}
3189

    
3190
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3191
                     int pts_num, int pts_den)
3192
{
3193
    s->pts_wrap_bits = pts_wrap_bits;
3194
    s->time_base.num = pts_num;
3195
    s->time_base.den = pts_den;
3196
}
3197

    
3198
/* fraction handling */
3199

    
3200
/**
3201
 * f = val + (num / den) + 0.5.
3202
 *
3203
 * 'num' is normalized so that it is such as 0 <= num < den.
3204
 *
3205
 * @param f fractional number
3206
 * @param val integer value
3207
 * @param num must be >= 0
3208
 * @param den must be >= 1
3209
 */
3210
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3211
{
3212
    num += (den >> 1);
3213
    if (num >= den) {
3214
        val += num / den;
3215
        num = num % den;
3216
    }
3217
    f->val = val;
3218
    f->num = num;
3219
    f->den = den;
3220
}
3221

    
3222
/**
3223
 * Fractional addition to f: f = f + (incr / f->den).
3224
 *
3225
 * @param f fractional number
3226
 * @param incr increment, can be positive or negative
3227
 */
3228
static void av_frac_add(AVFrac *f, int64_t incr)
3229
{
3230
    int64_t num, den;
3231

    
3232
    num = f->num + incr;
3233
    den = f->den;
3234
    if (num < 0) {
3235
        f->val += num / den;
3236
        num = num % den;
3237
        if (num < 0) {
3238
            num += den;
3239
            f->val--;
3240
        }
3241
    } else if (num >= den) {
3242
        f->val += num / den;
3243
        num = num % den;
3244
    }
3245
    f->num = num;
3246
}