Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ f3b5a1a2

History | View | Annotate | Download (97.1 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
/************************************************************/
297
/* input media file */
298

    
299
/**
300
 * Open a media file from an IO stream. 'fmt' must be specified.
301
 */
302
static const char* format_to_name(void* ptr)
303
{
304
    AVFormatContext* fc = (AVFormatContext*) ptr;
305
    if(fc->iformat) return fc->iformat->name;
306
    else if(fc->oformat) return fc->oformat->name;
307
    else return "NULL";
308
}
309

    
310
#define OFFSET(x) offsetof(AVFormatContext,x)
311
#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
312
//these names are too long to be readable
313
#define E AV_OPT_FLAG_ENCODING_PARAM
314
#define D AV_OPT_FLAG_DECODING_PARAM
315

    
316
static const AVOption options[]={
317
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
318
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
319
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
320
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
321
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
322
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
323
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
324
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
325
{"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},
326
{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
327
{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
328
{"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 */
329
{"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E|D, "fdebug"},
330
{"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E|D, "fdebug"},
331
{NULL},
332
};
333

    
334
#undef E
335
#undef D
336
#undef DEFAULT
337

    
338
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
339

    
340
static void avformat_get_context_defaults(AVFormatContext *s)
341
{
342
    memset(s, 0, sizeof(AVFormatContext));
343

    
344
    s->av_class = &av_format_context_class;
345

    
346
    av_opt_set_defaults(s);
347
}
348

    
349
AVFormatContext *av_alloc_format_context(void)
350
{
351
    AVFormatContext *ic;
352
    ic = av_malloc(sizeof(AVFormatContext));
353
    if (!ic) return ic;
354
    avformat_get_context_defaults(ic);
355
    ic->av_class = &av_format_context_class;
356
    return ic;
357
}
358

    
359
int av_open_input_stream(AVFormatContext **ic_ptr,
360
                         ByteIOContext *pb, const char *filename,
361
                         AVInputFormat *fmt, AVFormatParameters *ap)
362
{
363
    int err;
364
    AVFormatContext *ic;
365
    AVFormatParameters default_ap;
366

    
367
    if(!ap){
368
        ap=&default_ap;
369
        memset(ap, 0, sizeof(default_ap));
370
    }
371

    
372
    if(!ap->prealloced_context)
373
        ic = av_alloc_format_context();
374
    else
375
        ic = *ic_ptr;
376
    if (!ic) {
377
        err = AVERROR(ENOMEM);
378
        goto fail;
379
    }
380
    ic->iformat = fmt;
381
    ic->pb = pb;
382
    ic->duration = AV_NOPTS_VALUE;
383
    ic->start_time = AV_NOPTS_VALUE;
384
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
385

    
386
    /* allocate private data */
387
    if (fmt->priv_data_size > 0) {
388
        ic->priv_data = av_mallocz(fmt->priv_data_size);
389
        if (!ic->priv_data) {
390
            err = AVERROR(ENOMEM);
391
            goto fail;
392
        }
393
    } else {
394
        ic->priv_data = NULL;
395
    }
396

    
397
    err = ic->iformat->read_header(ic, ap);
398
    if (err < 0)
399
        goto fail;
400

    
401
    if (pb && !ic->data_offset)
402
        ic->data_offset = url_ftell(ic->pb);
403

    
404
    *ic_ptr = ic;
405
    return 0;
406
 fail:
407
    if (ic) {
408
        int i;
409
        av_freep(&ic->priv_data);
410
        for(i=0;i<ic->nb_streams;i++) {
411
            AVStream *st = ic->streams[i];
412
            if (st) {
413
                av_free(st->priv_data);
414
                av_free(st->codec->extradata);
415
            }
416
            av_free(st);
417
        }
418
    }
419
    av_free(ic);
420
    *ic_ptr = NULL;
421
    return err;
422
}
423

    
424
/** size of probe buffer, for guessing file type from file contents */
425
#define PROBE_BUF_MIN 2048
426
#define PROBE_BUF_MAX (1<<20)
427

    
428
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
429
                       AVInputFormat *fmt,
430
                       int buf_size,
431
                       AVFormatParameters *ap)
432
{
433
    int err, probe_size;
434
    AVProbeData probe_data, *pd = &probe_data;
435
    ByteIOContext *pb = NULL;
436

    
437
    pd->filename = "";
438
    if (filename)
439
        pd->filename = filename;
440
    pd->buf = NULL;
441
    pd->buf_size = 0;
442

    
443
    if (!fmt) {
444
        /* guess format if no file can be opened */
445
        fmt = av_probe_input_format(pd, 0);
446
    }
447

    
448
    /* Do not open file if the format does not need it. XXX: specific
449
       hack needed to handle RTSP/TCP */
450
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
451
        /* if no file needed do not try to open one */
452
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
453
            goto fail;
454
        }
455
        if (buf_size > 0) {
456
            url_setbufsize(pb, buf_size);
457
        }
458

    
459
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
460
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
461
            /* read probe data */
462
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
463
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
464
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
465
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
466
                url_fclose(pb);
467
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
468
                    pb = NULL;
469
                    err = AVERROR(EIO);
470
                    goto fail;
471
                }
472
            }
473
            /* guess file format */
474
            fmt = av_probe_input_format2(pd, 1, &score);
475
        }
476
        av_freep(&pd->buf);
477
    }
478

    
479
    /* if still no format found, error */
480
    if (!fmt) {
481
        err = AVERROR_NOFMT;
482
        goto fail;
483
    }
484

    
485
    /* check filename in case an image number is expected */
486
    if (fmt->flags & AVFMT_NEEDNUMBER) {
487
        if (!av_filename_number_test(filename)) {
488
            err = AVERROR_NUMEXPECTED;
489
            goto fail;
490
        }
491
    }
492
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
493
    if (err)
494
        goto fail;
495
    return 0;
496
 fail:
497
    av_freep(&pd->buf);
498
    if (pb)
499
        url_fclose(pb);
500
    *ic_ptr = NULL;
501
    return err;
502

    
503
}
504

    
505
/*******************************************************/
506

    
507
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
508
{
509
    int ret;
510
    AVStream *st;
511
    av_init_packet(pkt);
512
    ret= s->iformat->read_packet(s, pkt);
513
    if (ret < 0)
514
        return ret;
515
    st= s->streams[pkt->stream_index];
516

    
517
    switch(st->codec->codec_type){
518
    case CODEC_TYPE_VIDEO:
519
        if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
520
        break;
521
    case CODEC_TYPE_AUDIO:
522
        if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
523
        break;
524
    case CODEC_TYPE_SUBTITLE:
525
        if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
526
        break;
527
    }
528

    
529
    return ret;
530
}
531

    
532
/**********************************************************/
533

    
534
/**
535
 * Get the number of samples of an audio frame. Return -1 on error.
536
 */
537
static int get_audio_frame_size(AVCodecContext *enc, int size)
538
{
539
    int frame_size;
540

    
541
    if(enc->codec_id == CODEC_ID_VORBIS)
542
        return -1;
543

    
544
    if (enc->frame_size <= 1) {
545
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
546

    
547
        if (bits_per_sample) {
548
            if (enc->channels == 0)
549
                return -1;
550
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
551
        } else {
552
            /* used for example by ADPCM codecs */
553
            if (enc->bit_rate == 0)
554
                return -1;
555
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
556
        }
557
    } else {
558
        frame_size = enc->frame_size;
559
    }
560
    return frame_size;
561
}
562

    
563

    
564
/**
565
 * Return the frame duration in seconds. Return 0 if not available.
566
 */
567
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
568
                                   AVCodecParserContext *pc, AVPacket *pkt)
569
{
570
    int frame_size;
571

    
572
    *pnum = 0;
573
    *pden = 0;
574
    switch(st->codec->codec_type) {
575
    case CODEC_TYPE_VIDEO:
576
        if(st->time_base.num*1000LL > st->time_base.den){
577
            *pnum = st->time_base.num;
578
            *pden = st->time_base.den;
579
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
580
            *pnum = st->codec->time_base.num;
581
            *pden = st->codec->time_base.den;
582
            if (pc && pc->repeat_pict) {
583
                *pden *= 2;
584
                *pnum = (*pnum) * (2 + pc->repeat_pict);
585
            }
586
        }
587
        break;
588
    case CODEC_TYPE_AUDIO:
589
        frame_size = get_audio_frame_size(st->codec, pkt->size);
590
        if (frame_size < 0)
591
            break;
592
        *pnum = frame_size;
593
        *pden = st->codec->sample_rate;
594
        break;
595
    default:
596
        break;
597
    }
598
}
599

    
600
static int is_intra_only(AVCodecContext *enc){
601
    if(enc->codec_type == CODEC_TYPE_AUDIO){
602
        return 1;
603
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
604
        switch(enc->codec_id){
605
        case CODEC_ID_MJPEG:
606
        case CODEC_ID_MJPEGB:
607
        case CODEC_ID_LJPEG:
608
        case CODEC_ID_RAWVIDEO:
609
        case CODEC_ID_DVVIDEO:
610
        case CODEC_ID_HUFFYUV:
611
        case CODEC_ID_FFVHUFF:
612
        case CODEC_ID_ASV1:
613
        case CODEC_ID_ASV2:
614
        case CODEC_ID_VCR1:
615
            return 1;
616
        default: break;
617
        }
618
    }
619
    return 0;
620
}
621

    
622
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
623
                                      int64_t dts, int64_t pts)
624
{
625
    AVStream *st= s->streams[stream_index];
626
    AVPacketList *pktl= s->packet_buffer;
627

    
628
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
629
        return;
630

    
631
    st->first_dts= dts - st->cur_dts;
632
    st->cur_dts= dts;
633

    
634
    for(; pktl; pktl= pktl->next){
635
        if(pktl->pkt.stream_index != stream_index)
636
            continue;
637
        //FIXME think more about this check
638
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
639
            pktl->pkt.pts += st->first_dts;
640

    
641
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
642
            pktl->pkt.dts += st->first_dts;
643

    
644
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
645
            st->start_time= pktl->pkt.pts;
646
    }
647
    if (st->start_time == AV_NOPTS_VALUE)
648
        st->start_time = pts;
649
}
650

    
651
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
652
{
653
    AVPacketList *pktl= s->packet_buffer;
654
    int64_t cur_dts= 0;
655

    
656
    if(st->first_dts != AV_NOPTS_VALUE){
657
        cur_dts= st->first_dts;
658
        for(; pktl; pktl= pktl->next){
659
            if(pktl->pkt.stream_index == pkt->stream_index){
660
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
661
                    break;
662
                cur_dts -= pkt->duration;
663
            }
664
        }
665
        pktl= s->packet_buffer;
666
        st->first_dts = cur_dts;
667
    }else if(st->cur_dts)
668
        return;
669

    
670
    for(; pktl; pktl= pktl->next){
671
        if(pktl->pkt.stream_index != pkt->stream_index)
672
            continue;
673
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
674
           && !pktl->pkt.duration){
675
            pktl->pkt.dts= cur_dts;
676
            if(!st->codec->has_b_frames)
677
                pktl->pkt.pts= cur_dts;
678
            cur_dts += pkt->duration;
679
            pktl->pkt.duration= pkt->duration;
680
        }else
681
            break;
682
    }
