Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 5f8e0227

History | View | Annotate | Download (97.7 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 (!strcmp(fmt->name, "mp3"))
303
            st->codec->codec_id = CODEC_ID_MP3;
304
        else if (!strcmp(fmt->name, "ac3"))
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
        switch(st->codec->codec_type){
567
        case CODEC_TYPE_VIDEO:
568
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
569
            break;
570
        case CODEC_TYPE_AUDIO:
571
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
572
            break;
573
        case CODEC_TYPE_SUBTITLE:
574
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
575
            break;
576
        }
577

    
578
        if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
579
            return ret;
580

    
581
        add_to_pktbuf(&s->raw_packet_buffer, pkt);
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, ret;
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
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1449
                return ret;
1450
            av_update_cur_dts(s, st, ie->timestamp);
1451
        }else{
1452
            if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1453
                return ret;
1454
        }
1455
        for(i=0;; i++) {
1456
            int ret = av_read_frame(s, &pkt);
1457
            if(ret<0)
1458
                break;
1459
            av_free_packet(&pkt);
1460
            if(stream_index == pkt.stream_index){
1461
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1462
                    break;
1463
            }
1464
        }
1465
        index = av_index_search_timestamp(st, timestamp, flags);
1466
    }
1467
    if (index < 0)
1468
        return -1;
1469

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

    
1480
    return 0;
1481
}
1482

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

    
1488
    av_read_frame_flush(s);
1489

    
1490
    if(flags & AVSEEK_FLAG_BYTE)
1491
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1492

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

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

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

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

    
1519
/*******************************************************/
1520

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

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

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

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

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

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

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

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

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

    
1639
#define DURATION_MAX_READ_SIZE 250000
1640

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

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

    
1655
    /* flush packet queue */
1656
    flush_packet_queue(ic);
1657

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

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

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

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

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

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

    
1725
    fill_all_stream_timings(ic);
1726

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1889
static void compute_chapters_end(AVFormatContext *s)
1890
{
1891
    unsigned int i;
1892

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

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

    
1909
/* absolute maximum size we read until we abort */
1910
#define MAX_READ_SIZE        5000000
1911

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

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

    
1936
int av_find_stream_info(AVFormatContext *ic)
1937
{
1938
    int i, count, ret, read_size, j;
1939
    AVStream *st;
1940
    AVPacket pkt1, *pkt;
1941
    int64_t last_dts[MAX_STREAMS];
1942
    int duration_count[MAX_STREAMS]={0};
1943
    double (*duration_error)[MAX_STD_TIMEBASES];
1944
    offset_t old_offset = url_ftell(ic->pb);
1945
    int64_t codec_info_duration[MAX_STREAMS]={0};
1946
    int codec_info_nb_frames[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
    count = 0;
1973
    read_size = 0;
1974
    for(;;) {
1975
        /* check if one codec still needs to be handled */
1976
        for(i=0;i<ic->nb_streams;i++) {
1977
            st = ic->streams[i];
1978
            if (!has_codec_parameters(st->codec))
1979
                break;
1980
            /* variable fps and no guess at the real fps */
1981
            if(   tb_unreliable(st->codec)
1982
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1983
                break;
1984
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1985
                break;
1986
            if(st->first_dts == AV_NOPTS_VALUE)
1987
                break;
1988
        }
1989
        if (i == ic->nb_streams) {
1990
            /* NOTE: if the format has no header, then we need to read
1991
               some packets to get most of the streams, so we cannot
1992
               stop here */
1993
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1994
                /* if we found the info for all the codecs, we can stop */
1995
                ret = count;
1996
                break;
1997
            }
1998
        }
1999
        /* we did not get all the codec info, but we read too much data */
2000
        if (read_size >= MAX_READ_SIZE) {
2001
            ret = count;
2002
            break;
2003
        }
2004

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

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

    
2030
        read_size += pkt->size;
2031

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

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

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

    
2046
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2047
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2048
                if(duration_count[index] < 2)
2049
                    memset(duration_error[index], 0, sizeof(*duration_error));
2050
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2051
                    int framerate= get_std_framerate(i);
2052
                    int ticks= lrintf(dur*framerate/(1001*12));
2053
                    double error= dur - ticks*1001*12/(double)framerate;
2054
                    duration_error[index][i] += error*error;
2055
                }
2056
                duration_count[index]++;
2057
            }
2058
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2059
                last_dts[pkt->stream_index]= pkt->dts;
2060
        }
2061
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2062
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2063
            if(i){
2064
                st->codec->extradata_size= i;
2065
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2066
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2067
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2068
            }
2069
        }
2070

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

    
2092
        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) {
2093
            break;
2094
        }
2095
        count++;
2096
    }
2097

    
2098
    // close codecs which were opened in try_decode_frame()
