Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 730ba406

History | View | Annotate | Download (93 KB)

1
/*
2
 * Various utilities for ffmpeg system
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
 */
19
#include "avformat.h"
20
#include "allformats.h"
21
#include "opt.h"
22

    
23
#undef NDEBUG
24
#include <assert.h>
25

    
26
/**
27
 * @file libavformat/utils.c
28
 * Various utility functions for using ffmpeg library.
29
 */
30

    
31
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
32
static void av_frac_add(AVFrac *f, int64_t incr);
33
static void av_frac_set(AVFrac *f, int64_t val);
34

    
35
/** head of registered input format linked list. */
36
AVInputFormat *first_iformat = NULL;
37
/** head of registered output format linked list. */
38
AVOutputFormat *first_oformat = NULL;
39
/** head of registered image format linked list. */
40
AVImageFormat *first_image_format = NULL;
41

    
42
void av_register_input_format(AVInputFormat *format)
43
{
44
    AVInputFormat **p;
45
    p = &first_iformat;
46
    while (*p != NULL) p = &(*p)->next;
47
    *p = format;
48
    format->next = NULL;
49
}
50

    
51
void av_register_output_format(AVOutputFormat *format)
52
{
53
    AVOutputFormat **p;
54
    p = &first_oformat;
55
    while (*p != NULL) p = &(*p)->next;
56
    *p = format;
57
    format->next = NULL;
58
}
59

    
60
int match_ext(const char *filename, const char *extensions)
61
{
62
    const char *ext, *p;
63
    char ext1[32], *q;
64

    
65
    if(!filename)
66
        return 0;
67

    
68
    ext = strrchr(filename, '.');
69
    if (ext) {
70
        ext++;
71
        p = extensions;
72
        for(;;) {
73
            q = ext1;
74
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
75
                *q++ = *p++;
76
            *q = '\0';
77
            if (!strcasecmp(ext1, ext))
78
                return 1;
79
            if (*p == '\0')
80
                break;
81
            p++;
82
        }
83
    }
84
    return 0;
85
}
86

    
87
AVOutputFormat *guess_format(const char *short_name, const char *filename,
88
                             const char *mime_type)
89
{
90
    AVOutputFormat *fmt, *fmt_found;
91
    int score_max, score;
92

    
93
    /* specific test for image sequences */
94
#ifdef CONFIG_IMAGE2_MUXER
95
    if (!short_name && filename &&
96
        av_filename_number_test(filename) &&
97
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
98
        return guess_format("image2", NULL, NULL);
99
    }
100
#endif
101
    if (!short_name && filename &&
102
        av_filename_number_test(filename) &&
103
        guess_image_format(filename)) {
104
        return guess_format("image", NULL, NULL);
105
    }
106

    
107
    /* find the proper file type */
108
    fmt_found = NULL;
109
    score_max = 0;
110
    fmt = first_oformat;
111
    while (fmt != NULL) {
112
        score = 0;
113
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
114
            score += 100;
115
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
116
            score += 10;
117
        if (filename && fmt->extensions &&
118
            match_ext(filename, fmt->extensions)) {
119
            score += 5;
120
        }
121
        if (score > score_max) {
122
            score_max = score;
123
            fmt_found = fmt;
124
        }
125
        fmt = fmt->next;
126
    }
127
    return fmt_found;
128
}
129

    
130
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
131
                             const char *mime_type)
132
{
133
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
134

    
135
    if (fmt) {
136
        AVOutputFormat *stream_fmt;
137
        char stream_format_name[64];
138

    
139
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
140
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
141

    
142
        if (stream_fmt)
143
            fmt = stream_fmt;
144
    }
145

    
146
    return fmt;
147
}
148

    
149
/**
150
 * Guesses the codec id based upon muxer and filename.
151
 */
152
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
153
                            const char *filename, const char *mime_type, enum CodecType type){
154
    if(type == CODEC_TYPE_VIDEO){
155
        enum CodecID codec_id= CODEC_ID_NONE;
156

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

    
171
/**
172
 * finds AVInputFormat based on input format's short name.
173
 */
174
AVInputFormat *av_find_input_format(const char *short_name)
175
{
176
    AVInputFormat *fmt;
177
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
178
        if (!strcmp(fmt->name, short_name))
179
            return fmt;
180
    }
181
    return NULL;
182
}
183

    
184
/* memory handling */
185

    
186
/**
187
 * Default packet destructor.
188
 */
189
void av_destruct_packet(AVPacket *pkt)
190
{
191
    av_free(pkt->data);
192
    pkt->data = NULL; pkt->size = 0;
193
}
194

    
195
/**
196
 * Allocate the payload of a packet and intialized its fields to default values.
197
 *
198
 * @param pkt packet
199
 * @param size wanted payload size
200
 * @return 0 if OK. AVERROR_xxx otherwise.
201
 */
202
int av_new_packet(AVPacket *pkt, int size)
203
{
204
    void *data;
205
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
206
        return AVERROR_NOMEM;
207
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
208
    if (!data)
209
        return AVERROR_NOMEM;
210
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
211

    
212
    av_init_packet(pkt);
213
    pkt->data = data;
214
    pkt->size = size;
215
    pkt->destruct = av_destruct_packet;
216
    return 0;
217
}
218

    
219
/**
220
 * Allocate and read the payload of a packet and intialized its fields to default values.
221
 *
222
 * @param pkt packet
223
 * @param size wanted payload size
224
 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
225
 */
226
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
227
{
228
    int ret= av_new_packet(pkt, size);
229

    
230
    if(ret<0)
231
        return ret;
232

    
233
    pkt->pos= url_ftell(s);
234

    
235
    ret= get_buffer(s, pkt->data, size);
236
    if(ret<=0)
237
        av_free_packet(pkt);
238
    else
239
        pkt->size= ret;
240

    
241
    return ret;
242
}
243

    
244
/* This is a hack - the packet memory allocation stuff is broken. The
245
   packet is allocated if it was not really allocated */
246
int av_dup_packet(AVPacket *pkt)
247
{
248
    if (pkt->destruct != av_destruct_packet) {
249
        uint8_t *data;
250
        /* we duplicate the packet and don't forget to put the padding
251
           again */
252
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
253
            return AVERROR_NOMEM;
254
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
255
        if (!data) {
256
            return AVERROR_NOMEM;
257
        }
258
        memcpy(data, pkt->data, pkt->size);
259
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
260
        pkt->data = data;
261
        pkt->destruct = av_destruct_packet;
262
    }
263
    return 0;
264
}
265

    
266
/**
267
 * Allocate the payload of a packet and intialized its fields to default values.
268
 *
269
 * @param filename possible numbered sequence string
270
 * @return 1 if a valid numbered sequence string, 0 otherwise.
271
 */
272
int av_filename_number_test(const char *filename)
273
{
274
    char buf[1024];
275
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
276
}
277

    
278
/**
279
 * Guess file format.
280
 */
281
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
282
{
283
    AVInputFormat *fmt1, *fmt;
284
    int score, score_max;
285

    
286
    fmt = NULL;
287
    score_max = 0;
288
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
289
        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
290
            continue;
291
        score = 0;
292
        if (fmt1->read_probe) {
293
            score = fmt1->read_probe(pd);
294
        } else if (fmt1->extensions) {
295
            if (match_ext(pd->filename, fmt1->extensions)) {
296
                score = 50;
297
            }
298
        }
299
        if (score > score_max) {
300
            score_max = score;
301
            fmt = fmt1;
302
        }
303
    }
304
    return fmt;
305
}
306

    
307
/************************************************************/
308
/* input media file */
309

    
310
/**
311
 * Open a media file from an IO stream. 'fmt' must be specified.
312
 */
313
static const char* format_to_name(void* ptr)
314
{
315
    AVFormatContext* fc = (AVFormatContext*) ptr;
316
    if(fc->iformat) return fc->iformat->name;
317
    else if(fc->oformat) return fc->oformat->name;
318
    else return "NULL";
319
}
320

    
321
#define OFFSET(x) offsetof(AVFormatContext,x)
322
#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
323
//these names are too long to be readable
324
#define E AV_OPT_FLAG_ENCODING_PARAM
325
#define D AV_OPT_FLAG_DECODING_PARAM
326

    
327
static const AVOption options[]={
328
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
329
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
330
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
331
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D, "fflags"},
332
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
333
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
334
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
335
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
336
{NULL},
337
};
338

    
339
#undef E
340
#undef D
341
#undef DEFAULT
342

    
343
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
344

    
345
#if LIBAVCODEC_VERSION_INT > ((52<<16)+(0<<8)+0)
346
static
347
#endif
348
void avformat_get_context_defaults(AVFormatContext *s){
349
    memset(s, 0, sizeof(AVFormatContext));
350

    
351
    s->av_class = &av_format_context_class;
352

    
353
    av_opt_set_defaults(s);
354
}
355

    
356
AVFormatContext *av_alloc_format_context(void)
357
{
358
    AVFormatContext *ic;
359
    ic = av_malloc(sizeof(AVFormatContext));
360
    if (!ic) return ic;
361
    avformat_get_context_defaults(ic);
362
    ic->av_class = &av_format_context_class;
363
    return ic;
364
}
365

    
366
/**
367
 * Allocates all the structures needed to read an input stream.
368
 *        This does not open the needed codecs for decoding the stream[s].
369
 */
370
int av_open_input_stream(AVFormatContext **ic_ptr,
371
                         ByteIOContext *pb, const char *filename,
372
                         AVInputFormat *fmt, AVFormatParameters *ap)
373
{
374
    int err;
375
    AVFormatContext *ic;
376
    AVFormatParameters default_ap;
377

    
378
    if(!ap){
379
        ap=&default_ap;
380
        memset(ap, 0, sizeof(default_ap));
381
    }
382

    
383
    if(!ap->prealloced_context)
384
        ic = av_alloc_format_context();
385
    else
386
        ic = *ic_ptr;
387
    if (!ic) {
388
        err = AVERROR_NOMEM;
389
        goto fail;
390
    }
391
    ic->iformat = fmt;
392
    if (pb)
393
        ic->pb = *pb;
394
    ic->duration = AV_NOPTS_VALUE;
395
    ic->start_time = AV_NOPTS_VALUE;
396
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
397

    
398
    /* allocate private data */
399
    if (fmt->priv_data_size > 0) {
400
        ic->priv_data = av_mallocz(fmt->priv_data_size);
401
        if (!ic->priv_data) {
402
            err = AVERROR_NOMEM;
403
            goto fail;
404
        }
405
    } else {
406
        ic->priv_data = NULL;
407
    }
408

    
409
    err = ic->iformat->read_header(ic, ap);
410
    if (err < 0)
411
        goto fail;
412

    
413
    if (pb)
414
        ic->data_offset = url_ftell(&ic->pb);
415

    
416
    *ic_ptr = ic;
417
    return 0;
418
 fail:
419
    if (ic) {
420
        av_freep(&ic->priv_data);
421
    }
422
    av_free(ic);
423
    *ic_ptr = NULL;
424
    return err;
425
}
426

    
427
/** Size of probe buffer, for guessing file type from file contents. */
428
#define PROBE_BUF_MIN 2048
429
#define PROBE_BUF_MAX (1<<20)
430

    
431
/**
432
 * Open a media file as input. The codec are not opened. Only the file
433
 * header (if present) is read.
434
 *
435
 * @param ic_ptr the opened media file handle is put here
436
 * @param filename filename to open.
437
 * @param fmt if non NULL, force the file format to use
438
 * @param buf_size optional buffer size (zero if default is OK)
439
 * @param ap additionnal parameters needed when opening the file (NULL if default)
440
 * @return 0 if OK. AVERROR_xxx otherwise.
441
 */