683
    if(st->first_dts == AV_NOPTS_VALUE)
684
        st->cur_dts= cur_dts;
685
}
686

    
687
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
688
                               AVCodecParserContext *pc, AVPacket *pkt)
689
{
690
    int num, den, presentation_delayed, delay, i;
691
    int64_t offset;
692

    
693
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
694
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
695
        pkt->dts -= 1LL<<st->pts_wrap_bits;
696
    }
697

    
698
    if (pkt->duration == 0) {
699
        compute_frame_duration(&num, &den, st, pc, pkt);
700
        if (den && num) {
701
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
702

    
703
            if(pkt->duration != 0 && s->packet_buffer)
704
                update_initial_durations(s, st, pkt);
705
        }
706
    }
707

    
708
    /* correct timestamps with byte offset if demuxers only have timestamps
709
       on packet boundaries */
710
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
711
        /* this will estimate bitrate based on this frame's duration and size */
712
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
713
        if(pkt->pts != AV_NOPTS_VALUE)
714
            pkt->pts += offset;
715
        if(pkt->dts != AV_NOPTS_VALUE)
716
            pkt->dts += offset;
717
    }
718

    
719
    /* do we have a video B-frame ? */
720
    delay= st->codec->has_b_frames;
721
    presentation_delayed = 0;
722
    /* XXX: need has_b_frame, but cannot get it if the codec is
723
        not initialized */
724
    if (delay &&
725
        pc && pc->pict_type != FF_B_TYPE)
726
        presentation_delayed = 1;
727
    /* This may be redundant, but it should not hurt. */
728
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
729
        presentation_delayed = 1;
730

    
731
    if(st->cur_dts == AV_NOPTS_VALUE){
732
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
733
    }
734

    
735
//    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);
736
    /* interpolate PTS and DTS if they are not present */
737
    if(delay==0 || (delay==1 && pc)){
738
        if (presentation_delayed) {
739
            /* DTS = decompression timestamp */
740
            /* PTS = presentation timestamp */
741
            if (pkt->dts == AV_NOPTS_VALUE)
742
                pkt->dts = st->last_IP_pts;
743
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
744
            if (pkt->dts == AV_NOPTS_VALUE)
745
                pkt->dts = st->cur_dts;
746

    
747
            /* this is tricky: the dts must be incremented by the duration
748
            of the frame we are displaying, i.e. the last I- or P-frame */
749
            if (st->last_IP_duration == 0)
750
                st->last_IP_duration = pkt->duration;
751
            st->cur_dts = pkt->dts + st->last_IP_duration;
752
            st->last_IP_duration  = pkt->duration;
753
            st->last_IP_pts= pkt->pts;
754
            /* cannot compute PTS if not present (we can compute it only
755
            by knowing the future */
756
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
757
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
758
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
759
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
760
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
761
                    pkt->pts += pkt->duration;
762
    //                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);
763
                }
764
            }
765

    
766
            /* presentation is not delayed : PTS and DTS are the same */
767
            if(pkt->pts == AV_NOPTS_VALUE)
768
                pkt->pts = pkt->dts;
769
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
770
            if(pkt->pts == AV_NOPTS_VALUE)
771
                pkt->pts = st->cur_dts;
772
            pkt->dts = pkt->pts;
773
            st->cur_dts = pkt->pts + pkt->duration;
774
        }
775
    }
776

    
777
    if(pkt->pts != AV_NOPTS_VALUE){
778
        st->pts_buffer[0]= pkt->pts;
779
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
780
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
781
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
782
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
783
        if(pkt->dts == AV_NOPTS_VALUE)
784
            pkt->dts= st->pts_buffer[0];
785
        if(delay>1){
786
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
787
        }
788
        if(pkt->dts > st->cur_dts)
789
            st->cur_dts = pkt->dts;
790
    }
791

    
792
//    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);
793

    
794
    /* update flags */
795
    if(is_intra_only(st->codec))
796
        pkt->flags |= PKT_FLAG_KEY;
797
    else if (pc) {
798
        pkt->flags = 0;
799
        /* keyframe computation */
800
            if (pc->pict_type == FF_I_TYPE)
801
                pkt->flags |= PKT_FLAG_KEY;
802
    }
803
}
804

    
805
void av_destruct_packet_nofree(AVPacket *pkt)
806
{
807
    pkt->data = NULL; pkt->size = 0;
808
}
809

    
810
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
811
{
812
    AVStream *st;
813
    int len, ret, i;
814

    
815
    av_init_packet(pkt);
816

    
817
    for(;;) {
818
        /* select current input stream component */
819
        st = s->cur_st;
820
        if (st) {
821
            if (!st->need_parsing || !st->parser) {
822
                /* no parsing needed: we just output the packet as is */
823
                /* raw data support */
824
                *pkt = s->cur_pkt;
825
                compute_pkt_fields(s, st, NULL, pkt);
826
                s->cur_st = NULL;
827
                break;
828
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
829
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
830
                                      s->cur_ptr, s->cur_len,
831
                                      s->cur_pkt.pts, s->cur_pkt.dts);
832
                s->cur_pkt.pts = AV_NOPTS_VALUE;
833
                s->cur_pkt.dts = AV_NOPTS_VALUE;
834
                /* increment read pointer */
835
                s->cur_ptr += len;
836
                s->cur_len -= len;
837

    
838
                /* return packet if any */
839
                if (pkt->size) {
840
                got_packet:
841
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
842
                    pkt->duration = 0;
843
                    pkt->stream_index = st->index;
844
                    pkt->pts = st->parser->pts;
845
                    pkt->dts = st->parser->dts;
846
                    pkt->destruct = av_destruct_packet_nofree;
847
                    compute_pkt_fields(s, st, st->parser, pkt);
848

    
849
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
850
                        ff_reduce_index(s, st->index);
851
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
852
                                           0, 0, AVINDEX_KEYFRAME);
853
                    }
854

    
855
                    break;
856
                }
857
            } else {
858
                /* free packet */
859
                av_free_packet(&s->cur_pkt);
860
                s->cur_st = NULL;
861
            }
862
        } else {
863
            /* read next packet */
864
            ret = av_read_packet(s, &s->cur_pkt);
865
            if (ret < 0) {
866
                if (ret == AVERROR(EAGAIN))
867
                    return ret;
868
                /* return the last frames, if any */
869
                for(i = 0; i < s->nb_streams; i++) {
870
                    st = s->streams[i];
871
                    if (st->parser && st->need_parsing) {
872
                        av_parser_parse(st->parser, st->codec,
873
                                        &pkt->data, &pkt->size,
874
                                        NULL, 0,
875
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
876
                        if (pkt->size)
877
                            goto got_packet;
878
                    }
879
                }
880
                /* no more packets: really terminate parsing */
881
                return ret;
882
            }
883

    
884
            if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
885
               s->cur_pkt.dts != AV_NOPTS_VALUE &&
886
               s->cur_pkt.pts < s->cur_pkt.dts){
887
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
888
                    s->cur_pkt.stream_index,
889
                    s->cur_pkt.pts,
890
                    s->cur_pkt.dts,
891
                    s->cur_pkt.size);
892
//                av_free_packet(&s->cur_pkt);
893
//                return -1;
894
            }
895

    
896
            st = s->streams[s->cur_pkt.stream_index];
897
            if(s->debug & FF_FDEBUG_TS)
898
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
899
                    s->cur_pkt.stream_index,
900
                    s->cur_pkt.pts,
901
                    s->cur_pkt.dts,
902
                    s->cur_pkt.size);
903

    
904
            s->cur_st = st;
905
            s->cur_ptr = s->cur_pkt.data;
906
            s->cur_len = s->cur_pkt.size;
907
            if (st->need_parsing && !st->parser) {
908
                st->parser = av_parser_init(st->codec->codec_id);
909
                if (!st->parser) {
910
                    /* no parser available: just output the raw packets */
911
                    st->need_parsing = AVSTREAM_PARSE_NONE;
912
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
913
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
914
                }
915
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
916
                    st->parser->next_frame_offset=
917
                    st->parser->cur_offset= s->cur_pkt.pos;
918
                }
919
            }
920
        }
921
    }
922
    if(s->debug & FF_FDEBUG_TS)
923
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
924
            pkt->stream_index,
925
            pkt->pts,
926
            pkt->dts,
927
            pkt->size);
928

    
929
    return 0;
930
}
931

    
932
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
933
    AVPacketList *pktl= s->packet_buffer;
934
    AVPacketList **plast_pktl= &s->packet_buffer;
935

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

    
938
    pktl = av_mallocz(sizeof(AVPacketList));
939
    if (!pktl)
940
        return NULL;
941

    
942
    /* add the packet in the buffered packet list */
943
    *plast_pktl = pktl;
944
    pktl->pkt= *pkt;
945
    return &pktl->pkt;
946
}
947

    
948
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
949
{
950
    AVPacketList *pktl;
951
    int eof=0;
952
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
953

    
954
    for(;;){
955
        pktl = s->packet_buffer;
956
        if (pktl) {
957
            AVPacket *next_pkt= &pktl->pkt;
958

    
959
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
960
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
961
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
962
                       && next_pkt->dts < pktl->pkt.dts
963
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
964
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
965
                        next_pkt->pts= pktl->pkt.dts;
966
                    }
967
                    pktl= pktl->next;
968
                }
969
                pktl = s->packet_buffer;
970
            }
971

    
972
            if(   next_pkt->pts != AV_NOPTS_VALUE
973
               || next_pkt->dts == AV_NOPTS_VALUE
974
               || !genpts || eof){
975
                /* read packet from packet buffer, if there is data */
976
                *pkt = *next_pkt;
977
                s->packet_buffer = pktl->next;
978
                av_free(pktl);
979
                return 0;
980
            }
981
        }