2099
    for(i=0;i<ic->nb_streams;i++) {
2100
        st = ic->streams[i];
2101
        if(st->codec->codec)
2102
            avcodec_close(st->codec);
2103
    }
2104
    for(i=0;i<ic->nb_streams;i++) {
2105
        st = ic->streams[i];
2106
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2107
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2108
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2109

    
2110
            if(duration_count[i]
2111
               && tb_unreliable(st->codec) /*&&
2112
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2113
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2114
                double best_error= 2*av_q2d(st->time_base);
2115
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2116

    
2117
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2118
                    double error= duration_error[i][j] * get_std_framerate(j);
2119
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2120
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2121
                    if(error < best_error){
2122
                        best_error= error;
2123
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2124
                    }
2125
                }
2126
            }
2127

    
2128
            if (!st->r_frame_rate.num){
2129
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2130
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2131
                    st->r_frame_rate.num = st->codec->time_base.den;
2132
                    st->r_frame_rate.den = st->codec->time_base.num;
2133
                }else{
2134
                    st->r_frame_rate.num = st->time_base.den;
2135
                    st->r_frame_rate.den = st->time_base.num;
2136
                }
2137
            }
2138
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2139
            if(!st->codec->bits_per_sample)
2140
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2141
        }
2142
    }
2143

    
2144
    av_estimate_timings(ic, old_offset);
2145

    
2146
    compute_chapters_end(ic);
2147

    
2148
#if 0
2149
    /* correct DTS for B-frame streams with no timestamps */
2150
    for(i=0;i<ic->nb_streams;i++) {
2151
        st = ic->streams[i];
2152
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2153
            if(b-frames){
2154
                ppktl = &ic->packet_buffer;
2155
                while(ppkt1){
2156
                    if(ppkt1->stream_index != i)
2157
                        continue;
2158
                    if(ppkt1->pkt->dts < 0)
2159
                        break;
2160
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2161
                        break;
2162
                    ppkt1->pkt->dts -= delta;
2163
                    ppkt1= ppkt1->next;
2164
                }
2165
                if(ppkt1)
2166
                    continue;
2167
                st->cur_dts -= delta;
2168
            }
2169
        }
2170
    }
2171
#endif
2172

    
2173
    av_free(duration_error);
2174

    
2175
    return ret;
2176
}
2177

    
2178
/*******************************************************/
2179

    
2180
int av_read_play(AVFormatContext *s)
2181
{
2182
    if (s->iformat->read_play)
2183
        return s->iformat->read_play(s);
2184
    if (s->pb)
2185
        return av_url_read_fpause(s->pb, 0);
2186
    return AVERROR(ENOSYS);
2187
}
2188

    
2189
int av_read_pause(AVFormatContext *s)
2190
{
2191
    if (s->iformat->read_pause)
2192
        return s->iformat->read_pause(s);
2193
    if (s->pb)
2194
        return av_url_read_fpause(s->pb, 1);
2195
    return AVERROR(ENOSYS);
2196
}
2197

    
2198
void av_close_input_stream(AVFormatContext *s)
2199
{
2200
    int i;
2201
    AVStream *st;
2202

    
2203
    /* free previous packet */
2204
    if (s->cur_st && s->cur_st->parser)
2205
        av_free_packet(&s->cur_pkt);
2206

    
2207
    if (s->iformat->read_close)
2208
        s->iformat->read_close(s);
2209
    for(i=0;i<s->nb_streams;i++) {
2210
        /* free all data in a stream component */
2211
        st = s->streams[i];
2212
        if (st->parser) {
2213
            av_parser_close(st->parser);
2214
        }
2215
        av_free(st->index_entries);
2216
        av_free(st->codec->extradata);
2217
        av_free(st->codec);
2218
        av_free(st->filename);
2219
        av_free(st->priv_data);
2220
        av_free(st);
2221
    }
2222
    for(i=s->nb_programs-1; i>=0; i--) {
2223
        av_freep(&s->programs[i]->provider_name);
2224
        av_freep(&s->programs[i]->name);
2225
        av_freep(&s->programs[i]->stream_index);
2226
        av_freep(&s->programs[i]);
2227
    }
2228
    av_freep(&s->programs);
2229
    flush_packet_queue(s);
2230
    av_freep(&s->priv_data);
2231
    while(s->nb_chapters--) {
2232
        av_free(s->chapters[s->nb_chapters]->title);
2233
        av_free(s->chapters[s->nb_chapters]);
2234
    }
2235
    av_freep(&s->chapters);
2236
    av_free(s);
2237
}
2238

    
2239
void av_close_input_file(AVFormatContext *s)
2240
{
2241
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2242
    av_close_input_stream(s);
2243
    if (pb)
2244
        url_fclose(pb);
2245
}
2246

    
2247
AVStream *av_new_stream(AVFormatContext *s, int id)
2248
{
2249
    AVStream *st;
2250
    int i;
2251

    
2252
    if (s->nb_streams >= MAX_STREAMS)
2253
        return NULL;
2254

    
2255
    st = av_mallocz(sizeof(AVStream));
2256
    if (!st)
2257
        return NULL;
2258

    
2259
    st->codec= avcodec_alloc_context();
2260
    if (s->iformat) {
2261
        /* no default bitrate if decoding */
2262
        st->codec->bit_rate = 0;
2263
    }
2264
    st->index = s->nb_streams;
2265
    st->id = id;
2266
    st->start_time = AV_NOPTS_VALUE;
2267
    st->duration = AV_NOPTS_VALUE;
2268
        /* we set the current DTS to 0 so that formats without any timestamps
2269
           but durations get some timestamps, formats with some unknown
2270
           timestamps have their first few packets buffered and the
2271
           timestamps corrected before they are returned to the user */
2272
    st->cur_dts = 0;
2273
    st->first_dts = AV_NOPTS_VALUE;
2274

    
2275
    /* default pts setting is MPEG-like */
2276
    av_set_pts_info(st, 33, 1, 90000);
2277
    st->last_IP_pts = AV_NOPTS_VALUE;
2278
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2279
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2280

    
2281
    s->streams[s->nb_streams++] = st;
2282
    return st;
2283
}
2284

    
2285
AVProgram *av_new_program(AVFormatContext *ac, int id)
2286
{
2287
    AVProgram *program=NULL;
2288
    int i;
2289

    
2290
#ifdef DEBUG_SI
2291
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2292
#endif
2293

    
2294
    for(i=0; i<ac->nb_programs; i++)
2295
        if(ac->programs[i]->id == id)
2296
            program = ac->programs[i];
2297

    
2298
    if(!program){
2299
        program = av_mallocz(sizeof(AVProgram));
2300
        if (!program)
2301
            return NULL;
2302
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2303
        program->discard = AVDISCARD_NONE;
2304
    }
2305
    program->id = id;
2306

    
2307
    return program;
2308
}
2309

    
2310
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2311
{
2312
    assert(!provider_name == !name);
2313
    if(name){
2314
        av_free(program->provider_name);
2315
        av_free(program->         name);
2316
        program->provider_name = av_strdup(provider_name);
2317
        program->         name = av_strdup(         name);
2318
    }
2319
}
2320

    
2321
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2322
{
2323
    AVChapter *chapter = NULL;
2324
    int i;
2325

    
2326
    for(i=0; i<s->nb_chapters; i++)
2327
        if(s->chapters[i]->id == id)
2328
            chapter = s->chapters[i];
2329

    
2330
    if(!chapter){
2331
        chapter= av_mallocz(sizeof(AVChapter));
2332
        if(!chapter)
2333
            return NULL;
2334
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2335
    }
2336
    av_free(chapter->title);
2337
    chapter->title = av_strdup(title);
2338
    chapter->id    = id;
2339
    chapter->time_base= time_base;
2340
    chapter->start = start;
2341
    chapter->end   = end;
2342

    
2343
    return chapter;
2344
}
2345

    
2346
/************************************************************/
2347
/* output media file */
2348

    
2349
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2350
{
2351
    int ret;
2352

    
2353
    if (s->oformat->priv_data_size > 0) {
2354
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2355
        if (!s->priv_data)
2356
            return AVERROR(ENOMEM);
2357
    } else
2358
        s->priv_data = NULL;
2359

    
2360
    if (s->oformat->set_parameters) {
2361
        ret = s->oformat->set_parameters(s, ap);
2362
        if (ret < 0)
2363
            return ret;
2364
    }
2365
    return 0;
2366
}
2367

    
2368
int av_write_header(AVFormatContext *s)
2369
{
2370
    int ret, i;
2371
    AVStream *st;
2372

    
2373
    // some sanity checks
2374
    for(i=0;i<s->nb_streams;i++) {
2375
        st = s->streams[i];
2376

    
2377
        switch (st->codec->codec_type) {
2378
        case CODEC_TYPE_AUDIO:
2379
            if(st->codec->sample_rate<=0){
2380
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2381
                return -1;
2382
            }
2383
            break;
2384
        case CODEC_TYPE_VIDEO:
2385
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2386
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2387
                return -1;
2388
            }
2389
            if(st->codec->width<=0 || st->codec->height<=0){
2390
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2391
                return -1;
2392
            }
2393
            break;
2394
        }
2395

    
2396
        if(s->oformat->codec_tag){
2397
            if(st->codec->codec_tag){
2398
                //FIXME
2399
                //check that tag + id is in the table
2400
                //if neither is in the table -> OK
2401
                //if tag is in the table with another id -> FAIL
2402
                //if id is in the table with another tag -> FAIL unless strict < ?
2403
            }else
2404
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2405
        }
2406
    }
