Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 5cc9253f

History | View | Annotate | Download (91.8 KB)

1
/*
2
 * Various utilities for ffmpeg system
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 "opt.h"
23
#include "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 using ffmpeg library.
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 put the padding
245
           again */
246
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
247
            return AVERROR(ENOMEM);
248
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
249
        if (!data) {
250
            return AVERROR(ENOMEM);
251
        }
252
        memcpy(data, pkt->data, pkt->size);
253
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
254
        pkt->data = data;
255
        pkt->destruct = av_destruct_packet;
256
    }
257
    return 0;
258
}
259

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

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

    
271
    fmt = NULL;
272
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
273
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
274
            continue;
275
        score = 0;
276
        if (fmt1->read_probe) {
277
            score = fmt1->read_probe(pd);
278
        } else if (fmt1->extensions) {
279
            if (match_ext(pd->filename, fmt1->extensions)) {
280
                score = 50;
281
            }
282
        }
283
        if (score > *score_max) {
284
            *score_max = score;
285
            fmt = fmt1;
286
        }
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
{NULL},
328
};
329

    
330
#undef E
331
#undef D
332
#undef DEFAULT
333

    
334
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
335

    
336
static void avformat_get_context_defaults(AVFormatContext *s)
337
{
338
    memset(s, 0, sizeof(AVFormatContext));
339

    
340
    s->av_class = &av_format_context_class;
341

    
342
    av_opt_set_defaults(s);
343
}
344

    
345
AVFormatContext *av_alloc_format_context(void)
346
{
347
    AVFormatContext *ic;
348
    ic = av_malloc(sizeof(AVFormatContext));
349
    if (!ic) return ic;
350
    avformat_get_context_defaults(ic);
351
    ic->av_class = &av_format_context_class;
352
    return ic;
353
}
354

    
355
int av_open_input_stream(AVFormatContext **ic_ptr,
356
                         ByteIOContext *pb, const char *filename,
357
                         AVInputFormat *fmt, AVFormatParameters *ap)
358
{
359
    int err;
360
    AVFormatContext *ic;
361
    AVFormatParameters default_ap;
362

    
363
    if(!ap){
364
        ap=&default_ap;
365
        memset(ap, 0, sizeof(default_ap));
366
    }
367

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

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

    
393
    err = ic->iformat->read_header(ic, ap);
394
    if (err < 0)
395
        goto fail;
396

    
397
    if (pb && !ic->data_offset)
398
        ic->data_offset = url_ftell(ic->pb);
399

    
400
    *ic_ptr = ic;
401
    return 0;
402
 fail:
403
    if (ic) {
404
        av_freep(&ic->priv_data);
405
    }
406
    av_free(ic);
407
    *ic_ptr = NULL;
408
    return err;
409
}
410

    
411
/** Size of probe buffer, for guessing file type from file contents. */
412
#define PROBE_BUF_MIN 2048
413
#define PROBE_BUF_MAX (1<<20)
414

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

    
424
    pd->filename = "";
425
    if (filename)
426
        pd->filename = filename;
427
    pd->buf = NULL;
428
    pd->buf_size = 0;
429

    
430
    if (!fmt) {
431
        /* guess format if no file can be opened  */
432
        fmt = av_probe_input_format(pd, 0);
433
    }
434

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

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

    
466
    /* if still no format found, error */
467
    if (!fmt) {
468
        err = AVERROR_NOFMT;
469
        goto fail;
470
    }
471

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

    
490
}
491

    
492
/*******************************************************/
493

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

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

    
516
    return ret;
517
}
518

    
519
/**********************************************************/
520

    
521
/**
522
 * Get the number of samples of an audio frame. Return (-1) if error.
523
 */
524
static int get_audio_frame_size(AVCodecContext *enc, int size)
525
{
526
    int frame_size;
527

    
528
    if (enc->frame_size <= 1) {
529
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
530

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

    
547

    
548
/**
549
 * Return the frame duration in seconds, return 0 if not available.
550
 */
551
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
552
                                   AVCodecParserContext *pc, AVPacket *pkt)
553
{
554
    int frame_size;
555

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

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

    
606
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
607
                                      int64_t dts, int64_t pts)
608
{
609
    AVStream *st= s->streams[stream_index];
610
    AVPacketList *pktl= s->packet_buffer;
611

    
612
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
613
        return;
614

    
615
    st->first_dts= dts - st->cur_dts;
616
    st->cur_dts= dts;
617

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

    
625
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
626
            pktl->pkt.dts += st->first_dts;
627

    
628
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
629
            st->start_time= pktl->pkt.pts;
630
    }
631
    if (st->start_time == AV_NOPTS_VALUE)
632
        st->start_time = pts;
633
}
634

    
635
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
636
                               AVCodecParserContext *pc, AVPacket *pkt)
637
{
638
    int num, den, presentation_delayed, delay, i;
639
    int64_t offset;
640

    
641
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
642
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
643
        pkt->dts -= 1LL<<st->pts_wrap_bits;
644
    }
645

    
646
    if (pkt->duration == 0) {
647
        compute_frame_duration(&num, &den, st, pc, pkt);
648
        if (den && num) {
649
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
650
        }
651
    }
652

    
653
    /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
654
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
655
        /* this will estimate bitrate based on this frame's duration and size */
656
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
657
        if(pkt->pts != AV_NOPTS_VALUE)
658
            pkt->pts += offset;
659
        if(pkt->dts != AV_NOPTS_VALUE)
660
            pkt->dts += offset;
661
    }
662

    
663
    /* do we have a video B frame ? */
664
    delay= st->codec->has_b_frames;
665
    presentation_delayed = 0;
666
    /* XXX: need has_b_frame, but cannot get it if the codec is
667
        not initialized */
668
    if (delay &&
669
        pc && pc->pict_type != FF_B_TYPE)
670
        presentation_delayed = 1;
671
    /* This may be redundant, but it should not hurt. */
672
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
673
        presentation_delayed = 1;
674

    
675
    if(st->cur_dts == AV_NOPTS_VALUE){
676
        st->cur_dts = 0; //FIXME maybe set it to 0 during init
677
    }
678

    
679
//    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);
680
    /* interpolate PTS and DTS if they are not present */
681
    if(delay <=1){
682
        if (presentation_delayed) {
683
            /* DTS = decompression time stamp */
684
            /* PTS = presentation time stamp */
685
            if (pkt->dts == AV_NOPTS_VALUE)
686
                pkt->dts = st->last_IP_pts;
687
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
688
            if (pkt->dts == AV_NOPTS_VALUE)
689
                pkt->dts = st->cur_dts;
690

    
691
            /* this is tricky: the dts must be incremented by the duration
692
            of the frame we are displaying, i.e. the last I or P frame */
693
            if (st->last_IP_duration == 0)
694
                st->last_IP_duration = pkt->duration;
695
            st->cur_dts = pkt->dts + st->last_IP_duration;
696
            st->last_IP_duration  = pkt->duration;
697
            st->last_IP_pts= pkt->pts;
698
            /* cannot compute PTS if not present (we can compute it only
699
            by knowing the futur */
700
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
701
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
702
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
703
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
704
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
705
                    pkt->pts += pkt->duration;
706
    //                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);
707
                }
708
            }
709

    
710
            /* presentation is not delayed : PTS and DTS are the same */
711
            if(pkt->pts == AV_NOPTS_VALUE)
712
                pkt->pts = pkt->dts;
713
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
714
            if(pkt->pts == AV_NOPTS_VALUE)
715
                pkt->pts = st->cur_dts;
716
            pkt->dts = pkt->pts;
717
            st->cur_dts = pkt->pts + pkt->duration;
718
        }
719
    }
720

    
721
    if(pkt->pts != AV_NOPTS_VALUE){
722
        st->pts_buffer[0]= pkt->pts;
723
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
724
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
725
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
726
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
727
        if(pkt->dts == AV_NOPTS_VALUE)
728
            pkt->dts= st->pts_buffer[0];
729
        if(delay>1){
730
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
731
        }
732
        if(pkt->dts > st->cur_dts)
733
            st->cur_dts = pkt->dts;
734
    }
735

    
736
//    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);
737

    
738
    /* update flags */
739
    if(is_intra_only(st->codec))
740
        pkt->flags |= PKT_FLAG_KEY;
741
    else if (pc) {
742
        pkt->flags = 0;
743
        /* key frame computation */
744
            if (pc->pict_type == FF_I_TYPE)
745
                pkt->flags |= PKT_FLAG_KEY;
746
    }
747
}
748

    
749
void av_destruct_packet_nofree(AVPacket *pkt)
750
{
751
    pkt->data = NULL; pkt->size = 0;
752
}
753

    
754
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
755
{
756
    AVStream *st;
757
    int len, ret, i;
758

    
759
    av_init_packet(pkt);
760

    
761
    for(;;) {
762
        /* select current input stream component */
763
        st = s->cur_st;
764
        if (st) {
765
            if (!st->need_parsing || !st->parser) {
766
                /* no parsing needed: we just output the packet as is */
767
                /* raw data support */
768
                *pkt = s->cur_pkt;
769
                compute_pkt_fields(s, st, NULL, pkt);
770
                s->cur_st = NULL;
771
                break;
772
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
773
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
774
                                      s->cur_ptr, s->cur_len,
775
                                      s->cur_pkt.pts, s->cur_pkt.dts);
776
                s->cur_pkt.pts = AV_NOPTS_VALUE;
777
                s->cur_pkt.dts = AV_NOPTS_VALUE;
778
                /* increment read pointer */
779
                s->cur_ptr += len;
780
                s->cur_len -= len;
781

    
782
                /* return packet if any */
783
                if (pkt->size) {
784
                got_packet:
785
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
786
                    pkt->duration = 0;
787
                    pkt->stream_index = st->index;
788
                    pkt->pts = st->parser->pts;
789
                    pkt->dts = st->parser->dts;
790
                    pkt->destruct = av_destruct_packet_nofree;
791
                    compute_pkt_fields(s, st, st->parser, pkt);
792

    
793
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
794
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
795
                                           0, 0, AVINDEX_KEYFRAME);
796
                    }
797

    
798
                    break;
799
                }
800
            } else {
801
                /* free packet */
802
                av_free_packet(&s->cur_pkt);
803
                s->cur_st = NULL;
804
            }