982
        if(genpts){
983
            int ret= av_read_frame_internal(s, pkt);
984
            if(ret<0){
985
                if(pktl && ret != AVERROR(EAGAIN)){
986
                    eof=1;
987
                    continue;
988
                }else
989
                    return ret;
990
            }
991

    
992
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
993
                return AVERROR(ENOMEM);
994
        }else{
995
            assert(!s->packet_buffer);
996
            return av_read_frame_internal(s, pkt);
997
        }
998
    }
999
}
1000

    
1001
/* XXX: suppress the packet queue */
1002
static void flush_packet_queue(AVFormatContext *s)
1003
{
1004
    AVPacketList *pktl;
1005

    
1006
    for(;;) {
1007
        pktl = s->packet_buffer;
1008
        if (!pktl)
1009
            break;
1010
        s->packet_buffer = pktl->next;
1011
        av_free_packet(&pktl->pkt);
1012
        av_free(pktl);
1013
    }
1014
}
1015

    
1016
/*******************************************************/
1017
/* seek support */
1018

    
1019
int av_find_default_stream_index(AVFormatContext *s)
1020
{
1021
    int first_audio_index = -1;
1022
    int i;
1023
    AVStream *st;
1024

    
1025
    if (s->nb_streams <= 0)
1026
        return -1;
1027
    for(i = 0; i < s->nb_streams; i++) {
1028
        st = s->streams[i];
1029
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1030
            return i;
1031
        }
1032
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1033
            first_audio_index = i;
1034
    }
1035
    return first_audio_index >= 0 ? first_audio_index : 0;
1036
}
1037

    
1038
/**
1039
 * Flush the frame reader.
1040
 */
1041
static void av_read_frame_flush(AVFormatContext *s)
1042
{
1043
    AVStream *st;
1044
    int i;
1045

    
1046
    flush_packet_queue(s);
1047

    
1048
    /* free previous packet */
1049
    if (s->cur_st) {
1050
        if (s->cur_st->parser)
1051
            av_free_packet(&s->cur_pkt);
1052
        s->cur_st = NULL;
1053
    }
1054
    /* fail safe */
1055
    s->cur_ptr = NULL;
1056
    s->cur_len = 0;
1057

    
1058
    /* for each stream, reset read state */
1059
    for(i = 0; i < s->nb_streams; i++) {
1060
        st = s->streams[i];
1061

    
1062
        if (st->parser) {
1063
            av_parser_close(st->parser);
1064
            st->parser = NULL;
1065
        }
1066
        st->last_IP_pts = AV_NOPTS_VALUE;
1067
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1068
    }
1069
}
1070

    
1071
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1072
    int i;
1073

    
1074
    for(i = 0; i < s->nb_streams; i++) {
1075
        AVStream *st = s->streams[i];
1076

    
1077
        st->cur_dts = av_rescale(timestamp,
1078
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1079
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1080
    }
1081
}
1082

    
1083
void ff_reduce_index(AVFormatContext *s, int stream_index)
1084
{
1085
    AVStream *st= s->streams[stream_index];
1086
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1087

    
1088
    if((unsigned)st->nb_index_entries >= max_entries){
1089
        int i;
1090
        for(i=0; 2*i<st->nb_index_entries; i++)
1091
            st->index_entries[i]= st->index_entries[2*i];
1092
        st->nb_index_entries= i;
1093
    }
1094
}
1095

    
1096
int av_add_index_entry(AVStream *st,
1097
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1098
{
1099
    AVIndexEntry *entries, *ie;
1100
    int index;
1101

    
1102
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1103
        return -1;
1104

    
1105
    entries = av_fast_realloc(st->index_entries,
1106
                              &st->index_entries_allocated_size,
1107
                              (st->nb_index_entries + 1) *
1108
                              sizeof(AVIndexEntry));
1109
    if(!entries)
1110
        return -1;
1111

    
1112
    st->index_entries= entries;
1113

    
1114
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1115

    
1116
    if(index<0){
1117
        index= st->nb_index_entries++;
1118
        ie= &entries[index];
1119
        assert(index==0 || ie[-1].timestamp < timestamp);
1120
    }else{
1121
        ie= &entries[index];
1122
        if(ie->timestamp != timestamp){
1123
            if(ie->timestamp <= timestamp)
1124
                return -1;
1125
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1126
            st->nb_index_entries++;
1127
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1128
            distance= ie->min_distance;
1129
    }
1130

    
1131
    ie->pos = pos;
1132
    ie->timestamp = timestamp;
1133
    ie->min_distance= distance;
1134
    ie->size= size;
1135
    ie->flags = flags;
1136

    
1137
    return index;
1138
}
1139

    
1140
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1141
                              int flags)
1142
{
1143
    AVIndexEntry *entries= st->index_entries;
1144
    int nb_entries= st->nb_index_entries;
1145
    int a, b, m;
1146
    int64_t timestamp;
1147

    
1148
    a = - 1;
1149
    b = nb_entries;
1150

    
1151
    while (b - a > 1) {
1152
        m = (a + b) >> 1;
1153
        timestamp = entries[m].timestamp;
1154
        if(timestamp >= wanted_timestamp)
1155
            b = m;
1156
        if(timestamp <= wanted_timestamp)
1157
            a = m;
1158
    }
1159
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1160

    
1161
    if(!(flags & AVSEEK_FLAG_ANY)){
1162
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1163
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1164
        }
1165
    }
1166

    
1167
    if(m == nb_entries)
1168
        return -1;
1169
    return  m;
1170
}
1171

    
1172
#define DEBUG_SEEK
1173

    
1174
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1175
    AVInputFormat *avif= s->iformat;
1176
    int64_t pos_min, pos_max, pos, pos_limit;
1177
    int64_t ts_min, ts_max, ts;
1178
    int index;
1179
    AVStream *st;
1180

    
1181
    if (stream_index < 0)
1182
        return -1;
1183

    
1184
#ifdef DEBUG_SEEK
1185
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1186
#endif
1187

    
1188
    ts_max=
1189
    ts_min= AV_NOPTS_VALUE;
1190
    pos_limit= -1; //gcc falsely says it may be uninitialized
1191

    
1192
    st= s->streams[stream_index];
1193
    if(st->index_entries){
1194
        AVIndexEntry *e;
1195

    
1196
        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()
1197
        index= FFMAX(index, 0);
1198
        e= &st->index_entries[index];
1199

    
1200
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1201
            pos_min= e->pos;
1202
            ts_min= e->timestamp;
1203
#ifdef DEBUG_SEEK
1204
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1205
               pos_min,ts_min);
1206
#endif
1207
        }else{
1208
            assert(index==0);
1209
        }
1210

    
1211
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1212
        assert(index < st->nb_index_entries);
1213
        if(index >= 0){
1214
            e= &st->index_entries[index];
1215
            assert(e->timestamp >= target_ts);
1216
            pos_max= e->pos;
1217
            ts_max= e->timestamp;
1218
            pos_limit= pos_max - e->min_distance;
1219
#ifdef DEBUG_SEEK
1220
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1221
               pos_max,pos_limit, ts_max);
1222
#endif
1223
        }
1224
    }
1225

    
1226
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1227
    if(pos<0)
1228
        return -1;
1229

    
1230
    /* do the seek */
1231
    url_fseek(s->pb, pos, SEEK_SET);
1232

    
1233
    av_update_cur_dts(s, st, ts);
1234

    
1235
    return 0;
1236
}
1237

    
1238
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 )){
1239
    int64_t pos, ts;
1240
    int64_t start_pos, filesize;
1241
    int no_change;
1242

    
1243
#ifdef DEBUG_SEEK
1244
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1245
#endif
1246

    
1247
    if(ts_min == AV_NOPTS_VALUE){
1248
        pos_min = s->data_offset;
1249
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1250
        if (ts_min == AV_NOPTS_VALUE)
1251
            return -1;
1252
    }
1253

    
1254
    if(ts_max == AV_NOPTS_VALUE){
1255
        int step= 1024;
1256
        filesize = url_fsize(s->pb);
1257
        pos_max = filesize - 1;
1258
        do{
1259
            pos_max -= step;
1260
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1261
            step += step;
1262
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1263
        if (ts_max == AV_NOPTS_VALUE)
1264
            return -1;
1265

    
1266
        for(;;){
1267
            int64_t tmp_pos= pos_max + 1;
1268
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1269
            if(tmp_ts == AV_NOPTS_VALUE)
1270
                break;
1271
            ts_max= tmp_ts;
1272
            pos_max= tmp_pos;
1273
            if(tmp_pos >= filesize)
1274
                break;
1275
        }
1276
        pos_limit= pos_max;
1277
    }
1278

    
1279
    if(ts_min > ts_max){
1280
        return -1;
1281
    }else if(ts_min == ts_max){
1282
        pos_limit= pos_min;
1283
    }
1284

    
1285
    no_change=0;
1286
    while (pos_min < pos_limit) {
1287
#ifdef DEBUG_SEEK
1288
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1289
               pos_min, pos_max,
1290
               ts_min, ts_max);
1291
#endif
1292
        assert(pos_limit <= pos_max);
1293

    
1294
        if(no_change==0){
1295
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1296
            // interpolate position (better than dichotomy)
1297
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1298
                + pos_min - approximate_keyframe_distance;
1299
        }else if(no_change==1){
1300
            // bisection, if interpolation failed to change min or max pos last time
1301
            pos = (pos_min + pos_limit)>>1;
1302
        }else{
1303
            /* linear search if bisection failed, can only happen if there
1304
               are very few or no keyframes between min/max */
1305
            pos=pos_min;
1306
        }
1307
        if(pos <= pos_min)
1308
            pos= pos_min + 1;
1309
        else if(pos > pos_limit)
1310
            pos= pos_limit;
1311
        start_pos= pos;
1312

    
1313
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1314
        if(pos == pos_max)
1315
            no_change++;
1316
        else
1317
            no_change=0;
1318
#ifdef DEBUG_SEEK
1319
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);
1320
#endif
1321
        if(ts == AV_NOPTS_VALUE){
1322
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1323
            return -1;
1324
        }
1325
        assert(ts != AV_NOPTS_VALUE);
1326
        if (target_ts <= ts) {
1327
            pos_limit = start_pos - 1;
1328
            pos_max = pos;
1329
            ts_max = ts;
1330
        }
1331
        if (target_ts >= ts) {
1332
            pos_min = pos;
1333
            ts_min = ts;
1334
        }
1335
    }
1336

    
1337
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1338
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1339
#ifdef DEBUG_SEEK
1340
    pos_min = pos;
1341
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1342
    pos_min++;