2407

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

    
2414
    if(s->oformat->write_header){
2415
        ret = s->oformat->write_header(s);
2416
        if (ret < 0)
2417
            return ret;
2418
    }
2419

    
2420
    /* init PTS generation */
2421
    for(i=0;i<s->nb_streams;i++) {
2422
        int64_t den = AV_NOPTS_VALUE;
2423
        st = s->streams[i];
2424

    
2425
        switch (st->codec->codec_type) {
2426
        case CODEC_TYPE_AUDIO:
2427
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2428
            break;
2429
        case CODEC_TYPE_VIDEO:
2430
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2431
            break;
2432
        default:
2433
            break;
2434
        }
2435
        if (den != AV_NOPTS_VALUE) {
2436
            if (den <= 0)
2437
                return AVERROR_INVALIDDATA;
2438
            av_frac_init(&st->pts, 0, 0, den);
2439
        }
2440
    }
2441
    return 0;
2442
}
2443

    
2444
//FIXME merge with compute_pkt_fields
2445
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2446
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2447
    int num, den, frame_size, i;
2448

    
2449
//    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);
2450

    
2451
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2452
        return -1;*/
2453

    
2454
    /* duration field */
2455
    if (pkt->duration == 0) {
2456
        compute_frame_duration(&num, &den, st, NULL, pkt);
2457
        if (den && num) {
2458
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2459
        }
2460
    }