442
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
443
                       AVInputFormat *fmt,
444
                       int buf_size,
445
                       AVFormatParameters *ap)
446
{
447
    int err, must_open_file, file_opened, probe_size;
448
    AVProbeData probe_data, *pd = &probe_data;
449
    ByteIOContext pb1, *pb = &pb1;
450

    
451
    file_opened = 0;
452
    pd->filename = "";
453
    if (filename)
454
        pd->filename = filename;
455
    pd->buf = NULL;
456
    pd->buf_size = 0;
457

    
458
    if (!fmt) {
459
        /* guess format if no file can be opened  */
460
        fmt = av_probe_input_format(pd, 0);
461
    }
462

    
463
    /* do not open file if the format does not need it. XXX: specific
464
       hack needed to handle RTSP/TCP */
465
    must_open_file = 1;
466
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
467
        must_open_file = 0;
468
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
469
    }
470

    
471
    if (!fmt || must_open_file) {
472
        /* if no file needed do not try to open one */
473
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
474
            err = AVERROR_IO;
475
            goto fail;
476
        }
477
        file_opened = 1;
478
        if (buf_size > 0) {
479
            url_setbufsize(pb, buf_size);
480
        }
481

    
482
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
483
            /* read probe data */
484
            pd->buf= av_realloc(pd->buf, probe_size);
485
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
486
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
487
                url_fclose(pb);
488
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
489
                    file_opened = 0;
490
                    err = AVERROR_IO;
491
                    goto fail;
492
                }
493
            }
494
            /* guess file format */
495
            fmt = av_probe_input_format(pd, 1);
496
        }
497
        av_freep(&pd->buf);
498
    }
499

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

    
506
    /* XXX: suppress this hack for redirectors */
507
#ifdef CONFIG_NETWORK
508
    if (fmt == &redir_demuxer) {
509
        err = redir_open(ic_ptr, pb);
510
        url_fclose(pb);
511
        return err;
512
    }
513
#endif
514

    
515
    /* check filename in case of an image number is expected */
516
    if (fmt->flags & AVFMT_NEEDNUMBER) {
517
        if (!av_filename_number_test(filename)) {
518
            err = AVERROR_NUMEXPECTED;
519
            goto fail;
520
        }
521
    }
522
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
523
    if (err)
524
        goto fail;
525
    return 0;
526
 fail:
527
    av_freep(&pd->buf);
528
    if (file_opened)
529
        url_fclose(pb);
530
    *ic_ptr = NULL;
531
    return err;
532

    
533
}
534

    
535
/*******************************************************/
536

    
537
/**
538
 * Read a transport packet from a media file.
539
 *
540
 * This function is absolete and should never be used.
541
 * Use av_read_frame() instead.
542
 *
543
 * @param s media file handle
544
 * @param pkt is filled
545
 * @return 0 if OK. AVERROR_xxx if error.
546
 */
547
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
548
{
549
    return s->iformat->read_packet(s, pkt);
550
}
551

    
552
/**********************************************************/
553

    
554
/**
555
 * Get the number of samples of an audio frame. Return (-1) if error.
556
 */
557
static int get_audio_frame_size(AVCodecContext *enc, int size)
558
{
559
    int frame_size;
560

    
561
    if (enc->frame_size <= 1) {
562
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
563

    
564
        if (bits_per_sample) {
565
            if (enc->channels == 0)
566
                return -1;
567
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
568
        } else {
569
            /* used for example by ADPCM codecs */
570
            if (enc->bit_rate == 0)
571
                return -1;
572
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
573
        }
574
    } else {
575
        frame_size = enc->frame_size;
576
    }
577
    return frame_size;
578
}
579

    
580

    
581
/**
582
 * Return the frame duration in seconds, return 0 if not available.
583
 */
584
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
585
                                   AVCodecParserContext *pc, AVPacket *pkt)
586
{
587
    int frame_size;
588

    
589
    *pnum = 0;
590
    *pden = 0;
591
    switch(st->codec->codec_type) {
592
    case CODEC_TYPE_VIDEO:
593
        if(st->time_base.num*1000LL > st->time_base.den){
594
            *pnum = st->time_base.num;
595
            *pden = st->time_base.den;
596
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
597
            *pnum = st->codec->time_base.num;
598
            *pden = st->codec->time_base.den;
599
            if (pc && pc->repeat_pict) {
600
                *pden *= 2;
601
                *pnum = (*pnum) * (2 + pc->repeat_pict);
602
            }
603
        }
604
        break;
605
    case CODEC_TYPE_AUDIO:
606
        frame_size = get_audio_frame_size(st->codec, pkt->size);
607
        if (frame_size < 0)
608
            break;
609
        *pnum = frame_size;
610
        *pden = st->codec->sample_rate;
611
        break;
612
    default:
613
        break;
614
    }
615
}
616

    
617
static int is_intra_only(AVCodecContext *enc){
618
    if(enc->codec_type == CODEC_TYPE_AUDIO){
619
        return 1;
620
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
621
        switch(enc->codec_id){
622
        case CODEC_ID_MJPEG:
623
        case CODEC_ID_MJPEGB:
624
        case CODEC_ID_LJPEG:
625
        case CODEC_ID_RAWVIDEO:
626
        case CODEC_ID_DVVIDEO:
627
        case CODEC_ID_HUFFYUV:
628
        case CODEC_ID_FFVHUFF:
629
        case CODEC_ID_ASV1:
630
        case CODEC_ID_ASV2:
631
        case CODEC_ID_VCR1:
632
            return 1;
633
        default: break;
634
        }
635
    }
636
    return 0;
637
}
638

    
639
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
640
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
641
    int64_t delta= last_ts - mask/2;
642
    return  ((lsb - delta)&mask) + delta;
643
}
644

    
645
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
646
                               AVCodecParserContext *pc, AVPacket *pkt)
647
{
648
    int num, den, presentation_delayed;
649
    /* handle wrapping */
650
    if(st->cur_dts != AV_NOPTS_VALUE){
651
        if(pkt->pts != AV_NOPTS_VALUE)
652
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
653
        if(pkt->dts != AV_NOPTS_VALUE)
654
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
655
    }
656

    
657
    if (pkt->duration == 0) {
658
        compute_frame_duration(&num, &den, st, pc, pkt);
659
        if (den && num) {
660
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
661
        }
662
    }
663

    
664
    if(is_intra_only(st->codec))
665
        pkt->flags |= PKT_FLAG_KEY;
666

    
667
    /* do we have a video B frame ? */
668
    presentation_delayed = 0;
669
    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
670
        /* XXX: need has_b_frame, but cannot get it if the codec is
671
           not initialized */
672
        if ((   st->codec->codec_id == CODEC_ID_H264
673
             || st->codec->has_b_frames) &&
674
            pc && pc->pict_type != FF_B_TYPE)
675
            presentation_delayed = 1;
676
        /* this may be redundant, but it shouldnt hurt */
677
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
678
            presentation_delayed = 1;
679
    }
680

    
681
    if(st->cur_dts == AV_NOPTS_VALUE){
682
        if(presentation_delayed) st->cur_dts = -pkt->duration;
683
        else                     st->cur_dts = 0;
684
    }
685

    
686
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
687
    /* interpolate PTS and DTS if they are not present */
688
    if (presentation_delayed) {
689
        /* DTS = decompression time stamp */
690
        /* PTS = presentation time stamp */
691
        if (pkt->dts == AV_NOPTS_VALUE) {
692
            /* if we know the last pts, use it */
693
            if(st->last_IP_pts != AV_NOPTS_VALUE)
694
                st->cur_dts = pkt->dts = st->last_IP_pts;
695
            else
696
                pkt->dts = st->cur_dts;
697
        } else {
698
            st->cur_dts = pkt->dts;
699
        }
700
        /* this is tricky: the dts must be incremented by the duration
701
           of the frame we are displaying, i.e. the last I or P frame */
702
        if (st->last_IP_duration == 0)
703
            st->cur_dts += pkt->duration;
704
        else
705
            st->cur_dts += st->last_IP_duration;
706
        st->last_IP_duration  = pkt->duration;
707
        st->last_IP_pts= pkt->pts;
708
        /* cannot compute PTS if not present (we can compute it only
709
           by knowing the futur */
710
    } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
711
        if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
712
            int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
713
            int64_t new_diff= ABS(st->cur_dts - pkt->pts);
714
            if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
715
                pkt->pts += pkt->duration;
716
//                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
717
            }
718
        }
719

    
720
        /* presentation is not delayed : PTS and DTS are the same */
721
        if (pkt->pts == AV_NOPTS_VALUE) {
722
            if (pkt->dts == AV_NOPTS_VALUE) {
723
                pkt->pts = st->cur_dts;
724
                pkt->dts = st->cur_dts;
725
            }
726
            else {
727
                st->cur_dts = pkt->dts;
728
                pkt->pts = pkt->dts;
729
            }
730
        } else {
731
            st->cur_dts = pkt->pts;
732
            pkt->dts = pkt->pts;
733
        }
734
        st->cur_dts += pkt->duration;
735
    }
736
//    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
737

    
738
    /* update flags */
739
    if (pc) {
740
        pkt->flags = 0;
741
        /* key frame computation */
742
        switch(st->codec->codec_type) {
743
        case CODEC_TYPE_VIDEO:
744
            if (pc->pict_type == FF_I_TYPE)
745
                pkt->flags |= PKT_FLAG_KEY;
746
            break;
747
        case CODEC_TYPE_AUDIO:
748
            pkt->flags |= PKT_FLAG_KEY;
749
            break;
750
        default:
751
            break;
752
        }
753
    }
754
}
755

    
756
void av_destruct_packet_nofree(AVPacket *pkt)
757
{
758
    pkt->data = NULL; pkt->size = 0;
759
}
760

    
761
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
762
{
763
    AVStream *st;
764
    int len, ret, i;
765

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

    
787
                /* return packet if any */
788
                if (pkt->size) {
789
                got_packet:
790
                    pkt->duration = 0;
791
                    pkt->stream_index = st->index;
792
                    pkt->pts = st->parser->pts;
793
                    pkt->dts = st->parser->dts;
794
                    pkt->destruct = av_destruct_packet_nofree;
795
                    compute_pkt_fields(s, st, st->parser, pkt);
796
                    break;
797
                }
798
            } else {
799
                /* free packet */
800
                av_free_packet(&s->cur_pkt);
801
                s->cur_st = NULL;
802
            }
803
        } else {
804
            /* read next packet */
805
            ret = av_read_packet(s, &s->cur_pkt);
806
            if (ret < 0) {
807
                if (ret == -EAGAIN)
808
                    return ret;
809
                /* return the last frames, if any */
810
                for(i = 0; i < s->nb_streams; i++) {
811
                    st = s->streams[i];
812
                    if (st->parser && st->need_parsing) {
813
                        av_parser_parse(st->parser, st->codec,
814
                                        &pkt->data, &pkt->size,
815
                                        NULL, 0,
816
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
817
                        if (pkt->size)
818
                            goto got_packet;
819
                    }
820
                }
821
                /* no more packets: really terminates parsing */
822
                return ret;
823
            }
824

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

    
833
            s->cur_st = st;
834
            s->cur_ptr = s->cur_pkt.data;
835
            s->cur_len = s->cur_pkt.size;
836
            if (st->need_parsing && !st->parser) {
837
                st->parser = av_parser_init(st->codec->codec_id);
838
                if (!st->parser) {
839
                    /* no parser available : just output the raw packets */
840
                    st->need_parsing = 0;
841
                }else if(st->need_parsing == 2){
842
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
843
                }
844
            }
845
        }
846
    }