1343
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1344
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1345
           pos, ts_min, target_ts, ts_max);
1346
#endif
1347
    *ts_ret= ts;
1348
    return pos;
1349
}
1350

    
1351
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1352
    int64_t pos_min, pos_max;
1353
#if 0
1354
    AVStream *st;
1355

1356
    if (stream_index < 0)
1357
        return -1;
1358

1359
    st= s->streams[stream_index];
1360
#endif
1361

    
1362
    pos_min = s->data_offset;
1363
    pos_max = url_fsize(s->pb) - 1;
1364

    
1365
    if     (pos < pos_min) pos= pos_min;
1366
    else if(pos > pos_max) pos= pos_max;
1367

    
1368
    url_fseek(s->pb, pos, SEEK_SET);
1369

    
1370
#if 0
1371
    av_update_cur_dts(s, st, ts);
1372
#endif
1373
    return 0;
1374
}
1375

    
1376
static int av_seek_frame_generic(AVFormatContext *s,
1377
                                 int stream_index, int64_t timestamp, int flags)
1378
{
1379
    int index;
1380
    AVStream *st;
1381
    AVIndexEntry *ie;
1382

    
1383
    st = s->streams[stream_index];
1384

    
1385
    index = av_index_search_timestamp(st, timestamp, flags);
1386

    
1387
    if(index < 0 || index==st->nb_index_entries-1){
1388
        int i;
1389
        AVPacket pkt;
1390

    
1391
        if(st->nb_index_entries){
1392
            assert(st->index_entries);
1393
            ie= &st->index_entries[st->nb_index_entries-1];
1394
            url_fseek(s->pb, ie->pos, SEEK_SET);
1395
            av_update_cur_dts(s, st, ie->timestamp);
1396
        }else
1397
            url_fseek(s->pb, 0, SEEK_SET);
1398

    
1399
        for(i=0;; i++) {
1400
            int ret = av_read_frame(s, &pkt);
1401
            if(ret<0)
1402
                break;
1403
            av_free_packet(&pkt);
1404
            if(stream_index == pkt.stream_index){
1405
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1406
                    break;
1407
            }
1408
        }
1409
        index = av_index_search_timestamp(st, timestamp, flags);
1410
    }
1411
    if (index < 0)
1412
        return -1;
1413

    
1414
    av_read_frame_flush(s);
1415
    if (s->iformat->read_seek){
1416
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1417
            return 0;
1418
    }
1419
    ie = &st->index_entries[index];
1420
    url_fseek(s->pb, ie->pos, SEEK_SET);
1421

    
1422
    av_update_cur_dts(s, st, ie->timestamp);
1423

    
1424
    return 0;
1425
}
1426

    
1427
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1428
{
1429
    int ret;
1430
    AVStream *st;
1431

    
1432
    av_read_frame_flush(s);
1433

    
1434
    if(flags & AVSEEK_FLAG_BYTE)
1435
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1436

    
1437
    if(stream_index < 0){
1438
        stream_index= av_find_default_stream_index(s);
1439
        if(stream_index < 0)
1440
            return -1;
1441

    
1442
        st= s->streams[stream_index];
1443
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1444
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1445
    }
1446
    st= s->streams[stream_index];
1447

    
1448
    /* first, we try the format specific seek */
1449
    if (s->iformat->read_seek)
1450
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1451
    else
1452
        ret = -1;
1453
    if (ret >= 0) {
1454
        return 0;
1455
    }
1456

    
1457
    if(s->iformat->read_timestamp)
1458
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1459
    else
1460
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1461
}
1462

    
1463
/*******************************************************/
1464

    
1465
/**
1466
 * Returns TRUE if the stream has accurate duration in any stream.
1467
 *
1468
 * @return TRUE if the stream has accurate duration for at least one component.
1469
 */
1470
static int av_has_duration(AVFormatContext *ic)
1471
{
1472
    int i;
1473
    AVStream *st;
1474

    
1475
    for(i = 0;i < ic->nb_streams; i++) {
1476
        st = ic->streams[i];
1477
        if (st->duration != AV_NOPTS_VALUE)
1478
            return 1;
1479
    }
1480
    return 0;
1481
}
1482

    
1483
/**
1484
 * Estimate the stream timings from the one of each components.
1485
 *
1486
 * Also computes the global bitrate if possible.
1487
 */
1488
static void av_update_stream_timings(AVFormatContext *ic)
1489
{
1490
    int64_t start_time, start_time1, end_time, end_time1;
1491
    int64_t duration, duration1;
1492
    int i;
1493
    AVStream *st;
1494

    
1495
    start_time = INT64_MAX;
1496
    end_time = INT64_MIN;
1497
    duration = INT64_MIN;
1498
    for(i = 0;i < ic->nb_streams; i++) {
1499
        st = ic->streams[i];
1500
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1501
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1502
            if (start_time1 < start_time)
1503
                start_time = start_time1;
1504
            if (st->duration != AV_NOPTS_VALUE) {
1505
                end_time1 = start_time1
1506
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1507
                if (end_time1 > end_time)
1508
                    end_time = end_time1;
1509
            }
1510
        }
1511
        if (st->duration != AV_NOPTS_VALUE) {
1512
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1513
            if (duration1 > duration)
1514
                duration = duration1;
1515
        }
1516
    }
1517
    if (start_time != INT64_MAX) {
1518
        ic->start_time = start_time;
1519
        if (end_time != INT64_MIN) {
1520
            if (end_time - start_time > duration)
1521
                duration = end_time - start_time;
1522
        }
1523
    }
1524
    if (duration != INT64_MIN) {
1525
        ic->duration = duration;
1526
        if (ic->file_size > 0) {
1527
            /* compute the bitrate */
1528
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1529
                (double)ic->duration;
1530
        }
1531
    }
1532
}
1533

    
1534
static void fill_all_stream_timings(AVFormatContext *ic)
1535
{
1536
    int i;
1537
    AVStream *st;
1538

    
1539
    av_update_stream_timings(ic);
1540
    for(i = 0;i < ic->nb_streams; i++) {
1541
        st = ic->streams[i];
1542
        if (st->start_time == AV_NOPTS_VALUE) {
1543
            if(ic->start_time != AV_NOPTS_VALUE)
1544
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1545
            if(ic->duration != AV_NOPTS_VALUE)
1546
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1547
        }
1548
    }
1549
}
1550

    
1551
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1552
{
1553
    int64_t filesize, duration;
1554
    int bit_rate, i;
1555
    AVStream *st;
1556

    
1557
    /* if bit_rate is already set, we believe it */
1558
    if (ic->bit_rate == 0) {
1559
        bit_rate = 0;
1560
        for(i=0;i<ic->nb_streams;i++) {
1561
            st = ic->streams[i];
1562
            bit_rate += st->codec->bit_rate;
1563
        }
1564
        ic->bit_rate = bit_rate;
1565
    }
1566

    
1567
    /* if duration is already set, we believe it */
1568
    if (ic->duration == AV_NOPTS_VALUE &&
1569
        ic->bit_rate != 0 &&
1570
        ic->file_size != 0)  {
1571
        filesize = ic->file_size;
1572
        if (filesize > 0) {
1573
            for(i = 0; i < ic->nb_streams; i++) {
1574
                st = ic->streams[i];
1575
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1576
                if (st->duration == AV_NOPTS_VALUE)
1577
                    st->duration = duration;
1578
            }
1579
        }
1580
    }
1581
}
1582

    
1583
#define DURATION_MAX_READ_SIZE 250000
1584

    
1585
/* only usable for MPEG-PS streams */
1586
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1587
{
1588
    AVPacket pkt1, *pkt = &pkt1;
1589
    AVStream *st;
1590
    int read_size, i, ret;
1591
    int64_t end_time;
1592
    int64_t filesize, offset, duration;
1593

    
1594
    /* free previous packet */
1595
    if (ic->cur_st && ic->cur_st->parser)
1596
        av_free_packet(&ic->cur_pkt);
1597
    ic->cur_st = NULL;
1598

    
1599
    /* flush packet queue */
1600
    flush_packet_queue(ic);
1601

    
1602
    for(i=0;i<ic->nb_streams;i++) {
1603
        st = ic->streams[i];
1604
        if (st->parser) {
1605
            av_parser_close(st->parser);
1606
            st->parser= NULL;
1607
        }
1608
    }
1609

    
1610
    /* we read the first packets to get the first PTS (not fully
1611
       accurate, but it is enough now) */
1612
    url_fseek(ic->pb, 0, SEEK_SET);
1613
    read_size = 0;
1614
    for(;;) {
1615
        if (read_size >= DURATION_MAX_READ_SIZE)
1616
            break;
1617
        /* if all info is available, we can stop */
1618
        for(i = 0;i < ic->nb_streams; i++) {
1619
            st = ic->streams[i];
1620
            if (st->start_time == AV_NOPTS_VALUE)
1621
                break;
1622
        }
1623
        if (i == ic->nb_streams)
1624
            break;
1625

    
1626
        ret = av_read_packet(ic, pkt);
1627
        if (ret != 0)
1628
            break;
1629
        read_size += pkt->size;
1630
        st = ic->streams[pkt->stream_index];
1631
        if (pkt->pts != AV_NOPTS_VALUE) {
1632
            if (st->start_time == AV_NOPTS_VALUE)
1633
                st->start_time = pkt->pts;
1634
        }
1635
        av_free_packet(pkt);
1636
    }
1637

    
1638
    /* estimate the end time (duration) */
1639
    /* XXX: may need to support wrapping */
1640
    filesize = ic->file_size;
1641
    offset = filesize - DURATION_MAX_READ_SIZE;
1642
    if (offset < 0)
1643
        offset = 0;
1644

    
1645
    url_fseek(ic->pb, offset, SEEK_SET);
1646
    read_size = 0;
1647
    for(;;) {
1648
        if (read_size >= DURATION_MAX_READ_SIZE)
1649
            break;
1650

    
1651
        ret = av_read_packet(ic, pkt);
1652
        if (ret != 0)
1653
            break;
1654
        read_size += pkt->size;
1655
        st = ic->streams[pkt->stream_index];
1656
        if (pkt->pts != AV_NOPTS_VALUE &&
1657
            st->start_time != AV_NOPTS_VALUE) {
1658
            end_time = pkt->pts;
1659
            duration = end_time - st->start_time;
1660
            if (duration > 0) {
1661
                if (st->duration == AV_NOPTS_VALUE ||
1662
                    st->duration < duration)
1663
                    st->duration = duration;
1664
            }
1665
        }
1666
        av_free_packet(pkt);
1667
    }
1668

    
1669
    fill_all_stream_timings(ic);
1670

    
1671
    url_fseek(ic->pb, old_offset, SEEK_SET);
1672
    for(i=0; i<ic->nb_streams; i++){
1673
        st= ic->streams[i];
1674
        st->cur_dts= st->first_dts;
1675
        st->last_IP_pts = AV_NOPTS_VALUE;
1676
    }
1677
}
1678

    
1679
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1680
{
1681
    int64_t file_size;
1682

    
1683
    /* get the file size, if possible */
1684
    if (ic->iformat->flags & AVFMT_NOFILE) {
1685
        file_size = 0;
1686
    } else {
1687
        file_size = url_fsize(ic->pb);
1688
        if (file_size < 0)
1689
            file_size = 0;
1690
    }
1691
    ic->file_size = file_size;
1692

    
1693
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1694
         !strcmp(ic->iformat->name, "mpegts")) &&
