Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 45b2b05f

History | View | Annotate | Download (96.5 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
        av_freep(&ic->priv_data);
409
    }
410
    av_free(ic);
411
    *ic_ptr = NULL;
412
    return err;
413
}
414

    
415
/** size of probe buffer, for guessing file type from file contents */
416
#define PROBE_BUF_MIN 2048
417
#define PROBE_BUF_MAX (1<<20)
418

    
419
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
420
                       AVInputFormat *fmt,
421
                       int buf_size,
422
                       AVFormatParameters *ap)
423
{
424
    int err, probe_size;
425
    AVProbeData probe_data, *pd = &probe_data;
426
    ByteIOContext *pb = NULL;
427

    
428
    pd->filename = "";
429
    if (filename)
430
        pd->filename = filename;
431
    pd->buf = NULL;
432
    pd->buf_size = 0;
433

    
434
    if (!fmt) {
435
        /* guess format if no file can be opened */
436
        fmt = av_probe_input_format(pd, 0);
437
    }
438

    
439
    /* Do not open file if the format does not need it. XXX: specific
440
       hack needed to handle RTSP/TCP */
441
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
442
        /* if no file needed do not try to open one */
443
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
444
            goto fail;
445
        }
446
        if (buf_size > 0) {
447
            url_setbufsize(pb, buf_size);
448
        }
449

    
450
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
451
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
452
            /* read probe data */
453
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
454
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
455
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
456
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
457
                url_fclose(pb);
458
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
459
                    pb = NULL;
460
                    err = AVERROR(EIO);
461
                    goto fail;
462
                }
463
            }
464
            /* guess file format */
465
            fmt = av_probe_input_format2(pd, 1, &score);
466
        }
467
        av_freep(&pd->buf);
468
    }
469

    
470
    /* if still no format found, error */
471
    if (!fmt) {
472
        err = AVERROR_NOFMT;
473
        goto fail;
474
    }
475

    
476
    /* check filename in case an image number is expected */
477
    if (fmt->flags & AVFMT_NEEDNUMBER) {
478
        if (!av_filename_number_test(filename)) {
479
            err = AVERROR_NUMEXPECTED;
480
            goto fail;
481
        }
482
    }
483
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
484
    if (err)
485
        goto fail;
486
    return 0;
487
 fail:
488
    av_freep(&pd->buf);
489
    if (pb)
490
        url_fclose(pb);
491
    *ic_ptr = NULL;
492
    return err;
493

    
494
}
495

    
496
/*******************************************************/
497

    
498
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
499
{
500
    int ret;
501
    AVStream *st;
502
    av_init_packet(pkt);
503
    ret= s->iformat->read_packet(s, pkt);
504
    if (ret < 0)
505
        return ret;
506
    st= s->streams[pkt->stream_index];
507

    
508
    switch(st->codec->codec_type){
509
    case CODEC_TYPE_VIDEO:
510
        if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
511
        break;
512
    case CODEC_TYPE_AUDIO:
513
        if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
514
        break;
515
    case CODEC_TYPE_SUBTITLE:
516
        if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
517
        break;
518
    }
519

    
520
    return ret;
521
}
522

    
523
/**********************************************************/
524

    
525
/**
526
 * Get the number of samples of an audio frame. Return -1 on error.
527
 */
528
static int get_audio_frame_size(AVCodecContext *enc, int size)
529
{
530
    int frame_size;
531

    
532
    if (enc->frame_size <= 1) {
533
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
534

    
535
        if (bits_per_sample) {
536
            if (enc->channels == 0)
537
                return -1;
538
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
539
        } else {
540
            /* used for example by ADPCM codecs */
541
            if (enc->bit_rate == 0)
542
                return -1;
543
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
544
        }
545
    } else {
546
        frame_size = enc->frame_size;
547
    }
548
    return frame_size;
549
}
550

    
551

    
552
/**
553
 * Return the frame duration in seconds. Return 0 if not available.
554
 */
555
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
556
                                   AVCodecParserContext *pc, AVPacket *pkt)
557
{
558
    int frame_size;
559

    
560
    *pnum = 0;
561
    *pden = 0;
562
    switch(st->codec->codec_type) {
563
    case CODEC_TYPE_VIDEO:
564
        if(st->time_base.num*1000LL > st->time_base.den){
565
            *pnum = st->time_base.num;
566
            *pden = st->time_base.den;
567
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
568
            *pnum = st->codec->time_base.num;
569
            *pden = st->codec->time_base.den;
570
            if (pc && pc->repeat_pict) {
571
                *pden *= 2;
572
                *pnum = (*pnum) * (2 + pc->repeat_pict);
573
            }
574
        }
575
        break;
576
    case CODEC_TYPE_AUDIO:
577
        frame_size = get_audio_frame_size(st->codec, pkt->size);
578
        if (frame_size < 0)
579
            break;
580
        *pnum = frame_size;
581
        *pden = st->codec->sample_rate;
582
        break;
583
    default:
584
        break;
585
    }
586
}
587

    
588
static int is_intra_only(AVCodecContext *enc){
589
    if(enc->codec_type == CODEC_TYPE_AUDIO){
590
        return 1;
591
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
592
        switch(enc->codec_id){
593
        case CODEC_ID_MJPEG:
594
        case CODEC_ID_MJPEGB:
595
        case CODEC_ID_LJPEG:
596
        case CODEC_ID_RAWVIDEO:
597
        case CODEC_ID_DVVIDEO:
598
        case CODEC_ID_HUFFYUV:
599
        case CODEC_ID_FFVHUFF:
600
        case CODEC_ID_ASV1:
601
        case CODEC_ID_ASV2:
602
        case CODEC_ID_VCR1:
603
            return 1;
604
        default: break;
605
        }
606
    }
607
    return 0;
608
}
609

    
610
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
611
                                      int64_t dts, int64_t pts)
612
{
613
    AVStream *st= s->streams[stream_index];
614
    AVPacketList *pktl= s->packet_buffer;
615

    
616
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
617
        return;
618

    
619
    st->first_dts= dts - st->cur_dts;
620
    st->cur_dts= dts;
621

    
622
    for(; pktl; pktl= pktl->next){
623
        if(pktl->pkt.stream_index != stream_index)
624
            continue;
625
        //FIXME think more about this check
626
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
627
            pktl->pkt.pts += st->first_dts;
628

    
629
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
630
            pktl->pkt.dts += st->first_dts;
631

    
632
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
633
            st->start_time= pktl->pkt.pts;
634
    }
635
    if (st->start_time == AV_NOPTS_VALUE)
636
        st->start_time = pts;
637
}
638

    
639
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
640
{
641
    AVPacketList *pktl= s->packet_buffer;
642
    int64_t cur_dts= 0;
643

    
644
    if(st->first_dts != AV_NOPTS_VALUE){
645
        cur_dts= st->first_dts;
646
        for(; pktl; pktl= pktl->next){
647
            if(pktl->pkt.stream_index == pkt->stream_index){
648
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
649
                    break;
650
                cur_dts -= pkt->duration;
651
            }
652
        }
653
        pktl= s->packet_buffer;
654
        st->first_dts = cur_dts;
655
    }else if(st->cur_dts)
656
        return;
657

    
658
    for(; pktl; pktl= pktl->next){
659
        if(pktl->pkt.stream_index != pkt->stream_index)
660
            continue;
661
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
662
           && !pktl->pkt.duration){
663
            pktl->pkt.dts= cur_dts;
664
            if(!st->codec->has_b_frames)
665
                pktl->pkt.pts= cur_dts;
666
            cur_dts += pkt->duration;
667
            pktl->pkt.duration= pkt->duration;
668
        }else
669
            break;
670
    }
671
    if(st->first_dts == AV_NOPTS_VALUE)
672
        st->cur_dts= cur_dts;
673
}
674

    
675
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
676
                               AVCodecParserContext *pc, AVPacket *pkt)
677
{
678
    int num, den, presentation_delayed, delay, i;
679
    int64_t offset;
680

    
681
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
682
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
683
        pkt->dts -= 1LL<<st->pts_wrap_bits;
684
    }
685

    
686
    if (pkt->duration == 0) {
687
        compute_frame_duration(&num, &den, st, pc, pkt);
688
        if (den && num) {
689
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
690

    
691
            if(pkt->duration != 0 && s->packet_buffer)
692
                update_initial_durations(s, st, pkt);
693
        }
694
    }
695

    
696
    /* correct timestamps with byte offset if demuxers only have timestamps
697
       on packet boundaries */
698
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
699
        /* this will estimate bitrate based on this frame's duration and size */
700
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
701
        if(pkt->pts != AV_NOPTS_VALUE)
702
            pkt->pts += offset;
703
        if(pkt->dts != AV_NOPTS_VALUE)
704
            pkt->dts += offset;
705
    }
706

    
707
    /* do we have a video B-frame ? */
708
    delay= st->codec->has_b_frames;
709
    presentation_delayed = 0;
710
    /* XXX: need has_b_frame, but cannot get it if the codec is
711
        not initialized */
712
    if (delay &&
713
        pc && pc->pict_type != FF_B_TYPE)
714
        presentation_delayed = 1;
715
    /* This may be redundant, but it should not hurt. */
716
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
717
        presentation_delayed = 1;
718

    
719
    if(st->cur_dts == AV_NOPTS_VALUE){
720
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
721
    }
722

    
723
//    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);
724
    /* interpolate PTS and DTS if they are not present */
725
    if(delay==0 || (delay==1 && pc)){
726
        if (presentation_delayed) {
727
            /* DTS = decompression timestamp */
728
            /* PTS = presentation timestamp */
729
            if (pkt->dts == AV_NOPTS_VALUE)
730
                pkt->dts = st->last_IP_pts;
731
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
732
            if (pkt->dts == AV_NOPTS_VALUE)
733
                pkt->dts = st->cur_dts;
734

    
735
            /* this is tricky: the dts must be incremented by the duration
736
            of the frame we are displaying, i.e. the last I- or P-frame */
737
            if (st->last_IP_duration == 0)
738
                st->last_IP_duration = pkt->duration;
739
            st->cur_dts = pkt->dts + st->last_IP_duration;
740
            st->last_IP_duration  = pkt->duration;
741
            st->last_IP_pts= pkt->pts;
742
            /* cannot compute PTS if not present (we can compute it only
743
            by knowing the future */
744
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
745
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
746
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
747
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
748
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
749
                    pkt->pts += pkt->duration;
750
    //                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);
751
                }
752
            }
753

    
754
            /* presentation is not delayed : PTS and DTS are the same */
755
            if(pkt->pts == AV_NOPTS_VALUE)