805
        } else {
806
            /* read next packet */
807
            ret = av_read_packet(s, &s->cur_pkt);
808
            if (ret < 0) {
809
                if (ret == AVERROR(EAGAIN))
810
                    return ret;
811
                /* return the last frames, if any */
812
                for(i = 0; i < s->nb_streams; i++) {
813
                    st = s->streams[i];
814
                    if (st->parser && st->need_parsing) {
815
                        av_parser_parse(st->parser, st->codec,
816
                                        &pkt->data, &pkt->size,
817
                                        NULL, 0,
818
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
819
                        if (pkt->size)
820
                            goto got_packet;
821
                    }
822
                }
823
                /* no more packets: really terminates parsing */
824
                return ret;
825
            }
826

    
827
            st = s->streams[s->cur_pkt.stream_index];
828
            if(st->codec->debug & FF_DEBUG_PTS)
829
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
830
                    s->cur_pkt.stream_index,
831
                    s->cur_pkt.pts,
832
                    s->cur_pkt.dts,
833
                    s->cur_pkt.size);
834

    
835
            s->cur_st = st;
836
            s->cur_ptr = s->cur_pkt.data;
837
            s->cur_len = s->cur_pkt.size;
838
            if (st->need_parsing && !st->parser) {
839
                st->parser = av_parser_init(st->codec->codec_id);
840
                if (!st->parser) {
841
                    /* no parser available : just output the raw packets */
842
                    st->need_parsing = AVSTREAM_PARSE_NONE;
843
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
844
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
845
                }
846
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
847
                    st->parser->last_frame_offset=
848
                    st->parser->cur_offset= s->cur_pkt.pos;
849
                }
850
            }
851
        }
852
    }
853
    if(st->codec->debug & FF_DEBUG_PTS)
854
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
855
            pkt->stream_index,
856
            pkt->pts,
857
            pkt->dts,
858
            pkt->size);
859

    
860
    return 0;
861
}
862

    
863
static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
864
    AVPacketList *pktl= s->packet_buffer;
865
    AVPacketList **plast_pktl= &s->packet_buffer;
866

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

    
869
    pktl = av_mallocz(sizeof(AVPacketList));
870
    if (!pktl)
871
        return NULL;
872

    
873
    /* add the packet in the buffered packet list */
874
    *plast_pktl = pktl;
875
    pktl->pkt= *pkt;
876
    return &pktl->pkt;
877
}
878

    
879
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
880
{
881
    AVPacketList *pktl;
882
    int eof=0;
883
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
884

    
885
    for(;;){
886
        pktl = s->packet_buffer;
887
        if (pktl) {
888
            AVPacket *next_pkt= &pktl->pkt;
889

    
890
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
891
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
892
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
893
                       && next_pkt->dts < pktl->pkt.dts
894
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
895
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
896
                        next_pkt->pts= pktl->pkt.dts;
897
                    }
898
                    pktl= pktl->next;
899
                }
900
                pktl = s->packet_buffer;
901
            }
902

    
903
            if(   next_pkt->pts != AV_NOPTS_VALUE
904
               || next_pkt->dts == AV_NOPTS_VALUE
905
               || !genpts || eof){
906
                /* read packet from packet buffer, if there is data */
907
                *pkt = *next_pkt;
908
                s->packet_buffer = pktl->next;
909
                av_free(pktl);
910
                return 0;
911
            }
912
        }
913
        if(genpts){
914
            int ret= av_read_frame_internal(s, pkt);
915
            if(ret<0){
916
                if(pktl && ret != AVERROR(EAGAIN)){
917
                    eof=1;
918
                    continue;
919
                }else
920
                    return ret;
921
            }
922

    
923
            if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
924
                return AVERROR(ENOMEM);
925
        }else{
926
            assert(!s->packet_buffer);
927
            return av_read_frame_internal(s, pkt);
928
        }
929
    }
930
}
931

    
932
/* XXX: suppress the packet queue */
933
static void flush_packet_queue(AVFormatContext *s)
934
{
935
    AVPacketList *pktl;
936

    
937
    for(;;) {
938
        pktl = s->packet_buffer;
939
        if (!pktl)
940
            break;
941
        s->packet_buffer = pktl->next;
942
        av_free_packet(&pktl->pkt);
943
        av_free(pktl);
944
    }
945
}
946

    
947
/*******************************************************/
948
/* seek support */
949

    
950
int av_find_default_stream_index(AVFormatContext *s)
951
{
952
    int i;
953
    AVStream *st;
954

    
955
    if (s->nb_streams <= 0)
956
        return -1;
957
    for(i = 0; i < s->nb_streams; i++) {
958
        st = s->streams[i];
959
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
960
            return i;
961
        }
962
    }
963
    return 0;
964
}
965

    
966
/**
967
 * Flush the frame reader.
968
 */
969
static void av_read_frame_flush(AVFormatContext *s)
970
{
971
    AVStream *st;
972
    int i;
973

    
974
    flush_packet_queue(s);
975

    
976
    /* free previous packet */
977
    if (s->cur_st) {
978
        if (s->cur_st->parser)
979
            av_free_packet(&s->cur_pkt);
980
        s->cur_st = NULL;
981
    }
982
    /* fail safe */
983
    s->cur_ptr = NULL;
984
    s->cur_len = 0;
985

    
986
    /* for each stream, reset read state */
987
    for(i = 0; i < s->nb_streams; i++) {
988
        st = s->streams[i];
989

    
990
        if (st->parser) {
991
            av_parser_close(st->parser);
992
            st->parser = NULL;
993
        }
994
        st->last_IP_pts = AV_NOPTS_VALUE;
995
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
996
    }
997
}
998

    
999
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1000
    int i;
1001

    
1002
    for(i = 0; i < s->nb_streams; i++) {
1003
        AVStream *st = s->streams[i];
1004

    
1005
        st->cur_dts = av_rescale(timestamp,
1006
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1007
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1008
    }
1009
}
1010

    
1011
int av_add_index_entry(AVStream *st,
1012
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1013
{
1014
    AVIndexEntry *entries, *ie;
1015
    int index;
1016

    
1017
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1018
        return -1;
1019

    
1020
    entries = av_fast_realloc(st->index_entries,
1021
                              &st->index_entries_allocated_size,
1022
                              (st->nb_index_entries + 1) *
1023
                              sizeof(AVIndexEntry));
1024
    if(!entries)
1025
        return -1;
1026

    
1027
    st->index_entries= entries;
1028

    
1029
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1030

    
1031
    if(index<0){
1032
        index= st->nb_index_entries++;
1033
        ie= &entries[index];
1034
        assert(index==0 || ie[-1].timestamp < timestamp);
1035
    }else{
1036
        ie= &entries[index];
1037
        if(ie->timestamp != timestamp){
1038
            if(ie->timestamp <= timestamp)
1039
                return -1;
1040
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1041
            st->nb_index_entries++;
1042
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1043
            distance= ie->min_distance;
1044
    }
1045

    
1046
    ie->pos = pos;
1047
    ie->timestamp = timestamp;
1048
    ie->min_distance= distance;
1049
    ie->size= size;
1050
    ie->flags = flags;
1051

    
1052
    return index;
1053
}
1054

    
1055
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1056
                              int flags)
1057
{
1058
    AVIndexEntry *entries= st->index_entries;
1059
    int nb_entries= st->nb_index_entries;
1060
    int a, b, m;
1061
    int64_t timestamp;
1062

    
1063
    a = - 1;
1064
    b = nb_entries;
1065

    
1066
    while (b - a > 1) {
1067
        m = (a + b) >> 1;
1068
        timestamp = entries[m].timestamp;
1069
        if(timestamp >= wanted_timestamp)
1070
            b = m;
1071
        if(timestamp <= wanted_timestamp)
1072
            a = m;
1073
    }
1074
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1075

    
1076
    if(!(flags & AVSEEK_FLAG_ANY)){
1077
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1078
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1079
        }
1080
    }
1081

    
1082
    if(m == nb_entries)
1083
        return -1;
1084
    return  m;
1085
}
1086

    
1087
#define DEBUG_SEEK
1088

    
1089
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1090
    AVInputFormat *avif= s->iformat;
1091
    int64_t pos_min, pos_max, pos, pos_limit;
1092
    int64_t ts_min, ts_max, ts;
1093
    int index;
1094
    AVStream *st;
1095

    
1096
    if (stream_index < 0)
1097
        return -1;
1098

    
1099
#ifdef DEBUG_SEEK
1100
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1101
#endif
1102

    
1103
    ts_max=
1104
    ts_min= AV_NOPTS_VALUE;
1105
    pos_limit= -1; //gcc falsely says it may be uninitialized
1106

    
1107
    st= s->streams[stream_index];
1108
    if(st->index_entries){
1109
        AVIndexEntry *e;
1110

    
1111
        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()
1112
        index= FFMAX(index, 0);
1113
        e= &st->index_entries[index];
1114

    
1115
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1116
            pos_min= e->pos;
1117
            ts_min= e->timestamp;
1118
#ifdef DEBUG_SEEK
1119
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1120
               pos_min,ts_min);
1121
#endif
1122
        }else{
1123
            assert(index==0);
1124
        }
1125

    
1126
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1127
        assert(index < st->nb_index_entries);
1128
        if(index >= 0){
1129
            e= &st->index_entries[index];
1130
            assert(e->timestamp >= target_ts);
1131
            pos_max= e->pos;
1132
            ts_max= e->timestamp;
1133
            pos_limit= pos_max - e->min_distance;
1134
#ifdef DEBUG_SEEK
1135
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1136
               pos_max,pos_limit, ts_max);