847
    if(st->codec->debug & FF_DEBUG_PTS)
848
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%lld, dts=%lld, size=%d\n",
849
            pkt->stream_index,
850
            pkt->pts,
851
            pkt->dts,
852
            pkt->size);
853

    
854
    return 0;
855
}
856

    
857
/**
858
 * Return the next frame of a stream.
859
 *
860
 * The returned packet is valid
861
 * until the next av_read_frame() or until av_close_input_file() and
862
 * must be freed with av_free_packet. For video, the packet contains
863
 * exactly one frame. For audio, it contains an integer number of
864
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
865
 * data). If the audio frames have a variable size (e.g. MPEG audio),
866
 * then it contains one frame.
867
 *
868
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
869
 * values in AV_TIME_BASE unit (and guessed if the format cannot
870
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
871
 * has B frames, so it is better to rely on pkt->dts if you do not
872
 * decompress the payload.
873
 *
874
 * @return 0 if OK, < 0 if error or end of file.
875
 */
876
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
877
{
878
    AVPacketList *pktl;
879
    int eof=0;
880
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
881

    
882
    for(;;){
883
        pktl = s->packet_buffer;
884
        if (pktl) {
885
            AVPacket *next_pkt= &pktl->pkt;
886

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

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

    
921
            /* duplicate the packet */
922
            if (av_dup_packet(pkt) < 0)
923
                return AVERROR_NOMEM;
924

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

    
927
            pktl = av_mallocz(sizeof(AVPacketList));
928
            if (!pktl)
929
                return AVERROR_NOMEM;
930

    
931
            /* add the packet in the buffered packet list */
932
            *plast_pktl = pktl;
933
            pktl->pkt= *pkt;
934
        }else{
935
            assert(!s->packet_buffer);
936
            return av_read_frame_internal(s, pkt);
937
        }
938
    }
939
}
940

    
941
/* XXX: suppress the packet queue */
942
static void flush_packet_queue(AVFormatContext *s)
943
{
944
    AVPacketList *pktl;
945

    
946
    for(;;) {
947
        pktl = s->packet_buffer;
948
        if (!pktl)
949
            break;
950
        s->packet_buffer = pktl->next;
951
        av_free_packet(&pktl->pkt);
952
        av_free(pktl);
953
    }
954
}
955

    
956
/*******************************************************/
957
/* seek support */
958

    
959
int av_find_default_stream_index(AVFormatContext *s)
960
{
961
    int i;
962
    AVStream *st;
963

    
964
    if (s->nb_streams <= 0)
965
        return -1;
966
    for(i = 0; i < s->nb_streams; i++) {
967
        st = s->streams[i];
968
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
969
            return i;
970
        }
971
    }
972
    return 0;
973
}
974

    
975
/**
976
 * Flush the frame reader.
977
 */
978
static void av_read_frame_flush(AVFormatContext *s)
979
{
980
    AVStream *st;
981
    int i;
982

    
983
    flush_packet_queue(s);
984

    
985
    /* free previous packet */
986
    if (s->cur_st) {
987
        if (s->cur_st->parser)
988
            av_free_packet(&s->cur_pkt);
989
        s->cur_st = NULL;
990
    }
991
    /* fail safe */
992
    s->cur_ptr = NULL;
993
    s->cur_len = 0;
994

    
995
    /* for each stream, reset read state */
996
    for(i = 0; i < s->nb_streams; i++) {
997
        st = s->streams[i];
998

    
999
        if (st->parser) {
1000
            av_parser_close(st->parser);
1001
            st->parser = NULL;
1002
        }
1003
        st->last_IP_pts = AV_NOPTS_VALUE;
1004
        st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1005
    }
1006
}
1007

    
1008
/**
1009
 * Updates cur_dts of all streams based on given timestamp and AVStream.
1010
 *
1011
 * Stream ref_st unchanged, others set cur_dts in their native timebase
1012
 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1013
 * @param timestamp new dts expressed in time_base of param ref_st
1014
 * @param ref_st reference stream giving time_base of param timestamp
1015
 */
1016
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1017
    int i;
1018

    
1019
    for(i = 0; i < s->nb_streams; i++) {
1020
        AVStream *st = s->streams[i];
1021

    
1022
        st->cur_dts = av_rescale(timestamp,
1023
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1024
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1025
    }
1026
}
1027

    
1028
/**
1029
 * Add a index entry into a sorted list updateing if it is already there.
1030
 *
1031
 * @param timestamp timestamp in the timebase of the given stream
1032
 */
1033
int av_add_index_entry(AVStream *st,
1034
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1035
{
1036
    AVIndexEntry *entries, *ie;
1037
    int index;
1038

    
1039
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1040
        return -1;
1041

    
1042
    entries = av_fast_realloc(st->index_entries,
1043
                              &st->index_entries_allocated_size,
1044
                              (st->nb_index_entries + 1) *
1045
                              sizeof(AVIndexEntry));
1046
    if(!entries)
1047
        return -1;
1048

    
1049
    st->index_entries= entries;
1050

    
1051
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1052

    
1053
    if(index<0){
1054
        index= st->nb_index_entries++;
1055
        ie= &entries[index];
1056
        assert(index==0 || ie[-1].timestamp < timestamp);
1057
    }else{
1058
        ie= &entries[index];
1059
        if(ie->timestamp != timestamp){
1060
            if(ie->timestamp <= timestamp)
1061
                return -1;
1062
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1063
            st->nb_index_entries++;
1064
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1065
            distance= ie->min_distance;
1066
    }
1067

    
1068
    ie->pos = pos;
1069
    ie->timestamp = timestamp;
1070
    ie->min_distance= distance;
1071
    ie->size= size;
1072
    ie->flags = flags;
1073

    
1074
    return index;
1075
}
1076

    
1077
/**
1078
 * build an index for raw streams using a parser.
1079
 */
1080
static void av_build_index_raw(AVFormatContext *s)
1081
{
1082
    AVPacket pkt1, *pkt = &pkt1;
1083
    int ret;
1084
    AVStream *st;
1085

    
1086
    st = s->streams[0];
1087
    av_read_frame_flush(s);
1088
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1089

    
1090
    for(;;) {
1091
        ret = av_read_frame(s, pkt);
1092
        if (ret < 0)
1093
            break;
1094
        if (pkt->stream_index == 0 && st->parser &&
1095
            (pkt->flags & PKT_FLAG_KEY)) {
1096
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1097
                            0, 0, AVINDEX_KEYFRAME);
1098
        }
1099
        av_free_packet(pkt);
1100
    }
1101
}
1102

    
1103
/**
1104
 * Returns TRUE if we deal with a raw stream.
1105
 *
1106
 * Raw codec data and parsing needed.
1107
 */
1108
static int is_raw_stream(AVFormatContext *s)
1109
{
1110
    AVStream *st;
1111

    
1112
    if (s->nb_streams != 1)
1113
        return 0;
1114
    st = s->streams[0];
1115
    if (!st->need_parsing)
1116
        return 0;
1117
    return 1;
1118
}
1119

    
1120
/**
1121
 * Gets the index for a specific timestamp.
1122
 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1123
 *                 the timestamp which is <= the requested one, if backward is 0
1124
 *                 then it will be >=
1125
 *              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1126
 * @return < 0 if no such timestamp could be found
1127
 */
1128
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1129
                              int flags)
1130
{
1131
    AVIndexEntry *entries= st->index_entries;
1132
    int nb_entries= st->nb_index_entries;
1133
    int a, b, m;
1134
    int64_t timestamp;
1135

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

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

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

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

    
1160
#define DEBUG_SEEK
1161

    
1162
/**
1163
 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1164
 * this isnt supposed to be called directly by a user application, but by demuxers
1165
 * @param target_ts target timestamp in the time base of the given stream
1166
 * @param stream_index stream number
1167
 */
1168
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1169
    AVInputFormat *avif= s->iformat;
1170
    int64_t pos_min, pos_max, pos, pos_limit;
1171
    int64_t ts_min, ts_max, ts;
1172
    int64_t start_pos, filesize;
1173
    int index, no_change;
1174
    AVStream *st;
1175

    
1176
    if (stream_index < 0)
1177
        return -1;
1178

    
1179
#ifdef DEBUG_SEEK
1180
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1181
#endif
1182

    
1183
    ts_max=
1184
    ts_min= AV_NOPTS_VALUE;
1185
    pos_limit= -1; //gcc falsely says it may be uninitalized
1186

    
1187
    st= s->streams[stream_index];
1188
    if(st->index_entries){
1189
        AVIndexEntry *e;
1190

    
1191
        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()
1192
        index= FFMAX(index, 0);
1193
        e= &st->index_entries[index];
1194

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

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

    
1221
    if(ts_min == AV_NOPTS_VALUE){
1222
        pos_min = s->data_offset;
1223
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1224
        if (ts_min == AV_NOPTS_VALUE)
1225
            return -1;
1226
    }
1227

    
1228
    if(ts_max == AV_NOPTS_VALUE){
1229
        int step= 1024;
1230
        filesize = url_fsize(&s->pb);
1231
        pos_max = filesize - 1;
1232
        do{
1233
            pos_max -= step;
1234
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1235
            step += step;
1236
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1237
        if (ts_max == AV_NOPTS_VALUE)
1238
            return -1;
1239

    
1240
        for(;;){
1241
            int64_t tmp_pos= pos_max + 1;
1242
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1243
            if(tmp_ts == AV_NOPTS_VALUE)
1244
                break;
1245
            ts_max= tmp_ts;
1246
            pos_max= tmp_pos;
1247
            if(tmp_pos >= filesize)
1248
                break;
1249
        }
1250
        pos_limit= pos_max;
1251
    }
1252

    
1253
    if(ts_min > ts_max){
1254
        return -1;
1255
    }else if(ts_min == ts_max){
1256
        pos_limit= pos_min;
1257
    }
1258

    
1259
    no_change=0;
1260
    while (pos_min < pos_limit) {
1261
#ifdef DEBUG_SEEK
1262
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1263
               pos_min, pos_max,
1264
               ts_min, ts_max);
1265
#endif
1266
        assert(pos_limit <= pos_max);
1267

    
1268
        if(no_change==0){
1269
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1270
            // interpolate position (better than dichotomy)
1271
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1272
                + pos_min - approximate_keyframe_distance;
1273
        }else if(no_change==1){
1274
            // bisection, if interpolation failed to change min or max pos last time
1275
            pos = (pos_min + pos_limit)>>1;
1276
        }else{
1277
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1278
            pos=pos_min;
1279
        }
1280
        if(pos <= pos_min)
1281
            pos= pos_min + 1;
1282
        else if(pos > pos_limit)
1283
            pos= pos_limit;
1284
        start_pos= pos;
1285

    
1286
        ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1287
        if(pos == pos_max)
1288
            no_change++;
1289
        else
1290
            no_change=0;
1291
#ifdef DEBUG_SEEK
1292
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);
1293
#endif
1294
        assert(ts != AV_NOPTS_VALUE);
1295
        if (target_ts <= ts) {
1296
            pos_limit = start_pos - 1;
1297
            pos_max = pos;
1298
            ts_max = ts;
1299
        }
1300
        if (target_ts >= ts) {
1301
            pos_min = pos;
1302
            ts_min = ts;
1303
        }
1304
    }
1305

    
1306
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1307
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1308
#ifdef DEBUG_SEEK
1309
    pos_min = pos;
1310
    ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1311
    pos_min++;
1312
    ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1313
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1314
           pos, ts_min, target_ts, ts_max);