756
                pkt->pts = pkt->dts;
757
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
758
            if(pkt->pts == AV_NOPTS_VALUE)
759
                pkt->pts = st->cur_dts;
760
            pkt->dts = pkt->pts;
761
            st->cur_dts = pkt->pts + pkt->duration;
762
        }
763
    }
764

    
765
    if(pkt->pts != AV_NOPTS_VALUE){
766
        st->pts_buffer[0]= pkt->pts;
767
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
768
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
769
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
770
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
771
        if(pkt->dts == AV_NOPTS_VALUE)
772
            pkt->dts= st->pts_buffer[0];
773
        if(delay>1){
774
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
775
        }
776
        if(pkt->dts > st->cur_dts)
777
            st->cur_dts = pkt->dts;
778
    }
779

    
780
//    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);
781

    
782
    /* update flags */
783
    if(is_intra_only(st->codec))
784
        pkt->flags |= PKT_FLAG_KEY;
785
    else if (pc) {
786
        pkt->flags = 0;
787
        /* keyframe computation */
788
            if (pc->pict_type == FF_I_TYPE)
789
                pkt->flags |= PKT_FLAG_KEY;
790
    }
791
}
792

    
793
void av_destruct_packet_nofree(AVPacket *pkt)
794
{
795
    pkt->data = NULL; pkt->size = 0;
796
}
797

    
798
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
799
{
800
    AVStream *st;
801
    int len, ret, i;
802

    
803
    av_init_packet(pkt);
804

    
805
    for(;;) {
806
        /* select current input stream component */
807
        st = s->cur_st;
808
        if (st) {
809
            if (!st->need_parsing || !st->parser) {
810
                /* no parsing needed: we just output the packet as is */
811
                /* raw data support */
812
                *pkt = s->cur_pkt;
813
                compute_pkt_fields(s, st, NULL, pkt);
814
                s->cur_st = NULL;
815
                break;
816
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
817
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
818
                                      s->cur_ptr, s->cur_len,
819
                                      s->cur_pkt.pts, s->cur_pkt.dts);
820
                s->cur_pkt.pts = AV_NOPTS_VALUE;
821
                s->cur_pkt.dts = AV_NOPTS_VALUE;
822
                /* increment read pointer */
823
                s->cur_ptr += len;
824
                s->cur_len -= len;
825

    
826
                /* return packet if any */
827
                if (pkt->size) {
828
                got_packet:
829
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
830
                    pkt->duration = 0;
831
                    pkt->stream_index = st->index;
832
                    pkt->pts = st->parser->pts;
833
                    pkt->dts = st->parser->dts;
834
                    pkt->destruct = av_destruct_packet_nofree;
835
                    compute_pkt_fields(s, st, st->parser, pkt);
836

    
837
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
838
                        ff_reduce_index(s, st->index);
839
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
840
                                           0, 0, AVINDEX_KEYFRAME);
841
                    }
842

    
843
                    break;
844
                }
845
            } else {
846
                /* free packet */
847
                av_free_packet(&s->cur_pkt);
848
                s->cur_st = NULL;
849
            }
850
        } else {
851
            /* read next packet */
852
            ret = av_read_packet(s, &s->cur_pkt);
853
            if (ret < 0) {
854
                if (ret == AVERROR(EAGAIN))
855
                    return ret;
856
                /* return the last frames, if any */
857
                for(i = 0; i < s->nb_streams; i++) {
858
                    st = s->streams[i];
859
                    if (st->parser && st->need_parsing) {
860
                        av_parser_parse(st->parser, st->codec,
861
                                        &pkt->data, &pkt->size,
862
                                        NULL, 0,
863
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
864
                        if (pkt->size)
865
                            goto got_packet;
866
                    }
867
                }
868
                /* no more packets: really terminate parsing */
869
                return ret;
870
            }
871

    
872
            if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
873
               s->cur_pkt.dts != AV_NOPTS_VALUE &&
874
               s->cur_pkt.pts < s->cur_pkt.dts){
875
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
876
                    s->cur_pkt.stream_index,
877
                    s->cur_pkt.pts,
878
                    s->cur_pkt.dts,
879
                    s->cur_pkt.size);
880
//                av_free_packet(&s->cur_pkt);
881
//                return -1;
882
            }
883

    
884
            st = s->streams[s->cur_pkt.stream_index];
885
            if(s->debug & FF_FDEBUG_TS)
886
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
887
                    s->cur_pkt.stream_index,
888
                    s->cur_pkt.pts,
889
                    s->cur_pkt.dts,
890
                    s->cur_pkt.size);
891

    
892
            s->cur_st = st;
893
            s->cur_ptr = s->cur_pkt.data;
894
            s->cur_len = s->cur_pkt.size;
895
            if (st->need_parsing && !st->parser) {
896
                st->parser = av_parser_init(st->codec->codec_id);
897
                if (!st->parser) {
898
                    /* no parser available: just output the raw packets */
899
                    st->need_parsing = AVSTREAM_PARSE_NONE;
900
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
901
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
902
                }
903
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
904
                    st->parser->next_frame_offset=
905
                    st->parser->cur_offset= s->cur_pkt.pos;
906
                }
907
            }
908
        }
909
    }
910
    if(s->debug & FF_FDEBUG_TS)
911
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
912
            pkt->stream_index,
913
            pkt->pts,
914
            pkt->dts,
915
            pkt->size);
916

    
917
    return 0;
918
}
919

    
920
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
921
    AVPacketList *pktl= s->packet_buffer;
922
    AVPacketList **plast_pktl= &s->packet_buffer;
923

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

    
926
    pktl = av_mallocz(sizeof(AVPacketList));
927
    if (!pktl)
928
        return NULL;
929

    
930
    /* add the packet in the buffered packet list */
931
    *plast_pktl = pktl;
932
    pktl->pkt= *pkt;
933
    return &pktl->pkt;
934
}
935

    
936
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
937
{
938
    AVPacketList *pktl;
939
    int eof=0;
940
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
941

    
942
    for(;;){
943
        pktl = s->packet_buffer;
944
        if (pktl) {
945
            AVPacket *next_pkt= &pktl->pkt;
946

    
947
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
948
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
949
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
950
                       && next_pkt->dts < pktl->pkt.dts
951
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
952
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
953
                        next_pkt->pts= pktl->pkt.dts;
954
                    }
955
                    pktl= pktl->next;
956
                }
957
                pktl = s->packet_buffer;
958
            }
959

    
960
            if(   next_pkt->pts != AV_NOPTS_VALUE
961
               || next_pkt->dts == AV_NOPTS_VALUE
962
               || !genpts || eof){
963
                /* read packet from packet buffer, if there is data */
964
                *pkt = *next_pkt;
965
                s->packet_buffer = pktl->next;
966
                av_free(pktl);
967
                return 0;
968
            }
969
        }
970
        if(genpts){
971
            int ret= av_read_frame_internal(s, pkt);
972
            if(ret<0){
973
                if(pktl && ret != AVERROR(EAGAIN)){
974
                    eof=1;
975
                    continue;
976
                }else
977
                    return ret;
978
            }
979

    
980
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
981
                return AVERROR(ENOMEM);
982
        }else{
983
            assert(!s->packet_buffer);
984
            return av_read_frame_internal(s, pkt);
985
        }
986
    }
987
}
988

    
989
/* XXX: suppress the packet queue */
990
static void flush_packet_queue(AVFormatContext *s)
991
{
992
    AVPacketList *pktl;
993

    
994
    for(;;) {
995
        pktl = s->packet_buffer;
996
        if (!pktl)
997
            break;
998
        s->packet_buffer = pktl->next;
999
        av_free_packet(&pktl->pkt);
1000
        av_free(pktl);
1001
    }
1002
}
1003

    
1004
/*******************************************************/
1005
/* seek support */
1006

    
1007
int av_find_default_stream_index(AVFormatContext *s)
1008
{
1009
    int first_audio_index = -1;
1010
    int i;
1011
    AVStream *st;
1012

    
1013
    if (s->nb_streams <= 0)
1014
        return -1;
1015
    for(i = 0; i < s->nb_streams; i++) {
1016
        st = s->streams[i];
1017
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1018
            return i;
1019
        }
1020
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1021
            first_audio_index = i;
1022
    }
1023
    return first_audio_index >= 0 ? first_audio_index : 0;
1024
}
1025

    
1026
/**
1027
 * Flush the frame reader.
1028
 */
1029
static void av_read_frame_flush(AVFormatContext *s)
1030
{
1031
    AVStream *st;
1032
    int i;
1033

    
1034
    flush_packet_queue(s);
1035

    
1036
    /* free previous packet */
1037
    if (s->cur_st) {
1038
        if (s->cur_st->parser)
1039
            av_free_packet(&s->cur_pkt);
1040
        s->cur_st = NULL;
1041
    }
1042
    /* fail safe */
1043
    s->cur_ptr = NULL;
1044
    s->cur_len = 0;
1045

    
1046
    /* for each stream, reset read state */
1047
    for(i = 0; i < s->nb_streams; i++) {
1048
        st = s->streams[i];
1049

    
1050
        if (st->parser) {
1051
            av_parser_close(st->parser);
1052
            st->parser = NULL;
1053
        }
1054
        st->last_IP_pts = AV_NOPTS_VALUE;
1055
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1056
    }
1057
}
1058

    
1059
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1060
    int i;