1137
#endif
1138
        }
1139
    }
1140

    
1141
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1142
    if(pos<0)
1143
        return -1;
1144

    
1145
    /* do the seek */
1146
    url_fseek(s->pb, pos, SEEK_SET);
1147

    
1148
    av_update_cur_dts(s, st, ts);
1149

    
1150
    return 0;
1151
}
1152

    
1153
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 )){
1154
    int64_t pos, ts;
1155
    int64_t start_pos, filesize;
1156
    int no_change;
1157

    
1158
#ifdef DEBUG_SEEK
1159
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1160
#endif
1161

    
1162
    if(ts_min == AV_NOPTS_VALUE){
1163
        pos_min = s->data_offset;
1164
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1165
        if (ts_min == AV_NOPTS_VALUE)
1166
            return -1;
1167
    }
1168

    
1169
    if(ts_max == AV_NOPTS_VALUE){
1170
        int step= 1024;
1171
        filesize = url_fsize(s->pb);
1172
        pos_max = filesize - 1;
1173
        do{
1174
            pos_max -= step;
1175
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1176
            step += step;
1177
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1178
        if (ts_max == AV_NOPTS_VALUE)
1179
            return -1;
1180

    
1181
        for(;;){
1182
            int64_t tmp_pos= pos_max + 1;
1183
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1184
            if(tmp_ts == AV_NOPTS_VALUE)
1185
                break;
1186
            ts_max= tmp_ts;
1187
            pos_max= tmp_pos;
1188
            if(tmp_pos >= filesize)
1189
                break;
1190
        }
1191
        pos_limit= pos_max;
1192
    }
1193

    
1194
    if(ts_min > ts_max){
1195
        return -1;
1196
    }else if(ts_min == ts_max){
1197
        pos_limit= pos_min;
1198
    }
1199

    
1200
    no_change=0;
1201
    while (pos_min < pos_limit) {
1202
#ifdef DEBUG_SEEK
1203
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1204
               pos_min, pos_max,
1205
               ts_min, ts_max);
1206
#endif
1207
        assert(pos_limit <= pos_max);
1208

    
1209
        if(no_change==0){
1210
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1211
            // interpolate position (better than dichotomy)
1212
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1213
                + pos_min - approximate_keyframe_distance;
1214
        }else if(no_change==1){
1215
            // bisection, if interpolation failed to change min or max pos last time
1216
            pos = (pos_min + pos_limit)>>1;
1217
        }else{
1218
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1219
            pos=pos_min;
1220
        }
1221
        if(pos <= pos_min)
1222
            pos= pos_min + 1;
1223
        else if(pos > pos_limit)
1224
            pos= pos_limit;
1225
        start_pos= pos;
1226

    
1227
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1228
        if(pos == pos_max)
1229
            no_change++;
1230
        else
1231
            no_change=0;
1232
#ifdef DEBUG_SEEK
1233
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);
1234
#endif
1235
        if(ts == AV_NOPTS_VALUE){
1236
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1237
            return -1;
1238
        }
1239
        assert(ts != AV_NOPTS_VALUE);
1240
        if (target_ts <= ts) {
1241
            pos_limit = start_pos - 1;
1242
            pos_max = pos;
1243
            ts_max = ts;
1244
        }
1245
        if (target_ts >= ts) {
1246
            pos_min = pos;
1247
            ts_min = ts;
1248
        }
1249
    }
1250

    
1251
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1252
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1253
#ifdef DEBUG_SEEK
1254
    pos_min = pos;
1255
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1256
    pos_min++;
1257
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1258
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1259
           pos, ts_min, target_ts, ts_max);
1260
#endif
1261
    *ts_ret= ts;
1262
    return pos;
1263
}
1264

    
1265
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1266
    int64_t pos_min, pos_max;
1267
#if 0
1268
    AVStream *st;
1269

1270
    if (stream_index < 0)
1271
        return -1;
1272

1273
    st= s->streams[stream_index];
1274
#endif
1275

    
1276
    pos_min = s->data_offset;
1277
    pos_max = url_fsize(s->pb) - 1;
1278

    
1279
    if     (pos < pos_min) pos= pos_min;
1280
    else if(pos > pos_max) pos= pos_max;
1281

    
1282
    url_fseek(s->pb, pos, SEEK_SET);
1283

    
1284
#if 0
1285
    av_update_cur_dts(s, st, ts);
1286
#endif
1287
    return 0;
1288
}
1289

    
1290
static int av_seek_frame_generic(AVFormatContext *s,
1291
                                 int stream_index, int64_t timestamp, int flags)
1292
{
1293
    int index;
1294
    AVStream *st;
1295
    AVIndexEntry *ie;
1296

    
1297
    st = s->streams[stream_index];
1298

    
1299
    index = av_index_search_timestamp(st, timestamp, flags);
1300

    
1301
    if(index < 0 || index==st->nb_index_entries-1){
1302
        int i;
1303
        AVPacket pkt;
1304

    
1305
        if(st->index_entries && st->nb_index_entries){
1306
            ie= &st->index_entries[st->nb_index_entries-1];
1307
            url_fseek(s->pb, ie->pos, SEEK_SET);
1308
            av_update_cur_dts(s, st, ie->timestamp);
1309
        }else
1310
            url_fseek(s->pb, 0, SEEK_SET);
1311

    
1312
        for(i=0;; i++) {
1313
            int ret = av_read_frame(s, &pkt);
1314
            if(ret<0)
1315
                break;
1316
            av_free_packet(&pkt);
1317
            if(stream_index == pkt.stream_index){
1318
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1319
                    break;
1320
            }
1321
        }
1322
        index = av_index_search_timestamp(st, timestamp, flags);
1323
    }
1324
    if (index < 0)
1325
        return -1;
1326

    
1327
    av_read_frame_flush(s);
1328
    if (s->iformat->read_seek){
1329
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1330
            return 0;
1331
    }
1332
    ie = &st->index_entries[index];
1333
    url_fseek(s->pb, ie->pos, SEEK_SET);
1334

    
1335
    av_update_cur_dts(s, st, ie->timestamp);
1336

    
1337
    return 0;
1338
}
1339

    
1340
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1341
{
1342
    int ret;
1343
    AVStream *st;
1344

    
1345
    av_read_frame_flush(s);
1346

    
1347
    if(flags & AVSEEK_FLAG_BYTE)
1348
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1349

    
1350
    if(stream_index < 0){
1351
        stream_index= av_find_default_stream_index(s);
1352
        if(stream_index < 0)
1353
            return -1;
1354

    
1355
        st= s->streams[stream_index];
1356
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1357
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1358
    }
1359
    st= s->streams[stream_index];
1360

    
1361
    /* first, we try the format specific seek */
1362
    if (s->iformat->read_seek)
1363
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1364
    else
1365
        ret = -1;
1366
    if (ret >= 0) {
1367
        return 0;
1368
    }
1369

    
1370
    if(s->iformat->read_timestamp)
1371
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1372
    else
1373
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1374
}
1375

    
1376
/*******************************************************/
1377

    
1378
/**
1379
 * Returns TRUE if the stream has accurate duration in any stream.
1380
 *
1381
 * @return TRUE if the stream has accurate duration for at least one component.
1382
 */
1383
static int av_has_duration(AVFormatContext *ic)
1384
{
1385
    int i;
1386
    AVStream *st;
1387

    
1388
    for(i = 0;i < ic->nb_streams; i++) {
1389
        st = ic->streams[i];
1390
        if (st->duration != AV_NOPTS_VALUE)
1391
            return 1;
1392
    }
1393
    return 0;
1394
}
1395

    
1396
/**
1397
 * Estimate the stream timings from the one of each components.
1398
 *
1399
 * Also computes the global bitrate if possible.
1400
 */