2461

    
2462
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2463
        pkt->pts= pkt->dts;
2464

    
2465
    //XXX/FIXME this is a temporary hack until all encoders output pts
2466
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2467
        pkt->dts=
2468
//        pkt->pts= st->cur_dts;
2469
        pkt->pts= st->pts.val;
2470
    }
2471

    
2472
    //calculate dts from pts
2473
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2474
        st->pts_buffer[0]= pkt->pts;
2475
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2476
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2477
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2478
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2479

    
2480
        pkt->dts= st->pts_buffer[0];
2481
    }
2482

    
2483
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2484
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2485
        return -1;
2486
    }
2487
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2488
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2489
        return -1;
2490
    }
2491

    
2492
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2493
    st->cur_dts= pkt->dts;
2494
    st->pts.val= pkt->dts;
2495

    
2496
    /* update pts */
2497
    switch (st->codec->codec_type) {
2498
    case CODEC_TYPE_AUDIO:
2499
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2500

    
2501
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2502
           likely equal to the encoder delay, but it would be better if we
2503
           had the real timestamps from the encoder */
2504
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2505
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2506
        }
2507
        break;
2508
    case CODEC_TYPE_VIDEO:
2509
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2510
        break;
2511
    default:
2512
        break;
2513
    }
2514
    return 0;
2515
}
2516

    
2517
static void truncate_ts(AVStream *st, AVPacket *pkt){
2518
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2519

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

    
2523
    if (pkt->pts != AV_NOPTS_VALUE)
2524
        pkt->pts &= pts_mask;
2525
    if (pkt->dts != AV_NOPTS_VALUE)
2526
        pkt->dts &= pts_mask;
2527
}
2528

    
2529
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2530
{
2531
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2532

    
2533
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2534
        return ret;
2535

    
2536
    truncate_ts(s->streams[pkt->stream_index], pkt);
2537

    
2538
    ret= s->oformat->write_packet(s, pkt);
2539
    if(!ret)
2540
        ret= url_ferror(s->pb);
2541
    return ret;
2542
}
2543

    
2544
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2545
    AVPacketList *pktl, **next_point, *this_pktl;
2546
    int stream_count=0;
2547
    int streams[MAX_STREAMS];
2548

    
2549
    if(pkt){
2550
        AVStream *st= s->streams[ pkt->stream_index];
2551

    
2552
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2553

    
2554
        this_pktl = av_mallocz(sizeof(AVPacketList));
2555
        this_pktl->pkt= *pkt;
2556
        if(pkt->destruct == av_destruct_packet)
2557
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2558
        else
2559
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2560

    
2561
        next_point = &s->packet_buffer;
2562
        while(*next_point){
2563
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2564
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2565
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2566
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2567
                break;
2568
            next_point= &(*next_point)->next;
2569
        }
2570
        this_pktl->next= *next_point;
2571
        *next_point= this_pktl;
2572
    }
2573

    
2574
    memset(streams, 0, sizeof(streams));
2575
    pktl= s->packet_buffer;
2576
    while(pktl){
2577
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2578
        if(streams[ pktl->pkt.stream_index ] == 0)
2579
            stream_count++;
2580
        streams[ pktl->pkt.stream_index ]++;
2581
        pktl= pktl->next;
2582
    }