1061

    
1062
    for(i = 0; i < s->nb_streams; i++) {
1063
        AVStream *st = s->streams[i];
1064

    
1065
        st->cur_dts = av_rescale(timestamp,
1066
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1067
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1068
    }
1069
}
1070

    
1071
void ff_reduce_index(AVFormatContext *s, int stream_index)
1072
{
1073
    AVStream *st= s->streams[stream_index];
1074
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1075

    
1076
    if((unsigned)st->nb_index_entries >= max_entries){
1077
        int i;
1078
        for(i=0; 2*i<st->nb_index_entries; i++)
1079
            st->index_entries[i]= st->index_entries[2*i];
1080
        st->nb_index_entries= i;
1081
    }
1082
}
1083

    
1084
int av_add_index_entry(AVStream *st,
1085
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1086
{
1087
    AVIndexEntry *entries, *ie;
1088
    int index;
1089

    
1090
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1091
        return -1;
1092

    
1093
    entries = av_fast_realloc(st->index_entries,
1094
                              &st->index_entries_allocated_size,
1095
                              (st->nb_index_entries + 1) *
1096
                              sizeof(AVIndexEntry));
1097
    if(!entries)
1098
        return -1;
1099

    
1100
    st->index_entries= entries;
1101

    
1102
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1103

    
1104
    if(index<0){
1105
        index= st->nb_index_entries++;
1106
        ie= &entries[index];
1107
        assert(index==0 || ie[-1].timestamp < timestamp);
1108
    }else{
1109
        ie= &entries[index];
1110
        if(ie->timestamp != timestamp){
1111
            if(ie->timestamp <= timestamp)
1112
                return -1;
1113
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1114
            st->nb_index_entries++;
1115
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1116
            distance= ie->min_distance;
1117
    }
1118

    
1119
    ie->pos = pos;
1120
    ie->timestamp = timestamp;
1121
    ie->min_distance= distance;
1122
    ie->size= size;
1123
    ie->flags = flags;
1124

    
1125
    return index;
1126
}
1127

    
1128
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1129
                              int flags)
1130
{
1131
    AVIndexEntry *entries= st->index_entries;
1132
    int nb_entries= st->nb_index_entries;
1133
    int a, b, m;
1134
    int64_t timestamp;
1135

    
1136
    a = - 1;
1137
    b = nb_entries;
1138

    
1139
    while (b - a > 1) {
1140
        m = (a + b) >> 1;
1141
        timestamp = entries[m].timestamp;
1142
        if(timestamp >= wanted_timestamp)
1143
            b = m;
1144
        if(timestamp <= wanted_timestamp)
1145
            a = m;
1146
    }
1147
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1148

    
1149
    if(!(flags & AVSEEK_FLAG_ANY)){
1150
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1151
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1152
        }
1153
    }
1154

    
1155
    if(m == nb_entries)
1156
        return -1;
1157
    return  m;
1158
}
1159

    
1160
#define DEBUG_SEEK
1161

    
1162
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1163
    AVInputFormat *avif= s->iformat;
1164
    int64_t pos_min, pos_max, pos, pos_limit;
1165
    int64_t ts_min, ts_max, ts;
1166
    int index;
1167
    AVStream *st;
1168

    
1169
    if (stream_index < 0)
1170
        return -1;
1171

    
1172
#ifdef DEBUG_SEEK
1173
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1174
#endif
1175

    
1176
    ts_max=
1177
    ts_min= AV_NOPTS_VALUE;
1178
    pos_limit= -1; //gcc falsely says it may be uninitialized
1179

    
1180
    st= s->streams[stream_index];
1181
    if(st->index_entries){
1182
        AVIndexEntry *e;
1183

    
1184
        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()
1185
        index= FFMAX(index, 0);
1186
        e= &st->index_entries[index];
1187

    
1188
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1189
            pos_min= e->pos;
1190
            ts_min= e->timestamp;
1191
#ifdef DEBUG_SEEK
1192
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1193
               pos_min,ts_min);
1194
#endif
1195
        }else{
1196
            assert(index==0);
1197
        }
1198

    
1199
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1200
        assert(index < st->nb_index_entries);
1201
        if(index >= 0){
1202
            e= &st->index_entries[index];
1203
            assert(e->timestamp >= target_ts);
1204
            pos_max= e->pos;
1205
            ts_max= e->timestamp;
1206
            pos_limit= pos_max - e->min_distance;
1207
#ifdef DEBUG_SEEK
1208
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1209
               pos_max,pos_limit, ts_max);
1210
#endif
1211
        }
1212
    }
1213

    
1214
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1215
    if(pos<0)
1216
        return -1;
1217

    
1218
    /* do the seek */
1219
    url_fseek(s->pb, pos, SEEK_SET);
1220

    
1221
    av_update_cur_dts(s, st, ts);
1222

    
1223
    return 0;
1224
}
1225

    
1226
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 )){
1227
    int64_t pos, ts;
1228
    int64_t start_pos, filesize;
1229
    int no_change;
1230

    
1231
#ifdef DEBUG_SEEK
1232
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1233
#endif
1234

    
1235
    if(ts_min == AV_NOPTS_VALUE){
1236
        pos_min = s->data_offset;
1237
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1238
        if (ts_min == AV_NOPTS_VALUE)
1239
            return -1;
1240
    }
1241

    
1242
    if(ts_max == AV_NOPTS_VALUE){
1243
        int step= 1024;
1244
        filesize = url_fsize(s->pb);
1245
        pos_max = filesize - 1;
1246
        do{
1247
            pos_max -= step;
1248
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1249
            step += step;
1250
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1251
        if (ts_max == AV_NOPTS_VALUE)
1252
            return -1;
1253

    
1254
        for(;;){
1255
            int64_t tmp_pos= pos_max + 1;
1256
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1257
            if(tmp_ts == AV_NOPTS_VALUE)
1258
                break;
1259
            ts_max= tmp_ts;
1260
            pos_max= tmp_pos;
1261
            if(tmp_pos >= filesize)
1262
                break;
1263
        }
1264
        pos_limit= pos_max;
1265
    }
1266

    
1267
    if(ts_min > ts_max){
1268
        return -1;
1269
    }else if(ts_min == ts_max){
1270
        pos_limit= pos_min;
1271
    }
1272

    
1273
    no_change=0;
1274
    while (pos_min < pos_limit) {
1275
#ifdef DEBUG_SEEK
1276
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1277
               pos_min, pos_max,
1278
               ts_min, ts_max);
1279
#endif
1280
        assert(pos_limit <= pos_max);
1281

    
1282
        if(no_change==0){
1283
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1284
            // interpolate position (better than dichotomy)
1285
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1286
                + pos_min - approximate_keyframe_distance;
1287
        }else if(no_change==1){
1288
            // bisection, if interpolation failed to change min or max pos last time
1289
            pos = (pos_min + pos_limit)>>1;
1290
        }else{
1291
            /* linear search if bisection failed, can only happen if there
1292
               are very few or no keyframes between min/max */
1293
            pos=pos_min;
1294
        }
1295
        if(pos <= pos_min)
1296
            pos= pos_min + 1;
1297
        else if(pos > pos_limit)
1298
            pos= pos_limit;
1299
        start_pos= pos;
1300

    
1301
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1302
        if(pos == pos_max)
1303
            no_change++;
1304
        else
1305
            no_change=0;
1306
#ifdef DEBUG_SEEK
1307
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);
1308
#endif
1309
        if(ts == AV_NOPTS_VALUE){
1310
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1311
            return -1;
1312
        }
1313
        assert(ts != AV_NOPTS_VALUE);
1314
        if (target_ts <= ts) {
1315
            pos_limit = start_pos - 1;
1316
            pos_max = pos;
1317
            ts_max = ts;
1318
        }
1319
        if (target_ts >= ts) {
1320
            pos_min = pos;
1321
            ts_min = ts;
1322
        }
1323
    }
1324

    
1325
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1326
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1327
#ifdef DEBUG_SEEK
1328
    pos_min = pos;
1329
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1330
    pos_min++;
1331
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1332
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1333
           pos, ts_min, target_ts, ts_max);
1334
#endif
1335
    *ts_ret= ts;
1336
    return pos;
1337
}
1338

    
1339
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1340
    int64_t pos_min, pos_max;
1341
#if 0
1342
    AVStream *st;
1343

1344
    if (stream_index < 0)
1345
        return -1;
1346

1347
    st= s->streams[stream_index];
1348
#endif
1349

    
1350
    pos_min = s->data_offset;
1351
    pos_max = url_fsize(s->pb) - 1;
1352

    
1353
    if     (pos < pos_min) pos= pos_min;
1354
    else if(pos > pos_max) pos= pos_max;
1355

    
1356
    url_fseek(s->pb, pos, SEEK_SET);
1357

    
1358
#if 0
1359
    av_update_cur_dts(s, st, ts);
1360
#endif
1361
    return 0;
1362
}
1363

    
1364
static int av_seek_frame_generic(AVFormatContext *s,
1365
                                 int stream_index, int64_t timestamp, int flags)
1366
{
1367
    int index;
1368
    AVStream *st;
1369
    AVIndexEntry *ie;
1370

    
1371
    st = s->streams[stream_index];
1372

    
1373
    index = av_index_search_timestamp(st, timestamp, flags);
1374

    
1375
    if(index < 0 || index==st->nb_index_entries-1){
1376
        int i;
1377
        AVPacket pkt;
1378

    
1379
        if(st->nb_index_entries){
1380
            assert(st->index_entries);
1381
            ie= &st->index_entries[st->nb_index_entries-1];
1382
            url_fseek(s->pb, ie->pos, SEEK_SET);
1383
            av_update_cur_dts(s, st, ie->timestamp);
1384
        }else
1385
            url_fseek(s->pb, 0, SEEK_SET);
1386

    
1387
        for(i=0;; i++) {
1388
            int ret = av_read_frame(s, &pkt);
1389
            if(ret<0)
1390
                break;
1391
            av_free_packet(&pkt);
1392
            if(stream_index == pkt.stream_index){
1393
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1394
                    break;
1395
            }
1396
        }
1397
        index = av_index_search_timestamp(st, timestamp, flags);
1398
    }
1399
    if (index < 0)
1400
        return -1;
1401

    
1402
    av_read_frame_flush(s);
1403
    if (s->iformat->read_seek){
1404
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1405
            return 0;
1406
    }
1407
    ie = &st->index_entries[index];
1408
    url_fseek(s->pb, ie->pos, SEEK_SET);
1409

    
1410
    av_update_cur_dts(s, st, ie->timestamp);
1411

    
1412
    return 0;
1413
}
1414

    
1415
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1416
{
1417
    int ret;
1418
    AVStream *st;
1419

    
1420
    av_read_frame_flush(s);
1421

    
1422
    if(flags & AVSEEK_FLAG_BYTE)
1423
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1424

    
1425
    if(stream_index < 0){
1426
        stream_index= av_find_default_stream_index(s);
1427
        if(stream_index < 0)
1428
            return -1;
1429

    
1430
        st= s->streams[stream_index];
1431
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1432
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1433
    }
1434
    st= s->streams[stream_index];
1435

    
1436
    /* first, we try the format specific seek */
1437
    if (s->iformat->read_seek)
1438
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1439
    else
1440
        ret = -1;
1441
    if (ret >= 0) {
1442
        return 0;
1443
    }
1444

    
1445
    if(s->iformat->read_timestamp)
1446
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1447
    else
1448
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1449
}
1450

    
1451
/*******************************************************/
1452

    
1453
/**
1454
 * Returns TRUE if the stream has accurate duration in any stream.
1455
 *
1456
 * @return TRUE if the stream has accurate duration for at least one component.
1457
 */