1401
static void av_update_stream_timings(AVFormatContext *ic)
1402
{
1403
    int64_t start_time, start_time1, end_time, end_time1;
1404
    int64_t duration, duration1;
1405
    int i;
1406
    AVStream *st;
1407

    
1408
    start_time = INT64_MAX;
1409
    end_time = INT64_MIN;
1410
    duration = INT64_MIN;
1411
    for(i = 0;i < ic->nb_streams; i++) {
1412
        st = ic->streams[i];
1413
        if (st->start_time != AV_NOPTS_VALUE) {
1414
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1415
            if (start_time1 < start_time)
1416
                start_time = start_time1;
1417
            if (st->duration != AV_NOPTS_VALUE) {
1418
                end_time1 = start_time1
1419
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1420
                if (end_time1 > end_time)
1421
                    end_time = end_time1;
1422
            }
1423
        }
1424
        if (st->duration != AV_NOPTS_VALUE) {
1425
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1426
            if (duration1 > duration)
1427
                duration = duration1;
1428
        }
1429
    }
1430
    if (start_time != INT64_MAX) {
1431
        ic->start_time = start_time;
1432
        if (end_time != INT64_MIN) {
1433
            if (end_time - start_time > duration)
1434
                duration = end_time - start_time;
1435
        }
1436
    }
1437
    if (duration != INT64_MIN) {
1438
        ic->duration = duration;
1439
        if (ic->file_size > 0) {
1440
            /* compute the bit rate */
1441
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1442
                (double)ic->duration;
1443
        }
1444
    }
1445
}
1446

    
1447
static void fill_all_stream_timings(AVFormatContext *ic)
1448
{
1449
    int i;
1450
    AVStream *st;
1451

    
1452
    av_update_stream_timings(ic);
1453
    for(i = 0;i < ic->nb_streams; i++) {
1454
        st = ic->streams[i];
1455
        if (st->start_time == AV_NOPTS_VALUE) {
1456
            if(ic->start_time != AV_NOPTS_VALUE)
1457
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1458
            if(ic->duration != AV_NOPTS_VALUE)
1459
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1460
        }
1461
    }
1462
}
1463

    
1464
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1465
{
1466
    int64_t filesize, duration;
1467
    int bit_rate, i;
1468
    AVStream *st;
1469

    
1470
    /* if bit_rate is already set, we believe it */
1471
    if (ic->bit_rate == 0) {
1472
        bit_rate = 0;
1473
        for(i=0;i<ic->nb_streams;i++) {
1474
            st = ic->streams[i];
1475
            bit_rate += st->codec->bit_rate;
1476
        }
1477
        ic->bit_rate = bit_rate;
1478
    }
1479

    
1480
    /* if duration is already set, we believe it */
1481
    if (ic->duration == AV_NOPTS_VALUE &&
1482
        ic->bit_rate != 0 &&
1483
        ic->file_size != 0)  {
1484
        filesize = ic->file_size;
1485
        if (filesize > 0) {
1486
            for(i = 0; i < ic->nb_streams; i++) {
1487
                st = ic->streams[i];
1488
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1489
                if (st->duration == AV_NOPTS_VALUE)
1490
                    st->duration = duration;
1491
            }
1492
        }
1493
    }
1494
}
1495

    
1496
#define DURATION_MAX_READ_SIZE 250000
1497

    
1498
/* only usable for MPEG-PS streams */
1499
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1500
{
1501
    AVPacket pkt1, *pkt = &pkt1;
1502
    AVStream *st;
1503
    int read_size, i, ret;
1504
    int64_t end_time;
1505
    int64_t filesize, offset, duration;
1506

    
1507
    /* free previous packet */
1508
    if (ic->cur_st && ic->cur_st->parser)
1509
        av_free_packet(&ic->cur_pkt);
1510
    ic->cur_st = NULL;
1511

    
1512
    /* flush packet queue */
1513
    flush_packet_queue(ic);
1514

    
1515
    for(i=0;i<ic->nb_streams;i++) {
1516
        st = ic->streams[i];
1517
        if (st->parser) {
1518
            av_parser_close(st->parser);
1519
            st->parser= NULL;
1520
        }
1521
    }
1522

    
1523
    /* we read the first packets to get the first PTS (not fully
1524
       accurate, but it is enough now) */
1525
    url_fseek(ic->pb, 0, SEEK_SET);
1526
    read_size = 0;
1527
    for(;;) {
1528
        if (read_size >= DURATION_MAX_READ_SIZE)
1529
            break;
1530
        /* if all info is available, we can stop */
1531
        for(i = 0;i < ic->nb_streams; i++) {
1532
            st = ic->streams[i];
1533
            if (st->start_time == AV_NOPTS_VALUE)
1534
                break;
1535
        }
1536
        if (i == ic->nb_streams)
1537
            break;
1538

    
1539
        ret = av_read_packet(ic, pkt);
1540
        if (ret != 0)
1541
            break;
1542
        read_size += pkt->size;
1543
        st = ic->streams[pkt->stream_index];
1544
        if (pkt->pts != AV_NOPTS_VALUE) {
1545
            if (st->start_time == AV_NOPTS_VALUE)
1546
                st->start_time = pkt->pts;
1547
        }
1548
        av_free_packet(pkt);
1549
    }
1550

    
1551
    /* estimate the end time (duration) */
1552
    /* XXX: may need to support wrapping */
1553
    filesize = ic->file_size;
1554
    offset = filesize - DURATION_MAX_READ_SIZE;
1555
    if (offset < 0)
1556
        offset = 0;
1557

    
1558
    url_fseek(ic->pb, offset, SEEK_SET);
1559
    read_size = 0;
1560
    for(;;) {
1561
        if (read_size >= DURATION_MAX_READ_SIZE)
1562
            break;
1563

    
1564
        ret = av_read_packet(ic, pkt);
1565
        if (ret != 0)
1566
            break;
1567
        read_size += pkt->size;
1568
        st = ic->streams[pkt->stream_index];
1569
        if (pkt->pts != AV_NOPTS_VALUE &&
1570
            st->start_time != AV_NOPTS_VALUE) {
1571
            end_time = pkt->pts;
1572
            duration = end_time - st->start_time;
1573
            if (duration > 0) {
1574
                if (st->duration == AV_NOPTS_VALUE ||
1575
                    st->duration < duration)
1576
                    st->duration = duration;
1577
            }
1578
        }
1579
        av_free_packet(pkt);
1580
    }
1581

    
1582
    fill_all_stream_timings(ic);
1583

    
1584
    url_fseek(ic->pb, old_offset, SEEK_SET);
1585
    for(i=0; i<ic->nb_streams; i++){
1586
        st= ic->streams[i];
1587
        st->cur_dts= st->first_dts;
1588
        st->last_IP_pts = AV_NOPTS_VALUE;
1589
    }
1590
}
1591

    
1592
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1593
{
1594
    int64_t file_size;
1595

    
1596
    /* get the file size, if possible */
1597
    if (ic->iformat->flags & AVFMT_NOFILE) {
1598
        file_size = 0;
1599
    } else {
1600
        file_size = url_fsize(ic->pb);
1601
        if (file_size < 0)
1602
            file_size = 0;
1603
    }
1604
    ic->file_size = file_size;
1605

    
1606
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1607
         !strcmp(ic->iformat->name, "mpegts")) &&
1608
        file_size && !url_is_streamed(ic->pb)) {
1609
        /* get accurate estimate from the PTSes */
1610
        av_estimate_timings_from_pts(ic, old_offset);
1611
    } else if (av_has_duration(ic)) {
1612
        /* at least one components has timings - we use them for all
1613
           the components */
1614
        fill_all_stream_timings(ic);
1615
    } else {
1616
        /* less precise: use bit rate info */
1617
        av_estimate_timings_from_bit_rate(ic);
1618
    }
1619
    av_update_stream_timings(ic);
1620

    
1621
#if 0
1622
    {
1623
        int i;
1624
        AVStream *st;
1625
        for(i = 0;i < ic->nb_streams; i++) {
1626
            st = ic->streams[i];
1627
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1628
               i, (double)st->start_time / AV_TIME_BASE,
1629
               (double)st->duration / AV_TIME_BASE);
1630
        }
1631
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1632
               (double)ic->start_time / AV_TIME_BASE,
1633
               (double)ic->duration / AV_TIME_BASE,
1634
               ic->bit_rate / 1000);
1635
    }
1636
#endif
1637
}
1638

    
1639
static int has_codec_parameters(AVCodecContext *enc)
1640
{
1641
    int val;
1642
    switch(enc->codec_type) {
1643
    case CODEC_TYPE_AUDIO:
1644
        val = enc->sample_rate;
1645
        break;
1646
    case CODEC_TYPE_VIDEO:
1647
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1648
        break;
1649
    default:
1650
        val = 1;
1651
        break;
1652
    }
1653
    return (enc->codec_id != CODEC_ID_NONE && val != 0);
1654
}
1655

    
1656
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1657
{
1658
    int16_t *samples;
1659
    AVCodec *codec;
1660
    int got_picture, data_size, ret=0;
1661
    AVFrame picture;
1662

    
1663
  if(!st->codec->codec){
1664
    codec = avcodec_find_decoder(st->codec->codec_id);
1665
    if (!codec)
1666
        return -1;
1667
    ret = avcodec_open(st->codec, codec);
1668
    if (ret < 0)
1669
        return ret;
1670
  }
1671

    
1672
  if(!has_codec_parameters(st->codec)){
1673
    switch(st->codec->codec_type) {
1674
    case CODEC_TYPE_VIDEO:
1675
        ret = avcodec_decode_video(st->codec, &picture,
1676
                                   &got_picture, (uint8_t *)data, size);
1677
        break;
1678
    case CODEC_TYPE_AUDIO:
1679
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1680
        samples = av_malloc(data_size);
1681
        if (!samples)
1682
            goto fail;
1683
        ret = avcodec_decode_audio2(st->codec, samples,
1684
                                    &data_size, (uint8_t *)data, size);
1685
        av_free(samples);
1686
        break;
1687
    default:
1688
        break;
1689
    }
1690
  }
1691
 fail:
1692
    return ret;
1693
}
1694

    
1695
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1696
{
1697
    AVInputFormat *fmt;
1698
    fmt = av_probe_input_format2(pd, 1, &score);
1699

    
1700
    if (fmt) {
1701
        if (strncmp(fmt->name, "mp3", 3) == 0)
1702
            st->codec->codec_id = CODEC_ID_MP3;
1703
        else if (strncmp(fmt->name, "ac3", 3) == 0)
1704
            st->codec->codec_id = CODEC_ID_AC3;
1705
    }
1706
    return !!fmt;
1707
}
1708

    
1709
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1710
{
1711
    while (tags->id != CODEC_ID_NONE) {
1712
        if (tags->id == id)
1713
            return tags->tag;
1714
        tags++;
1715
    }
1716
    return 0;
1717
}
1718

    
1719
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1720
{
1721
    int i;
1722
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1723
        if(tag == tags[i].tag)
1724
            return tags[i].id;
1725
    }
1726
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1727
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1728
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1729
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1730
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1731
            return tags[i].id;
1732
    }
1733
    return CODEC_ID_NONE;
1734
}
1735

    
1736
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1737
{
1738
    int i;
1739
    for(i=0; tags && tags[i]; i++){
1740
        int tag= codec_get_tag(tags[i], id);
1741
        if(tag) return tag;
1742
    }
1743
    return 0;
1744
}
1745

    
1746
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1747
{
1748
    int i;
1749
    for(i=0; tags && tags[i]; i++){
1750
        enum CodecID id= codec_get_id(tags[i], tag);
1751
        if(id!=CODEC_ID_NONE) return id;
1752
    }
1753
    return CODEC_ID_NONE;
1754
}
1755

    
1756
/* absolute maximum size we read until we abort */
1757
#define MAX_READ_SIZE        5000000
1758

    
1759
#define MAX_STD_TIMEBASES (60*12+5)
1760
static int get_std_framerate(int i){
1761
    if(i<60*12) return i*1001;
1762
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1763
}
1764

    
1765
/*
1766
 * Is the time base unreliable.
1767
 * This is a heuristic to balance between quick acceptance of the values in
1768
 * the headers vs. some extra checks.
1769
 * Old divx and xvid often have nonsense timebases like 1fps or 2fps.
1770
 * Mpeg2 commonly misuses field repeat flags to store different framerates.
1771
 * And there are "variable" fps files this needs to detect as well.
1772
 */