2583

    
2584
    if(stream_count && (s->nb_streams == stream_count || flush)){
2585
        pktl= s->packet_buffer;
2586
        *out= pktl->pkt;
2587

    
2588
        s->packet_buffer= pktl->next;
2589
        av_freep(&pktl);
2590
        return 1;
2591
    }else{
2592
        av_init_packet(out);
2593
        return 0;
2594
    }
2595
}
2596

    
2597
/**
2598
 * Interleaves an AVPacket correctly so it can be muxed.
2599
 * @param out the interleaved packet will be output here
2600
 * @param in the input packet
2601
 * @param flush 1 if no further packets are available as input and all
2602
 *              remaining packets should be output
2603
 * @return 1 if a packet was output, 0 if no packet could be output,
2604
 *         < 0 if an error occurred
2605
 */
2606
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2607
    if(s->oformat->interleave_packet)
2608
        return s->oformat->interleave_packet(s, out, in, flush);
2609
    else
2610
        return av_interleave_packet_per_dts(s, out, in, flush);
2611
}
2612

    
2613
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2614
    AVStream *st= s->streams[ pkt->stream_index];
2615

    
2616
    //FIXME/XXX/HACK drop zero sized packets
2617
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2618
        return 0;
2619

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

    
2624
    if(pkt->dts == AV_NOPTS_VALUE)
2625
        return -1;
2626

    
2627
    for(;;){
2628
        AVPacket opkt;
2629
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2630
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2631
            return ret;
2632

    
2633
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2634
        ret= s->oformat->write_packet(s, &opkt);
2635

    
2636
        av_free_packet(&opkt);
2637
        pkt= NULL;
2638

    
2639
        if(ret<0)
2640
            return ret;
2641
        if(url_ferror(s->pb))
2642
            return url_ferror(s->pb);
2643
    }