1458
static int av_has_duration(AVFormatContext *ic)
1459
{
1460
    int i;
1461
    AVStream *st;
1462

    
1463
    for(i = 0;i < ic->nb_streams; i++) {
1464
        st = ic->streams[i];
1465
        if (st->duration != AV_NOPTS_VALUE)
1466
            return 1;
1467
    }
1468
    return 0;
1469
}
1470

    
1471
/**
1472
 * Estimate the stream timings from the one of each components.
1473
 *
1474
 * Also computes the global bitrate if possible.
1475
 */
1476
static void av_update_stream_timings(AVFormatContext *ic)
1477
{
1478
    int64_t start_time, start_time1, end_time, end_time1;
1479
    int64_t duration, duration1;
1480
    int i;
1481
    AVStream *st;
1482

    
1483
    start_time = INT64_MAX;
1484
    end_time = INT64_MIN;
1485
    duration = INT64_MIN;
1486
    for(i = 0;i < ic->nb_streams; i++) {
1487
        st = ic->streams[i];
1488
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1489
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1490
            if (start_time1 < start_time)
1491
                start_time = start_time1;
1492
            if (st->duration != AV_NOPTS_VALUE) {
1493
                end_time1 = start_time1
1494
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1495
                if (end_time1 > end_time)
1496
                    end_time = end_time1;
1497
            }
1498
        }
1499
        if (st->duration != AV_NOPTS_VALUE) {
1500
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1501
            if (duration1 > duration)
1502
                duration = duration1;
1503
        }
1504
    }
1505
    if (start_time != INT64_MAX) {
1506
        ic->start_time = start_time;
1507
        if (end_time != INT64_MIN) {
1508
            if (end_time - start_time > duration)
1509
                duration = end_time - start_time;
1510
        }
1511
    }
1512
    if (duration != INT64_MIN) {
1513
        ic->duration = duration;
1514
        if (ic->file_size > 0) {
1515
            /* compute the bitrate */
1516
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1517
                (double)ic->duration;
1518
        }
1519
    }
1520
}
1521

    
1522
static void fill_all_stream_timings(AVFormatContext *ic)
1523
{
1524
    int i;
1525
    AVStream *st;
1526

    
1527
    av_update_stream_timings(ic);
1528
    for(i = 0;i < ic->nb_streams; i++) {
1529
        st = ic->streams[i];
1530
        if (st->start_time == AV_NOPTS_VALUE) {
1531
            if(ic->start_time != AV_NOPTS_VALUE)
1532
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1533
            if(ic->duration != AV_NOPTS_VALUE)
1534
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1535
        }
1536
    }
1537
}
1538

    
1539
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1540
{
1541
    int64_t filesize, duration;
1542
    int bit_rate, i;
1543
    AVStream *st;
1544

    
1545
    /* if bit_rate is already set, we believe it */
1546
    if (ic->bit_rate == 0) {
1547
        bit_rate = 0;
1548
        for(i=0;i<ic->nb_streams;i++) {
1549
            st = ic->streams[i];
1550
            bit_rate += st->codec->bit_rate;
1551
        }
1552
        ic->bit_rate = bit_rate;
1553
    }
1554

    
1555
    /* if duration is already set, we believe it */
1556
    if (ic->duration == AV_NOPTS_VALUE &&
1557
        ic->bit_rate != 0 &&
1558
        ic->file_size != 0)  {
1559
        filesize = ic->file_size;
1560
        if (filesize > 0) {
1561
            for(i = 0; i < ic->nb_streams; i++) {
1562
                st = ic->streams[i];
1563
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1564
                if (st->duration == AV_NOPTS_VALUE)
1565
                    st->duration = duration;
1566
            }
1567
        }
1568
    }
1569
}
1570

    
1571
#define DURATION_MAX_READ_SIZE 250000
1572

    
1573
/* only usable for MPEG-PS streams */
1574
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1575
{
1576
    AVPacket pkt1, *pkt = &pkt1;
1577
    AVStream *st;
1578
    int read_size, i, ret;
1579
    int64_t end_time;
1580
    int64_t filesize, offset, duration;
1581

    
1582
    /* free previous packet */
1583
    if (ic->cur_st && ic->cur_st->parser)
1584
        av_free_packet(&ic->cur_pkt);
1585
    ic->cur_st = NULL;
1586

    
1587
    /* flush packet queue */
1588
    flush_packet_queue(ic);
1589

    
1590
    for(i=0;i<ic->nb_streams;i++) {
1591
        st = ic->streams[i];
1592
        if (st->parser) {
1593
            av_parser_close(st->parser);
1594
            st->parser= NULL;
1595
        }
1596
    }
1597

    
1598
    /* we read the first packets to get the first PTS (not fully
1599
       accurate, but it is enough now) */
1600
    url_fseek(ic->pb, 0, SEEK_SET);
1601
    read_size = 0;
1602
    for(;;) {
1603
        if (read_size >= DURATION_MAX_READ_SIZE)
1604
            break;
1605
        /* if all info is available, we can stop */
1606
        for(i = 0;i < ic->nb_streams; i++) {
1607
            st = ic->streams[i];
1608
            if (st->start_time == AV_NOPTS_VALUE)
1609
                break;
1610
        }
1611
        if (i == ic->nb_streams)
1612
            break;
1613

    
1614
        ret = av_read_packet(ic, pkt);
1615
        if (ret != 0)
1616
            break;
1617
        read_size += pkt->size;
1618
        st = ic->streams[pkt->stream_index];
1619
        if (pkt->pts != AV_NOPTS_VALUE) {
1620
            if (st->start_time == AV_NOPTS_VALUE)
1621
                st->start_time = pkt->pts;
1622
        }
1623
        av_free_packet(pkt);
1624
    }
1625

    
1626
    /* estimate the end time (duration) */
1627
    /* XXX: may need to support wrapping */
1628
    filesize = ic->file_size;
1629
    offset = filesize - DURATION_MAX_READ_SIZE;
1630
    if (offset < 0)
1631
        offset = 0;
1632

    
1633
    url_fseek(ic->pb, offset, SEEK_SET);
1634
    read_size = 0;
1635
    for(;;) {
1636
        if (read_size >= DURATION_MAX_READ_SIZE)
1637
            break;
1638

    
1639
        ret = av_read_packet(ic, pkt);
1640
        if (ret != 0)
1641
            break;
1642
        read_size += pkt->size;
1643
        st = ic->streams[pkt->stream_index];
1644
        if (pkt->pts != AV_NOPTS_VALUE &&
1645
            st->start_time != AV_NOPTS_VALUE) {
1646
            end_time = pkt->pts;
1647
            duration = end_time - st->start_time;
1648
            if (duration > 0) {
1649
                if (st->duration == AV_NOPTS_VALUE ||
1650
                    st->duration < duration)
1651
                    st->duration = duration;
1652
            }
1653
        }
1654
        av_free_packet(pkt);
1655
    }
1656

    
1657
    fill_all_stream_timings(ic);
1658

    
1659
    url_fseek(ic->pb, old_offset, SEEK_SET);
1660
    for(i=0; i<ic->nb_streams; i++){
1661
        st= ic->streams[i];
1662
        st->cur_dts= st->first_dts;
1663
        st->last_IP_pts = AV_NOPTS_VALUE;
1664
    }
1665
}
1666

    
1667
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1668
{
1669
    int64_t file_size;
1670

    
1671
    /* get the file size, if possible */
1672
    if (ic->iformat->flags & AVFMT_NOFILE) {
1673
        file_size = 0;
1674
    } else {
1675
        file_size = url_fsize(ic->pb);
1676
        if (file_size < 0)
1677
            file_size = 0;
1678
    }
1679
    ic->file_size = file_size;
1680

    
1681
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1682
         !strcmp(ic->iformat->name, "mpegts")) &&
1683
        file_size && !url_is_streamed(ic->pb)) {
1684
        /* get accurate estimate from the PTSes */
1685
        av_estimate_timings_from_pts(ic, old_offset);
1686
    } else if (av_has_duration(ic)) {
1687
        /* at least one component has timings - we use them for all
1688
           the components */
1689
        fill_all_stream_timings(ic);
1690
    } else {
1691
        /* less precise: use bitrate info */
1692
        av_estimate_timings_from_bit_rate(ic);
1693
    }
1694
    av_update_stream_timings(ic);
1695

    
1696
#if 0
1697
    {
1698
        int i;
1699
        AVStream *st;
1700
        for(i = 0;i < ic->nb_streams; i++) {
1701
            st = ic->streams[i];
1702
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1703
               i, (double)st->start_time / AV_TIME_BASE,
1704
               (double)st->duration / AV_TIME_BASE);
1705
        }
1706
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1707
               (double)ic->start_time / AV_TIME_BASE,
1708
               (double)ic->duration / AV_TIME_BASE,
1709
               ic->bit_rate / 1000);
1710
    }
1711
#endif
1712
}
1713

    
1714
static int has_codec_parameters(AVCodecContext *enc)
1715
{
1716
    int val;
1717
    switch(enc->codec_type) {
1718
    case CODEC_TYPE_AUDIO:
1719
        val = enc->sample_rate && enc->channels;
1720
        break;
1721
    case CODEC_TYPE_VIDEO:
1722
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1723
        break;
1724
    default:
1725
        val = 1;
1726
        break;
1727
    }
1728
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1729
}
1730

    
1731
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1732
{
1733
    int16_t *samples;
1734
    AVCodec *codec;
1735
    int got_picture, data_size, ret=0;
1736
    AVFrame picture;
1737

    
1738
  if(!st->codec->codec){
1739
    codec = avcodec_find_decoder(st->codec->codec_id);
1740
    if (!codec)
1741
        return -1;
1742
    ret = avcodec_open(st->codec, codec);
1743
    if (ret < 0)
1744
        return ret;
1745
  }
1746

    
1747
  if(!has_codec_parameters(st->codec)){
1748
    switch(st->codec->codec_type) {
1749
    case CODEC_TYPE_VIDEO:
1750
        ret = avcodec_decode_video(st->codec, &picture,
1751
                                   &got_picture, data, size);
1752
        break;
1753
    case CODEC_TYPE_AUDIO:
1754
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1755
        samples = av_malloc(data_size);
1756
        if (!samples)
1757
            goto fail;
1758
        ret = avcodec_decode_audio2(st->codec, samples,
1759
                                    &data_size, data, size);
1760
        av_free(samples);
1761
        break;
1762
    default:
1763
        break;
1764
    }
1765
  }
1766
 fail:
1767
    return ret;
1768
}
1769

    
1770
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1771
{
1772
    AVInputFormat *fmt;
1773
    fmt = av_probe_input_format2(pd, 1, &score);
1774

    
1775
    if (fmt) {
1776
        if (strncmp(fmt->name, "mp3", 3) == 0)
1777
            st->codec->codec_id = CODEC_ID_MP3;
1778
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1779
            st->codec->codec_id = CODEC_ID_AC3;
1780
    }
1781
    return !!fmt;
1782
}
1783

    
1784
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1785
{
1786
    while (tags->id != CODEC_ID_NONE) {
1787
        if (tags->id == id)
1788
            return tags->tag;
1789
        tags++;
1790
    }
1791
    return 0;
1792
}
1793

    
1794
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1795
{
1796
    int i;
1797
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1798
        if(tag == tags[i].tag)
1799
            return tags[i].id;
1800
    }