1773
static int tb_unreliable(AVCodecContext *c){
1774
    if(   c->time_base.den >= 101L*c->time_base.num
1775
       || c->time_base.den <    5L*c->time_base.num
1776
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1777
       || c->codec_tag == ff_get_fourcc("XVID")*/
1778
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1779
        return 1;
1780
    return 0;
1781
}
1782

    
1783
int av_find_stream_info(AVFormatContext *ic)
1784
{
1785
    int i, count, ret, read_size, j;
1786
    AVStream *st;
1787
    AVPacket pkt1, *pkt;
1788
    int64_t last_dts[MAX_STREAMS];
1789
    int duration_count[MAX_STREAMS]={0};
1790
    double (*duration_error)[MAX_STD_TIMEBASES];
1791
    offset_t old_offset = url_ftell(ic->pb);
1792
    int64_t codec_info_duration[MAX_STREAMS]={0};
1793
    int codec_info_nb_frames[MAX_STREAMS]={0};
1794
    AVProbeData probe_data[MAX_STREAMS];
1795
    int codec_identified[MAX_STREAMS]={0};
1796

    
1797
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1798
    if (!duration_error) return AVERROR(ENOMEM);
1799

    
1800
    for(i=0;i<ic->nb_streams;i++) {
1801
        st = ic->streams[i];
1802
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1803
/*            if(!st->time_base.num)
1804
                st->time_base= */
1805
            if(!st->codec->time_base.num)
1806
                st->codec->time_base= st->time_base;
1807
        }
1808
        //only for the split stuff
1809
        if (!st->parser) {
1810
            st->parser = av_parser_init(st->codec->codec_id);
1811
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1812
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1813
            }
1814
        }
1815
    }
1816

    
1817
    for(i=0;i<MAX_STREAMS;i++){
1818
        last_dts[i]= AV_NOPTS_VALUE;
1819
    }
1820

    
1821
    memset(probe_data, 0, sizeof(probe_data));
1822
    count = 0;
1823
    read_size = 0;
1824
    for(;;) {
1825
        /* check if one codec still needs to be handled */
1826
        for(i=0;i<ic->nb_streams;i++) {
1827
            st = ic->streams[i];
1828
            if (!has_codec_parameters(st->codec))
1829
                break;
1830
            /* variable fps and no guess at the real fps */
1831
            if(   tb_unreliable(st->codec)
1832
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1833
                break;
1834
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1835
                break;
1836
            if(st->first_dts == AV_NOPTS_VALUE)
1837
                break;
1838
        }
1839
        if (i == ic->nb_streams) {
1840
            /* NOTE: if the format has no header, then we need to read
1841
               some packets to get most of the streams, so we cannot
1842
               stop here */
1843
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1844
                /* if we found the info for all the codecs, we can stop */
1845
                ret = count;
1846
                break;
1847
            }
1848
        }
1849
        /* we did not get all the codec info, but we read too much data */
1850
        if (read_size >= MAX_READ_SIZE) {
1851
            ret = count;
1852
            break;
1853
        }
1854

    
1855
        /* NOTE: a new stream can be added there if no header in file
1856
           (AVFMTCTX_NOHEADER) */
1857
        ret = av_read_frame_internal(ic, &pkt1);
1858
        if (ret < 0) {
1859
            /* EOF or error */
1860
            ret = -1; /* we could not have all the codec parameters before EOF */
1861
            for(i=0;i<ic->nb_streams;i++) {
1862
                st = ic->streams[i];
1863
                if (!has_codec_parameters(st->codec)){
1864
                    char buf[256];
1865
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1866
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1867
                } else {
1868
                    ret = 0;
1869
                }
1870
            }
1871
            break;
1872
        }
1873

    
1874
        pkt= add_to_pktbuf(ic, &pkt1);
1875
        if(av_dup_packet(pkt) < 0)
1876
            return AVERROR(ENOMEM);
1877

    
1878
        read_size += pkt->size;
1879

    
1880
        st = ic->streams[pkt->stream_index];
1881
        if(codec_info_nb_frames[st->index]>1)
1882
            codec_info_duration[st->index] += pkt->duration;
1883
        if (pkt->duration != 0)
1884
            codec_info_nb_frames[st->index]++;
1885

    
1886
        {
1887
            int index= pkt->stream_index;
1888
            int64_t last= last_dts[index];
1889
            int64_t duration= pkt->dts - last;
1890

    
1891
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1892
                double dur= duration * av_q2d(st->time_base);
1893

    
1894
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1895
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1896
                if(duration_count[index] < 2)
1897
                    memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1898
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1899
                    int framerate= get_std_framerate(i);
1900
                    int ticks= lrintf(dur*framerate/(1001*12));
1901
                    double error= dur - ticks*1001*12/(double)framerate;
1902
                    duration_error[index][i] += error*error;
1903
                }
1904
                duration_count[index]++;
1905
            }
1906
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1907
                last_dts[pkt->stream_index]= pkt->dts;
1908

    
1909
            if (st->codec->codec_id == CODEC_ID_NONE) {
1910
                AVProbeData *pd = &(probe_data[st->index]);
1911
                pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
1912
                memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1913
                pd->buf_size += pkt->size;
1914
                memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1915
            }
1916
        }
1917
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1918
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1919
            if(i){
1920
                st->codec->extradata_size= i;
1921
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1922
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1923
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1924
            }
1925
        }
1926

    
1927
        /* if still no information, we try to open the codec and to
1928
           decompress the frame. We try to avoid that in most cases as
1929
           it takes longer and uses more memory. For MPEG4, we need to
1930
           decompress for Quicktime. */
1931
        if (!has_codec_parameters(st->codec) /*&&
1932
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1933
             st->codec->codec_id == CODEC_ID_H264 ||
1934
             st->codec->codec_id == CODEC_ID_H263 ||
1935
             st->codec->codec_id == CODEC_ID_H261 ||
1936
             st->codec->codec_id == CODEC_ID_VORBIS ||
1937
             st->codec->codec_id == CODEC_ID_MJPEG ||
1938
             st->codec->codec_id == CODEC_ID_PNG ||
1939
             st->codec->codec_id == CODEC_ID_PAM ||
1940
             st->codec->codec_id == CODEC_ID_PGM ||
1941
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1942
             st->codec->codec_id == CODEC_ID_PBM ||
1943
             st->codec->codec_id == CODEC_ID_PPM ||
1944
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1945
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1946
            try_decode_frame(st, pkt->data, pkt->size);
1947

    
1948
        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) {
1949
            break;
1950
        }
1951
        count++;
1952
    }
1953

    
1954
    // close codecs which where opened in try_decode_frame()
1955
    for(i=0;i<ic->nb_streams;i++) {
1956
        st = ic->streams[i];
1957
        if(st->codec->codec)
1958
            avcodec_close(st->codec);
1959
    }
1960
    for(i=0;i<ic->nb_streams;i++) {
1961
        st = ic->streams[i];
1962
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1963
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1964
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1965

    
1966
            if(duration_count[i]
1967
               && tb_unreliable(st->codec) /*&&
1968
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1969
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1970
                double best_error= 2*av_q2d(st->time_base);
1971
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
1972

    
1973
                for(j=1; j<MAX_STD_TIMEBASES; j++){
1974
                    double error= duration_error[i][j] * get_std_framerate(j);
1975
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1976
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1977
                    if(error < best_error){
1978
                        best_error= error;
1979
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1980
                    }
1981
                }
1982
            }
1983

    
1984
            if (!st->r_frame_rate.num){
1985
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1986
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1987
                    st->r_frame_rate.num = st->codec->time_base.den;
1988
                    st->r_frame_rate.den = st->codec->time_base.num;
1989
                }else{
1990
                    st->r_frame_rate.num = st->time_base.den;
1991
                    st->r_frame_rate.den = st->time_base.num;
1992
                }
1993
            }
1994
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1995
            if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1996
                codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
1997
                if (codec_identified[st->index]) {
1998
                    st->need_parsing = AVSTREAM_PARSE_FULL;
1999
                }
2000
            }
2001
            if(!st->codec->bits_per_sample)
2002
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2003
        }
2004
    }
2005

    
2006
    av_estimate_timings(ic, old_offset);
2007

    
2008
    for(i=0;i<ic->nb_streams;i++) {
2009
        st = ic->streams[i];
2010
        if (codec_identified[st->index])
2011
            break;
2012
    }
2013
    //FIXME this is a mess
2014
    if(i!=ic->nb_streams){
2015
        av_read_frame_flush(ic);
2016
        for(i=0;i<ic->nb_streams;i++) {
2017
            st = ic->streams[i];
2018
            if (codec_identified[st->index]) {
2019
                av_seek_frame(ic, st->index, 0.0, 0);
2020
            }
2021
            st->cur_dts= st->first_dts;
2022
        }
2023
        url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2024
    }
2025

    
2026
#if 0
2027
    /* correct DTS for b frame streams with no timestamps */
2028
    for(i=0;i<ic->nb_streams;i++) {
2029
        st = ic->streams[i];
2030
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2031
            if(b-frames){
2032
                ppktl = &ic->packet_buffer;
2033
                while(ppkt1){
2034
                    if(ppkt1->stream_index != i)
2035
                        continue;
2036
                    if(ppkt1->pkt->dts < 0)
2037
                        break;
2038
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2039
                        break;
2040
                    ppkt1->pkt->dts -= delta;
2041
                    ppkt1= ppkt1->next;
2042
                }
2043
                if(ppkt1)
2044
                    continue;
2045
                st->cur_dts -= delta;
2046
            }
2047
        }
2048
    }