1315
#endif
1316
    /* do the seek */
1317
    url_fseek(&s->pb, pos, SEEK_SET);
1318

    
1319
    av_update_cur_dts(s, st, ts);
1320

    
1321
    return 0;
1322
}
1323

    
1324
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1325
    int64_t pos_min, pos_max;
1326
#if 0
1327
    AVStream *st;
1328

1329
    if (stream_index < 0)
1330
        return -1;
1331

1332
    st= s->streams[stream_index];
1333
#endif
1334

    
1335
    pos_min = s->data_offset;
1336
    pos_max = url_fsize(&s->pb) - 1;
1337

    
1338
    if     (pos < pos_min) pos= pos_min;
1339
    else if(pos > pos_max) pos= pos_max;
1340

    
1341
    url_fseek(&s->pb, pos, SEEK_SET);
1342

    
1343
#if 0
1344
    av_update_cur_dts(s, st, ts);
1345
#endif
1346
    return 0;
1347
}
1348

    
1349
static int av_seek_frame_generic(AVFormatContext *s,
1350
                                 int stream_index, int64_t timestamp, int flags)
1351
{
1352
    int index;
1353
    AVStream *st;
1354
    AVIndexEntry *ie;
1355

    
1356
    if (!s->index_built) {
1357
        if (is_raw_stream(s)) {
1358
            av_build_index_raw(s);
1359
        } else {
1360
            return -1;
1361
        }
1362
        s->index_built = 1;
1363
    }
1364

    
1365
    st = s->streams[stream_index];
1366
    index = av_index_search_timestamp(st, timestamp, flags);
1367
    if (index < 0)
1368
        return -1;
1369

    
1370
    /* now we have found the index, we can seek */
1371
    ie = &st->index_entries[index];
1372
    av_read_frame_flush(s);
1373
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1374

    
1375
    av_update_cur_dts(s, st, ie->timestamp);
1376

    
1377
    return 0;
1378
}
1379

    
1380
/**
1381
 * Seek to the key frame at timestamp.
1382
 * 'timestamp' in 'stream_index'.
1383
 * @param stream_index If stream_index is (-1), a default
1384
 * stream is selected, and timestamp is automatically converted
1385
 * from AV_TIME_BASE units to the stream specific time_base.
1386
 * @param timestamp timestamp in AVStream.time_base units
1387
 *        or if there is no stream specified then in AV_TIME_BASE units
1388
 * @param flags flags which select direction and seeking mode
1389
 * @return >= 0 on success
1390
 */
1391
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1392
{
1393
    int ret;
1394
    AVStream *st;
1395

    
1396
    av_read_frame_flush(s);
1397

    
1398
    if(flags & AVSEEK_FLAG_BYTE)
1399
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1400

    
1401
    if(stream_index < 0){
1402
        stream_index= av_find_default_stream_index(s);
1403
        if(stream_index < 0)
1404
            return -1;
1405

    
1406
        st= s->streams[stream_index];
1407
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1408
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1409
    }
1410
    st= s->streams[stream_index];
1411

    
1412
    /* first, we try the format specific seek */
1413
    if (s->iformat->read_seek)
1414
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1415
    else
1416
        ret = -1;
1417
    if (ret >= 0) {
1418
        return 0;
1419
    }
1420

    
1421
    if(s->iformat->read_timestamp)
1422
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1423
    else
1424
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1425
}
1426

    
1427
/*******************************************************/
1428

    
1429
/**
1430
 * Returns TRUE if the stream has accurate timings in any stream.
1431
 *
1432
 * @return TRUE if the stream has accurate timings for at least one component.
1433
 */
1434
static int av_has_timings(AVFormatContext *ic)
1435
{
1436
    int i;
1437
    AVStream *st;
1438

    
1439
    for(i = 0;i < ic->nb_streams; i++) {
1440
        st = ic->streams[i];
1441
        if (st->start_time != AV_NOPTS_VALUE &&
1442
            st->duration != AV_NOPTS_VALUE)
1443
            return 1;
1444
    }
1445
    return 0;
1446
}
1447

    
1448
/**
1449
 * Estimate the stream timings from the one of each components.
1450
 *
1451
 * Also computes the global bitrate if possible.
1452
 */
1453
static void av_update_stream_timings(AVFormatContext *ic)
1454
{
1455
    int64_t start_time, start_time1, end_time, end_time1;
1456
    int i;
1457
    AVStream *st;
1458

    
1459
    start_time = MAXINT64;
1460
    end_time = MININT64;
1461
    for(i = 0;i < ic->nb_streams; i++) {
1462
        st = ic->streams[i];
1463
        if (st->start_time != AV_NOPTS_VALUE) {
1464
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1465
            if (start_time1 < start_time)
1466
                start_time = start_time1;
1467
            if (st->duration != AV_NOPTS_VALUE) {
1468
                end_time1 = start_time1
1469
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1470
                if (end_time1 > end_time)
1471
                    end_time = end_time1;
1472
            }
1473
        }
1474
    }
1475
    if (start_time != MAXINT64) {
1476
        ic->start_time = start_time;
1477
        if (end_time != MININT64) {
1478
            ic->duration = end_time - start_time;
1479
            if (ic->file_size > 0) {
1480
                /* compute the bit rate */
1481
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1482
                    (double)ic->duration;
1483
            }
1484
        }
1485
    }
1486

    
1487
}
1488

    
1489
static void fill_all_stream_timings(AVFormatContext *ic)
1490
{
1491
    int i;
1492
    AVStream *st;
1493

    
1494
    av_update_stream_timings(ic);
1495
    for(i = 0;i < ic->nb_streams; i++) {
1496
        st = ic->streams[i];
1497
        if (st->start_time == AV_NOPTS_VALUE) {
1498
            if(ic->start_time != AV_NOPTS_VALUE)
1499
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1500
            if(ic->duration != AV_NOPTS_VALUE)
1501
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1502
        }
1503
    }
1504
}
1505

    
1506
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1507
{
1508
    int64_t filesize, duration;
1509
    int bit_rate, i;
1510
    AVStream *st;
1511

    
1512
    /* if bit_rate is already set, we believe it */
1513
    if (ic->bit_rate == 0) {
1514
        bit_rate = 0;
1515
        for(i=0;i<ic->nb_streams;i++) {
1516
            st = ic->streams[i];
1517
            bit_rate += st->codec->bit_rate;
1518
        }
1519
        ic->bit_rate = bit_rate;
1520
    }
1521

    
1522
    /* if duration is already set, we believe it */
1523
    if (ic->duration == AV_NOPTS_VALUE &&
1524
        ic->bit_rate != 0 &&
1525
        ic->file_size != 0)  {
1526
        filesize = ic->file_size;
1527
        if (filesize > 0) {
1528
            for(i = 0; i < ic->nb_streams; i++) {
1529
                st = ic->streams[i];
1530
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1531
                if (st->start_time == AV_NOPTS_VALUE ||
1532
                    st->duration == AV_NOPTS_VALUE) {
1533
                    st->start_time = 0;
1534
                    st->duration = duration;
1535
                }
1536
            }
1537
        }
1538
    }
1539
}
1540

    
1541
#define DURATION_MAX_READ_SIZE 250000
1542

    
1543
/* only usable for MPEG-PS streams */
1544
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1545
{
1546
    AVPacket pkt1, *pkt = &pkt1;
1547
    AVStream *st;
1548
    int read_size, i, ret;
1549
    int64_t end_time;
1550
    int64_t filesize, offset, duration;
1551

    
1552
    /* free previous packet */
1553
    if (ic->cur_st && ic->cur_st->parser)
1554
        av_free_packet(&ic->cur_pkt);
1555
    ic->cur_st = NULL;
1556

    
1557
    /* flush packet queue */
1558
    flush_packet_queue(ic);
1559

    
1560
    for(i=0;i<ic->nb_streams;i++) {
1561
        st = ic->streams[i];
1562
        if (st->parser) {
1563
            av_parser_close(st->parser);
1564
            st->parser= NULL;
1565
        }
1566
    }
1567

    
1568
    /* we read the first packets to get the first PTS (not fully
1569
       accurate, but it is enough now) */
1570
    url_fseek(&ic->pb, 0, SEEK_SET);
1571
    read_size = 0;
1572
    for(;;) {
1573
        if (read_size >= DURATION_MAX_READ_SIZE)
1574
            break;
1575
        /* if all info is available, we can stop */
1576
        for(i = 0;i < ic->nb_streams; i++) {
1577
            st = ic->streams[i];
1578
            if (st->start_time == AV_NOPTS_VALUE)
1579
                break;
1580
        }
1581
        if (i == ic->nb_streams)
1582
            break;
1583

    
1584
        ret = av_read_packet(ic, pkt);
1585
        if (ret != 0)
1586
            break;
1587
        read_size += pkt->size;
1588
        st = ic->streams[pkt->stream_index];
1589
        if (pkt->pts != AV_NOPTS_VALUE) {
1590
            if (st->start_time == AV_NOPTS_VALUE)
1591
                st->start_time = pkt->pts;
1592
        }
1593
        av_free_packet(pkt);
1594
    }
1595

    
1596
    /* estimate the end time (duration) */
1597
    /* XXX: may need to support wrapping */
1598
    filesize = ic->file_size;
1599
    offset = filesize - DURATION_MAX_READ_SIZE;
1600
    if (offset < 0)
1601
        offset = 0;
1602

    
1603
    url_fseek(&ic->pb, offset, SEEK_SET);
1604
    read_size = 0;
1605
    for(;;) {
1606
        if (read_size >= DURATION_MAX_READ_SIZE)
1607
            break;
1608
        /* if all info is available, we can stop */
1609
        for(i = 0;i < ic->nb_streams; i++) {
1610
            st = ic->streams[i];
1611
            if (st->duration == AV_NOPTS_VALUE)
1612
                break;
1613
        }
1614
        if (i == ic->nb_streams)
1615
            break;
1616

    
1617
        ret = av_read_packet(ic, pkt);
1618
        if (ret != 0)
1619
            break;
1620
        read_size += pkt->size;
1621
        st = ic->streams[pkt->stream_index];
1622
        if (pkt->pts != AV_NOPTS_VALUE) {
1623
            end_time = pkt->pts;
1624
            duration = end_time - st->start_time;
1625
            if (duration > 0) {
1626
                if (st->duration == AV_NOPTS_VALUE ||
1627
                    st->duration < duration)
1628
                    st->duration = duration;
1629
            }
1630
        }
1631
        av_free_packet(pkt);
1632
    }
1633

    
1634
    fill_all_stream_timings(ic);
1635

    
1636
    url_fseek(&ic->pb, 0, SEEK_SET);
1637
}
1638

    
1639
static void av_estimate_timings(AVFormatContext *ic)
1640
{
1641
    int64_t file_size;
1642

    
1643
    /* get the file size, if possible */
1644
    if (ic->iformat->flags & AVFMT_NOFILE) {
1645
        file_size = 0;
1646
    } else {
1647
        file_size = url_fsize(&ic->pb);
1648
        if (file_size < 0)
1649
            file_size = 0;
1650
    }
1651
    ic->file_size = file_size;
1652

    
1653
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1654
         !strcmp(ic->iformat->name, "mpegts")) &&