1801
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1802
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1803
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1804
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1805
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1806
            return tags[i].id;
1807
    }
1808
    return CODEC_ID_NONE;
1809
}
1810

    
1811
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1812
{
1813
    int i;
1814
    for(i=0; tags && tags[i]; i++){
1815
        int tag= codec_get_tag(tags[i], id);
1816
        if(tag) return tag;
1817
    }
1818
    return 0;
1819
}
1820

    
1821
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1822
{
1823
    int i;
1824
    for(i=0; tags && tags[i]; i++){
1825
        enum CodecID id= codec_get_id(tags[i], tag);
1826
        if(id!=CODEC_ID_NONE) return id;
1827
    }
1828
    return CODEC_ID_NONE;
1829
}
1830

    
1831
static void compute_chapters_end(AVFormatContext *s)
1832
{
1833
    unsigned int i;
1834

    
1835
    for (i=0; i+1<s->nb_chapters; i++)
1836
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1837
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1838
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1839
            s->chapters[i]->end = s->chapters[i+1]->start;
1840
        }
1841

    
1842
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1843
        assert(s->start_time != AV_NOPTS_VALUE);
1844
        assert(s->duration > 0);
1845
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1846
                                           AV_TIME_BASE_Q,
1847
                                           s->chapters[i]->time_base);
1848
    }
1849
}
1850

    
1851
/* absolute maximum size we read until we abort */
1852
#define MAX_READ_SIZE        5000000
1853

    
1854
#define MAX_STD_TIMEBASES (60*12+5)
1855
static int get_std_framerate(int i){
1856
    if(i<60*12) return i*1001;
1857
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1858
}
1859

    
1860
/*
1861
 * Is the time base unreliable.
1862
 * This is a heuristic to balance between quick acceptance of the values in
1863
 * the headers vs. some extra checks.
1864
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1865
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1866
 * And there are "variable" fps files this needs to detect as well.
1867
 */
1868
static int tb_unreliable(AVCodecContext *c){
1869
    if(   c->time_base.den >= 101L*c->time_base.num
1870
       || c->time_base.den <    5L*c->time_base.num
1871
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1872
       || c->codec_tag == ff_get_fourcc("XVID")*/
1873
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1874
        return 1;
1875
    return 0;
1876
}
1877

    
1878
int av_find_stream_info(AVFormatContext *ic)
1879
{
1880
    int i, count, ret, read_size, j;
1881
    AVStream *st;
1882
    AVPacket pkt1, *pkt;
1883
    int64_t last_dts[MAX_STREAMS];
1884
    int duration_count[MAX_STREAMS]={0};
1885
    double (*duration_error)[MAX_STD_TIMEBASES];
1886
    offset_t old_offset = url_ftell(ic->pb);
1887
    int64_t codec_info_duration[MAX_STREAMS]={0};
1888
    int codec_info_nb_frames[MAX_STREAMS]={0};
1889
    AVProbeData probe_data[MAX_STREAMS];
1890
    int codec_identified[MAX_STREAMS]={0};
1891

    
1892
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1893
    if (!duration_error) return AVERROR(ENOMEM);
1894

    
1895
    for(i=0;i<ic->nb_streams;i++) {
1896
        st = ic->streams[i];
1897
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1898
/*            if(!st->time_base.num)
1899
                st->time_base= */
1900
            if(!st->codec->time_base.num)
1901
                st->codec->time_base= st->time_base;
1902
        }
1903
        //only for the split stuff
1904
        if (!st->parser) {
1905
            st->parser = av_parser_init(st->codec->codec_id);
1906
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1907
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1908
            }
1909
        }
1910
    }
1911

    
1912
    for(i=0;i<MAX_STREAMS;i++){
1913
        last_dts[i]= AV_NOPTS_VALUE;
1914
    }
1915

    
1916
    memset(probe_data, 0, sizeof(probe_data));
1917
    count = 0;
1918
    read_size = 0;
1919
    for(;;) {
1920
        /* check if one codec still needs to be handled */
1921
        for(i=0;i<ic->nb_streams;i++) {
1922
            st = ic->streams[i];
1923
            if (!has_codec_parameters(st->codec))
1924
                break;
1925
            /* variable fps and no guess at the real fps */
1926
            if(   tb_unreliable(st->codec)
1927
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1928
                break;
1929
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1930
                break;
1931
            if(st->first_dts == AV_NOPTS_VALUE)
1932
                break;
1933
        }
1934
        if (i == ic->nb_streams) {
1935
            /* NOTE: if the format has no header, then we need to read
1936
               some packets to get most of the streams, so we cannot
1937
               stop here */
1938
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1939
                /* if we found the info for all the codecs, we can stop */
1940
                ret = count;
1941
                break;
1942
            }
1943
        }
1944
        /* we did not get all the codec info, but we read too much data */
1945
        if (read_size >= MAX_READ_SIZE) {
1946
            ret = count;
1947
            break;
1948
        }
1949

    
1950
        /* NOTE: a new stream can be added there if no header in file
1951
           (AVFMTCTX_NOHEADER) */
1952
        ret = av_read_frame_internal(ic, &pkt1);
1953
        if (ret < 0) {
1954
            /* EOF or error */
1955
            ret = -1; /* we could not have all the codec parameters before EOF */
1956
            for(i=0;i<ic->nb_streams;i++) {
1957
                st = ic->streams[i];
1958
                if (!has_codec_parameters(st->codec)){
1959
                    char buf[256];
1960
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1961
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1962
                } else {
1963
                    ret = 0;
1964
                }
1965
            }
1966
            break;
1967
        }
1968

    
1969
        pkt= add_to_pktbuf(ic, &pkt1);
1970
        if(av_dup_packet(pkt) < 0)
1971
            return AVERROR(ENOMEM);
1972

    
1973
        read_size += pkt->size;
1974

    
1975
        st = ic->streams[pkt->stream_index];
1976
        if(codec_info_nb_frames[st->index]>1)
1977
            codec_info_duration[st->index] += pkt->duration;
1978
        if (pkt->duration != 0)
1979
            codec_info_nb_frames[st->index]++;
1980

    
1981
        {
1982
            int index= pkt->stream_index;
1983
            int64_t last= last_dts[index];
1984
            int64_t duration= pkt->dts - last;
1985

    
1986
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1987
                double dur= duration * av_q2d(st->time_base);
1988

    
1989
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1990
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1991
                if(duration_count[index] < 2)
1992
                    memset(duration_error[index], 0, sizeof(*duration_error));
1993
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1994
                    int framerate= get_std_framerate(i);
1995
                    int ticks= lrintf(dur*framerate/(1001*12));
1996
                    double error= dur - ticks*1001*12/(double)framerate;
1997
                    duration_error[index][i] += error*error;
1998
                }
1999
                duration_count[index]++;
2000
            }
2001
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2002
                last_dts[pkt->stream_index]= pkt->dts;
2003

    
2004
            if (st->codec->codec_id == CODEC_ID_NONE) {
2005
                AVProbeData *pd = &(probe_data[st->index]);
2006
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
2007
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
2008
                pd->buf_size += pkt->size;
2009
                memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
2010
            }
2011
        }
2012
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2013
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2014
            if(i){
2015
                st->codec->extradata_size= i;
2016
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2017
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2018
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2019
            }
2020
        }
2021

    
2022
        /* if still no information, we try to open the codec and to
2023
           decompress the frame. We try to avoid that in most cases as
2024
           it takes longer and uses more memory. For MPEG-4, we need to
2025
           decompress for QuickTime. */
2026
        if (!has_codec_parameters(st->codec) /*&&
2027
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2028
             st->codec->codec_id == CODEC_ID_H264 ||
2029
             st->codec->codec_id == CODEC_ID_H263 ||
2030
             st->codec->codec_id == CODEC_ID_H261 ||
2031
             st->codec->codec_id == CODEC_ID_VORBIS ||
2032
             st->codec->codec_id == CODEC_ID_MJPEG ||
2033
             st->codec->codec_id == CODEC_ID_PNG ||
2034
             st->codec->codec_id == CODEC_ID_PAM ||
2035
             st->codec->codec_id == CODEC_ID_PGM ||
2036
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2037
             st->codec->codec_id == CODEC_ID_PBM ||
2038
             st->codec->codec_id == CODEC_ID_PPM ||
2039
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2040
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2041
            try_decode_frame(st, pkt->data, pkt->size);
2042

    
2043
        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) {
2044
            break;
2045
        }
2046
        count++;
2047
    }
2048

    
2049
    // close codecs which were opened in try_decode_frame()
2050
    for(i=0;i<ic->nb_streams;i++) {
2051
        st = ic->streams[i];
2052
        if(st->codec->codec)
2053
            avcodec_close(st->codec);
2054
    }
2055
    for(i=0;i<ic->nb_streams;i++) {
2056
        st = ic->streams[i];
2057
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2058
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2059
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2060

    
2061
            if(duration_count[i]
2062
               && tb_unreliable(st->codec) /*&&
2063
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2064
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2065
                double best_error= 2*av_q2d(st->time_base);
2066
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2067

    
2068
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2069
                    double error= duration_error[i][j] * get_std_framerate(j);
2070
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2071
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2072
                    if(error < best_error){
2073
                        best_error= error;
2074
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2075
                    }
2076
                }
2077
            }
2078

    
2079
            if (!st->r_frame_rate.num){
2080
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2081
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2082
                    st->r_frame_rate.num = st->codec->time_base.den;
2083
                    st->r_frame_rate.den = st->codec->time_base.num;
2084
                }else{
2085
                    st->r_frame_rate.num = st->time_base.den;
2086
                    st->r_frame_rate.den = st->time_base.num;
2087
                }
2088
            }
2089
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2090
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
2091
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
2092
                if (codec_identified[st->index]) {
2093
                    st->need_parsing = AVSTREAM_PARSE_FULL;
2094
                }
2095
            }
2096
            if(!st->codec->bits_per_sample)
2097
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2098
        }
2099
    }
2100

    
2101
    av_estimate_timings(ic, old_offset);
2102

    
2103
    for(i=0;i<ic->nb_streams;i++) {
2104
        st = ic->streams[i];
2105
        if (codec_identified[st->index])
2106
            break;
2107
    }
2108
    //FIXME this is a mess
2109
    if(i!=ic->nb_streams){
2110
        av_read_frame_flush(ic);
2111
        for(i=0;i<ic->nb_streams;i++) {
2112
            st = ic->streams[i];
2113
            if (codec_identified[st->index]) {
2114
                av_seek_frame(ic, st->index, 0.0, 0);
2115
            }
2116
            st->cur_dts= st->first_dts;
2117
        }
2118
        url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2119
    }
2120

    
2121
    compute_chapters_end(ic);
2122

    
2123
#if 0
2124
    /* correct DTS for B-frame streams with no timestamps */
2125
    for(i=0;i<ic->nb_streams;i++) {
2126
        st = ic->streams[i];
2127
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2128
            if(b-frames){
2129
                ppktl = &ic->packet_buffer;
2130
                while(ppkt1){
2131
                    if(ppkt1->stream_index != i)
2132
                        continue;
2133
                    if(ppkt1->pkt->dts < 0)
2134
                        break;
2135
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2136
                        break;
2137
                    ppkt1->pkt->dts -= delta;
2138
                    ppkt1= ppkt1->next;
2139
                }
2140
                if(ppkt1)
2141
                    continue;
2142
                st->cur_dts -= delta;
2143
            }
2144
        }
2145
    }