2644
}
2645

    
2646
int av_write_trailer(AVFormatContext *s)
2647
{
2648
    int ret, i;
2649

    
2650
    for(;;){
2651
        AVPacket pkt;
2652
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2653
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2654
            goto fail;
2655
        if(!ret)
2656
            break;
2657

    
2658
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2659
        ret= s->oformat->write_packet(s, &pkt);
2660

    
2661
        av_free_packet(&pkt);
2662

    
2663
        if(ret<0)
2664
            goto fail;
2665
        if(url_ferror(s->pb))
2666
            goto fail;
2667
    }
2668

    
2669
    if(s->oformat->write_trailer)
2670
        ret = s->oformat->write_trailer(s);
2671
fail:
2672
    if(ret == 0)
2673
       ret=url_ferror(s->pb);
2674
    for(i=0;i<s->nb_streams;i++)
2675
        av_freep(&s->streams[i]->priv_data);
2676
    av_freep(&s->priv_data);
2677
    return ret;
2678
}
2679

    
2680
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2681
{
2682
    int i, j;
2683
    AVProgram *program=NULL;
2684
    void *tmp;
2685

    
2686
    for(i=0; i<ac->nb_programs; i++){
2687
        if(ac->programs[i]->id != progid)
2688
            continue;
2689
        program = ac->programs[i];
2690
        for(j=0; j<program->nb_stream_indexes; j++)
2691
            if(program->stream_index[j] == idx)
2692
                return;
2693

    
2694
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2695
        if(!tmp)
2696
            return;
2697
        program->stream_index = tmp;
2698
        program->stream_index[program->nb_stream_indexes++] = idx;
2699
        return;
2700
    }
2701
}
2702

    
2703
/* "user interface" functions */
2704
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2705
{
2706
    char buf[256];
2707
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2708
    AVStream *st = ic->streams[i];
2709
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2710
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2711
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2712
    /* the pid is an important information, so we display it */
2713
    /* XXX: add a generic system */
2714
    if (flags & AVFMT_SHOW_IDS)
2715
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2716
    if (strlen(st->language) > 0)
2717
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2718
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2719
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2720
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2721
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2722
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2723
/*      else if(st->time_base.den && st->time_base.num)
2724
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2725
        else
2726
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2727
    }
2728
    av_log(NULL, AV_LOG_INFO, "\n");
2729
}
2730

    
2731
void dump_format(AVFormatContext *ic,
2732
                 int index,
2733
                 const char *url,
2734
                 int is_output)
2735
{
2736
    int i;
2737

    
2738
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2739
            is_output ? "Output" : "Input",
2740
            index,
2741
            is_output ? ic->oformat->name : ic->iformat->name,
2742
            is_output ? "to" : "from", url);
2743
    if (!is_output) {
2744
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2745
        if (ic->duration != AV_NOPTS_VALUE) {
2746
            int hours, mins, secs, us;
2747
            secs = ic->duration / AV_TIME_BASE;
2748
            us = ic->duration % AV_TIME_BASE;
2749
            mins = secs / 60;
2750
            secs %= 60;
2751
            hours = mins / 60;
2752
            mins %= 60;
2753
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2754
                   (100 * us) / AV_TIME_BASE);
2755
        } else {
2756
            av_log(NULL, AV_LOG_INFO, "N/A");
2757
        }
2758
        if (ic->start_time != AV_NOPTS_VALUE) {
2759
            int secs, us;
2760
            av_log(NULL, AV_LOG_INFO, ", start: ");
2761
            secs = ic->start_time / AV_TIME_BASE;
2762
            us = ic->start_time % AV_TIME_BASE;
2763
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2764
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2765
        }
2766
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2767
        if (ic->bit_rate) {
2768
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2769
        } else {
2770
            av_log(NULL, AV_LOG_INFO, "N/A");
2771
        }
2772
        av_log(NULL, AV_LOG_INFO, "\n");
2773
    }
2774
    if(ic->nb_programs) {
2775
        int j, k;
2776
        for(j=0; j<ic->nb_programs; j++) {
2777
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2778
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2779
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2780
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2781
         }
2782
    } else
2783
    for(i=0;i<ic->nb_streams;i++)
2784
        dump_stream_format(ic, i, index, is_output);
2785
}
2786

    
2787
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2788
{
2789
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2790
}
2791

    
2792
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2793
{
2794
    AVRational frame_rate;
2795
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2796
    *frame_rate_num= frame_rate.num;
2797
    *frame_rate_den= frame_rate.den;
2798
    return ret;
2799
}
2800

    
2801
/**
2802
 * Gets the current time in microseconds.
2803
 */
2804
int64_t av_gettime(void)
2805
{
2806
    struct timeval tv;
2807
    gettimeofday(&tv,NULL);
2808
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2809
}
2810

    
2811
int64_t parse_date(const char *datestr, int duration)
2812
{
2813
    const char *p;
2814
    int64_t t;
2815
    struct tm dt;
2816
    int i;
2817
    static const char *date_fmt[] = {
2818
        "%Y-%m-%d",
2819
        "%Y%m%d",
2820
    };
2821
    static const char *time_fmt[] = {
2822
        "%H:%M:%S",
2823
        "%H%M%S",
2824
    };
2825
    const char *q;
2826
    int is_utc, len;
2827
    char lastch;
2828
    int negative = 0;
2829

    
2830
#undef time
2831
    time_t now = time(0);
2832

    
2833
    len = strlen(datestr);
2834
    if (len > 0)
2835
        lastch = datestr[len - 1];
2836
    else
2837
        lastch = '\0';
2838
    is_utc = (lastch == 'z' || lastch == 'Z');
2839

    
2840
    memset(&dt, 0, sizeof(dt));
2841

    
2842
    p = datestr;
2843
    q = NULL;
2844
    if (!duration) {
2845
        /* parse the year-month-day part */
2846
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2847
            q = small_strptime(p, date_fmt[i], &dt);
2848
            if (q) {
2849
                break;
2850
            }
2851
        }
2852

    
2853
        /* if the year-month-day part is missing, then take the
2854
         * current year-month-day time */
2855
        if (!q) {
2856
            if (is_utc) {
2857
                dt = *gmtime(&now);
2858
            } else {
2859
                dt = *localtime(&now);
2860
            }
2861
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2862
        } else {
2863
            p = q;
2864
        }
2865

    
2866
        if (*p == 'T' || *p == 't' || *p == ' ')
2867
            p++;
2868

    
2869
        /* parse the hour-minute-second part */
2870
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2871
            q = small_strptime(p, time_fmt[i], &dt);
2872
            if (q) {
2873
                break;
2874
            }
2875
        }
2876
    } else {
2877
        /* parse datestr as a duration */
2878
        if (p[0] == '-') {
2879
            negative = 1;
2880
            ++p;
2881
        }
2882
        /* parse datestr as HH:MM:SS */
2883
        q = small_strptime(p, time_fmt[0], &dt);
2884
        if (!q) {
2885
            /* parse datestr as S+ */
2886
            dt.tm_sec = strtol(p, (char **)&q, 10);
2887
            if (q == p)
2888
                /* the parsing didn't succeed */
2889
                return INT64_MIN;
2890
            dt.tm_min = 0;
2891
            dt.tm_hour = 0;
2892
        }
2893
    }
2894

    
2895
    /* Now we have all the fields that we can get */
2896
    if (!q) {
2897
        return INT64_MIN;
2898
    }