1655
        file_size && !ic->pb.is_streamed) {
1656
        /* get accurate estimate from the PTSes */
1657
        av_estimate_timings_from_pts(ic);
1658
    } else if (av_has_timings(ic)) {
1659
        /* at least one components has timings - we use them for all
1660
           the components */
1661
        fill_all_stream_timings(ic);
1662
    } else {
1663
        /* less precise: use bit rate info */
1664
        av_estimate_timings_from_bit_rate(ic);
1665
    }
1666
    av_update_stream_timings(ic);
1667

    
1668
#if 0
1669
    {
1670
        int i;
1671
        AVStream *st;
1672
        for(i = 0;i < ic->nb_streams; i++) {
1673
            st = ic->streams[i];
1674
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1675
               i, (double)st->start_time / AV_TIME_BASE,
1676
               (double)st->duration / AV_TIME_BASE);
1677
        }
1678
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1679
               (double)ic->start_time / AV_TIME_BASE,
1680
               (double)ic->duration / AV_TIME_BASE,
1681
               ic->bit_rate / 1000);
1682
    }
1683
#endif
1684
}
1685

    
1686
static int has_codec_parameters(AVCodecContext *enc)
1687
{
1688
    int val;
1689
    switch(enc->codec_type) {
1690
    case CODEC_TYPE_AUDIO:
1691
        val = enc->sample_rate;
1692
        break;
1693
    case CODEC_TYPE_VIDEO:
1694
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1695
        break;
1696
    default:
1697
        val = 1;
1698
        break;
1699
    }
1700
    return (val != 0);
1701
}
1702

    
1703
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1704
{
1705
    int16_t *samples;
1706
    AVCodec *codec;
1707
    int got_picture, ret=0;
1708
    AVFrame picture;
1709

    
1710
  if(!st->codec->codec){
1711
    codec = avcodec_find_decoder(st->codec->codec_id);
1712
    if (!codec)
1713
        return -1;
1714
    ret = avcodec_open(st->codec, codec);
1715
    if (ret < 0)
1716
        return ret;
1717
  }
1718

    
1719
  if(!has_codec_parameters(st->codec)){
1720
    switch(st->codec->codec_type) {
1721
    case CODEC_TYPE_VIDEO:
1722
        ret = avcodec_decode_video(st->codec, &picture,
1723
                                   &got_picture, (uint8_t *)data, size);
1724
        break;
1725
    case CODEC_TYPE_AUDIO:
1726
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1727
        if (!samples)
1728
            goto fail;
1729
        ret = avcodec_decode_audio(st->codec, samples,
1730
                                   &got_picture, (uint8_t *)data, size);
1731
        av_free(samples);
1732
        break;
1733
    default:
1734
        break;
1735
    }
1736
  }
1737
 fail:
1738
    return ret;
1739
}
1740

    
1741
/* absolute maximum size we read until we abort */
1742
#define MAX_READ_SIZE        5000000
1743

    
1744
/* maximum duration until we stop analysing the stream */
1745
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 3.0))
1746

    
1747
/**
1748
 * Read the beginning of a media file to get stream information. This
1749
 * is useful for file formats with no headers such as MPEG. This
1750
 * function also compute the real frame rate in case of mpeg2 repeat
1751
 * frame mode.
1752
 *
1753
 * @param ic media file handle
1754
 * @return >=0 if OK. AVERROR_xxx if error.
1755
 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1756
 */
1757
int av_find_stream_info(AVFormatContext *ic)
1758
{
1759
    int i, count, ret, read_size, j;
1760
    AVStream *st;
1761
    AVPacket pkt1, *pkt;
1762
    AVPacketList *pktl=NULL, **ppktl;
1763
    int64_t last_dts[MAX_STREAMS];
1764
    int64_t duration_sum[MAX_STREAMS];
1765
    int duration_count[MAX_STREAMS]={0};
1766

    
1767
    for(i=0;i<ic->nb_streams;i++) {
1768
        st = ic->streams[i];
1769
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1770
/*            if(!st->time_base.num)
1771
                st->time_base= */
1772
            if(!st->codec->time_base.num)
1773
                st->codec->time_base= st->time_base;
1774
        }
1775
        //only for the split stuff
1776
        if (!st->parser) {
1777
            st->parser = av_parser_init(st->codec->codec_id);
1778
            if(st->need_parsing == 2 && st->parser){
1779
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1780
            }
1781
        }
1782
    }
1783

    
1784
    for(i=0;i<MAX_STREAMS;i++){
1785
        last_dts[i]= AV_NOPTS_VALUE;
1786
        duration_sum[i]= INT64_MAX;
1787
    }
1788

    
1789
    count = 0;
1790
    read_size = 0;
1791
    ppktl = &ic->packet_buffer;
1792
    for(;;) {
1793
        /* check if one codec still needs to be handled */
1794
        for(i=0;i<ic->nb_streams;i++) {
1795
            st = ic->streams[i];
1796
            if (!has_codec_parameters(st->codec))
1797
                break;
1798
            /* variable fps and no guess at the real fps */
1799
            if(   st->codec->time_base.den >= 101LL*st->codec->time_base.num
1800
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1801
                break;
1802
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1803
                break;
1804
        }
1805
        if (i == ic->nb_streams) {
1806
            /* NOTE: if the format has no header, then we need to read
1807
               some packets to get most of the streams, so we cannot
1808
               stop here */
1809
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1810
                /* if we found the info for all the codecs, we can stop */
1811
                ret = count;
1812
                break;
1813
            }
1814
        }
1815
        /* we did not get all the codec info, but we read too much data */
1816
        if (read_size >= MAX_READ_SIZE) {
1817
            ret = count;
1818
            break;
1819
        }
1820

    
1821
        /* NOTE: a new stream can be added there if no header in file
1822
           (AVFMTCTX_NOHEADER) */
1823
        ret = av_read_frame_internal(ic, &pkt1);
1824
        if (ret < 0) {
1825
            /* EOF or error */
1826
            ret = -1; /* we could not have all the codec parameters before EOF */
1827
            for(i=0;i<ic->nb_streams;i++) {
1828
                st = ic->streams[i];
1829
                if (!has_codec_parameters(st->codec)){
1830
                    char buf[256];
1831
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1832
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1833
                } else {
1834
                    ret = 0;
1835
                }
1836
            }
1837
            break;
1838
        }
1839

    
1840
        pktl = av_mallocz(sizeof(AVPacketList));
1841
        if (!pktl) {
1842
            ret = AVERROR_NOMEM;
1843
            break;
1844
        }
1845

    
1846
        /* add the packet in the buffered packet list */
1847
        *ppktl = pktl;
1848
        ppktl = &pktl->next;
1849

    
1850
        pkt = &pktl->pkt;
1851
        *pkt = pkt1;
1852

    
1853
        /* duplicate the packet */
1854
        if (av_dup_packet(pkt) < 0) {
1855
                ret = AVERROR_NOMEM;
1856
                break;
1857
        }
1858

    
1859
        read_size += pkt->size;
1860

    
1861
        st = ic->streams[pkt->stream_index];
1862
        st->codec_info_duration += pkt->duration;
1863
        if (pkt->duration != 0)
1864
            st->codec_info_nb_frames++;
1865

    
1866
        {
1867
            int index= pkt->stream_index;
1868
            int64_t last= last_dts[index];
1869
            int64_t duration= pkt->dts - last;
1870

    
1871
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1872
                if(duration*duration_count[index]*10/9 < duration_sum[index]){
1873
                    duration_sum[index]= duration;
1874
                    duration_count[index]=1;
1875
                }else{
1876
                    int factor= av_rescale(2*duration, duration_count[index], duration_sum[index]);
1877
                    if(factor==3)
1878
                         duration_count[index] *= 2;
1879
                    factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1880
                    duration_sum[index] += duration;
1881
                    duration_count[index]+= factor;
1882
                }
1883
                if(st->codec_info_nb_frames == 0 && 0)
1884
                    st->codec_info_duration += duration;
1885
            }
1886
            last_dts[pkt->stream_index]= pkt->dts;
1887
        }
1888
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1889
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1890
            if(i){
1891
                st->codec->extradata_size= i;
1892
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1893
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1894
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1895
            }
1896
        }
1897

    
1898
        /* if still no information, we try to open the codec and to
1899
           decompress the frame. We try to avoid that in most cases as
1900
           it takes longer and uses more memory. For MPEG4, we need to
1901
           decompress for Quicktime. */
1902
        if (!has_codec_parameters(st->codec) /*&&
1903
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1904
             st->codec->codec_id == CODEC_ID_H264 ||
1905
             st->codec->codec_id == CODEC_ID_H263 ||
1906
             st->codec->codec_id == CODEC_ID_H261 ||
1907
             st->codec->codec_id == CODEC_ID_VORBIS ||
1908
             st->codec->codec_id == CODEC_ID_MJPEG ||
1909
             st->codec->codec_id == CODEC_ID_PNG ||
1910
             st->codec->codec_id == CODEC_ID_PAM ||
1911
             st->codec->codec_id == CODEC_ID_PGM ||
1912
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1913
             st->codec->codec_id == CODEC_ID_PBM ||
1914
             st->codec->codec_id == CODEC_ID_PPM ||
1915
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1916
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1917
            try_decode_frame(st, pkt->data, pkt->size);
1918

    
1919
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
1920
            break;
1921
        }
1922
        count++;
1923
    }
1924

    
1925
    // close codecs which where opened in try_decode_frame()
1926
    for(i=0;i<ic->nb_streams;i++) {
1927
        st = ic->streams[i];
1928
        if(st->codec->codec)
1929
            avcodec_close(st->codec);
1930
    }
1931
    for(i=0;i<ic->nb_streams;i++) {
1932
        st = ic->streams[i];
1933
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1934
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1935
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1936

    
1937
            if(duration_count[i]
1938
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
1939
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1940
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
1941
                int64_t num, den, error, best_error;
1942

    
1943
                num= st->time_base.den*duration_count[i];
1944
                den= st->time_base.num*duration_sum[i];
1945

    
1946
                best_error= INT64_MAX;
1947
                for(j=1; j<60*12; j++){
1948
                    error= ABS(1001*12*num - 1001*j*den);
1949
                    if(error < best_error){
1950
                        best_error= error;
1951
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
1952
                    }
1953
                }
1954
                for(j=0; j<3; j++){
1955
                    static const int ticks[]= {24,30,60};
1956
                    error= ABS(1001*12*num - 1000*12*den * ticks[j]);
1957
                    if(error < best_error){
1958
                        best_error= error;
1959
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, ticks[j]*1000, 1001, INT_MAX);
1960
                    }
1961
                }
1962
            }
1963

    
1964
            /* if no real frame rate, use the codec one */
1965
            if (!st->r_frame_rate.num){
1966
                st->r_frame_rate.num = st->codec->time_base.den;
1967
                st->r_frame_rate.den = st->codec->time_base.num;
1968
            }
1969
        }
1970
    }
1971

    
1972
    av_estimate_timings(ic);
1973
#if 0
1974
    /* correct DTS for b frame streams with no timestamps */