1695
        file_size && !url_is_streamed(ic->pb)) {
1696
        /* get accurate estimate from the PTSes */
1697
        av_estimate_timings_from_pts(ic, old_offset);
1698
    } else if (av_has_duration(ic)) {
1699
        /* at least one component has timings - we use them for all
1700
           the components */
1701
        fill_all_stream_timings(ic);
1702
    } else {
1703
        /* less precise: use bitrate info */
1704
        av_estimate_timings_from_bit_rate(ic);
1705
    }
1706
    av_update_stream_timings(ic);
1707

    
1708
#if 0
1709
    {
1710
        int i;
1711
        AVStream *st;
1712
        for(i = 0;i < ic->nb_streams; i++) {
1713
            st = ic->streams[i];
1714
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1715
               i, (double)st->start_time / AV_TIME_BASE,
1716
               (double)st->duration / AV_TIME_BASE);
1717
        }
1718
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1719
               (double)ic->start_time / AV_TIME_BASE,
1720
               (double)ic->duration / AV_TIME_BASE,
1721
               ic->bit_rate / 1000);
1722
    }
1723
#endif
1724
}
1725

    
1726
static int has_codec_parameters(AVCodecContext *enc)
1727
{
1728
    int val;
1729
    switch(enc->codec_type) {
1730
    case CODEC_TYPE_AUDIO:
1731
        val = enc->sample_rate && enc->channels;
1732
        if(!enc->frame_size &&
1733
           (enc->codec_id == CODEC_ID_VORBIS ||
1734
            enc->codec_id == CODEC_ID_AAC))
1735
            return 0;
1736
        break;
1737
    case CODEC_TYPE_VIDEO:
1738
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1739
        break;
1740
    default:
1741
        val = 1;
1742
        break;
1743
    }
1744
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1745
}
1746

    
1747
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1748
{
1749
    int16_t *samples;
1750
    AVCodec *codec;
1751
    int got_picture, data_size, ret=0;
1752
    AVFrame picture;
1753

    
1754
  if(!st->codec->codec){
1755
    codec = avcodec_find_decoder(st->codec->codec_id);
1756
    if (!codec)
1757
        return -1;
1758
    ret = avcodec_open(st->codec, codec);
1759
    if (ret < 0)
1760
        return ret;
1761
  }
1762

    
1763
  if(!has_codec_parameters(st->codec)){
1764
    switch(st->codec->codec_type) {
1765
    case CODEC_TYPE_VIDEO:
1766
        ret = avcodec_decode_video(st->codec, &picture,
1767
                                   &got_picture, data, size);
1768
        break;
1769
    case CODEC_TYPE_AUDIO:
1770
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1771
        samples = av_malloc(data_size);
1772
        if (!samples)
1773
            goto fail;
1774
        ret = avcodec_decode_audio2(st->codec, samples,
1775
                                    &data_size, data, size);
1776
        av_free(samples);
1777
        break;
1778
    default:
1779
        break;
1780
    }
1781
  }
1782
 fail:
1783
    return ret;
1784
}
1785

    
1786
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1787
{
1788
    AVInputFormat *fmt;
1789
    fmt = av_probe_input_format2(pd, 1, &score);
1790

    
1791
    if (fmt) {
1792
        if (strncmp(fmt->name, "mp3", 3) == 0)
1793
            st->codec->codec_id = CODEC_ID_MP3;
1794
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1795
            st->codec->codec_id = CODEC_ID_AC3;
1796
    }
1797
    return !!fmt;
1798
}
1799

    
1800
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1801
{
1802
    while (tags->id != CODEC_ID_NONE) {
1803
        if (tags->id == id)
1804
            return tags->tag;
1805
        tags++;
1806
    }
1807
    return 0;
1808
}
1809

    
1810
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1811
{
1812
    int i;
1813
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1814
        if(tag == tags[i].tag)
1815
            return tags[i].id;
1816
    }
1817
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1818
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1819
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1820
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1821
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1822
            return tags[i].id;
1823
    }
1824
    return CODEC_ID_NONE;
1825
}
1826

    
1827
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1828
{
1829
    int i;
1830
    for(i=0; tags && tags[i]; i++){
1831
        int tag= codec_get_tag(tags[i], id);
1832
        if(tag) return tag;
1833
    }
1834
    return 0;
1835
}
1836

    
1837
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1838
{
1839
    int i;
1840
    for(i=0; tags && tags[i]; i++){
1841
        enum CodecID id= codec_get_id(tags[i], tag);
1842
        if(id!=CODEC_ID_NONE) return id;
1843
    }
1844
    return CODEC_ID_NONE;
1845
}
1846

    
1847
static void compute_chapters_end(AVFormatContext *s)
1848
{
1849
    unsigned int i;
1850

    
1851
    for (i=0; i+1<s->nb_chapters; i++)
1852
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1853
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1854
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1855
            s->chapters[i]->end = s->chapters[i+1]->start;
1856
        }
1857

    
1858
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1859
        assert(s->start_time != AV_NOPTS_VALUE);
1860
        assert(s->duration > 0);
1861
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1862
                                           AV_TIME_BASE_Q,
1863
                                           s->chapters[i]->time_base);
1864
    }
1865
}
1866

    
1867
/* absolute maximum size we read until we abort */
1868
#define MAX_READ_SIZE        5000000
1869

    
1870
#define MAX_STD_TIMEBASES (60*12+5)
1871
static int get_std_framerate(int i){
1872
    if(i<60*12) return i*1001;
1873
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1874
}
1875

    
1876
/*
1877
 * Is the time base unreliable.
1878
 * This is a heuristic to balance between quick acceptance of the values in
1879
 * the headers vs. some extra checks.
1880
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1881
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1882
 * And there are "variable" fps files this needs to detect as well.
1883
 */
1884
static int tb_unreliable(AVCodecContext *c){
1885
    if(   c->time_base.den >= 101L*c->time_base.num
1886
       || c->time_base.den <    5L*c->time_base.num
1887
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1888
       || c->codec_tag == ff_get_fourcc("XVID")*/
1889
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1890
        return 1;
1891
    return 0;
1892
}
1893

    
1894
int av_find_stream_info(AVFormatContext *ic)
1895
{
1896
    int i, count, ret, read_size, j;
1897
    AVStream *st;
1898
    AVPacket pkt1, *pkt;
1899
    int64_t last_dts[MAX_STREAMS];
1900
    int duration_count[MAX_STREAMS]={0};
1901
    double (*duration_error)[MAX_STD_TIMEBASES];
1902
    offset_t old_offset = url_ftell(ic->pb);
1903
    int64_t codec_info_duration[MAX_STREAMS]={0};
1904
    int codec_info_nb_frames[MAX_STREAMS]={0};
1905
    AVProbeData probe_data[MAX_STREAMS];
1906
    int codec_identified[MAX_STREAMS]={0};
1907

    
1908
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1909
    if (!duration_error) return AVERROR(ENOMEM);
1910

    
1911
    for(i=0;i<ic->nb_streams;i++) {
1912
        st = ic->streams[i];
1913
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1914
/*            if(!st->time_base.num)
1915
                st->time_base= */
1916
            if(!st->codec->time_base.num)
1917
                st->codec->time_base= st->time_base;
1918
        }
1919
        //only for the split stuff
1920
        if (!st->parser) {
1921
            st->parser = av_parser_init(st->codec->codec_id);
1922
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1923
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1924
            }
1925
        }
1926
    }
1927

    
1928
    for(i=0;i<MAX_STREAMS;i++){
1929
        last_dts[i]= AV_NOPTS_VALUE;
1930
    }
1931

    
1932
    memset(probe_data, 0, sizeof(probe_data));
1933
    count = 0;
1934
    read_size = 0;
1935
    for(;;) {
1936
        /* check if one codec still needs to be handled */
1937
        for(i=0;i<ic->nb_streams;i++) {
1938
            st = ic->streams[i];
1939
            if (!has_codec_parameters(st->codec))
1940
                break;
1941
            /* variable fps and no guess at the real fps */
1942
            if(   tb_unreliable(st->codec)
1943
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1944
                break;
1945
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1946
                break;
1947
            if(st->first_dts == AV_NOPTS_VALUE)
1948
                break;
1949
        }
1950
        if (i == ic->nb_streams) {
1951
            /* NOTE: if the format has no header, then we need to read
1952
               some packets to get most of the streams, so we cannot
1953
               stop here */
1954
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1955
                /* if we found the info for all the codecs, we can stop */
1956
                ret = count;
1957
                break;
1958
            }
1959
        }
1960
        /* we did not get all the codec info, but we read too much data */
1961
        if (read_size >= MAX_READ_SIZE) {
1962
            ret = count;
1963
            break;
1964
        }
1965

    
1966
        /* NOTE: a new stream can be added there if no header in file
1967
           (AVFMTCTX_NOHEADER) */
1968
        ret = av_read_frame_internal(ic, &pkt1);
1969
        if (ret < 0) {
1970
            /* EOF or error */
1971
            ret = -1; /* we could not have all the codec parameters before EOF */
1972
            for(i=0;i<ic->nb_streams;i++) {
1973
                st = ic->streams[i];
1974
                if (!has_codec_parameters(st->codec)){
1975
                    char buf[256];
1976
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1977
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1978
                } else {
1979
                    ret = 0;
1980
                }
1981
            }
1982
            break;
1983
        }
1984

    
1985
        pkt= add_to_pktbuf(ic, &pkt1);
1986
        if(av_dup_packet(pkt) < 0)
1987
            return AVERROR(ENOMEM);
1988

    
1989
        read_size += pkt->size;
1990

    
1991
        st = ic->streams[pkt->stream_index];
1992
        if(codec_info_nb_frames[st->index]>1)
1993
            codec_info_duration[st->index] += pkt->duration;
1994
        if (pkt->duration != 0)
1995
            codec_info_nb_frames[st->index]++;
1996

    
1997
        {
1998
            int index= pkt->stream_index;
1999
            int64_t last= last_dts[index];
2000
            int64_t duration= pkt->dts - last;
2001

    
2002
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2003
                double dur= duration * av_q2d(st->time_base);
2004

    
2005
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2006
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2007
                if(duration_count[index] < 2)
2008
                    memset(duration_error[index], 0, sizeof(*duration_error));
2009
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2010
                    int framerate= get_std_framerate(i);
2011
                    int ticks= lrintf(dur*framerate/(1001*12));
2012
                    double error= dur - ticks*1001*12/(double)framerate;
2013
                    duration_error[index][i] += error*error;
2014
                }
2015
                duration_count[index]++;
2016
            }