2049
#endif
2050

    
2051
    av_free(duration_error);
2052
    for(i=0;i<MAX_STREAMS;i++){
2053
        av_freep(&(probe_data[i].buf));
2054
    }
2055

    
2056
    return ret;
2057
}
2058

    
2059
/*******************************************************/
2060

    
2061
int av_read_play(AVFormatContext *s)
2062
{
2063
    if (s->iformat->read_play)
2064
        return s->iformat->read_play(s);
2065
    if (s->pb)
2066
        return av_url_read_fpause(s->pb, 0);
2067
    return AVERROR(ENOSYS);
2068
}
2069

    
2070
int av_read_pause(AVFormatContext *s)
2071
{
2072
    if (s->iformat->read_pause)
2073
        return s->iformat->read_pause(s);
2074
    if (s->pb)
2075
        return av_url_read_fpause(s->pb, 1);
2076
    return AVERROR(ENOSYS);
2077
}
2078

    
2079
void av_close_input_stream(AVFormatContext *s)
2080
{
2081
    int i;
2082
    AVStream *st;
2083

    
2084
    /* free previous packet */
2085
    if (s->cur_st && s->cur_st->parser)
2086
        av_free_packet(&s->cur_pkt);
2087

    
2088
    if (s->iformat->read_close)
2089
        s->iformat->read_close(s);
2090
    for(i=0;i<s->nb_streams;i++) {
2091
        /* free all data in a stream component */
2092
        st = s->streams[i];
2093
        if (st->parser) {
2094
            av_parser_close(st->parser);
2095
        }
2096
        av_free(st->index_entries);
2097
        av_free(st->codec->extradata);
2098
        av_free(st->codec);
2099
        av_free(st);
2100
    }
2101
    for(i=s->nb_programs-1; i>=0; i--) {
2102
        av_freep(&s->programs[i]->provider_name);
2103
        av_freep(&s->programs[i]->name);
2104
        av_freep(&s->programs[i]->stream_index);
2105
        av_freep(&s->programs[i]);
2106
    }
2107
    flush_packet_queue(s);
2108
    av_freep(&s->priv_data);
2109
    av_free(s);
2110
}
2111

    
2112
void av_close_input_file(AVFormatContext *s)
2113
{
2114
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2115
    av_close_input_stream(s);
2116
    if (pb)
2117
        url_fclose(pb);
2118
}
2119

    
2120
AVStream *av_new_stream(AVFormatContext *s, int id)
2121
{
2122
    AVStream *st;
2123
    int i;
2124

    
2125
    if (s->nb_streams >= MAX_STREAMS)
2126
        return NULL;
2127

    
2128
    st = av_mallocz(sizeof(AVStream));
2129
    if (!st)
2130
        return NULL;
2131

    
2132
    st->codec= avcodec_alloc_context();
2133
    if (s->iformat) {
2134
        /* no default bitrate if decoding */
2135
        st->codec->bit_rate = 0;
2136
    }
2137
    st->index = s->nb_streams;
2138
    st->id = id;
2139
    st->start_time = AV_NOPTS_VALUE;
2140
    st->duration = AV_NOPTS_VALUE;
2141
    st->cur_dts = AV_NOPTS_VALUE;
2142
    st->first_dts = AV_NOPTS_VALUE;
2143

    
2144
    /* default pts settings is MPEG like */
2145
    av_set_pts_info(st, 33, 1, 90000);
2146
    st->last_IP_pts = AV_NOPTS_VALUE;
2147
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2148
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2149

    
2150
    s->streams[s->nb_streams++] = st;
2151
    return st;
2152
}
2153

    
2154
AVProgram *av_new_program(AVFormatContext *ac, int id)
2155
{
2156
    AVProgram *program=NULL;
2157
    int i;
2158

    
2159
#ifdef DEBUG_SI
2160
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2161
#endif
2162

    
2163
    for(i=0; i<ac->nb_programs; i++)
2164
        if(ac->programs[i]->id == id)
2165
            program = ac->programs[i];
2166

    
2167
    if(!program){
2168
        program = av_mallocz(sizeof(AVProgram));
2169
        if (!program)
2170
            return NULL;
2171
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2172
        program->discard = AVDISCARD_NONE;
2173
    }
2174
    program->id = id;
2175

    
2176
    return program;
2177
}
2178

    
2179
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2180
{
2181
    assert(!provider_name == !name);
2182
    if(name){
2183
        av_free(program->provider_name);
2184
        av_free(program->         name);
2185
        program->provider_name = av_strdup(provider_name);
2186
        program->         name = av_strdup(         name);
2187
    }
2188
}
2189

    
2190

    
2191
/************************************************************/
2192
/* output media file */
2193

    
2194
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2195
{
2196
    int ret;
2197

    
2198
    if (s->oformat->priv_data_size > 0) {
2199
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2200
        if (!s->priv_data)
2201
            return AVERROR(ENOMEM);
2202
    } else
2203
        s->priv_data = NULL;
2204

    
2205
    if (s->oformat->set_parameters) {
2206
        ret = s->oformat->set_parameters(s, ap);
2207
        if (ret < 0)
2208
            return ret;
2209
    }
2210
    return 0;
2211
}
2212

    
2213
int av_write_header(AVFormatContext *s)
2214
{
2215
    int ret, i;
2216
    AVStream *st;
2217

    
2218
    // some sanity checks
2219
    for(i=0;i<s->nb_streams;i++) {
2220
        st = s->streams[i];
2221

    
2222
        switch (st->codec->codec_type) {
2223
        case CODEC_TYPE_AUDIO:
2224
            if(st->codec->sample_rate<=0){
2225
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2226
                return -1;
2227
            }
2228
            break;
2229
        case CODEC_TYPE_VIDEO:
2230
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2231
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2232
                return -1;
2233
            }
2234
            if(st->codec->width<=0 || st->codec->height<=0){
2235
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2236
                return -1;
2237
            }
2238
            break;
2239
        }
2240

    
2241
        if(s->oformat->codec_tag){
2242
            if(st->codec->codec_tag){
2243
                //FIXME
2244
                //check that tag + id is in the table
2245
                //if neither is in the table -> ok
2246
                //if tag is in the table with another id -> FAIL
2247
                //if id is in the table with another tag -> FAIL unless strict < ?
2248
            }else
2249
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2250
        }
2251
    }
2252

    
2253
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2254
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2255
        if (!s->priv_data)
2256
            return AVERROR(ENOMEM);
2257
    }
2258

    
2259
    if(s->oformat->write_header){
2260
        ret = s->oformat->write_header(s);
2261
        if (ret < 0)
2262
            return ret;
2263
    }
2264

    
2265
    /* init PTS generation */
2266
    for(i=0;i<s->nb_streams;i++) {
2267
        int64_t den = AV_NOPTS_VALUE;
2268
        st = s->streams[i];
2269

    
2270
        switch (st->codec->codec_type) {
2271
        case CODEC_TYPE_AUDIO:
2272
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2273
            break;
2274
        case CODEC_TYPE_VIDEO:
2275
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2276
            break;
2277
        default:
2278
            break;
2279
        }
2280
        if (den != AV_NOPTS_VALUE) {
2281
            if (den <= 0)
2282
                return AVERROR_INVALIDDATA;
2283
            av_frac_init(&st->pts, 0, 0, den);
2284
        }
2285
    }
2286
    return 0;
2287
}
2288

    
2289
//FIXME merge with compute_pkt_fields
2290
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2291
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2292
    int num, den, frame_size, i;
2293

    
2294
//    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);
2295

    
2296
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2297
        return -1;*/
2298

    
2299
    /* duration field */
2300
    if (pkt->duration == 0) {
2301
        compute_frame_duration(&num, &den, st, NULL, pkt);
2302
        if (den && num) {
2303
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2304
        }
2305
    }
2306

    
2307
    //XXX/FIXME this is a temporary hack until all encoders output pts
2308
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2309
        pkt->dts=
2310
//        pkt->pts= st->cur_dts;
2311
        pkt->pts= st->pts.val;
2312
    }
2313

    
2314
    //calculate dts from pts
2315
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2316
        st->pts_buffer[0]= pkt->pts;
2317
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2318
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2319
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2320
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2321

    
2322
        pkt->dts= st->pts_buffer[0];
2323
    }
2324

    
2325
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2326
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2327
        return -1;
2328
    }
2329
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2330
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2331
        return -1;
2332
    }
2333

    
2334
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2335
    st->cur_dts= pkt->dts;
2336
    st->pts.val= pkt->dts;
2337

    
2338
    /* update pts */
2339
    switch (st->codec->codec_type) {
2340
    case CODEC_TYPE_AUDIO:
2341
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2342

    
2343
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2344
           but it would be better if we had the real timestamps from the encoder */
2345
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2346
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2347
        }
2348
        break;
2349
    case CODEC_TYPE_VIDEO:
2350
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2351
        break;
2352
    default:
2353
        break;
2354
    }
2355
    return 0;
2356
}
2357

    
2358
static void truncate_ts(AVStream *st, AVPacket *pkt){
2359
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2360

    
2361
//    if(pkt->dts < 0)
2362
//        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2363

    
2364
    if (pkt->pts != AV_NOPTS_VALUE)
2365
        pkt->pts &= pts_mask;
2366
    if (pkt->dts != AV_NOPTS_VALUE)
2367
        pkt->dts &= pts_mask;
2368
}
2369

    
2370
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2371
{
2372
    int ret;
2373

    
2374
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2375
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2376
        return ret;
2377

    
2378
    truncate_ts(s->streams[pkt->stream_index], pkt);
2379

    
2380
    ret= s->oformat->write_packet(s, pkt);
2381
    if(!ret)
2382
        ret= url_ferror(s->pb);
2383
    return ret;
2384
}
2385

    
2386
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2387
    AVPacketList *pktl, **next_point, *this_pktl;