1975
    for(i=0;i<ic->nb_streams;i++) {
1976
        st = ic->streams[i];
1977
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1978
            if(b-frames){
1979
                ppktl = &ic->packet_buffer;
1980
                while(ppkt1){
1981
                    if(ppkt1->stream_index != i)
1982
                        continue;
1983
                    if(ppkt1->pkt->dts < 0)
1984
                        break;
1985
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1986
                        break;
1987
                    ppkt1->pkt->dts -= delta;
1988
                    ppkt1= ppkt1->next;
1989
                }
1990
                if(ppkt1)
1991
                    continue;
1992
                st->cur_dts -= delta;
1993
            }
1994
        }
1995
    }
1996
#endif
1997
    return ret;
1998
}
1999

    
2000
/*******************************************************/
2001

    
2002
/**
2003
 * start playing a network based stream (e.g. RTSP stream) at the
2004
 * current position
2005
 */
2006
int av_read_play(AVFormatContext *s)
2007
{
2008
    if (!s->iformat->read_play)
2009
        return AVERROR_NOTSUPP;
2010
    return s->iformat->read_play(s);
2011
}
2012

    
2013
/**
2014
 * Pause a network based stream (e.g. RTSP stream).
2015
 *
2016
 * Use av_read_play() to resume it.
2017
 */
2018
int av_read_pause(AVFormatContext *s)
2019
{
2020
    if (!s->iformat->read_pause)
2021
        return AVERROR_NOTSUPP;
2022
    return s->iformat->read_pause(s);
2023
}
2024

    
2025
/**
2026
 * Close a media file (but not its codecs).
2027
 *
2028
 * @param s media file handle
2029
 */
2030
void av_close_input_file(AVFormatContext *s)
2031
{
2032
    int i, must_open_file;
2033
    AVStream *st;
2034

    
2035
    /* free previous packet */
2036
    if (s->cur_st && s->cur_st->parser)
2037
        av_free_packet(&s->cur_pkt);
2038

    
2039
    if (s->iformat->read_close)
2040
        s->iformat->read_close(s);
2041
    for(i=0;i<s->nb_streams;i++) {
2042
        /* free all data in a stream component */
2043
        st = s->streams[i];
2044
        if (st->parser) {
2045
            av_parser_close(st->parser);
2046
        }
2047
        av_free(st->index_entries);
2048
        av_free(st->codec->extradata);
2049
        av_free(st->codec);
2050
        av_free(st);
2051
    }
2052
    flush_packet_queue(s);
2053
    must_open_file = 1;
2054
    if (s->iformat->flags & AVFMT_NOFILE) {
2055
        must_open_file = 0;
2056
    }
2057
    if (must_open_file) {
2058
        url_fclose(&s->pb);
2059
    }
2060
    av_freep(&s->priv_data);
2061
    av_free(s);
2062
}
2063

    
2064
/**
2065
 * Add a new stream to a media file.
2066
 *
2067
 * Can only be called in the read_header() function. If the flag
2068
 * AVFMTCTX_NOHEADER is in the format context, then new streams
2069
 * can be added in read_packet too.
2070
 *
2071
 * @param s media file handle
2072
 * @param id file format dependent stream id
2073
 */
2074
AVStream *av_new_stream(AVFormatContext *s, int id)
2075
{
2076
    AVStream *st;
2077
    int i;
2078

    
2079
    if (s->nb_streams >= MAX_STREAMS)
2080
        return NULL;
2081

    
2082
    st = av_mallocz(sizeof(AVStream));
2083
    if (!st)
2084
        return NULL;
2085

    
2086
    st->codec= avcodec_alloc_context();
2087
    if (s->iformat) {
2088
        /* no default bitrate if decoding */
2089
        st->codec->bit_rate = 0;
2090
    }
2091
    st->index = s->nb_streams;
2092
    st->id = id;
2093
    st->start_time = AV_NOPTS_VALUE;
2094
    st->duration = AV_NOPTS_VALUE;
2095
    st->cur_dts = AV_NOPTS_VALUE;
2096

    
2097
    /* default pts settings is MPEG like */
2098
    av_set_pts_info(st, 33, 1, 90000);
2099
    st->last_IP_pts = AV_NOPTS_VALUE;
2100
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2101
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2102

    
2103
    s->streams[s->nb_streams++] = st;
2104
    return st;
2105
}
2106

    
2107
/************************************************************/
2108
/* output media file */
2109

    
2110
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2111
{
2112
    int ret;
2113

    
2114
    if (s->oformat->priv_data_size > 0) {
2115
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2116
        if (!s->priv_data)
2117
            return AVERROR_NOMEM;
2118
    } else
2119
        s->priv_data = NULL;
2120

    
2121
    if (s->oformat->set_parameters) {
2122
        ret = s->oformat->set_parameters(s, ap);
2123
        if (ret < 0)
2124
            return ret;
2125
    }
2126
    return 0;
2127
}
2128

    
2129
/**
2130
 * allocate the stream private data and write the stream header to an
2131
 * output media file
2132
 *
2133
 * @param s media file handle
2134
 * @return 0 if OK. AVERROR_xxx if error.
2135
 */
2136
int av_write_header(AVFormatContext *s)
2137
{
2138
    int ret, i;
2139
    AVStream *st;
2140

    
2141
    // some sanity checks
2142
    for(i=0;i<s->nb_streams;i++) {
2143
        st = s->streams[i];
2144

    
2145
        switch (st->codec->codec_type) {
2146
        case CODEC_TYPE_AUDIO:
2147
            if(st->codec->sample_rate<=0){
2148
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2149
                return -1;
2150
            }
2151
            break;
2152
        case CODEC_TYPE_VIDEO:
2153
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2154
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2155
                return -1;
2156
            }
2157
            if(st->codec->width<=0 || st->codec->height<=0){
2158
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2159
                return -1;
2160
            }
2161
            break;
2162
        }
2163
    }
2164

    
2165
    if(s->oformat->write_header){
2166
        ret = s->oformat->write_header(s);
2167
        if (ret < 0)
2168
            return ret;
2169
    }
2170

    
2171
    /* init PTS generation */
2172
    for(i=0;i<s->nb_streams;i++) {
2173
        int64_t den = AV_NOPTS_VALUE;
2174
        st = s->streams[i];
2175

    
2176
        switch (st->codec->codec_type) {
2177
        case CODEC_TYPE_AUDIO:
2178
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2179
            break;
2180
        case CODEC_TYPE_VIDEO:
2181
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2182
            break;
2183
        default:
2184
            break;
2185
        }
2186
        if (den != AV_NOPTS_VALUE) {
2187
            if (den <= 0)
2188
                return AVERROR_INVALIDDATA;
2189
            av_frac_init(&st->pts, 0, 0, den);
2190
        }
2191
    }
2192
    return 0;
2193
}
2194

    
2195
//FIXME merge with compute_pkt_fields
2196
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2197
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2198
    int num, den, frame_size, i;
2199

    
2200
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2201

    
2202
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2203
        return -1;*/
2204

    
2205
    /* duration field */
2206
    if (pkt->duration == 0) {
2207
        compute_frame_duration(&num, &den, st, NULL, pkt);
2208
        if (den && num) {
2209
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2210
        }
2211
    }
2212

    
2213
    //XXX/FIXME this is a temporary hack until all encoders output pts
2214
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2215
        pkt->dts=
2216
//        pkt->pts= st->cur_dts;
2217
        pkt->pts= st->pts.val;
2218
    }
2219

    
2220
    //calculate dts from pts
2221
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2222
        st->pts_buffer[0]= pkt->pts;
2223
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2224
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2225
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2226
            SWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2227

    
2228
        pkt->dts= st->pts_buffer[0];
2229
    }
2230

    
2231
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2232
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2233
        return -1;
2234
    }
2235
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2236
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2237
        return -1;
2238
    }
2239

    
2240
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2241
    st->cur_dts= pkt->dts;
2242
    st->pts.val= pkt->dts;
2243

    
2244
    /* update pts */
2245
    switch (st->codec->codec_type) {
2246
    case CODEC_TYPE_AUDIO:
2247
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2248

    
2249
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2250
           but it would be better if we had the real timestamps from the encoder */
2251
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2252
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2253
        }
2254
        break;
2255
    case CODEC_TYPE_VIDEO:
2256
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2257
        break;
2258
    default:
2259
        break;
2260
    }
2261
    return 0;
2262
}
2263

    
2264
static void truncate_ts(AVStream *st, AVPacket *pkt){
2265
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2266

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

    
2270
    pkt->pts &= pts_mask;
2271
    pkt->dts &= pts_mask;
2272
}
2273

    
2274
/**
2275
 * Write a packet to an output media file.
2276
 *
2277
 * The packet shall contain one audio or video frame.
2278
 *
2279
 * @param s media file handle
2280
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2281
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2282
 */
2283
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2284
{
2285
    int ret;
2286

    
2287
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2288
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2289
        return ret;
2290

    
2291
    truncate_ts(s->streams[pkt->stream_index], pkt);
2292

    
2293
    ret= s->oformat->write_packet(s, pkt);
2294
    if(!ret)
2295
        ret= url_ferror(&s->pb);
2296
    return ret;
2297
}
2298

    
2299
/**
2300
 * Interleave a packet per DTS in an output media file.
2301
 *
2302
 * Packets with pkt->destruct == av_destruct_packet will be freed inside this function,
2303
 * so they cannot be used after it, note calling av_free_packet() on them is still safe.
2304
 *
2305
 * @param s media file handle
2306
 * @param out the interleaved packet will be output here
2307
 * @param in the input packet
2308
 * @param flush 1 if no further packets are available as input and all
2309
 *              remaining packets should be output
2310
 * @return 1 if a packet was output, 0 if no packet could be output,
2311
 *         < 0 if an error occured
2312
 */
2313
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2314
    AVPacketList *pktl, **next_point, *this_pktl;
2315
    int stream_count=0;
2316
    int streams[MAX_STREAMS];
2317

    
2318
    if(pkt){
2319
        AVStream *st= s->streams[ pkt->stream_index];
2320

    
2321
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2322

    
2323
        this_pktl = av_mallocz(sizeof(AVPacketList));
2324
        this_pktl->pkt= *pkt;
2325
        if(pkt->destruct == av_destruct_packet)
2326
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2327
        else
2328
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2329

    
2330
        next_point = &s->packet_buffer;
2331
        while(*next_point){
2332
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2333
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2334
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2335
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2336
                break;
2337
            next_point= &(*next_point)->next;
2338
        }
2339
        this_pktl->next= *next_point;
2340
        *next_point= this_pktl;
2341
    }
2342

    
2343
    memset(streams, 0, sizeof(streams));
2344
    pktl= s->packet_buffer;
2345
    while(pktl){
2346
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2347
        if(streams[ pktl->pkt.stream_index ] == 0)
2348
            stream_count++;
2349
        streams[ pktl->pkt.stream_index ]++;
2350
        pktl= pktl->next;
2351
    }
2352

    
2353
    if(s->nb_streams == stream_count || (flush && stream_count)){
2354
        pktl= s->packet_buffer;
2355
        *out= pktl->pkt;
2356

    
2357
        s->packet_buffer= pktl->next;
2358
        av_freep(&pktl);
2359
        return 1;
2360
    }else{
2361
        av_init_packet(out);
2362
        return 0;
2363
    }