2017
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2018
                last_dts[pkt->stream_index]= pkt->dts;
2019

    
2020
            if (st->codec->codec_id == CODEC_ID_NONE) {
2021
                AVProbeData *pd = &(probe_data[st->index]);
2022
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
2023
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
2024
                pd->buf_size += pkt->size;
2025
                memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
2026
            }
2027
        }
2028
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2029
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2030
            if(i){
2031
                st->codec->extradata_size= i;
2032
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2033
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2034
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2035
            }
2036
        }
2037

    
2038
        /* if still no information, we try to open the codec and to
2039
           decompress the frame. We try to avoid that in most cases as
2040
           it takes longer and uses more memory. For MPEG-4, we need to
2041
           decompress for QuickTime. */
2042
        if (!has_codec_parameters(st->codec) /*&&
2043
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2044
             st->codec->codec_id == CODEC_ID_H264 ||
2045
             st->codec->codec_id == CODEC_ID_H263 ||
2046
             st->codec->codec_id == CODEC_ID_H261 ||
2047
             st->codec->codec_id == CODEC_ID_VORBIS ||
2048
             st->codec->codec_id == CODEC_ID_MJPEG ||
2049
             st->codec->codec_id == CODEC_ID_PNG ||
2050
             st->codec->codec_id == CODEC_ID_PAM ||
2051
             st->codec->codec_id == CODEC_ID_PGM ||
2052
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2053
             st->codec->codec_id == CODEC_ID_PBM ||
2054
             st->codec->codec_id == CODEC_ID_PPM ||
2055
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2056
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2057
            try_decode_frame(st, pkt->data, pkt->size);
2058

    
2059
        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) {
2060
            break;
2061
        }
2062
        count++;
2063
    }
2064

    
2065
    // close codecs which were opened in try_decode_frame()
2066
    for(i=0;i<ic->nb_streams;i++) {
2067
        st = ic->streams[i];
2068
        if(st->codec->codec)
2069
            avcodec_close(st->codec);
2070
    }
2071
    for(i=0;i<ic->nb_streams;i++) {
2072
        st = ic->streams[i];
2073
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2074
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2075
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2076

    
2077
            if(duration_count[i]
2078
               && tb_unreliable(st->codec) /*&&
2079
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2080
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2081
                double best_error= 2*av_q2d(st->time_base);
2082
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2083

    
2084
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2085
                    double error= duration_error[i][j] * get_std_framerate(j);
2086
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2087
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2088
                    if(error < best_error){
2089
                        best_error= error;
2090
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2091
                    }
2092
                }
2093
            }
2094

    
2095
            if (!st->r_frame_rate.num){
2096
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2097
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2098
                    st->r_frame_rate.num = st->codec->time_base.den;
2099
                    st->r_frame_rate.den = st->codec->time_base.num;
2100
                }else{
2101
                    st->r_frame_rate.num = st->time_base.den;
2102
                    st->r_frame_rate.den = st->time_base.num;
2103
                }
2104
            }
2105
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2106
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
2107
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
2108
                if (codec_identified[st->index]) {
2109
                    st->need_parsing = AVSTREAM_PARSE_FULL;
2110
                }
2111
            }
2112
            if(!st->codec->bits_per_sample)
2113
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2114
        }
2115
    }
2116

    
2117
    av_estimate_timings(ic, old_offset);
2118

    
2119
    for(i=0;i<ic->nb_streams;i++) {
2120
        st = ic->streams[i];
2121
        if (codec_identified[st->index])
2122
            break;
2123
    }
2124
    //FIXME this is a mess
2125
    if(i!=ic->nb_streams){
2126
        av_read_frame_flush(ic);
2127
        for(i=0;i<ic->nb_streams;i++) {
2128
            st = ic->streams[i];
2129
            if (codec_identified[st->index]) {
2130
                av_seek_frame(ic, st->index, 0.0, 0);
2131
            }
2132
            st->cur_dts= st->first_dts;
2133
        }
2134
        url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2135
    }
2136

    
2137
    compute_chapters_end(ic);
2138

    
2139
#if 0
2140
    /* correct DTS for B-frame streams with no timestamps */
2141
    for(i=0;i<ic->nb_streams;i++) {
2142
        st = ic->streams[i];
2143
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2144
            if(b-frames){
2145
                ppktl = &ic->packet_buffer;
2146
                while(ppkt1){
2147
                    if(ppkt1->stream_index != i)
2148
                        continue;
2149
                    if(ppkt1->pkt->dts < 0)
2150
                        break;
2151
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2152
                        break;
2153
                    ppkt1->pkt->dts -= delta;
2154
                    ppkt1= ppkt1->next;
2155
                }
2156
                if(ppkt1)
2157
                    continue;
2158
                st->cur_dts -= delta;
2159
            }
2160
        }
2161
    }
2162
#endif
2163

    
2164
    av_free(duration_error);
2165
    for(i=0;i<MAX_STREAMS;i++){
2166
        av_freep(&(probe_data[i].buf));
2167
    }
2168

    
2169
    return ret;
2170
}
2171

    
2172
/*******************************************************/
2173

    
2174
int av_read_play(AVFormatContext *s)
2175
{
2176
    if (s->iformat->read_play)
2177
        return s->iformat->read_play(s);
2178
    if (s->pb)
2179
        return av_url_read_fpause(s->pb, 0);
2180
    return AVERROR(ENOSYS);
2181
}
2182

    
2183
int av_read_pause(AVFormatContext *s)
2184
{
2185
    if (s->iformat->read_pause)
2186
        return s->iformat->read_pause(s);
2187
    if (s->pb)
2188
        return av_url_read_fpause(s->pb, 1);
2189
    return AVERROR(ENOSYS);
2190
}
2191

    
2192
void av_close_input_stream(AVFormatContext *s)
2193
{
2194
    int i;
2195
    AVStream *st;
2196

    
2197
    /* free previous packet */
2198
    if (s->cur_st && s->cur_st->parser)
2199
        av_free_packet(&s->cur_pkt);
2200

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

    
2233
void av_close_input_file(AVFormatContext *s)
2234
{
2235
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2236
    av_close_input_stream(s);
2237
    if (pb)
2238
        url_fclose(pb);
2239
}
2240

    
2241
AVStream *av_new_stream(AVFormatContext *s, int id)
2242
{
2243
    AVStream *st;
2244
    int i;
2245

    
2246
    if (s->nb_streams >= MAX_STREAMS)
2247
        return NULL;
2248

    
2249
    st = av_mallocz(sizeof(AVStream));
2250
    if (!st)
2251
        return NULL;
2252

    
2253
    st->codec= avcodec_alloc_context();
2254
    if (s->iformat) {
2255
        /* no default bitrate if decoding */
2256
        st->codec->bit_rate = 0;
2257
    }
2258
    st->index = s->nb_streams;
2259
    st->id = id;
2260
    st->start_time = AV_NOPTS_VALUE;
2261
    st->duration = AV_NOPTS_VALUE;
2262
    st->cur_dts = AV_NOPTS_VALUE;
2263
    st->first_dts = AV_NOPTS_VALUE;
2264

    
2265
    /* default pts setting is MPEG-like */
2266
    av_set_pts_info(st, 33, 1, 90000);
2267
    st->last_IP_pts = AV_NOPTS_VALUE;
2268
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2269
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2270

    
2271
    s->streams[s->nb_streams++] = st;
2272
    return st;
2273
}
2274

    
2275
AVProgram *av_new_program(AVFormatContext *ac, int id)
2276
{
2277
    AVProgram *program=NULL;
2278
    int i;
2279

    
2280
#ifdef DEBUG_SI
2281
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2282
#endif
2283

    
2284
    for(i=0; i<ac->nb_programs; i++)
2285
        if(ac->programs[i]->id == id)
2286
            program = ac->programs[i];
2287

    
2288
    if(!program){
2289
        program = av_mallocz(sizeof(AVProgram));
2290
        if (!program)
2291
            return NULL;
2292
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2293
        program->discard = AVDISCARD_NONE;
2294
    }
2295
    program->id = id;
2296

    
2297
    return program;
2298
}
2299

    
2300
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2301
{
2302
    assert(!provider_name == !name);
2303
    if(name){
2304
        av_free(program->provider_name);
2305
        av_free(program->         name);
2306
        program->provider_name = av_strdup(provider_name);
2307
        program->         name = av_strdup(         name);
2308
    }
2309
}
2310

    
2311
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2312
{
2313
    AVChapter *chapter = NULL;
2314
    int i;
2315

    
2316
    for(i=0; i<s->nb_chapters; i++)
2317
        if(s->chapters[i]->id == id)
2318
            chapter = s->chapters[i];
2319

    
2320
    if(!chapter){
2321
        chapter= av_mallocz(sizeof(AVChapter));
2322
        if(!chapter)
2323
            return NULL;
2324
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2325
    }
2326
    av_free(chapter->title);
2327
    chapter->title = av_strdup(title);
2328
    chapter->id    = id;
2329
    chapter->time_base= time_base;
2330
    chapter->start = start;
2331
    chapter->end   = end;
2332

    
2333
    return chapter;
2334
}
2335

    
2336
/************************************************************/
2337
/* output media file */
2338

    
2339
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2340
{
2341
    int ret;
2342

    
2343
    if (s->oformat->priv_data_size > 0) {
2344
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2345
        if (!s->priv_data)
2346
            return AVERROR(ENOMEM);
2347
    } else
2348
        s->priv_data = NULL;
2349

    
2350
    if (s->oformat->set_parameters) {
2351
        ret = s->oformat->set_parameters(s, ap);
2352
        if (ret < 0)
2353
            return ret;
2354
    }
2355
    return 0;
2356
}
2357

    
2358
int av_write_header(AVFormatContext *s)
2359
{
2360
    int ret, i;
2361
    AVStream *st;
2362

    
2363
    // some sanity checks
2364
    for(i=0;i<s->nb_streams;i++) {
2365
        st = s->streams[i];
2366

    
2367
        switch (st->codec->codec_type) {
2368
        case CODEC_TYPE_AUDIO:
2369
            if(st->codec->sample_rate<=0){
2370
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2371
                return -1;
2372
            }
2373
            break;
2374
        case CODEC_TYPE_VIDEO:
2375
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2376
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2377
                return -1;
2378
            }
2379
            if(st->codec->width<=0 || st->codec->height<=0){
2380
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2381
                return -1;
2382
            }
2383
            break;
2384
        }
2385

    
2386
        if(s->oformat->codec_tag){
2387
            if(st->codec->codec_tag){
2388
                //FIXME
2389
                //check that tag + id is in the table
2390
                //if neither is in the table -> OK
2391
                //if tag is in the table with another id -> FAIL
2392
                //if id is in the table with another tag -> FAIL unless strict < ?
2393
            }else
2394
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2395
        }
2396
    }
2397

    
2398
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2399
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2400
        if (!s->priv_data)
2401
            return AVERROR(ENOMEM);
2402
    }