2388
    int stream_count=0;
2389
    int streams[MAX_STREAMS];
2390

    
2391
    if(pkt){
2392
        AVStream *st= s->streams[ pkt->stream_index];
2393

    
2394
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2395

    
2396
        this_pktl = av_mallocz(sizeof(AVPacketList));
2397
        this_pktl->pkt= *pkt;
2398
        if(pkt->destruct == av_destruct_packet)
2399
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2400
        else
2401
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2402

    
2403
        next_point = &s->packet_buffer;
2404
        while(*next_point){
2405
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2406
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2407
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2408
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2409
                break;
2410
            next_point= &(*next_point)->next;
2411
        }
2412
        this_pktl->next= *next_point;
2413
        *next_point= this_pktl;
2414
    }
2415

    
2416
    memset(streams, 0, sizeof(streams));
2417
    pktl= s->packet_buffer;
2418
    while(pktl){
2419
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2420
        if(streams[ pktl->pkt.stream_index ] == 0)
2421
            stream_count++;
2422
        streams[ pktl->pkt.stream_index ]++;
2423
        pktl= pktl->next;
2424
    }
2425

    
2426
    if(s->nb_streams == stream_count || (flush && stream_count)){
2427
        pktl= s->packet_buffer;
2428
        *out= pktl->pkt;
2429

    
2430
        s->packet_buffer= pktl->next;
2431
        av_freep(&pktl);
2432
        return 1;
2433
    }else{
2434
        av_init_packet(out);
2435
        return 0;
2436
    }
2437
}
2438

    
2439
/**
2440
 * Interleaves a AVPacket correctly so it can be muxed.
2441
 * @param out the interleaved packet will be output here
2442
 * @param in the input packet
2443
 * @param flush 1 if no further packets are available as input and all
2444
 *              remaining packets should be output
2445
 * @return 1 if a packet was output, 0 if no packet could be output,
2446
 *         < 0 if an error occured
2447
 */
2448
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2449
    if(s->oformat->interleave_packet)
2450
        return s->oformat->interleave_packet(s, out, in, flush);
2451
    else
2452
        return av_interleave_packet_per_dts(s, out, in, flush);
2453
}
2454

    
2455
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2456
    AVStream *st= s->streams[ pkt->stream_index];
2457

    
2458
    //FIXME/XXX/HACK drop zero sized packets
2459
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2460
        return 0;
2461

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

    
2466
    if(pkt->dts == AV_NOPTS_VALUE)
2467
        return -1;
2468

    
2469
    for(;;){
2470
        AVPacket opkt;
2471
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2472
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2473
            return ret;
2474

    
2475
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2476
        ret= s->oformat->write_packet(s, &opkt);
2477

    
2478
        av_free_packet(&opkt);
2479
        pkt= NULL;
2480

    
2481
        if(ret<0)
2482
            return ret;
2483
        if(url_ferror(s->pb))
2484
            return url_ferror(s->pb);
2485
    }
2486
}
2487

    
2488
int av_write_trailer(AVFormatContext *s)
2489
{
2490
    int ret, i;
2491

    
2492
    for(;;){
2493
        AVPacket pkt;
2494
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2495
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2496
            goto fail;
2497
        if(!ret)
2498
            break;
2499

    
2500
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2501
        ret= s->oformat->write_packet(s, &pkt);
2502

    
2503
        av_free_packet(&pkt);
2504

    
2505
        if(ret<0)
2506
            goto fail;
2507
        if(url_ferror(s->pb))
2508
            goto fail;
2509
    }
2510

    
2511
    if(s->oformat->write_trailer)
2512
        ret = s->oformat->write_trailer(s);
2513
fail:
2514
    if(ret == 0)
2515
       ret=url_ferror(s->pb);
2516
    for(i=0;i<s->nb_streams;i++)
2517
        av_freep(&s->streams[i]->priv_data);
2518
    av_freep(&s->priv_data);
2519
    return ret;
2520
}
2521

    
2522
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2523
{
2524
    int i, j;
2525
    AVProgram *program=NULL;
2526
    void *tmp;
2527

    
2528
    for(i=0; i<ac->nb_programs; i++){
2529
        if(ac->programs[i]->id != progid)
2530
            continue;
2531
        program = ac->programs[i];
2532
        for(j=0; j<program->nb_stream_indexes; j++)
2533
            if(program->stream_index[j] == idx)
2534
                return;
2535

    
2536
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2537
        if(!tmp)
2538
            return;
2539
        program->stream_index = tmp;
2540
        program->stream_index[program->nb_stream_indexes++] = idx;
2541
        return;
2542
    }
2543
}
2544

    
2545
/* "user interface" functions */
2546
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2547
{
2548
    char buf[256];
2549
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2550
    AVStream *st = ic->streams[i];
2551
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2552
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2553
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2554
    /* the pid is an important information, so we display it */
2555
    /* XXX: add a generic system */
2556
    if (flags & AVFMT_SHOW_IDS)
2557
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2558
    if (strlen(st->language) > 0)
2559
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2560
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2561
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2562
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2563
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2564
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2565
/*      else if(st->time_base.den && st->time_base.num)
2566
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2567
        else
2568
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2569
    }
2570
    av_log(NULL, AV_LOG_INFO, "\n");
2571
}
2572

    
2573
void dump_format(AVFormatContext *ic,
2574
                 int index,
2575
                 const char *url,
2576
                 int is_output)
2577
{
2578
    int i;
2579

    
2580
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2581
            is_output ? "Output" : "Input",
2582
            index,
2583
            is_output ? ic->oformat->name : ic->iformat->name,
2584
            is_output ? "to" : "from", url);
2585
    if (!is_output) {
2586
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2587
        if (ic->duration != AV_NOPTS_VALUE) {
2588
            int hours, mins, secs, us;
2589
            secs = ic->duration / AV_TIME_BASE;
2590
            us = ic->duration % AV_TIME_BASE;
2591
            mins = secs / 60;
2592
            secs %= 60;
2593
            hours = mins / 60;
2594
            mins %= 60;
2595
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2596
                   (10 * us) / AV_TIME_BASE);
2597
        } else {
2598
            av_log(NULL, AV_LOG_INFO, "N/A");
2599
        }
2600
        if (ic->start_time != AV_NOPTS_VALUE) {
2601
            int secs, us;
2602
            av_log(NULL, AV_LOG_INFO, ", start: ");
2603
            secs = ic->start_time / AV_TIME_BASE;
2604
            us = ic->start_time % AV_TIME_BASE;
2605
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2606
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2607
        }
2608
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2609
        if (ic->bit_rate) {
2610
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2611
        } else {
2612
            av_log(NULL, AV_LOG_INFO, "N/A");
2613
        }
2614
        av_log(NULL, AV_LOG_INFO, "\n");
2615
    }
2616
    if(ic->nb_programs) {
2617
        int j, k;
2618
        for(j=0; j<ic->nb_programs; j++) {
2619
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2620
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2621
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2622
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2623
         }
2624
    } else
2625
    for(i=0;i<ic->nb_streams;i++)
2626
        dump_stream_format(ic, i, index, is_output);
2627
}
2628

    
2629
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2630
{
2631
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2632
}
2633

    
2634
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2635
{
2636
    AVRational frame_rate;
2637
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2638
    *frame_rate_num= frame_rate.num;
2639
    *frame_rate_den= frame_rate.den;
2640
    return ret;
2641
}
2642

    
2643
/**
2644
 * gets the current time in micro seconds.
2645
 */
2646
int64_t av_gettime(void)
2647
{
2648
    struct timeval tv;
2649
    gettimeofday(&tv,NULL);
2650
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2651
}
2652

    
2653
int64_t parse_date(const char *datestr, int duration)
2654
{
2655
    const char *p;
2656
    int64_t t;
2657
    struct tm dt;
2658
    int i;
2659
    static const char *date_fmt[] = {
2660
        "%Y-%m-%d",
2661
        "%Y%m%d",
2662
    };
2663
    static const char *time_fmt[] = {
2664
        "%H:%M:%S",
2665
        "%H%M%S",
2666
    };
2667
    const char *q;
2668
    int is_utc, len;
2669
    char lastch;
2670
    int negative = 0;
2671

    
2672
#undef time
2673
    time_t now = time(0);
2674

    
2675
    len = strlen(datestr);
2676
    if (len > 0)
2677
        lastch = datestr[len - 1];
2678
    else
2679
        lastch = '\0';
2680
    is_utc = (lastch == 'z' || lastch == 'Z');
2681

    
2682
    memset(&dt, 0, sizeof(dt));
2683

    
2684
    p = datestr;
2685
    q = NULL;
2686
    if (!duration) {
2687
        /* parse the year-month-day part */
2688
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2689
            q = small_strptime(p, date_fmt[i], &dt);
2690
            if (q) {
2691
                break;
2692
            }
2693
        }
2694

    
2695
        /* if the year-month-day part is missing, then take the
2696
         * current year-month-day time */
2697
        if (!q) {
2698
            if (is_utc) {
2699
                dt = *gmtime(&now);
2700
            } else {
2701
                dt = *localtime(&now);
2702
            }
2703
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2704
        } else {
2705
            p = q;
2706
        }
2707

    
2708
        if (*p == 'T' || *p == 't' || *p == ' ')
2709
            p++;
2710

    
2711
        /* parse the hour-minute-second part */
2712
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2713
            q = small_strptime(p, time_fmt[i], &dt);
2714
            if (q) {
2715
                break;
2716
            }
2717
        }
2718
    } else {
2719
        /* parse datestr as a duration */
2720
        if (p[0] == '-') {
2721
            negative = 1;
2722
            ++p;
2723
        }
2724
        /* parse datestr as HH:MM:SS */
2725
        q = small_strptime(p, time_fmt[0], &dt);
2726
        if (!q) {
2727
            /* parse datestr as S+ */
2728
            dt.tm_sec = strtol(p, (char **)&q, 10);
2729
            if (q == p)
2730
                /* the parsing didn't succeed */
2731
                return INT64_MIN;
2732
            dt.tm_min = 0;
2733
            dt.tm_hour = 0;
2734
        }
2735
    }