2364
}
2365

    
2366
/**
2367
 * Interleaves a AVPacket correctly so it can be muxed.
2368
 * @param out the interleaved packet will be output here
2369
 * @param in the input packet
2370
 * @param flush 1 if no further packets are available as input and all
2371
 *              remaining packets should be output
2372
 * @return 1 if a packet was output, 0 if no packet could be output,
2373
 *         < 0 if an error occured
2374
 */
2375
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2376
    if(s->oformat->interleave_packet)
2377
        return s->oformat->interleave_packet(s, out, in, flush);
2378
    else
2379
        return av_interleave_packet_per_dts(s, out, in, flush);
2380
}
2381

    
2382
/**
2383
 * Writes a packet to an output media file ensuring correct interleaving.
2384
 *
2385
 * The packet must contain one audio or video frame.
2386
 * If the packets are already correctly interleaved the application should
2387
 * call av_write_frame() instead as its slightly faster, its also important
2388
 * to keep in mind that completly non interleaved input will need huge amounts
2389
 * of memory to interleave with this, so its prefereable to interleave at the
2390
 * demuxer level
2391
 *
2392
 * @param s media file handle
2393
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2394
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2395
 */
2396
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2397
    AVStream *st= s->streams[ pkt->stream_index];
2398

    
2399
    //FIXME/XXX/HACK drop zero sized packets
2400
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2401
        return 0;
2402

    
2403
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2404
    if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2405
        return -1;
2406

    
2407
    if(pkt->dts == AV_NOPTS_VALUE)
2408
        return -1;
2409

    
2410
    for(;;){
2411
        AVPacket opkt;
2412
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2413
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2414
            return ret;
2415

    
2416
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2417
        ret= s->oformat->write_packet(s, &opkt);
2418

    
2419
        av_free_packet(&opkt);
2420
        pkt= NULL;
2421

    
2422
        if(ret<0)
2423
            return ret;
2424
        if(url_ferror(&s->pb))
2425
            return url_ferror(&s->pb);
2426
    }
2427
}
2428

    
2429
/**
2430
 * @brief Write the stream trailer to an output media file and
2431
 *        free the file private data.
2432
 *
2433
 * @param s media file handle
2434
 * @return 0 if OK. AVERROR_xxx if error.
2435
 */
2436
int av_write_trailer(AVFormatContext *s)
2437
{
2438
    int ret, i;
2439

    
2440
    for(;;){
2441
        AVPacket pkt;
2442
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2443
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2444
            goto fail;
2445
        if(!ret)
2446
            break;
2447

    
2448
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2449
        ret= s->oformat->write_packet(s, &pkt);
2450

    
2451
        av_free_packet(&pkt);
2452

    
2453
        if(ret<0)
2454
            goto fail;
2455
        if(url_ferror(&s->pb))
2456
            goto fail;
2457
    }
2458

    
2459
    if(s->oformat->write_trailer)
2460
        ret = s->oformat->write_trailer(s);
2461
fail:
2462
    if(ret == 0)
2463
       ret=url_ferror(&s->pb);
2464
    for(i=0;i<s->nb_streams;i++)
2465
        av_freep(&s->streams[i]->priv_data);
2466
    av_freep(&s->priv_data);
2467
    return ret;
2468
}
2469

    
2470
/* "user interface" functions */
2471

    
2472
void dump_format(AVFormatContext *ic,
2473
                 int index,
2474
                 const char *url,
2475
                 int is_output)
2476
{
2477
    int i, flags;
2478
    char buf[256];
2479

    
2480
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2481
            is_output ? "Output" : "Input",
2482
            index,
2483
            is_output ? ic->oformat->name : ic->iformat->name,
2484
            is_output ? "to" : "from", url);
2485
    if (!is_output) {
2486
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2487
        if (ic->duration != AV_NOPTS_VALUE) {
2488
            int hours, mins, secs, us;
2489
            secs = ic->duration / AV_TIME_BASE;
2490
            us = ic->duration % AV_TIME_BASE;
2491
            mins = secs / 60;
2492
            secs %= 60;
2493
            hours = mins / 60;
2494
            mins %= 60;
2495
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2496
                   (10 * us) / AV_TIME_BASE);
2497
        } else {
2498
            av_log(NULL, AV_LOG_INFO, "N/A");
2499
        }
2500
        if (ic->start_time != AV_NOPTS_VALUE) {
2501
            int secs, us;
2502
            av_log(NULL, AV_LOG_INFO, ", start: ");
2503
            secs = ic->start_time / AV_TIME_BASE;
2504
            us = ic->start_time % AV_TIME_BASE;
2505
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2506
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2507
        }
2508
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2509
        if (ic->bit_rate) {
2510
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2511
        } else {
2512
            av_log(NULL, AV_LOG_INFO, "N/A");
2513
        }
2514
        av_log(NULL, AV_LOG_INFO, "\n");
2515
    }
2516
    for(i=0;i<ic->nb_streams;i++) {
2517
        AVStream *st = ic->streams[i];
2518
        int g= ff_gcd(st->time_base.num, st->time_base.den);
2519
        avcodec_string(buf, sizeof(buf), st->codec, is_output);
2520
        av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2521
        /* the pid is an important information, so we display it */
2522
        /* XXX: add a generic system */
2523
        if (is_output)
2524
            flags = ic->oformat->flags;
2525
        else
2526
            flags = ic->iformat->flags;
2527
        if (flags & AVFMT_SHOW_IDS) {
2528
            av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2529
        }
2530
        if (strlen(st->language) > 0) {
2531
            av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2532
        }
2533
        av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2534
        av_log(NULL, AV_LOG_INFO, ": %s", buf);
2535
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2536
            if(st->r_frame_rate.den && st->r_frame_rate.num)
2537
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2538
/*            else if(st->time_base.den && st->time_base.num)
2539
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2540
            else
2541
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2542
        }
2543
        av_log(NULL, AV_LOG_INFO, "\n");
2544
    }
2545
}
2546

    
2547
typedef struct {
2548
    const char *abv;
2549
    int width, height;
2550
    int frame_rate, frame_rate_base;
2551
} AbvEntry;
2552

    
2553
static AbvEntry frame_abvs[] = {
2554
    { "ntsc",      720, 480, 30000, 1001 },
2555
    { "pal",       720, 576,    25,    1 },
2556
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2557
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2558
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2559
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2560
    { "film",      352, 240,    24,    1 },
2561
    { "ntsc-film", 352, 240, 24000, 1001 },
2562
    { "sqcif",     128,  96,     0,    0 },
2563
    { "qcif",      176, 144,     0,    0 },
2564
    { "cif",       352, 288,     0,    0 },
2565
    { "4cif",      704, 576,     0,    0 },
2566
};
2567

    
2568
/**
2569
 * parses width and height out of string str.
2570
 */
2571
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2572
{
2573
    int i;
2574
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2575
    const char *p;
2576
    int frame_width = 0, frame_height = 0;
2577

    
2578
    for(i=0;i<n;i++) {
2579
        if (!strcmp(frame_abvs[i].abv, str)) {
2580
            frame_width = frame_abvs[i].width;
2581
            frame_height = frame_abvs[i].height;
2582
            break;
2583
        }
2584
    }
2585
    if (i == n) {
2586
        p = str;
2587
        frame_width = strtol(p, (char **)&p, 10);
2588
        if (*p)
2589
            p++;
2590
        frame_height = strtol(p, (char **)&p, 10);
2591
    }
2592
    if (frame_width <= 0 || frame_height <= 0)
2593
        return -1;
2594
    *width_ptr = frame_width;
2595
    *height_ptr = frame_height;
2596
    return 0;
2597
}
2598

    
2599
/**
2600
 * Converts frame rate from string to a fraction.
2601
 *
2602
 * First we try to get an exact integer or fractional frame rate.
2603
 * If this fails we convert the frame rate to a double and return
2604
 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2605
 */
2606
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2607
{
2608
    int i;
2609
    char* cp;
2610

    
2611
    /* First, we check our abbreviation table */
2612
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2613
         if (!strcmp(frame_abvs[i].abv, arg)) {
2614
             *frame_rate = frame_abvs[i].frame_rate;
2615
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2616
             return 0;
2617
         }
2618

    
2619
    /* Then, we try to parse it as fraction */
2620
    cp = strchr(arg, '/');
2621
    if (!cp)
2622
        cp = strchr(arg, ':');
2623
    if (cp) {
2624
        char* cpp;
2625
        *frame_rate = strtol(arg, &cpp, 10);
2626
        if (cpp != arg || cpp == cp)
2627
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2628
        else
2629
           *frame_rate = 0;
2630
    }
2631
    else {
2632
        /* Finally we give up and parse it as double */
2633
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2634
        *frame_rate_base = time_base.den;
2635
        *frame_rate = time_base.num;
2636
    }
2637
    if (!*frame_rate || !*frame_rate_base)
2638
        return -1;
2639
    else
2640
        return 0;
2641
}
2642

    
2643
/**
2644
 * Converts date string to number of seconds since Jan 1st, 1970.
2645
 *
2646
 * @code
2647
 * Syntax:
2648
 * - If not a duration:
2649
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2650
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2651
 * Return the date in micro seconds since 1970
2652
 *
2653
 * - If a duration:
2654
 *  HH[:MM[:SS[.m...]]]
2655
 *  S+[.m...]
2656
 * @endcode
2657
 */
2658
#ifndef CONFIG_WINCE
2659
int64_t parse_date(const char *datestr, int duration)
2660
{
2661
    const char *p;
2662
    int64_t t;
2663
    struct tm dt;
2664
    int i;
2665
    static const char *date_fmt[] = {
2666
        "%Y-%m-%d",
2667
        "%Y%m%d",
2668
    };
2669
    static const char *time_fmt[] = {
2670
        "%H:%M:%S",
2671
        "%H%M%S",
2672
    };
2673
    const char *q;
2674
    int is_utc, len;
2675
    char lastch;
2676
    int negative = 0;
2677

    
2678
#undef time
2679
    time_t now = time(0);
2680

    
2681
    len = strlen(datestr);
2682
    if (len > 0)
2683
        lastch = datestr[len - 1];
2684
    else
2685
        lastch = '\0';
2686
    is_utc = (lastch == 'z' || lastch == 'Z');
2687

    
2688
    memset(&dt, 0, sizeof(dt));
2689

    
2690
    p = datestr;
2691
    q = NULL;
2692
    if (!duration) {
2693
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2694
            q = small_strptime(p, date_fmt[i], &dt);
2695
            if (q) {
2696
                break;
2697
            }
2698
        }
2699

    
2700
        if (!q) {
2701
            if (is_utc) {
2702
                dt = *gmtime(&now);
2703
            } else {
2704
                dt = *localtime(&now);
2705
            }
2706
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2707
        } else {
2708
            p = q;
2709
        }
2710

    
2711
        if (*p == 'T' || *p == 't' || *p == ' ')
2712
            p++;
2713

    
2714
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2715
            q = small_strptime(p, time_fmt[i], &dt);
2716
            if (q) {
2717
                break;
2718
            }
2719
        }
2720
    } else {
2721
        if (p[0] == '-') {
2722
            negative = 1;
2723
            ++p;
2724
        }
2725
        q = small_strptime(p, time_fmt[0], &dt);
2726
        if (!q) {
2727
            dt.tm_sec = strtol(p, (char **)&q, 10);
2728
            dt.tm_min = 0;
2729
            dt.tm_hour = 0;
2730
        }
2731
    }
2732

    
2733
    /* Now we have all the fields that we can get */