2899

    
2900
    if (duration) {
2901
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2902
    } else {
2903
        dt.tm_isdst = -1;       /* unknown */
2904
        if (is_utc) {
2905
            t = mktimegm(&dt);
2906
        } else {
2907
            t = mktime(&dt);
2908
        }
2909
    }
2910

    
2911
    t *= 1000000;
2912

    
2913
    /* parse the .m... part */
2914
    if (*q == '.') {
2915
        int val, n;
2916
        q++;
2917
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2918
            if (!isdigit(*q))
2919
                break;
2920
            val += n * (*q - '0');
2921
        }
2922
        t += val;
2923
    }
2924
    return negative ? -t : t;
2925
}
2926

    
2927
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2928
{
2929
    const char *p;
2930
    char tag[128], *q;
2931

    
2932
    p = info;
2933
    if (*p == '?')
2934
        p++;
2935
    for(;;) {
2936
        q = tag;
2937
        while (*p != '\0' && *p != '=' && *p != '&') {
2938
            if ((q - tag) < sizeof(tag) - 1)
2939
                *q++ = *p;
2940
            p++;
2941
        }
2942
        *q = '\0';
2943
        q = arg;
2944
        if (*p == '=') {
2945
            p++;
2946
            while (*p != '&' && *p != '\0') {
2947
                if ((q - arg) < arg_size - 1) {
2948
                    if (*p == '+')
2949
                        *q++ = ' ';
2950
                    else
2951
                        *q++ = *p;
2952
                }
2953
                p++;
2954
            }
2955
            *q = '\0';
2956
        }
2957
        if (!strcmp(tag, tag1))
2958
            return 1;
2959
        if (*p != '&')
2960
            break;
2961
        p++;
2962
    }
2963
    return 0;
2964
}
2965

    
2966
int av_get_frame_filename(char *buf, int buf_size,
2967
                          const char *path, int number)
2968
{
2969
    const char *p;
2970
    char *q, buf1[20], c;
2971
    int nd, len, percentd_found;
2972

    
2973
    q = buf;
2974
    p = path;
2975
    percentd_found = 0;
2976
    for(;;) {
2977
        c = *p++;
2978
        if (c == '\0')
2979
            break;
2980
        if (c == '%') {
2981
            do {
2982
                nd = 0;
2983
                while (isdigit(*p)) {
2984
                    nd = nd * 10 + *p++ - '0';
2985
                }
2986
                c = *p++;
2987
            } while (isdigit(c));
2988

    
2989
            switch(c) {
2990
            case '%':
2991
                goto addchar;
2992
            case 'd':
2993
                if (percentd_found)
2994
                    goto fail;
2995
                percentd_found = 1;
2996
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2997
                len = strlen(buf1);
2998
                if ((q - buf + len) > buf_size - 1)
2999
                    goto fail;
3000
                memcpy(q, buf1, len);
3001
                q += len;
3002
                break;
3003
            default:
3004
                goto fail;
3005
            }
3006
        } else {
3007
        addchar:
3008
            if ((q - buf) < buf_size - 1)
3009
                *q++ = c;
3010
        }
3011
    }
3012
    if (!percentd_found)
3013
        goto fail;
3014
    *q = '\0';
3015
    return 0;
3016
 fail:
3017
    *q = '\0';
3018
    return -1;
3019
}
3020

    
3021
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3022
{
3023
    int len, i, j, c;
3024
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3025

    
3026
    for(i=0;i<size;i+=16) {
3027
        len = size - i;
3028
        if (len > 16)
3029
            len = 16;
3030
        PRINT("%08x ", i);
3031
        for(j=0;j<16;j++) {
3032
            if (j < len)
3033
                PRINT(" %02x", buf[i+j]);
3034
            else
3035
                PRINT("   ");
3036
        }
3037
        PRINT(" ");
3038
        for(j=0;j<len;j++) {
3039
            c = buf[i+j];
3040
            if (c < ' ' || c > '~')
3041
                c = '.';
3042
            PRINT("%c", c);
3043
        }
3044
        PRINT("\n");
3045
    }
3046
#undef PRINT
3047
}
3048

    
3049
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3050
{
3051
    hex_dump_internal(NULL, f, 0, buf, size);
3052
}
3053

    
3054
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3055
{
3056
    hex_dump_internal(avcl, NULL, level, buf, size);
3057
}
3058

    
3059
 //FIXME needs to know the time_base