2736

    
2737
    /* Now we have all the fields that we can get */
2738
    if (!q) {
2739
        return INT64_MIN;
2740
    }
2741

    
2742
    if (duration) {
2743
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2744
    } else {
2745
        dt.tm_isdst = -1;       /* unknown */
2746
        if (is_utc) {
2747
            t = mktimegm(&dt);
2748
        } else {
2749
            t = mktime(&dt);
2750
        }
2751
    }
2752

    
2753
    t *= 1000000;
2754

    
2755
    /* parse the .m... part */
2756
    if (*q == '.') {
2757
        int val, n;
2758
        q++;
2759
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2760
            if (!isdigit(*q))
2761
                break;
2762
            val += n * (*q - '0');
2763
        }
2764
        t += val;
2765
    }
2766
    return negative ? -t : t;
2767
}
2768

    
2769
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2770
{
2771
    const char *p;
2772
    char tag[128], *q;
2773

    
2774
    p = info;
2775
    if (*p == '?')
2776
        p++;
2777
    for(;;) {
2778
        q = tag;
2779
        while (*p != '\0' && *p != '=' && *p != '&') {
2780
            if ((q - tag) < sizeof(tag) - 1)
2781
                *q++ = *p;
2782
            p++;
2783
        }
2784
        *q = '\0';
2785
        q = arg;
2786
        if (*p == '=') {
2787
            p++;
2788
            while (*p != '&' && *p != '\0') {
2789
                if ((q - arg) < arg_size - 1) {
2790
                    if (*p == '+')
2791
                        *q++ = ' ';
2792
                    else
2793
                        *q++ = *p;
2794
                }
2795
                p++;
2796
            }
2797
            *q = '\0';
2798
        }
2799
        if (!strcmp(tag, tag1))
2800
            return 1;
2801
        if (*p != '&')
2802
            break;
2803
        p++;
2804
    }
2805
    return 0;
2806
}
2807

    
2808
int av_get_frame_filename(char *buf, int buf_size,
2809
                          const char *path, int number)
2810
{
2811
    const char *p;
2812
    char *q, buf1[20], c;
2813
    int nd, len, percentd_found;
2814

    
2815
    q = buf;
2816
    p = path;
2817
    percentd_found = 0;
2818
    for(;;) {
2819
        c = *p++;
2820
        if (c == '\0')
2821
            break;
2822
        if (c == '%') {
2823
            do {
2824
                nd = 0;
2825
                while (isdigit(*p)) {
2826
                    nd = nd * 10 + *p++ - '0';
2827
                }
2828
                c = *p++;
2829
            } while (isdigit(c));
2830

    
2831
            switch(c) {
2832
            case '%':
2833
                goto addchar;
2834
            case 'd':
2835
                if (percentd_found)
2836
                    goto fail;
2837
                percentd_found = 1;
2838
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2839
                len = strlen(buf1);
2840
                if ((q - buf + len) > buf_size - 1)
2841
                    goto fail;
2842
                memcpy(q, buf1, len);
2843
                q += len;
2844
                break;
2845
            default:
2846
                goto fail;
2847
            }
2848
        } else {
2849
        addchar:
2850
            if ((q - buf) < buf_size - 1)
2851
                *q++ = c;
2852
        }
2853
    }
2854
    if (!percentd_found)
2855
        goto fail;
2856
    *q = '\0';
2857
    return 0;
2858
 fail:
2859
    *q = '\0';
2860
    return -1;
2861
}
2862

    
2863
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2864
{
2865
    int len, i, j, c;
2866
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2867

    
2868
    for(i=0;i<size;i+=16) {
2869
        len = size - i;
2870
        if (len > 16)
2871
            len = 16;
2872
        PRINT("%08x ", i);
2873
        for(j=0;j<16;j++) {
2874
            if (j < len)
2875
                PRINT(" %02x", buf[i+j]);
2876
            else
2877
                PRINT("   ");
2878
        }
2879
        PRINT(" ");
2880
        for(j=0;j<len;j++) {
2881
            c = buf[i+j];
2882
            if (c < ' ' || c > '~')
2883
                c = '.';
2884
            PRINT("%c", c);
2885
        }
2886
        PRINT("\n");
2887
    }
2888
#undef PRINT
2889
}
2890

    
2891
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2892
{
2893
    hex_dump_internal(NULL, f, 0, buf, size);
2894
}
2895

    
2896
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2897
{
2898
    hex_dump_internal(avcl, NULL, level, buf, size);
2899
}
2900

    
2901
 //FIXME needs to know the time_base
2902
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2903
{
2904
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2905
    PRINT("stream #%d:\n", pkt->stream_index);
2906
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2907
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2908
    /* DTS is _always_ valid after av_read_frame() */
2909
    PRINT("  dts=");
2910
    if (pkt->dts == AV_NOPTS_VALUE)
2911
        PRINT("N/A");
2912
    else
2913
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2914
    /* PTS may be not known if B frames are present */
2915
    PRINT("  pts=");
2916
    if (pkt->pts == AV_NOPTS_VALUE)
2917
        PRINT("N/A");
2918
    else
2919
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2920
    PRINT("\n");
2921
    PRINT("  size=%d\n", pkt->size);
2922
#undef PRINT
2923
    if (dump_payload)
2924
        av_hex_dump(f, pkt->data, pkt->size);
2925
}
2926

    
2927
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2928
{
2929
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2930
}
2931

    
2932
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2933
{
2934
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2935
}
2936

    
2937
void url_split(char *proto, int proto_size,
2938
               char *authorization, int authorization_size,
2939
               char *hostname, int hostname_size,
2940
               int *port_ptr,
2941
               char *path, int path_size,
2942
               const char *url)
2943
{
2944
    const char *p, *ls, *at, *col, *brk;
2945

    
2946
    if (port_ptr)               *port_ptr = -1;
2947
    if (proto_size > 0)         proto[0] = 0;
2948
    if (authorization_size > 0) authorization[0] = 0;
2949
    if (hostname_size > 0)      hostname[0] = 0;
2950
    if (path_size > 0)          path[0] = 0;
2951

    
2952
    /* parse protocol */
2953
    if ((p = strchr(url, ':'))) {
2954
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2955
        p++; /* skip ':' */
2956
        if (*p == '/') p++;
2957
        if (*p == '/') p++;
2958
    } else {
2959
        /* no protocol means plain filename */
2960
        av_strlcpy(path, url, path_size);
2961
        return;
2962
    }
2963

    
2964
    /* separate path from hostname */
2965
    ls = strchr(p, '/');
2966
    if(!ls)
2967
        ls = strchr(p, '?');
2968
    if(ls)
2969
        av_strlcpy(path, ls, path_size);
2970
    else
2971
        ls = &p[strlen(p)]; // XXX
2972

    
2973
    /* the rest is hostname, use that to parse auth/port */
2974
    if (ls != p) {
2975
        /* authorization (user[:pass]@hostname) */
2976
        if ((at = strchr(p, '@')) && at < ls) {
2977
            av_strlcpy(authorization, p,
2978
                       FFMIN(authorization_size, at + 1 - p));
2979
            p = at + 1; /* skip '@' */
2980
        }
2981

    
2982
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
2983
            /* [host]:port */
2984
            av_strlcpy(hostname, p + 1,
2985
                       FFMIN(hostname_size, brk - p));
2986
            if (brk[1] == ':' && port_ptr)
2987
                *port_ptr = atoi(brk + 2);
2988
        } else if ((col = strchr(p, ':')) && col < ls) {
2989
            av_strlcpy(hostname, p,
2990
                       FFMIN(col + 1 - p, hostname_size));
2991
            if (port_ptr) *port_ptr = atoi(col + 1);
2992
        } else
2993
            av_strlcpy(hostname, p,
2994
                       FFMIN(ls + 1 - p, hostname_size));
2995
    }
2996
}
2997

    
2998
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2999
                     int pts_num, int pts_den)
3000
{
3001
    s->pts_wrap_bits = pts_wrap_bits;
3002
    s->time_base.num = pts_num;
3003
    s->time_base.den = pts_den;
3004
}
3005

    
3006
/* fraction handling */
3007

    
3008
/**
3009
 * f = val + (num / den) + 0.5.
3010
 *
3011
 * 'num' is normalized so that it is such as 0 <= num < den.
3012
 *
3013
 * @param f fractional number
3014
 * @param val integer value
3015
 * @param num must be >= 0
3016
 * @param den must be >= 1
3017
 */
3018
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3019
{
3020
    num += (den >> 1);
3021
    if (num >= den) {
3022
        val += num / den;
3023
        num = num % den;
3024
    }
3025
    f->val = val;
3026
    f->num = num;
3027
    f->den = den;
3028
}
3029

    
3030
/**
3031
 * Fractionnal addition to f: f = f + (incr / f->den).
3032
 *
3033
 * @param f fractional number
3034
 * @param incr increment, can be positive or negative
3035
 */
3036
static void av_frac_add(AVFrac *f, int64_t incr)
3037
{
3038
    int64_t num, den;
3039

    
3040
    num = f->num + incr;
3041
    den = f->den;
3042
    if (num < 0) {
3043
        f->val += num / den;
3044
        num = num % den;
3045
        if (num < 0) {
3046
            num += den;
3047
            f->val--;
3048
        }
3049
    } else if (num >= den) {
3050
        f->val += num / den;
3051
        num = num % den;
3052
    }
3053
    f->num = num;
3054
}