2146
#endif
2147

    
2148
    av_free(duration_error);
2149
    for(i=0;i<MAX_STREAMS;i++){
2150
        av_freep(&(probe_data[i].buf));
2151
    }
2152

    
2153
    return ret;
2154
}
2155

    
2156
/*******************************************************/
2157

    
2158
int av_read_play(AVFormatContext *s)
2159
{
2160
    if (s->iformat->read_play)
2161
        return s->iformat->read_play(s);
2162
    if (s->pb)
2163
        return av_url_read_fpause(s->pb, 0);
2164
    return AVERROR(ENOSYS);
2165
}
2166

    
2167
int av_read_pause(AVFormatContext *s)
2168
{
2169
    if (s->iformat->read_pause)
2170
        return s->iformat->read_pause(s);
2171
    if (s->pb)
2172
        return av_url_read_fpause(s->pb, 1);
2173
    return AVERROR(ENOSYS);
2174
}
2175

    
2176
void av_close_input_stream(AVFormatContext *s)
2177
{
2178
    int i;
2179
    AVStream *st;
2180

    
2181
    /* free previous packet */
2182
    if (s->cur_st && s->cur_st->parser)
2183
        av_free_packet(&s->cur_pkt);
2184

    
2185
    if (s->iformat->read_close)
2186
        s->iformat->read_close(s);
2187
    for(i=0;i<s->nb_streams;i++) {
2188
        /* free all data in a stream component */
2189
        st = s->streams[i];
2190
        if (st->parser) {
2191
            av_parser_close(st->parser);
2192
        }
2193
        av_free(st->index_entries);
2194
        av_free(st->codec->extradata);
2195
        av_free(st->codec);
2196
        av_free(st->filename);
2197
        av_free(st);
2198
    }
2199
    for(i=s->nb_programs-1; i>=0; i--) {
2200
        av_freep(&s->programs[i]->provider_name);
2201
        av_freep(&s->programs[i]->name);
2202
        av_freep(&s->programs[i]->stream_index);
2203
        av_freep(&s->programs[i]);
2204
    }
2205
    av_freep(&s->programs);
2206
    flush_packet_queue(s);
2207
    av_freep(&s->priv_data);
2208
    while(s->nb_chapters--) {
2209
        av_free(s->chapters[s->nb_chapters]->title);
2210
        av_free(s->chapters[s->nb_chapters]);
2211
    }
2212
    av_freep(&s->chapters);
2213
    av_free(s);
2214
}
2215

    
2216
void av_close_input_file(AVFormatContext *s)
2217
{
2218
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2219
    av_close_input_stream(s);
2220
    if (pb)
2221
        url_fclose(pb);
2222
}
2223

    
2224
AVStream *av_new_stream(AVFormatContext *s, int id)
2225
{
2226
    AVStream *st;
2227
    int i;
2228

    
2229
    if (s->nb_streams >= MAX_STREAMS)
2230
        return NULL;
2231

    
2232
    st = av_mallocz(sizeof(AVStream));
2233
    if (!st)
2234
        return NULL;
2235

    
2236
    st->codec= avcodec_alloc_context();
2237
    if (s->iformat) {
2238
        /* no default bitrate if decoding */
2239
        st->codec->bit_rate = 0;
2240
    }
2241
    st->index = s->nb_streams;
2242
    st->id = id;
2243
    st->start_time = AV_NOPTS_VALUE;
2244
    st->duration = AV_NOPTS_VALUE;
2245
    st->cur_dts = AV_NOPTS_VALUE;
2246
    st->first_dts = AV_NOPTS_VALUE;
2247

    
2248
    /* default pts setting is MPEG-like */
2249
    av_set_pts_info(st, 33, 1, 90000);
2250
    st->last_IP_pts = AV_NOPTS_VALUE;
2251
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2252
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2253

    
2254
    s->streams[s->nb_streams++] = st;
2255
    return st;
2256
}
2257

    
2258
AVProgram *av_new_program(AVFormatContext *ac, int id)
2259
{
2260
    AVProgram *program=NULL;
2261
    int i;
2262

    
2263
#ifdef DEBUG_SI
2264
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2265
#endif
2266

    
2267
    for(i=0; i<ac->nb_programs; i++)
2268
        if(ac->programs[i]->id == id)
2269
            program = ac->programs[i];
2270

    
2271
    if(!program){
2272
        program = av_mallocz(sizeof(AVProgram));
2273
        if (!program)
2274
            return NULL;
2275
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2276
        program->discard = AVDISCARD_NONE;
2277
    }
2278
    program->id = id;
2279

    
2280
    return program;
2281
}
2282

    
2283
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2284
{
2285
    assert(!provider_name == !name);
2286
    if(name){
2287
        av_free(program->provider_name);
2288
        av_free(program->         name);
2289
        program->provider_name = av_strdup(provider_name);
2290
        program->         name = av_strdup(         name);
2291
    }
2292
}
2293

    
2294
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2295
{
2296
    AVChapter *chapter = NULL;
2297
    int i;
2298

    
2299
    for(i=0; i<s->nb_chapters; i++)
2300
        if(s->chapters[i]->id == id)
2301
            chapter = s->chapters[i];
2302

    
2303
    if(!chapter){
2304
        chapter= av_mallocz(sizeof(AVChapter));
2305
        if(!chapter)
2306
            return NULL;
2307
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2308
    }
2309
    av_free(chapter->title);
2310
    chapter->title = av_strdup(title);
2311
    chapter->id    = id;
2312
    chapter->time_base= time_base;
2313
    chapter->start = start;
2314
    chapter->end   = end;
2315

    
2316
    return chapter;
2317
}
2318

    
2319
/************************************************************/
2320
/* output media file */
2321

    
2322
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2323
{
2324
    int ret;
2325

    
2326
    if (s->oformat->priv_data_size > 0) {
2327
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2328
        if (!s->priv_data)
2329
            return AVERROR(ENOMEM);
2330
    } else
2331
        s->priv_data = NULL;
2332

    
2333
    if (s->oformat->set_parameters) {
2334
        ret = s->oformat->set_parameters(s, ap);
2335
        if (ret < 0)
2336
            return ret;
2337
    }
2338
    return 0;
2339
}
2340

    
2341
int av_write_header(AVFormatContext *s)
2342
{
2343
    int ret, i;
2344
    AVStream *st;
2345

    
2346
    // some sanity checks
2347
    for(i=0;i<s->nb_streams;i++) {
2348
        st = s->streams[i];
2349

    
2350
        switch (st->codec->codec_type) {
2351
        case CODEC_TYPE_AUDIO:
2352
            if(st->codec->sample_rate<=0){
2353
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2354
                return -1;
2355
            }
2356
            break;
2357
        case CODEC_TYPE_VIDEO:
2358
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2359
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2360
                return -1;
2361
            }
2362
            if(st->codec->width<=0 || st->codec->height<=0){
2363
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2364
                return -1;
2365
            }
2366
            break;
2367
        }
2368

    
2369
        if(s->oformat->codec_tag){
2370
            if(st->codec->codec_tag){
2371
                //FIXME
2372
                //check that tag + id is in the table
2373
                //if neither is in the table -> OK
2374
                //if tag is in the table with another id -> FAIL
2375
                //if id is in the table with another tag -> FAIL unless strict < ?
2376
            }else
2377
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2378
        }
2379
    }
2380

    
2381
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2382
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2383
        if (!s->priv_data)
2384
            return AVERROR(ENOMEM);
2385
    }
2386

    
2387
    if(s->oformat->write_header){
2388
        ret = s->oformat->write_header(s);
2389
        if (ret < 0)
2390
            return ret;
2391
    }
2392

    
2393
    /* init PTS generation */
2394
    for(i=0;i<s->nb_streams;i++) {
2395
        int64_t den = AV_NOPTS_VALUE;
2396
        st = s->streams[i];
2397

    
2398
        switch (st->codec->codec_type) {
2399
        case CODEC_TYPE_AUDIO:
2400
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2401
            break;
2402
        case CODEC_TYPE_VIDEO:
2403
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2404
            break;
2405
        default:
2406
            break;
2407
        }
2408
        if (den != AV_NOPTS_VALUE) {
2409
            if (den <= 0)
2410
                return AVERROR_INVALIDDATA;
2411
            av_frac_init(&st->pts, 0, 0, den);
2412
        }
2413
    }
2414
    return 0;
2415
}
2416

    
2417
//FIXME merge with compute_pkt_fields
2418
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2419
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2420
    int num, den, frame_size, i;
2421

    
2422
//    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);
2423

    
2424
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2425
        return -1;*/
2426

    
2427
    /* duration field */
2428
    if (pkt->duration == 0) {
2429
        compute_frame_duration(&num, &den, st, NULL, pkt);
2430
        if (den && num) {
2431
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2432
        }
2433
    }
2434

    
2435
    //XXX/FIXME this is a temporary hack until all encoders output pts
2436
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2437
        pkt->dts=
2438
//        pkt->pts= st->cur_dts;
2439
        pkt->pts= st->pts.val;
2440
    }
2441

    
2442
    //calculate dts from pts
2443
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2444
        st->pts_buffer[0]= pkt->pts;