2403

    
2404
    if(s->oformat->write_header){
2405
        ret = s->oformat->write_header(s);
2406
        if (ret < 0)
2407
            return ret;
2408
    }
2409

    
2410
    /* init PTS generation */
2411
    for(i=0;i<s->nb_streams;i++) {
2412
        int64_t den = AV_NOPTS_VALUE;
2413
        st = s->streams[i];
2414

    
2415
        switch (st->codec->codec_type) {
2416
        case CODEC_TYPE_AUDIO:
2417
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2418
            break;
2419
        case CODEC_TYPE_VIDEO:
2420
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2421
            break;
2422
        default:
2423
            break;
2424
        }
2425
        if (den != AV_NOPTS_VALUE) {
2426
            if (den <= 0)
2427
                return AVERROR_INVALIDDATA;
2428
            av_frac_init(&st->pts, 0, 0, den);
2429
        }
2430
    }
2431
    return 0;
2432
}
2433

    
2434
//FIXME merge with compute_pkt_fields
2435
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2436
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2437
    int num, den, frame_size, i;
2438

    
2439
//    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);
2440

    
2441
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2442
        return -1;*/
2443

    
2444
    /* duration field */
2445
    if (pkt->duration == 0) {
2446
        compute_frame_duration(&num, &den, st, NULL, pkt);
2447
        if (den && num) {
2448
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2449
        }
2450
    }
2451

    
2452
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2453
        pkt->pts= pkt->dts;
2454

    
2455
    //XXX/FIXME this is a temporary hack until all encoders output pts
2456
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2457
        pkt->dts=
2458
//        pkt->pts= st->cur_dts;
2459
        pkt->pts= st->pts.val;
2460
    }
2461

    
2462
    //calculate dts from pts
2463
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2464
        st->pts_buffer[0]= pkt->pts;
2465
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2466
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2467
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2468
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2469

    
2470
        pkt->dts= st->pts_buffer[0];
2471
    }
2472

    
2473
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2474
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2475
        return -1;
2476
    }
2477
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2478
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2479
        return -1;
2480
    }
2481

    
2482
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2483
    st->cur_dts= pkt->dts;
2484
    st->pts.val= pkt->dts;
2485

    
2486
    /* update pts */
2487
    switch (st->codec->codec_type) {
2488
    case CODEC_TYPE_AUDIO:
2489
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2490

    
2491
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2492
           likely equal to the encoder delay, but it would be better if we
2493
           had the real timestamps from the encoder */
2494
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2495
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2496
        }
2497
        break;
2498
    case CODEC_TYPE_VIDEO:
2499
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2500
        break;
2501
    default:
2502
        break;
2503
    }
2504
    return 0;
2505
}
2506

    
2507
static void truncate_ts(AVStream *st, AVPacket *pkt){
2508
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2509

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

    
2513
    if (pkt->pts != AV_NOPTS_VALUE)
2514
        pkt->pts &= pts_mask;
2515
    if (pkt->dts != AV_NOPTS_VALUE)
2516
        pkt->dts &= pts_mask;
2517
}
2518

    
2519
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2520
{
2521
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2522

    
2523
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2524
        return ret;
2525

    
2526
    truncate_ts(s->streams[pkt->stream_index], pkt);
2527

    
2528
    ret= s->oformat->write_packet(s, pkt);
2529
    if(!ret)
2530
        ret= url_ferror(s->pb);
2531
    return ret;
2532
}
2533

    
2534
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2535
    AVPacketList *pktl, **next_point, *this_pktl;
2536
    int stream_count=0;
2537
    int streams[MAX_STREAMS];
2538

    
2539
    if(pkt){
2540
        AVStream *st= s->streams[ pkt->stream_index];
2541

    
2542
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2543

    
2544
        this_pktl = av_mallocz(sizeof(AVPacketList));
2545
        this_pktl->pkt= *pkt;
2546
        if(pkt->destruct == av_destruct_packet)
2547
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2548
        else
2549
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2550

    
2551
        next_point = &s->packet_buffer;
2552
        while(*next_point){
2553
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2554
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2555
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2556
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2557
                break;
2558
            next_point= &(*next_point)->next;
2559
        }
2560
        this_pktl->next= *next_point;
2561
        *next_point= this_pktl;
2562
    }
2563

    
2564
    memset(streams, 0, sizeof(streams));
2565
    pktl= s->packet_buffer;
2566
    while(pktl){
2567
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2568
        if(streams[ pktl->pkt.stream_index ] == 0)
2569
            stream_count++;
2570
        streams[ pktl->pkt.stream_index ]++;
2571
        pktl= pktl->next;
2572
    }
2573

    
2574
    if(stream_count && (s->nb_streams == stream_count || flush)){
2575
        pktl= s->packet_buffer;
2576
        *out= pktl->pkt;
2577

    
2578
        s->packet_buffer= pktl->next;
2579
        av_freep(&pktl);
2580
        return 1;
2581
    }else{
2582
        av_init_packet(out);
2583
        return 0;
2584
    }
2585
}
2586

    
2587
/**
2588
 * Interleaves an AVPacket correctly so it can be muxed.
2589
 * @param out the interleaved packet will be output here
2590
 * @param in the input packet
2591
 * @param flush 1 if no further packets are available as input and all
2592
 *              remaining packets should be output
2593
 * @return 1 if a packet was output, 0 if no packet could be output,
2594
 *         < 0 if an error occurred
2595
 */
2596
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2597
    if(s->oformat->interleave_packet)
2598
        return s->oformat->interleave_packet(s, out, in, flush);
2599
    else
2600
        return av_interleave_packet_per_dts(s, out, in, flush);
2601
}
2602

    
2603
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2604
    AVStream *st= s->streams[ pkt->stream_index];
2605

    
2606
    //FIXME/XXX/HACK drop zero sized packets
2607
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2608
        return 0;
2609

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

    
2614
    if(pkt->dts == AV_NOPTS_VALUE)
2615
        return -1;
2616

    
2617
    for(;;){
2618
        AVPacket opkt;
2619
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2620
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2621
            return ret;
2622

    
2623
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2624
        ret= s->oformat->write_packet(s, &opkt);
2625

    
2626
        av_free_packet(&opkt);
2627
        pkt= NULL;
2628

    
2629
        if(ret<0)
2630
            return ret;
2631
        if(url_ferror(s->pb))
2632
            return url_ferror(s->pb);
2633
    }
2634
}
2635

    
2636
int av_write_trailer(AVFormatContext *s)
2637
{
2638
    int ret, i;
2639

    
2640
    for(;;){
2641
        AVPacket pkt;
2642
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2643
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2644
            goto fail;
2645
        if(!ret)
2646
            break;
2647

    
2648
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2649
        ret= s->oformat->write_packet(s, &pkt);
2650

    
2651
        av_free_packet(&pkt);
2652

    
2653
        if(ret<0)
2654
            goto fail;
2655
        if(url_ferror(s->pb))
2656
            goto fail;
2657
    }
2658

    
2659
    if(s->oformat->write_trailer)
2660
        ret = s->oformat->write_trailer(s);
2661
fail:
2662
    if(ret == 0)
2663
       ret=url_ferror(s->pb);
2664
    for(i=0;i<s->nb_streams;i++)
2665
        av_freep(&s->streams[i]->priv_data);
2666
    av_freep(&s->priv_data);
2667
    return ret;
2668
}
2669

    
2670
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2671
{
2672
    int i, j;
2673
    AVProgram *program=NULL;
2674
    void *tmp;
2675

    
2676
    for(i=0; i<ac->nb_programs; i++){
2677
        if(ac->programs[i]->id != progid)
2678
            continue;
2679
        program = ac->programs[i];
2680
        for(j=0; j<program->nb_stream_indexes; j++)
2681
            if(program->stream_index[j] == idx)
2682
                return;
2683

    
2684
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2685
        if(!tmp)
2686
            return;
2687
        program->stream_index = tmp;
2688
        program->stream_index[program->nb_stream_indexes++] = idx;
2689
        return;
2690
    }
2691
}
2692

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

    
2721
void dump_format(AVFormatContext *ic,
2722
                 int index,
2723
                 const char *url,
2724
                 int is_output)