2734
    if (!q) {
2735
        if (duration)
2736
            return 0;
2737
        else
2738
            return now * int64_t_C(1000000);
2739
    }
2740

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

    
2752
    t *= 1000000;
2753

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

    
2768
/**
2769
 * Attempts to find a specific tag in a URL.
2770
 *
2771
 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2772
 * Return 1 if found.
2773
 */
2774
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2775
{
2776
    const char *p;
2777
    char tag[128], *q;
2778

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

    
2813
/**
2814
 * Returns in 'buf' the path with '%d' replaced by number.
2815

2816
 * Also handles the '%0nd' format where 'n' is the total number
2817
 * of digits and '%%'.
2818
 *
2819
 * @param buf destination buffer
2820
 * @param buf_size destination buffer size
2821
 * @param path numbered sequence string
2822
 * @number frame number
2823
 * @return 0 if OK, -1 if format error.
2824
 */
2825
int av_get_frame_filename(char *buf, int buf_size,
2826
                          const char *path, int number)
2827
{
2828
    const char *p;
2829
    char *q, buf1[20], c;
2830
    int nd, len, percentd_found;
2831

    
2832
    q = buf;
2833
    p = path;
2834
    percentd_found = 0;
2835
    for(;;) {
2836
        c = *p++;
2837
        if (c == '\0')
2838
            break;
2839
        if (c == '%') {
2840
            do {
2841
                nd = 0;
2842
                while (isdigit(*p)) {
2843
                    nd = nd * 10 + *p++ - '0';
2844
                }
2845
                c = *p++;
2846
            } while (isdigit(c));
2847

    
2848
            switch(c) {
2849
            case '%':
2850
                goto addchar;
2851
            case 'd':
2852
                if (percentd_found)
2853
                    goto fail;
2854
                percentd_found = 1;
2855
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2856
                len = strlen(buf1);
2857
                if ((q - buf + len) > buf_size - 1)
2858
                    goto fail;
2859
                memcpy(q, buf1, len);
2860
                q += len;
2861
                break;
2862
            default:
2863
                goto fail;
2864
            }
2865
        } else {
2866
        addchar:
2867
            if ((q - buf) < buf_size - 1)
2868
                *q++ = c;
2869
        }
2870
    }
2871
    if (!percentd_found)
2872
        goto fail;
2873
    *q = '\0';
2874
    return 0;
2875
 fail:
2876
    *q = '\0';
2877
    return -1;
2878
}
2879

    
2880
/**
2881
 * Print  nice hexa dump of a buffer
2882
 * @param f stream for output
2883
 * @param buf buffer
2884
 * @param size buffer size
2885
 */
2886
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2887
{
2888
    int len, i, j, c;
2889

    
2890
    for(i=0;i<size;i+=16) {
2891
        len = size - i;
2892
        if (len > 16)
2893
            len = 16;
2894
        fprintf(f, "%08x ", i);
2895
        for(j=0;j<16;j++) {
2896
            if (j < len)
2897
                fprintf(f, " %02x", buf[i+j]);
2898
            else
2899
                fprintf(f, "   ");
2900
        }
2901
        fprintf(f, " ");
2902
        for(j=0;j<len;j++) {
2903
            c = buf[i+j];
2904
            if (c < ' ' || c > '~')
2905
                c = '.';
2906
            fprintf(f, "%c", c);
2907
        }
2908
        fprintf(f, "\n");
2909
    }
2910
}
2911

    
2912
/**
2913
 * Print on 'f' a nice dump of a packet
2914
 * @param f stream for output
2915
 * @param pkt packet to dump
2916
 * @param dump_payload true if the payload must be displayed too
2917
 */
2918
 //FIXME needs to know the time_base
2919
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2920
{
2921
    fprintf(f, "stream #%d:\n", pkt->stream_index);
2922
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2923
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2924
    /* DTS is _always_ valid after av_read_frame() */
2925
    fprintf(f, "  dts=");
2926
    if (pkt->dts == AV_NOPTS_VALUE)
2927
        fprintf(f, "N/A");
2928
    else
2929
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2930
    /* PTS may be not known if B frames are present */
2931
    fprintf(f, "  pts=");
2932
    if (pkt->pts == AV_NOPTS_VALUE)
2933
        fprintf(f, "N/A");
2934
    else
2935
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2936
    fprintf(f, "\n");
2937
    fprintf(f, "  size=%d\n", pkt->size);
2938
    if (dump_payload)
2939
        av_hex_dump(f, pkt->data, pkt->size);
2940
}
2941

    
2942
void url_split(char *proto, int proto_size,
2943
               char *authorization, int authorization_size,
2944
               char *hostname, int hostname_size,
2945
               int *port_ptr,
2946
               char *path, int path_size,
2947
               const char *url)
2948
{
2949
    const char *p;
2950
    char *q;
2951
    int port;
2952

    
2953
    port = -1;
2954

    
2955
    p = url;
2956
    q = proto;
2957
    while (*p != ':' && *p != '\0') {
2958
        if ((q - proto) < proto_size - 1)
2959
            *q++ = *p;
2960
        p++;
2961
    }
2962
    if (proto_size > 0)
2963
        *q = '\0';
2964
    if (authorization_size > 0)
2965
        authorization[0] = '\0';
2966
    if (*p == '\0') {
2967
        if (proto_size > 0)
2968
            proto[0] = '\0';
2969
        if (hostname_size > 0)
2970
            hostname[0] = '\0';
2971
        p = url;
2972
    } else {
2973
        char *at,*slash; // PETR: position of '@' character and '/' character
2974

    
2975
        p++;
2976
        if (*p == '/')
2977
            p++;
2978
        if (*p == '/')
2979
            p++;
2980
        at = strchr(p,'@'); // PETR: get the position of '@'
2981
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2982
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2983

    
2984
        q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
2985

    
2986
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2987
            if (*p == '@') {    // PETR: passed '@'
2988
              if (authorization_size > 0)
2989
                  *q = '\0';
2990
              q = hostname;
2991
              at = NULL;
2992
            } else if (!at) {   // PETR: hostname
2993
              if ((q - hostname) < hostname_size - 1)
2994
                  *q++ = *p;
2995
            } else {
2996
              if ((q - authorization) < authorization_size - 1)
2997
                *q++ = *p;
2998
            }
2999
            p++;
3000
        }
3001
        if (hostname_size > 0)
3002
            *q = '\0';
3003
        if (*p == ':') {
3004
            p++;
3005
            port = strtoul(p, (char **)&p, 10);
3006
        }
3007
    }
3008
    if (port_ptr)
3009
        *port_ptr = port;
3010
    pstrcpy(path, path_size, p);
3011
}
3012

    
3013
/**
3014
 * Set the pts for a given stream.
3015
 *
3016
 * @param s stream
3017
 * @param pts_wrap_bits number of bits effectively used by the pts
3018
 *        (used for wrap control, 33 is the value for MPEG)
3019
 * @param pts_num numerator to convert to seconds (MPEG: 1)
3020
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3021
 */
3022
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3023
                     int pts_num, int pts_den)
3024
{
3025
    s->pts_wrap_bits = pts_wrap_bits;
3026
    s->time_base.num = pts_num;
3027
    s->time_base.den = pts_den;
3028
}
3029

    
3030
/* fraction handling */
3031

    
3032
/**
3033
 * f = val + (num / den) + 0.5.
3034
 *
3035
 * 'num' is normalized so that it is such as 0 <= num < den.
3036
 *
3037
 * @param f fractional number
3038
 * @param val integer value
3039
 * @param num must be >= 0
3040
 * @param den must be >= 1
3041
 */
3042
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3043
{
3044
    num += (den >> 1);
3045
    if (num >= den) {
3046
        val += num / den;
3047
        num = num % den;
3048
    }
3049
    f->val = val;
3050
    f->num = num;
3051
    f->den = den;
3052
}
3053

    
3054
/**
3055
 * Set f to (val + 0.5).
3056
 */
3057
static void av_frac_set(AVFrac *f, int64_t val)
3058
{
3059
    f->val = val;
3060
    f->num = f->den >> 1;
3061
}
3062

    
3063
/**
3064
 * Fractionnal addition to f: f = f + (incr / f->den).
3065
 *
3066
 * @param f fractional number
3067
 * @param incr increment, can be positive or negative
3068
 */
3069
static void av_frac_add(AVFrac *f, int64_t incr)
3070
{
3071
    int64_t num, den;
3072

    
3073
    num = f->num + incr;
3074
    den = f->den;
3075
    if (num < 0) {
3076
        f->val += num / den;
3077
        num = num % den;
3078
        if (num < 0) {
3079
            num += den;
3080
            f->val--;
3081
        }
3082
    } else if (num >= den) {
3083
        f->val += num / den;
3084
        num = num % den;
3085
    }
3086
    f->num = num;
3087
}
3088

    
3089
/**
3090
 * register a new image format
3091
 * @param img_fmt Image format descriptor
3092
 */
3093
void av_register_image_format(AVImageFormat *img_fmt)
3094
{
3095
    AVImageFormat **p;
3096

    
3097
    p = &first_image_format;
3098
    while (*p != NULL) p = &(*p)->next;
3099
    *p = img_fmt;
3100
    img_fmt->next = NULL;
3101
}
3102

    
3103
/**
3104
 * Guesses image format based on data in the image.
3105
 */
3106
AVImageFormat *av_probe_image_format(AVProbeData *pd)
3107
{
3108
    AVImageFormat *fmt1, *fmt;
3109
    int score, score_max;
3110

    
3111
    fmt = NULL;
3112
    score_max = 0;
3113
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3114
        if (fmt1->img_probe) {
3115
            score = fmt1->img_probe(pd);
3116
            if (score > score_max) {
3117
                score_max = score;
3118
                fmt = fmt1;
3119
            }
3120
        }
3121
    }
3122
    return fmt;
3123
}
3124

    
3125
/**
3126
 * Guesses image format based on file name extensions.
3127
 */
3128
AVImageFormat *guess_image_format(const char *filename)
3129
{
3130
    AVImageFormat *fmt1;
3131

    
3132
    for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3133
        if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3134
            return fmt1;
3135
    }
3136
    return NULL;
3137
}
3138

    
3139
/**
3140
 * Read an image from a stream.
3141
 * @param gb byte stream containing the image
3142
 * @param fmt image format, NULL if probing is required
3143
 */
3144
int av_read_image(ByteIOContext *pb, const char *filename,
3145
                  AVImageFormat *fmt,
3146
                  int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3147
{
3148
    uint8_t buf[PROBE_BUF_MIN];
3149
    AVProbeData probe_data, *pd = &probe_data;
3150
    offset_t pos;
3151
    int ret;
3152

    
3153
    if (!fmt) {
3154
        pd->filename = filename;
3155
        pd->buf = buf;
3156
        pos = url_ftell(pb);
3157
        pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3158
        url_fseek(pb, pos, SEEK_SET);
3159
        fmt = av_probe_image_format(pd);
3160
    }
3161
    if (!fmt)
3162
        return AVERROR_NOFMT;
3163
    ret = fmt->img_read(pb, alloc_cb, opaque);
3164
    return ret;
3165
}
3166

    
3167
/**
3168
 * Write an image to a stream.
3169
 * @param pb byte stream for the image output
3170
 * @param fmt image format
3171
 * @param img image data and informations
3172
 */
3173
int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3174
{
3175
    return fmt->img_write(pb, img);
3176
}
3177