2445
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2446
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2447
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2448
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2449

    
2450
        pkt->dts= st->pts_buffer[0];
2451
    }
2452

    
2453
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2454
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2455
        return -1;
2456
    }
2457
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2458
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2459
        return -1;
2460
    }
2461

    
2462
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2463
    st->cur_dts= pkt->dts;
2464
    st->pts.val= pkt->dts;
2465

    
2466
    /* update pts */
2467
    switch (st->codec->codec_type) {
2468
    case CODEC_TYPE_AUDIO:
2469
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2470

    
2471
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2472
           likely equal to the encoder delay, but it would be better if we
2473
           had the real timestamps from the encoder */
2474
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2475
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2476
        }
2477
        break;
2478
    case CODEC_TYPE_VIDEO:
2479
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2480
        break;
2481
    default:
2482
        break;
2483
    }
2484
    return 0;
2485
}
2486

    
2487
static void truncate_ts(AVStream *st, AVPacket *pkt){
2488
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2489

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

    
2493
    if (pkt->pts != AV_NOPTS_VALUE)
2494
        pkt->pts &= pts_mask;
2495
    if (pkt->dts != AV_NOPTS_VALUE)
2496
        pkt->dts &= pts_mask;
2497
}
2498

    
2499
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2500
{
2501
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2502

    
2503
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2504
        return ret;
2505

    
2506
    truncate_ts(s->streams[pkt->stream_index], pkt);
2507

    
2508
    ret= s->oformat->write_packet(s, pkt);
2509
    if(!ret)
2510
        ret= url_ferror(s->pb);
2511
    return ret;
2512
}
2513

    
2514
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2515
    AVPacketList *pktl, **next_point, *this_pktl;
2516
    int stream_count=0;
2517
    int streams[MAX_STREAMS];
2518

    
2519
    if(pkt){
2520
        AVStream *st= s->streams[ pkt->stream_index];
2521

    
2522
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2523

    
2524
        this_pktl = av_mallocz(sizeof(AVPacketList));
2525
        this_pktl->pkt= *pkt;
2526
        if(pkt->destruct == av_destruct_packet)
2527
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2528
        else
2529
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2530

    
2531
        next_point = &s->packet_buffer;
2532
        while(*next_point){
2533
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2534
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2535
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2536
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2537
                break;
2538
            next_point= &(*next_point)->next;
2539
        }
2540
        this_pktl->next= *next_point;
2541
        *next_point= this_pktl;
2542
    }
2543

    
2544
    memset(streams, 0, sizeof(streams));
2545
    pktl= s->packet_buffer;
2546
    while(pktl){
2547
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2548
        if(streams[ pktl->pkt.stream_index ] == 0)
2549
            stream_count++;
2550
        streams[ pktl->pkt.stream_index ]++;
2551
        pktl= pktl->next;
2552
    }
2553

    
2554
    if(s->nb_streams == stream_count || (flush && stream_count)){
2555
        pktl= s->packet_buffer;
2556
        *out= pktl->pkt;
2557

    
2558
        s->packet_buffer= pktl->next;
2559
        av_freep(&pktl);
2560
        return 1;
2561
    }else{
2562
        av_init_packet(out);
2563
        return 0;
2564
    }
2565
}
2566

    
2567
/**
2568
 * Interleaves an AVPacket correctly so it can be muxed.
2569
 * @param out the interleaved packet will be output here
2570
 * @param in the input packet
2571
 * @param flush 1 if no further packets are available as input and all
2572
 *              remaining packets should be output
2573
 * @return 1 if a packet was output, 0 if no packet could be output,
2574
 *         < 0 if an error occurred
2575
 */
2576
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2577
    if(s->oformat->interleave_packet)
2578
        return s->oformat->interleave_packet(s, out, in, flush);
2579
    else
2580
        return av_interleave_packet_per_dts(s, out, in, flush);
2581
}
2582

    
2583
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2584
    AVStream *st= s->streams[ pkt->stream_index];
2585

    
2586
    //FIXME/XXX/HACK drop zero sized packets
2587
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2588
        return 0;
2589

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

    
2594
    if(pkt->dts == AV_NOPTS_VALUE)
2595
        return -1;
2596

    
2597
    for(;;){
2598
        AVPacket opkt;
2599
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2600
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2601
            return ret;
2602

    
2603
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2604
        ret= s->oformat->write_packet(s, &opkt);
2605

    
2606
        av_free_packet(&opkt);
2607
        pkt= NULL;
2608

    
2609
        if(ret<0)
2610
            return ret;
2611
        if(url_ferror(s->pb))
2612
            return url_ferror(s->pb);
2613
    }
2614
}
2615

    
2616
int av_write_trailer(AVFormatContext *s)
2617
{
2618
    int ret, i;
2619

    
2620
    for(;;){
2621
        AVPacket pkt;
2622
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2623
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2624
            goto fail;
2625
        if(!ret)
2626
            break;
2627

    
2628
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2629
        ret= s->oformat->write_packet(s, &pkt);
2630

    
2631
        av_free_packet(&pkt);
2632

    
2633
        if(ret<0)
2634
            goto fail;
2635
        if(url_ferror(s->pb))
2636
            goto fail;
2637
    }
2638

    
2639
    if(s->oformat->write_trailer)
2640
        ret = s->oformat->write_trailer(s);
2641
fail:
2642
    if(ret == 0)
2643
       ret=url_ferror(s->pb);
2644
    for(i=0;i<s->nb_streams;i++)
2645
        av_freep(&s->streams[i]->priv_data);
2646
    av_freep(&s->priv_data);
2647
    return ret;
2648
}
2649

    
2650
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2651
{
2652
    int i, j;
2653
    AVProgram *program=NULL;
2654
    void *tmp;
2655

    
2656
    for(i=0; i<ac->nb_programs; i++){
2657
        if(ac->programs[i]->id != progid)
2658
            continue;
2659
        program = ac->programs[i];
2660
        for(j=0; j<program->nb_stream_indexes; j++)
2661
            if(program->stream_index[j] == idx)
2662
                return;
2663

    
2664
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2665
        if(!tmp)
2666
            return;
2667
        program->stream_index = tmp;
2668
        program->stream_index[program->nb_stream_indexes++] = idx;
2669
        return;
2670
    }
2671
}
2672

    
2673
/* "user interface" functions */
2674
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2675
{
2676
    char buf[256];
2677
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2678
    AVStream *st = ic->streams[i];
2679
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2680
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2681
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2682
    /* the pid is an important information, so we display it */
2683
    /* XXX: add a generic system */
2684
    if (flags & AVFMT_SHOW_IDS)
2685
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2686
    if (strlen(st->language) > 0)
2687
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2688
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2689
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2690
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2691
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2692
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2693
/*      else if(st->time_base.den && st->time_base.num)
2694
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2695
        else
2696
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2697
    }
2698
    av_log(NULL, AV_LOG_INFO, "\n");
2699
}
2700

    
2701
void dump_format(AVFormatContext *ic,
2702
                 int index,
2703
                 const char *url,
2704
                 int is_output)
2705
{
2706
    int i;
2707

    
2708
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2709
            is_output ? "Output" : "Input",
2710
            index,
2711
            is_output ? ic->oformat->name : ic->iformat->name,
2712
            is_output ? "to" : "from", url);
2713
    if (!is_output) {
2714
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2715
        if (ic->duration != AV_NOPTS_VALUE) {
2716
            int hours, mins, secs, us;
2717
            secs = ic->duration / AV_TIME_BASE;
2718
            us = ic->duration % AV_TIME_BASE;
2719
            mins = secs / 60;
2720
            secs %= 60;
2721
            hours = mins / 60;
2722
            mins %= 60;
2723
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2724
                   (100 * us) / AV_TIME_BASE);
2725
        } else {
2726
            av_log(NULL, AV_LOG_INFO, "N/A");
2727
        }
2728
        if (ic->start_time != AV_NOPTS_VALUE) {
2729
            int secs, us;
2730
            av_log(NULL, AV_LOG_INFO, ", start: ");
2731
            secs = ic->start_time / AV_TIME_BASE;
2732
            us = ic->start_time % AV_TIME_BASE;
2733
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2734
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2735
        }
2736
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2737
        if (ic->bit_rate) {
2738
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2739
        } else {
2740
            av_log(NULL, AV_LOG_INFO, "N/A");
2741
        }
2742
        av_log(NULL, AV_LOG_INFO, "\n");
2743
    }
2744
    if(ic->nb_programs) {
2745
        int j, k;
2746
        for(j=0; j<ic->nb_programs; j++) {
2747
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2748
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2749
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2750
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2751
         }
2752
    } else
2753
    for(i=0;i<ic->nb_streams;i++)
2754
        dump_stream_format(ic, i, index, is_output);
2755
}
2756

    
2757
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2758
{
2759
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2760
}
2761

    
2762
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2763
{
2764
    AVRational frame_rate;
2765
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2766
    *frame_rate_num= frame_rate.num;
2767
    *frame_rate_den= frame_rate.den;
2768
    return ret;
2769
}
2770

    
2771
/**
2772
 * Gets the current time in microseconds.
2773
 */
2774
int64_t av_gettime(void)
2775
{
2776
    struct timeval tv;
2777
    gettimeofday(&tv,NULL);
2778
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2779
}
2780

    
2781
int64_t parse_date(const char *datestr, int duration)
2782
{
2783
    const char *p;
2784
    int64_t t;
2785
    struct tm dt;
2786
    int i;
2787
    static const char *date_fmt[] = {
2788
        "%Y-%m-%d",
2789
        "%Y%m%d",
2790
    };
2791
    static const char *time_fmt[] = {
2792
        "%H:%M:%S",
2793
        "%H%M%S",
2794
    };
2795
    const char *q;
2796
    int is_utc, len;
2797
    char lastch;
2798
    int negative = 0;
2799

    
2800
#undef time
2801
    time_t now = time(0);
2802

    
2803
    len = strlen(datestr);
2804
    if (len > 0)
2805
        lastch = datestr[len - 1];
2806
    else
2807
        lastch = '\0';
2808
    is_utc = (lastch == 'z' || lastch == 'Z');
2809

    
2810
    memset(&dt, 0, sizeof(dt));
2811

    
2812
    p = datestr;
2813
    q = NULL;
2814
    if (!duration) {
2815
        /* parse the year-month-day part */
2816
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2817
            q = small_strptime(p, date_fmt[i], &dt);
2818
            if (q) {
2819
                break;
2820
            }
2821
        }
2822

    
2823
        /* if the year-month-day part is missing, then take the
2824
         * current year-month-day time */
2825
        if (!q) {
2826
            if (is_utc) {
2827
                dt = *gmtime(&now);
2828
            } else {
2829
                dt = *localtime(&now);
2830
            }
2831
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2832
        } else {
2833
            p = q;
2834
        }
2835

    
2836
        if (*p == 'T' || *p == 't' || *p == ' ')
2837
            p++;
2838

    
2839
        /* parse the hour-minute-second part */
2840
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2841
            q = small_strptime(p, time_fmt[i], &dt);
2842
            if (q) {
2843
                break;
2844
            }
2845
        }
2846
    } else {
2847
        /* parse datestr as a duration */
2848
        if (p[0] == '-') {
2849
            negative = 1;
2850
            ++p;
2851
        }
2852
        /* parse datestr as HH:MM:SS */
2853
        q = small_strptime(p, time_fmt[0], &dt);
2854
        if (!q) {
2855
            /* parse datestr as S+ */
2856
            dt.tm_sec = strtol(p, (char **)&q, 10);
2857
            if (q == p)
2858
                /* the parsing didn't succeed */
2859
                return INT64_MIN;
2860
            dt.tm_min = 0;
2861
            dt.tm_hour = 0;
2862
        }
2863
    }