2725
{
2726
    int i;
2727

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

    
2777
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2778
{
2779
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2780
}
2781

    
2782
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2783
{
2784
    AVRational frame_rate;
2785
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2786
    *frame_rate_num= frame_rate.num;
2787
    *frame_rate_den= frame_rate.den;
2788
    return ret;
2789
}
2790

    
2791
/**
2792
 * Gets the current time in microseconds.
2793
 */
2794
int64_t av_gettime(void)
2795
{
2796
    struct timeval tv;
2797
    gettimeofday(&tv,NULL);
2798
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2799
}
2800

    
2801
int64_t parse_date(const char *datestr, int duration)
2802
{
2803
    const char *p;
2804
    int64_t t;
2805
    struct tm dt;
2806
    int i;
2807
    static const char *date_fmt[] = {
2808
        "%Y-%m-%d",
2809
        "%Y%m%d",
2810
    };
2811
    static const char *time_fmt[] = {
2812
        "%H:%M:%S",
2813
        "%H%M%S",
2814
    };
2815
    const char *q;
2816
    int is_utc, len;
2817
    char lastch;
2818
    int negative = 0;
2819

    
2820
#undef time
2821
    time_t now = time(0);
2822

    
2823
    len = strlen(datestr);
2824
    if (len > 0)
2825
        lastch = datestr[len - 1];
2826
    else
2827
        lastch = '\0';
2828
    is_utc = (lastch == 'z' || lastch == 'Z');
2829

    
2830
    memset(&dt, 0, sizeof(dt));
2831

    
2832
    p = datestr;
2833
    q = NULL;
2834
    if (!duration) {
2835
        /* parse the year-month-day part */
2836
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2837
            q = small_strptime(p, date_fmt[i], &dt);
2838
            if (q) {
2839
                break;
2840
            }
2841
        }
2842

    
2843
        /* if the year-month-day part is missing, then take the
2844
         * current year-month-day time */
2845
        if (!q) {
2846
            if (is_utc) {
2847
                dt = *gmtime(&now);
2848
            } else {
2849
                dt = *localtime(&now);
2850
            }
2851
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2852
        } else {
2853
            p = q;
2854
        }
2855

    
2856
        if (*p == 'T' || *p == 't' || *p == ' ')
2857
            p++;
2858

    
2859
        /* parse the hour-minute-second part */
2860
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2861
            q = small_strptime(p, time_fmt[i], &dt);
2862
            if (q) {
2863
                break;
2864
            }
2865
        }
2866
    } else {
2867
        /* parse datestr as a duration */
2868
        if (p[0] == '-') {
2869
            negative = 1;
2870
            ++p;
2871
        }
2872
        /* parse datestr as HH:MM:SS */
2873
        q = small_strptime(p, time_fmt[0], &dt);
2874
        if (!q) {
2875
            /* parse datestr as S+ */
2876
            dt.tm_sec = strtol(p, (char **)&q, 10);
2877
            if (q == p)
2878
                /* the parsing didn't succeed */
2879
                return INT64_MIN;
2880
            dt.tm_min = 0;
2881
            dt.tm_hour = 0;
2882
        }
2883
    }
2884

    
2885
    /* Now we have all the fields that we can get */
2886
    if (!q) {
2887
        return INT64_MIN;
2888
    }
2889

    
2890
    if (duration) {
2891
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2892
    } else {
2893
        dt.tm_isdst = -1;       /* unknown */
2894
        if (is_utc) {
2895
            t = mktimegm(&dt);
2896
        } else {
2897
            t = mktime(&dt);
2898
        }
2899
    }
2900

    
2901
    t *= 1000000;
2902

    
2903
    /* parse the .m... part */
2904
    if (*q == '.') {
2905
        int val, n;
2906
        q++;
2907
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2908
            if (!isdigit(*q))
2909
                break;
2910
            val += n * (*q - '0');
2911
        }
2912
        t += val;
2913
    }
2914
    return negative ? -t : t;
2915
}
2916

    
2917
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2918
{
2919
    const char *p;
2920
    char tag[128], *q;
2921

    
2922
    p = info;
2923
    if (*p == '?')
2924
        p++;
2925
    for(;;) {
2926
        q = tag;
2927
        while (*p != '\0' && *p != '=' && *p != '&') {
2928
            if ((q - tag) < sizeof(tag) - 1)
2929
                *q++ = *p;
2930
            p++;
2931
        }
2932
        *q = '\0';
2933
        q = arg;
2934
        if (*p == '=') {
2935
            p++;
2936
            while (*p != '&' && *p != '\0') {
2937
                if ((q - arg) < arg_size - 1) {
2938
                    if (*p == '+')
2939
                        *q++ = ' ';
2940
                    else
2941
                        *q++ = *p;
2942
                }
2943
                p++;
2944
            }
2945
            *q = '\0';
2946
        }
2947
        if (!strcmp(tag, tag1))
2948
            return 1;
2949
        if (*p != '&')
2950
            break;
2951
        p++;
2952
    }
2953
    return 0;
2954
}
2955

    
2956
int av_get_frame_filename(char *buf, int buf_size,
2957
                          const char *path, int number)
2958
{
2959
    const char *p;
2960
    char *q, buf1[20], c;
2961
    int nd, len, percentd_found;
2962

    
2963
    q = buf;
2964
    p = path;
2965
    percentd_found = 0;
2966
    for(;;) {
2967
        c = *p++;
2968
        if (c == '\0')
2969
            break;
2970
        if (c == '%') {
2971
            do {
2972
                nd = 0;
2973
                while (isdigit(*p)) {
2974
                    nd = nd * 10 + *p++ - '0';
2975
                }
2976
                c = *p++;
2977
            } while (isdigit(c));
2978

    
2979
            switch(c) {
2980
            case '%':
2981
                goto addchar;
2982
            case 'd':
2983
                if (percentd_found)
2984
                    goto fail;
2985
                percentd_found = 1;
2986
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2987
                len = strlen(buf1);
2988
                if ((q - buf + len) > buf_size - 1)
2989
                    goto fail;
2990
                memcpy(q, buf1, len);
2991
                q += len;
2992
                break;
2993
            default:
2994
                goto fail;
2995
            }
2996
        } else {
2997
        addchar:
2998
            if ((q - buf) < buf_size - 1)
2999
                *q++ = c;
3000
        }
3001
    }
3002
    if (!percentd_found)
3003
        goto fail;
3004
    *q = '\0';
3005
    return 0;
3006
 fail:
3007
    *q = '\0';
3008
    return -1;
3009
}
3010

    
3011
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3012
{
3013
    int len, i, j, c;
3014
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3015

    
3016
    for(i=0;i<size;i+=16) {
3017
        len = size - i;
3018
        if (len > 16)
3019
            len = 16;
3020
        PRINT("%08x ", i);
3021
        for(j=0;j<16;j++) {
3022
            if (j < len)
3023
                PRINT(" %02x", buf[i+j]);
3024
            else
3025
                PRINT("   ");
3026
        }
3027
        PRINT(" ");
3028
        for(j=0;j<len;j++) {
3029
            c = buf[i+j];
3030
            if (c < ' ' || c > '~')
3031
                c = '.';
3032
            PRINT("%c", c);
3033
        }
3034
        PRINT("\n");
3035
    }
3036
#undef PRINT
3037
}
3038

    
3039
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3040
{
3041
    hex_dump_internal(NULL, f, 0, buf, size);
3042
}
3043

    
3044
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3045
{
3046
    hex_dump_internal(avcl, NULL, level, buf, size);
3047
}
3048

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

    
3075
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3076
{
3077
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3078
}
3079

    
3080
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3081
{
3082
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3083
}
3084

    
3085
void url_split(char *proto, int proto_size,
3086
               char *authorization, int authorization_size,
3087
               char *hostname, int hostname_size,
3088
               int *port_ptr,
3089
               char *path, int path_size,
3090
               const char *url)
3091
{
3092
    const char *p, *ls, *at, *col, *brk;
3093

    
3094
    if (port_ptr)               *port_ptr = -1;
3095
    if (proto_size > 0)         proto[0] = 0;
3096
    if (authorization_size > 0) authorization[0] = 0;
3097
    if (hostname_size > 0)      hostname[0] = 0;
3098
    if (path_size > 0)          path[0] = 0;
3099

    
3100
    /* parse protocol */
3101
    if ((p = strchr(url, ':'))) {
3102
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3103
        p++; /* skip ':' */
3104
        if (*p == '/') p++;
3105
        if (*p == '/') p++;
3106
    } else {
3107
        /* no protocol means plain filename */
3108
        av_strlcpy(path, url, path_size);
3109
        return;
3110
    }
3111

    
3112
    /* separate path from hostname */
3113
    ls = strchr(p, '/');
3114
    if(!ls)
3115
        ls = strchr(p, '?');
3116
    if(ls)
3117
        av_strlcpy(path, ls, path_size);
3118
    else
3119
        ls = &p[strlen(p)]; // XXX
3120

    
3121
    /* the rest is hostname, use that to parse auth/port */
3122
    if (ls != p) {
3123
        /* authorization (user[:pass]@hostname) */
3124
        if ((at = strchr(p, '@')) && at < ls) {
3125
            av_strlcpy(authorization, p,
3126
                       FFMIN(authorization_size, at + 1 - p));
3127
            p = at + 1; /* skip '@' */
3128
        }
3129

    
3130
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3131
            /* [host]:port */
3132
            av_strlcpy(hostname, p + 1,
3133
                       FFMIN(hostname_size, brk - p));
3134
            if (brk[1] == ':' && port_ptr)
3135
                *port_ptr = atoi(brk + 2);
3136
        } else if ((col = strchr(p, ':')) && col < ls) {
3137
            av_strlcpy(hostname, p,
3138
                       FFMIN(col + 1 - p, hostname_size));
3139
            if (port_ptr) *port_ptr = atoi(col + 1);
3140
        } else
3141
            av_strlcpy(hostname, p,
3142
                       FFMIN(ls + 1 - p, hostname_size));
3143
    }
3144
}
3145

    
3146
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3147
                     int pts_num, int pts_den)
3148
{
3149
    s->pts_wrap_bits = pts_wrap_bits;
3150
    s->time_base.num = pts_num;
3151
    s->time_base.den = pts_den;
3152
}
3153

    
3154
/* fraction handling */
3155

    
3156
/**
3157
 * f = val + (num / den) + 0.5.
3158
 *
3159
 * 'num' is normalized so that it is such as 0 <= num < den.
3160
 *
3161
 * @param f fractional number
3162
 * @param val integer value
3163
 * @param num must be >= 0
3164
 * @param den must be >= 1
3165
 */
3166
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3167
{
3168
    num += (den >> 1);
3169
    if (num >= den) {
3170
        val += num / den;
3171
        num = num % den;
3172
    }
3173
    f->val = val;
3174
    f->num = num;
3175
    f->den = den;
3176
}
3177

    
3178
/**
3179
 * Fractional addition to f: f = f + (incr / f->den).
3180
 *
3181
 * @param f fractional number
3182
 * @param incr increment, can be positive or negative
3183
 */
3184
static void av_frac_add(AVFrac *f, int64_t incr)
3185
{
3186
    int64_t num, den;
3187

    
3188
    num = f->num + incr;
3189
    den = f->den;
3190
    if (num < 0) {
3191
        f->val += num / den;
3192
        num = num % den;
3193
        if (num < 0) {
3194
            num += den;
3195
            f->val--;
3196
        }
3197
    } else if (num >= den) {
3198
        f->val += num / den;
3199
        num = num % den;
3200
    }
3201
    f->num = num;
3202
}