3060
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3061
{
3062
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3063
    PRINT("stream #%d:\n", pkt->stream_index);
3064
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3065
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3066
    /* DTS is _always_ valid after av_read_frame() */
3067
    PRINT("  dts=");
3068
    if (pkt->dts == AV_NOPTS_VALUE)
3069
        PRINT("N/A");
3070
    else
3071
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3072
    /* PTS may not be known if B-frames are present. */
3073
    PRINT("  pts=");
3074
    if (pkt->pts == AV_NOPTS_VALUE)
3075
        PRINT("N/A");
3076
    else
3077
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3078
    PRINT("\n");
3079
    PRINT("  size=%d\n", pkt->size);
3080
#undef PRINT
3081
    if (dump_payload)
3082
        av_hex_dump(f, pkt->data, pkt->size);
3083
}
3084

    
3085
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3086
{
3087
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3088
}
3089

    
3090
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3091
{
3092
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3093
}
3094

    
3095
void url_split(char *proto, int proto_size,
3096
               char *authorization, int authorization_size,
3097
               char *hostname, int hostname_size,
3098
               int *port_ptr,
3099
               char *path, int path_size,
3100
               const char *url)
3101
{
3102
    const char *p, *ls, *at, *col, *brk;
3103

    
3104
    if (port_ptr)               *port_ptr = -1;
3105
    if (proto_size > 0)         proto[0] = 0;
3106
    if (authorization_size > 0) authorization[0] = 0;
3107
    if (hostname_size > 0)      hostname[0] = 0;
3108
    if (path_size > 0)          path[0] = 0;
3109

    
3110
    /* parse protocol */
3111
    if ((p = strchr(url, ':'))) {
3112
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3113
        p++; /* skip ':' */
3114
        if (*p == '/') p++;
3115
        if (*p == '/') p++;
3116
    } else {
3117
        /* no protocol means plain filename */
3118
        av_strlcpy(path, url, path_size);
3119
        return;
3120
    }
3121

    
3122
    /* separate path from hostname */
3123
    ls = strchr(p, '/');
3124
    if(!ls)
3125
        ls = strchr(p, '?');
3126
    if(ls)
3127
        av_strlcpy(path, ls, path_size);
3128
    else
3129
        ls = &p[strlen(p)]; // XXX
3130

    
3131
    /* the rest is hostname, use that to parse auth/port */
3132
    if (ls != p) {
3133
        /* authorization (user[:pass]@hostname) */
3134
        if ((at = strchr(p, '@')) && at < ls) {
3135
            av_strlcpy(authorization, p,
3136
                       FFMIN(authorization_size, at + 1 - p));
3137
            p = at + 1; /* skip '@' */
3138
        }
3139

    
3140
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3141
            /* [host]:port */
3142
            av_strlcpy(hostname, p + 1,
3143
                       FFMIN(hostname_size, brk - p));
3144
            if (brk[1] == ':' && port_ptr)
3145
                *port_ptr = atoi(brk + 2);
3146
        } else if ((col = strchr(p, ':')) && col < ls) {
3147
            av_strlcpy(hostname, p,
3148
                       FFMIN(col + 1 - p, hostname_size));
3149
            if (port_ptr) *port_ptr = atoi(col + 1);
3150
        } else
3151
            av_strlcpy(hostname, p,
3152
                       FFMIN(ls + 1 - p, hostname_size));
3153
    }
3154
}
3155

    
3156
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3157
                     int pts_num, int pts_den)
3158
{
3159
    unsigned int gcd= ff_gcd(pts_num, pts_den);
3160
    s->pts_wrap_bits = pts_wrap_bits;
3161
    s->time_base.num = pts_num/gcd;
3162
    s->time_base.den = pts_den/gcd;
3163

    
3164
    if(gcd>1)
3165
        av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);
3166
}
3167

    
3168
/* fraction handling */
3169

    
3170
/**
3171
 * f = val + (num / den) + 0.5.
3172
 *
3173
 * 'num' is normalized so that it is such as 0 <= num < den.
3174
 *
3175
 * @param f fractional number
3176
 * @param val integer value
3177
 * @param num must be >= 0
3178
 * @param den must be >= 1
3179
 */
3180
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3181
{
3182
    num += (den >> 1);
3183
    if (num >= den) {
3184
        val += num / den;
3185
        num = num % den;
3186
    }
3187
    f->val = val;
3188
    f->num = num;
3189
    f->den = den;
3190
}
3191

    
3192
/**
3193
 * Fractional addition to f: f = f + (incr / f->den).
3194
 *
3195
 * @param f fractional number
3196
 * @param incr increment, can be positive or negative
3197
 */
3198
static void av_frac_add(AVFrac *f, int64_t incr)
3199
{
3200
    int64_t num, den;
3201

    
3202
    num = f->num + incr;
3203
    den = f->den;
3204
    if (num < 0) {
3205
        f->val += num / den;
3206
        num = num % den;
3207
        if (num < 0) {
3208
            num += den;
3209
            f->val--;
3210
        }
3211
    } else if (num >= den) {
3212
        f->val += num / den;
3213
        num = num % den;
3214
    }
3215
    f->num = num;
3216
}