2864

    
2865
    /* Now we have all the fields that we can get */
2866
    if (!q) {
2867
        return INT64_MIN;
2868
    }
2869

    
2870
    if (duration) {
2871
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2872
    } else {
2873
        dt.tm_isdst = -1;       /* unknown */
2874
        if (is_utc) {
2875
            t = mktimegm(&dt);
2876
        } else {
2877
            t = mktime(&dt);
2878
        }
2879
    }
2880

    
2881
    t *= 1000000;
2882

    
2883
    /* parse the .m... part */
2884
    if (*q == '.') {
2885
        int val, n;
2886
        q++;
2887
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2888
            if (!isdigit(*q))
2889
                break;
2890
            val += n * (*q - '0');
2891
        }
2892
        t += val;
2893
    }
2894
    return negative ? -t : t;
2895
}
2896

    
2897
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2898
{
2899
    const char *p;
2900
    char tag[128], *q;
2901

    
2902
    p = info;
2903
    if (*p == '?')
2904
        p++;
2905
    for(;;) {
2906
        q = tag;
2907
        while (*p != '\0' && *p != '=' && *p != '&') {
2908
            if ((q - tag) < sizeof(tag) - 1)
2909
                *q++ = *p;
2910
            p++;
2911
        }
2912
        *q = '\0';
2913
        q = arg;
2914
        if (*p == '=') {
2915
            p++;
2916
            while (*p != '&' && *p != '\0') {
2917
                if ((q - arg) < arg_size - 1) {
2918
                    if (*p == '+')
2919
                        *q++ = ' ';
2920
                    else
2921
                        *q++ = *p;
2922
                }
2923
                p++;
2924
            }
2925
            *q = '\0';
2926
        }
2927
        if (!strcmp(tag, tag1))
2928
            return 1;
2929
        if (*p != '&')
2930
            break;
2931
        p++;
2932
    }
2933
    return 0;
2934
}
2935

    
2936
int av_get_frame_filename(char *buf, int buf_size,
2937
                          const char *path, int number)
2938
{
2939
    const char *p;
2940
    char *q, buf1[20], c;
2941
    int nd, len, percentd_found;
2942

    
2943
    q = buf;
2944
    p = path;
2945
    percentd_found = 0;
2946
    for(;;) {
2947
        c = *p++;
2948
        if (c == '\0')
2949
            break;
2950
        if (c == '%') {
2951
            do {
2952
                nd = 0;
2953
                while (isdigit(*p)) {
2954
                    nd = nd * 10 + *p++ - '0';
2955
                }
2956
                c = *p++;
2957
            } while (isdigit(c));
2958

    
2959
            switch(c) {
2960
            case '%':
2961
                goto addchar;
2962
            case 'd':
2963
                if (percentd_found)
2964
                    goto fail;
2965
                percentd_found = 1;
2966
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2967
                len = strlen(buf1);
2968
                if ((q - buf + len) > buf_size - 1)
2969
                    goto fail;
2970
                memcpy(q, buf1, len);
2971
                q += len;
2972
                break;
2973
            default:
2974
                goto fail;
2975
            }
2976
        } else {
2977
        addchar:
2978
            if ((q - buf) < buf_size - 1)
2979
                *q++ = c;
2980
        }
2981
    }
2982
    if (!percentd_found)
2983
        goto fail;
2984
    *q = '\0';
2985
    return 0;
2986
 fail:
2987
    *q = '\0';
2988
    return -1;
2989
}
2990

    
2991
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2992
{
2993
    int len, i, j, c;
2994
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2995

    
2996
    for(i=0;i<size;i+=16) {
2997
        len = size - i;
2998
        if (len > 16)
2999
            len = 16;
3000
        PRINT("%08x ", i);
3001
        for(j=0;j<16;j++) {
3002
            if (j < len)
3003
                PRINT(" %02x", buf[i+j]);
3004
            else
3005
                PRINT("   ");
3006
        }
3007
        PRINT(" ");
3008
        for(j=0;j<len;j++) {
3009
            c = buf[i+j];
3010
            if (c < ' ' || c > '~')
3011
                c = '.';
3012
            PRINT("%c", c);
3013
        }
3014
        PRINT("\n");
3015
    }
3016
#undef PRINT
3017
}
3018

    
3019
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3020
{
3021
    hex_dump_internal(NULL, f, 0, buf, size);
3022
}
3023

    
3024
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3025
{
3026
    hex_dump_internal(avcl, NULL, level, buf, size);
3027
}
3028

    
3029
 //FIXME needs to know the time_base
3030
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3031
{
3032
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3033
    PRINT("stream #%d:\n", pkt->stream_index);
3034
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3035
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3036
    /* DTS is _always_ valid after av_read_frame() */
3037
    PRINT("  dts=");
3038
    if (pkt->dts == AV_NOPTS_VALUE)
3039
        PRINT("N/A");
3040
    else
3041
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3042
    /* PTS may not be known if B-frames are present. */
3043
    PRINT("  pts=");
3044
    if (pkt->pts == AV_NOPTS_VALUE)
3045
        PRINT("N/A");
3046
    else
3047
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3048
    PRINT("\n");
3049
    PRINT("  size=%d\n", pkt->size);
3050
#undef PRINT
3051
    if (dump_payload)
3052
        av_hex_dump(f, pkt->data, pkt->size);
3053
}
3054

    
3055
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3056
{
3057
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3058
}
3059

    
3060
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3061
{
3062
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3063
}
3064

    
3065
void url_split(char *proto, int proto_size,
3066
               char *authorization, int authorization_size,
3067
               char *hostname, int hostname_size,
3068
               int *port_ptr,
3069
               char *path, int path_size,
3070
               const char *url)
3071
{
3072
    const char *p, *ls, *at, *col, *brk;
3073

    
3074
    if (port_ptr)               *port_ptr = -1;
3075
    if (proto_size > 0)         proto[0] = 0;
3076
    if (authorization_size > 0) authorization[0] = 0;
3077
    if (hostname_size > 0)      hostname[0] = 0;
3078
    if (path_size > 0)          path[0] = 0;
3079

    
3080
    /* parse protocol */
3081
    if ((p = strchr(url, ':'))) {
3082
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3083
        p++; /* skip ':' */
3084
        if (*p == '/') p++;
3085
        if (*p == '/') p++;
3086
    } else {
3087
        /* no protocol means plain filename */
3088
        av_strlcpy(path, url, path_size);
3089
        return;
3090
    }
3091

    
3092
    /* separate path from hostname */
3093
    ls = strchr(p, '/');
3094
    if(!ls)
3095
        ls = strchr(p, '?');
3096
    if(ls)
3097
        av_strlcpy(path, ls, path_size);
3098
    else
3099
        ls = &p[strlen(p)]; // XXX
3100

    
3101
    /* the rest is hostname, use that to parse auth/port */
3102
    if (ls != p) {
3103
        /* authorization (user[:pass]@hostname) */
3104
        if ((at = strchr(p, '@')) && at < ls) {
3105
            av_strlcpy(authorization, p,
3106
                       FFMIN(authorization_size, at + 1 - p));
3107
            p = at + 1; /* skip '@' */
3108
        }
3109

    
3110
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3111
            /* [host]:port */
3112
            av_strlcpy(hostname, p + 1,
3113
                       FFMIN(hostname_size, brk - p));
3114
            if (brk[1] == ':' && port_ptr)
3115
                *port_ptr = atoi(brk + 2);
3116
        } else if ((col = strchr(p, ':')) && col < ls) {
3117
            av_strlcpy(hostname, p,
3118
                       FFMIN(col + 1 - p, hostname_size));
3119
            if (port_ptr) *port_ptr = atoi(col + 1);
3120
        } else
3121
            av_strlcpy(hostname, p,
3122
                       FFMIN(ls + 1 - p, hostname_size));
3123
    }
3124
}
3125

    
3126
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3127
                     int pts_num, int pts_den)
3128
{
3129
    s->pts_wrap_bits = pts_wrap_bits;
3130
    s->time_base.num = pts_num;
3131
    s->time_base.den = pts_den;
3132
}
3133

    
3134
/* fraction handling */
3135

    
3136
/**
3137
 * f = val + (num / den) + 0.5.
3138
 *
3139
 * 'num' is normalized so that it is such as 0 <= num < den.
3140
 *
3141
 * @param f fractional number
3142
 * @param val integer value
3143
 * @param num must be >= 0
3144
 * @param den must be >= 1
3145
 */
3146
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3147
{
3148
    num += (den >> 1);
3149
    if (num >= den) {
3150
        val += num / den;
3151
        num = num % den;
3152
    }
3153
    f->val = val;
3154
    f->num = num;
3155
    f->den = den;
3156
}
3157

    
3158
/**
3159
 * Fractional addition to f: f = f + (incr / f->den).
3160
 *
3161
 * @param f fractional number
3162
 * @param incr increment, can be positive or negative
3163
 */
3164
static void av_frac_add(AVFrac *f, int64_t incr)
3165
{
3166
    int64_t num, den;
3167

    
3168
    num = f->num + incr;
3169
    den = f->den;
3170
    if (num < 0) {
3171
        f->val += num / den;
3172
        num = num % den;
3173
        if (num < 0) {
3174
            num += den;
3175
            f->val--;
3176
        }
3177
    } else if (num >= den) {
3178
        f->val += num / den;
3179
        num = num % den;
3180
    }
3181
    f->num = num;
3182
}