Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ bb54f6ab

History | View | Annotate | Download (91 KB)

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

    
25
#undef NDEBUG
26
#include <assert.h>
27

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

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

    
37
/** head of registered input format linked list. */
38
AVInputFormat *first_iformat = NULL;
39
/** head of registered output format linked list. */
40
AVOutputFormat *first_oformat = 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
    /* find the proper file type */
102
    fmt_found = NULL;
103
    score_max = 0;
104
    fmt = first_oformat;
105
    while (fmt != NULL) {
106
        score = 0;
107
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
108
            score += 100;
109
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
110
            score += 10;
111
        if (filename && fmt->extensions &&
112
            match_ext(filename, fmt->extensions)) {
113
            score += 5;
114
        }
115
        if (score > score_max) {
116
            score_max = score;
117
            fmt_found = fmt;
118
        }
119
        fmt = fmt->next;
120
    }
121
    return fmt_found;
122
}
123

    
124
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
125
                             const char *mime_type)
126
{
127
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
128

    
129
    if (fmt) {
130
        AVOutputFormat *stream_fmt;
131
        char stream_format_name[64];
132

    
133
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
134
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
135

    
136
        if (stream_fmt)
137
            fmt = stream_fmt;
138
    }
139

    
140
    return fmt;
141
}
142

    
143
/**
144
 * Guesses the codec id based upon muxer and filename.
145
 */
146
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
147
                            const char *filename, const char *mime_type, enum CodecType type){
148
    if(type == CODEC_TYPE_VIDEO){
149
        enum CodecID codec_id= CODEC_ID_NONE;
150

    
151
#ifdef CONFIG_IMAGE2_MUXER
152
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
153
            codec_id= av_guess_image2_codec(filename);
154
        }
155
#endif
156
        if(codec_id == CODEC_ID_NONE)
157
            codec_id= fmt->video_codec;
158
        return codec_id;
159
    }else if(type == CODEC_TYPE_AUDIO)
160
        return fmt->audio_codec;
161
    else
162
        return CODEC_ID_NONE;
163
}
164

    
165
/**
166
 * finds AVInputFormat based on input format's short name.
167
 */
168
AVInputFormat *av_find_input_format(const char *short_name)
169
{
170
    AVInputFormat *fmt;
171
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
172
        if (!strcmp(fmt->name, short_name))
173
            return fmt;
174
    }
175
    return NULL;
176
}
177

    
178
/* memory handling */
179

    
180
/**
181
 * Default packet destructor.
182
 */
183
void av_destruct_packet(AVPacket *pkt)
184
{
185
    av_free(pkt->data);
186
    pkt->data = NULL; pkt->size = 0;
187
}
188

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

    
206
    av_init_packet(pkt);
207
    pkt->data = data;
208
    pkt->size = size;
209
    pkt->destruct = av_destruct_packet;
210
    return 0;
211
}
212

    
213
/**
214
 * Allocate and read the payload of a packet and intialized its fields to default values.
215
 *
216
 * @param pkt packet
217
 * @param size wanted payload size
218
 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
219
 */
220
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
221
{
222
    int ret= av_new_packet(pkt, size);
223

    
224
    if(ret<0)
225
        return ret;
226

    
227
    pkt->pos= url_ftell(s);
228

    
229
    ret= get_buffer(s, pkt->data, size);
230
    if(ret<=0)
231
        av_free_packet(pkt);
232
    else
233
        pkt->size= ret;
234

    
235
    return ret;
236
}
237

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

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

    
272
/**
273
 * Guess file format.
274
 */
275
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
276
{
277
    AVInputFormat *fmt1, *fmt;
278
    int score, score_max;
279

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

    
301
/************************************************************/
302
/* input media file */
303

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

    
315
#define OFFSET(x) offsetof(AVFormatContext,x)
316
#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
317
//these names are too long to be readable
318
#define E AV_OPT_FLAG_ENCODING_PARAM
319
#define D AV_OPT_FLAG_DECODING_PARAM
320

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

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

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

    
339
#if LIBAVFORMAT_VERSION_INT >= ((51<<16)+(0<<8)+0)
340
static
341
#endif
342
void avformat_get_context_defaults(AVFormatContext *s){
343
    memset(s, 0, sizeof(AVFormatContext));
344

    
345
    s->av_class = &av_format_context_class;
346

    
347
    av_opt_set_defaults(s);
348
}
349

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

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

    
372
    if(!ap){
373
        ap=&default_ap;
374
        memset(ap, 0, sizeof(default_ap));
375
    }
376

    
377
    if(!ap->prealloced_context)
378
        ic = av_alloc_format_context();
379
    else
380
        ic = *ic_ptr;
381
    if (!ic) {
382
        err = AVERROR_NOMEM;
383
        goto fail;
384
    }
385
    ic->iformat = fmt;
386
    if (pb)
387
        ic->pb = *pb;
388
    ic->duration = AV_NOPTS_VALUE;
389
    ic->start_time = AV_NOPTS_VALUE;
390
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
391

    
392
    /* allocate private data */
393
    if (fmt->priv_data_size > 0) {
394
        ic->priv_data = av_mallocz(fmt->priv_data_size);
395
        if (!ic->priv_data) {
396
            err = AVERROR_NOMEM;
397
            goto fail;
398
        }
399
    } else {
400
        ic->priv_data = NULL;
401
    }
402

    
403
    err = ic->iformat->read_header(ic, ap);
404
    if (err < 0)
405
        goto fail;
406

    
407
    if (pb && !ic->data_offset)
408
        ic->data_offset = url_ftell(&ic->pb);
409

    
410
    *ic_ptr = ic;
411
    return 0;
412
 fail:
413
    if (ic) {
414
        av_freep(&ic->priv_data);
415
    }
416
    av_free(ic);
417
    *ic_ptr = NULL;
418
    return err;
419
}
420

    
421
/** Size of probe buffer, for guessing file type from file contents. */
422
#define PROBE_BUF_MIN 2048
423
#define PROBE_BUF_MAX (1<<20)
424

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

    
445
    file_opened = 0;
446
    pd->filename = "";
447
    if (filename)
448
        pd->filename = filename;
449
    pd->buf = NULL;
450
    pd->buf_size = 0;
451

    
452
    if (!fmt) {
453
        /* guess format if no file can be opened  */
454
        fmt = av_probe_input_format(pd, 0);
455
    }
456

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

    
465
    if (!fmt || must_open_file) {
466
        /* if no file needed do not try to open one */
467
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
468
            err = AVERROR_IO;
469
            goto fail;
470
        }
471
        file_opened = 1;
472
        if (buf_size > 0) {
473
            url_setbufsize(pb, buf_size);
474
        }
475

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

    
494
    /* if still no format found, error */
495
    if (!fmt) {
496
        err = AVERROR_NOFMT;
497
        goto fail;
498
    }
499

    
500
    /* XXX: suppress this hack for redirectors */
501
#ifdef CONFIG_NETWORK
502
    if (fmt == &redir_demuxer) {
503
        err = redir_open(ic_ptr, pb);
504
        url_fclose(pb);
505
        return err;
506
    }
507
#endif
508

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

    
527
}
528

    
529
/*******************************************************/
530

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

    
546
/**********************************************************/
547

    
548
/**
549
 * Get the number of samples of an audio frame. Return (-1) if error.
550
 */
551
static int get_audio_frame_size(AVCodecContext *enc, int size)
552
{
553
    int frame_size;
554

    
555
    if (enc->frame_size <= 1) {
556
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
557

    
558
        if (bits_per_sample) {
559
            if (enc->channels == 0)
560
                return -1;
561
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
562
        } else {
563
            /* used for example by ADPCM codecs */
564
            if (enc->bit_rate == 0)
565
                return -1;
566
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
567
        }
568
    } else {
569
        frame_size = enc->frame_size;
570
    }
571
    return frame_size;
572
}
573

    
574

    
575
/**
576
 * Return the frame duration in seconds, return 0 if not available.
577
 */
578
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
579
                                   AVCodecParserContext *pc, AVPacket *pkt)
580
{
581
    int frame_size;
582

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

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

    
633
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
634
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
635
    int64_t delta= last_ts - mask/2;
636
    return  ((lsb - delta)&mask) + delta;
637
}
638

    
639
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
640
                               AVCodecParserContext *pc, AVPacket *pkt)
641
{
642
    int num, den, presentation_delayed;
643
    /* handle wrapping */
644
    if(st->cur_dts != AV_NOPTS_VALUE){
645
        if(pkt->pts != AV_NOPTS_VALUE)
646
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
647
        if(pkt->dts != AV_NOPTS_VALUE)
648
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
649
    }
650

    
651
    if (pkt->duration == 0) {
652
        compute_frame_duration(&num, &den, st, pc, pkt);
653
        if (den && num) {
654
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
655
        }
656
    }
657

    
658
    if(is_intra_only(st->codec))
659
        pkt->flags |= PKT_FLAG_KEY;
660

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

    
675
    if(st->cur_dts == AV_NOPTS_VALUE){
676
        if(presentation_delayed) st->cur_dts = -pkt->duration;
677
        else                     st->cur_dts = 0;
678
    }
679

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

    
714
        /* presentation is not delayed : PTS and DTS are the same */
715
        if (pkt->pts == AV_NOPTS_VALUE) {
716
            if (pkt->dts == AV_NOPTS_VALUE) {
717
                pkt->pts = st->cur_dts;
718
                pkt->dts = st->cur_dts;
719
            }
720
            else {
721
                st->cur_dts = pkt->dts;
722
                pkt->pts = pkt->dts;
723
            }
724
        } else {
725
            st->cur_dts = pkt->pts;
726
            pkt->dts = pkt->pts;
727
        }
728
        st->cur_dts += pkt->duration;
729
    }
730
//    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
731

    
732
    /* update flags */
733
    if (pc) {
734
        pkt->flags = 0;
735
        /* key frame computation */
736
        switch(st->codec->codec_type) {
737
        case CODEC_TYPE_VIDEO:
738
            if (pc->pict_type == FF_I_TYPE)
739
                pkt->flags |= PKT_FLAG_KEY;
740
            break;
741
        case CODEC_TYPE_AUDIO:
742
            pkt->flags |= PKT_FLAG_KEY;
743
            break;
744
        default:
745
            break;
746
        }
747
    }
748
}
749

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

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

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

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

    
819
            st = s->streams[s->cur_pkt.stream_index];
820
            if(st->codec->debug & FF_DEBUG_PTS)
821
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
822
                    s->cur_pkt.stream_index,
823
                    s->cur_pkt.pts,
824
                    s->cur_pkt.dts,
825
                    s->cur_pkt.size);
826

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

    
848
    return 0;
849
}
850

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

    
876
    for(;;){
877
        pktl = s->packet_buffer;
878
        if (pktl) {
879
            AVPacket *next_pkt= &pktl->pkt;
880

    
881
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
882
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
883
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
884
                       && next_pkt->dts < pktl->pkt.dts
885
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
886
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
887
                        next_pkt->pts= pktl->pkt.dts;
888
                    }
889
                    pktl= pktl->next;
890
                }
891
                pktl = s->packet_buffer;
892
            }
893

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

    
915
            /* duplicate the packet */
916
            if (av_dup_packet(pkt) < 0)
917
                return AVERROR_NOMEM;
918

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

    
921
            pktl = av_mallocz(sizeof(AVPacketList));
922
            if (!pktl)
923
                return AVERROR_NOMEM;
924

    
925
            /* add the packet in the buffered packet list */
926
            *plast_pktl = pktl;
927
            pktl->pkt= *pkt;
928
        }else{
929
            assert(!s->packet_buffer);
930
            return av_read_frame_internal(s, pkt);
931
        }
932
    }
933
}
934

    
935
/* XXX: suppress the packet queue */
936
static void flush_packet_queue(AVFormatContext *s)
937
{
938
    AVPacketList *pktl;
939

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

    
950
/*******************************************************/
951
/* seek support */
952

    
953
int av_find_default_stream_index(AVFormatContext *s)
954
{
955
    int i;
956
    AVStream *st;
957

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

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

    
977
    flush_packet_queue(s);
978

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

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

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

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

    
1013
    for(i = 0; i < s->nb_streams; i++) {
1014
        AVStream *st = s->streams[i];
1015

    
1016
        st->cur_dts = av_rescale(timestamp,
1017
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1018
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1019
    }
1020
}
1021

    
1022
/**
1023
 * Add a index entry into a sorted list updateing if it is already there.
1024
 *
1025
 * @param timestamp timestamp in the timebase of the given stream
1026
 */
1027
int av_add_index_entry(AVStream *st,
1028
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1029
{
1030
    AVIndexEntry *entries, *ie;
1031
    int index;
1032

    
1033
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1034
        return -1;
1035

    
1036
    entries = av_fast_realloc(st->index_entries,
1037
                              &st->index_entries_allocated_size,
1038
                              (st->nb_index_entries + 1) *
1039
                              sizeof(AVIndexEntry));
1040
    if(!entries)
1041
        return -1;
1042

    
1043
    st->index_entries= entries;
1044

    
1045
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1046

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

    
1062
    ie->pos = pos;
1063
    ie->timestamp = timestamp;
1064
    ie->min_distance= distance;
1065
    ie->size= size;
1066
    ie->flags = flags;
1067

    
1068
    return index;
1069
}
1070

    
1071
/**
1072
 * build an index for raw streams using a parser.
1073
 */
1074
static void av_build_index_raw(AVFormatContext *s)
1075
{
1076
    AVPacket pkt1, *pkt = &pkt1;
1077
    int ret;
1078
    AVStream *st;
1079

    
1080
    st = s->streams[0];
1081
    av_read_frame_flush(s);
1082
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
1083

    
1084
    for(;;) {
1085
        ret = av_read_frame(s, pkt);
1086
        if (ret < 0)
1087
            break;
1088
        if (pkt->stream_index == 0 && st->parser &&
1089
            (pkt->flags & PKT_FLAG_KEY)) {
1090
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1091
                            0, 0, AVINDEX_KEYFRAME);
1092
        }
1093
        av_free_packet(pkt);
1094
    }
1095
}
1096

    
1097
/**
1098
 * Returns TRUE if we deal with a raw stream.
1099
 *
1100
 * Raw codec data and parsing needed.
1101
 */
1102
static int is_raw_stream(AVFormatContext *s)
1103
{
1104
    AVStream *st;
1105

    
1106
    if (s->nb_streams != 1)
1107
        return 0;
1108
    st = s->streams[0];
1109
    if (!st->need_parsing)
1110
        return 0;
1111
    return 1;
1112
}
1113

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

    
1130
    a = - 1;
1131
    b = nb_entries;
1132

    
1133
    while (b - a > 1) {
1134
        m = (a + b) >> 1;
1135
        timestamp = entries[m].timestamp;
1136
        if(timestamp >= wanted_timestamp)
1137
            b = m;
1138
        if(timestamp <= wanted_timestamp)
1139
            a = m;
1140
    }
1141
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1142

    
1143
    if(!(flags & AVSEEK_FLAG_ANY)){
1144
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1145
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1146
        }
1147
    }
1148

    
1149
    if(m == nb_entries)
1150
        return -1;
1151
    return  m;
1152
}
1153

    
1154
#define DEBUG_SEEK
1155

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

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

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

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

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

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

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

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

    
1215
    if(ts_min == AV_NOPTS_VALUE){
1216
        pos_min = s->data_offset;
1217
        ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1218
        if (ts_min == AV_NOPTS_VALUE)
1219
            return -1;
1220
    }
1221

    
1222
    if(ts_max == AV_NOPTS_VALUE){
1223
        int step= 1024;
1224
        filesize = url_fsize(&s->pb);
1225
        pos_max = filesize - 1;
1226
        do{
1227
            pos_max -= step;
1228
            ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1229
            step += step;
1230
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1231
        if (ts_max == AV_NOPTS_VALUE)
1232
            return -1;
1233

    
1234
        for(;;){
1235
            int64_t tmp_pos= pos_max + 1;
1236
            int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1237
            if(tmp_ts == AV_NOPTS_VALUE)
1238
                break;
1239
            ts_max= tmp_ts;
1240
            pos_max= tmp_pos;
1241
            if(tmp_pos >= filesize)
1242
                break;
1243
        }
1244
        pos_limit= pos_max;
1245
    }
1246

    
1247
    if(ts_min > ts_max){
1248
        return -1;
1249
    }else if(ts_min == ts_max){
1250
        pos_limit= pos_min;
1251
    }
1252

    
1253
    no_change=0;
1254
    while (pos_min < pos_limit) {
1255
#ifdef DEBUG_SEEK
1256
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1257
               pos_min, pos_max,
1258
               ts_min, ts_max);
1259
#endif
1260
        assert(pos_limit <= pos_max);
1261

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

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

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

    
1313
    av_update_cur_dts(s, st, ts);
1314

    
1315
    return 0;
1316
}
1317

    
1318
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1319
    int64_t pos_min, pos_max;
1320
#if 0
1321
    AVStream *st;
1322

1323
    if (stream_index < 0)
1324
        return -1;
1325

1326
    st= s->streams[stream_index];
1327
#endif
1328

    
1329
    pos_min = s->data_offset;
1330
    pos_max = url_fsize(&s->pb) - 1;
1331

    
1332
    if     (pos < pos_min) pos= pos_min;
1333
    else if(pos > pos_max) pos= pos_max;
1334

    
1335
    url_fseek(&s->pb, pos, SEEK_SET);
1336

    
1337
#if 0
1338
    av_update_cur_dts(s, st, ts);
1339
#endif
1340
    return 0;
1341
}
1342

    
1343
static int av_seek_frame_generic(AVFormatContext *s,
1344
                                 int stream_index, int64_t timestamp, int flags)
1345
{
1346
    int index;
1347
    AVStream *st;
1348
    AVIndexEntry *ie;
1349

    
1350
    if (!s->index_built) {
1351
        if (is_raw_stream(s)) {
1352
            av_build_index_raw(s);
1353
        } else {
1354
            return -1;
1355
        }
1356
        s->index_built = 1;
1357
    }
1358

    
1359
    st = s->streams[stream_index];
1360
    index = av_index_search_timestamp(st, timestamp, flags);
1361
    if (index < 0)
1362
        return -1;
1363

    
1364
    /* now we have found the index, we can seek */
1365
    ie = &st->index_entries[index];
1366
    av_read_frame_flush(s);
1367
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1368

    
1369
    av_update_cur_dts(s, st, ie->timestamp);
1370

    
1371
    return 0;
1372
}
1373

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

    
1390
    av_read_frame_flush(s);
1391

    
1392
    if(flags & AVSEEK_FLAG_BYTE)
1393
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1394

    
1395
    if(stream_index < 0){
1396
        stream_index= av_find_default_stream_index(s);
1397
        if(stream_index < 0)
1398
            return -1;
1399

    
1400
        st= s->streams[stream_index];
1401
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1402
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1403
    }
1404
    st= s->streams[stream_index];
1405

    
1406
    /* first, we try the format specific seek */
1407
    if (s->iformat->read_seek)
1408
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1409
    else
1410
        ret = -1;
1411
    if (ret >= 0) {
1412
        return 0;
1413
    }
1414

    
1415
    if(s->iformat->read_timestamp)
1416
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1417
    else
1418
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1419
}
1420

    
1421
/*******************************************************/
1422

    
1423
/**
1424
 * Returns TRUE if the stream has accurate timings in any stream.
1425
 *
1426
 * @return TRUE if the stream has accurate timings for at least one component.
1427
 */
1428
static int av_has_timings(AVFormatContext *ic)
1429
{
1430
    int i;
1431
    AVStream *st;
1432

    
1433
    for(i = 0;i < ic->nb_streams; i++) {
1434
        st = ic->streams[i];
1435
        if (st->start_time != AV_NOPTS_VALUE &&
1436
            st->duration != AV_NOPTS_VALUE)
1437
            return 1;
1438
    }
1439
    return 0;
1440
}
1441

    
1442
/**
1443
 * Estimate the stream timings from the one of each components.
1444
 *
1445
 * Also computes the global bitrate if possible.
1446
 */
1447
static void av_update_stream_timings(AVFormatContext *ic)
1448
{
1449
    int64_t start_time, start_time1, end_time, end_time1;
1450
    int i;
1451
    AVStream *st;
1452

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

    
1481
}
1482

    
1483
static void fill_all_stream_timings(AVFormatContext *ic)
1484
{
1485
    int i;
1486
    AVStream *st;
1487

    
1488
    av_update_stream_timings(ic);
1489
    for(i = 0;i < ic->nb_streams; i++) {
1490
        st = ic->streams[i];
1491
        if (st->start_time == AV_NOPTS_VALUE) {
1492
            if(ic->start_time != AV_NOPTS_VALUE)
1493
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1494
            if(ic->duration != AV_NOPTS_VALUE)
1495
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1496
        }
1497
    }
1498
}
1499

    
1500
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1501
{
1502
    int64_t filesize, duration;
1503
    int bit_rate, i;
1504
    AVStream *st;
1505

    
1506
    /* if bit_rate is already set, we believe it */
1507
    if (ic->bit_rate == 0) {
1508
        bit_rate = 0;
1509
        for(i=0;i<ic->nb_streams;i++) {
1510
            st = ic->streams[i];
1511
            bit_rate += st->codec->bit_rate;
1512
        }
1513
        ic->bit_rate = bit_rate;
1514
    }
1515

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

    
1535
#define DURATION_MAX_READ_SIZE 250000
1536

    
1537
/* only usable for MPEG-PS streams */
1538
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1539
{
1540
    AVPacket pkt1, *pkt = &pkt1;
1541
    AVStream *st;
1542
    int read_size, i, ret;
1543
    int64_t end_time;
1544
    int64_t filesize, offset, duration;
1545

    
1546
    /* free previous packet */
1547
    if (ic->cur_st && ic->cur_st->parser)
1548
        av_free_packet(&ic->cur_pkt);
1549
    ic->cur_st = NULL;
1550

    
1551
    /* flush packet queue */
1552
    flush_packet_queue(ic);
1553

    
1554
    for(i=0;i<ic->nb_streams;i++) {
1555
        st = ic->streams[i];
1556
        if (st->parser) {
1557
            av_parser_close(st->parser);
1558
            st->parser= NULL;
1559
        }
1560
    }
1561

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

    
1578
        ret = av_read_packet(ic, pkt);
1579
        if (ret != 0)
1580
            break;
1581
        read_size += pkt->size;
1582
        st = ic->streams[pkt->stream_index];
1583
        if (pkt->pts != AV_NOPTS_VALUE) {
1584
            if (st->start_time == AV_NOPTS_VALUE)
1585
                st->start_time = pkt->pts;
1586
        }
1587
        av_free_packet(pkt);
1588
    }
1589

    
1590
    /* estimate the end time (duration) */
1591
    /* XXX: may need to support wrapping */
1592
    filesize = ic->file_size;
1593
    offset = filesize - DURATION_MAX_READ_SIZE;
1594
    if (offset < 0)
1595
        offset = 0;
1596

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

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

    
1628
    fill_all_stream_timings(ic);
1629

    
1630
    url_fseek(&ic->pb, 0, SEEK_SET);
1631
}
1632

    
1633
static void av_estimate_timings(AVFormatContext *ic)
1634
{
1635
    int64_t file_size;
1636

    
1637
    /* get the file size, if possible */
1638
    if (ic->iformat->flags & AVFMT_NOFILE) {
1639
        file_size = 0;
1640
    } else {
1641
        file_size = url_fsize(&ic->pb);
1642
        if (file_size < 0)
1643
            file_size = 0;
1644
    }
1645
    ic->file_size = file_size;
1646

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

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

    
1680
static int has_codec_parameters(AVCodecContext *enc)
1681
{
1682
    int val;
1683
    switch(enc->codec_type) {
1684
    case CODEC_TYPE_AUDIO:
1685
        val = enc->sample_rate;
1686
        break;
1687
    case CODEC_TYPE_VIDEO:
1688
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1689
        break;
1690
    default:
1691
        val = 1;
1692
        break;
1693
    }
1694
    return (val != 0);
1695
}
1696

    
1697
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1698
{
1699
    int16_t *samples;
1700
    AVCodec *codec;
1701
    int got_picture, ret=0;
1702
    AVFrame picture;
1703

    
1704
  if(!st->codec->codec){
1705
    codec = avcodec_find_decoder(st->codec->codec_id);
1706
    if (!codec)
1707
        return -1;
1708
    ret = avcodec_open(st->codec, codec);
1709
    if (ret < 0)
1710
        return ret;
1711
  }
1712

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

    
1735
/* absolute maximum size we read until we abort */
1736
#define MAX_READ_SIZE        5000000
1737

    
1738
/* maximum duration until we stop analysing the stream */
1739
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 3.0))
1740

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

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

    
1778
    for(i=0;i<MAX_STREAMS;i++){
1779
        last_dts[i]= AV_NOPTS_VALUE;
1780
        duration_sum[i]= INT64_MAX;
1781
    }
1782

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

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

    
1834
        pktl = av_mallocz(sizeof(AVPacketList));
1835
        if (!pktl) {
1836
            ret = AVERROR_NOMEM;
1837
            break;
1838
        }
1839

    
1840
        /* add the packet in the buffered packet list */
1841
        *ppktl = pktl;
1842
        ppktl = &pktl->next;
1843

    
1844
        pkt = &pktl->pkt;
1845
        *pkt = pkt1;
1846

    
1847
        /* duplicate the packet */
1848
        if (av_dup_packet(pkt) < 0) {
1849
            ret = AVERROR_NOMEM;
1850
            break;
1851
        }
1852

    
1853
        read_size += pkt->size;
1854

    
1855
        st = ic->streams[pkt->stream_index];
1856
        st->codec_info_duration += pkt->duration;
1857
        if (pkt->duration != 0)
1858
            st->codec_info_nb_frames++;
1859

    
1860
        {
1861
            int index= pkt->stream_index;
1862
            int64_t last= last_dts[index];
1863
            int64_t duration= pkt->dts - last;
1864

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

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

    
1913
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
1914
            break;
1915
        }
1916
        count++;
1917
    }
1918

    
1919
    // close codecs which where opened in try_decode_frame()
1920
    for(i=0;i<ic->nb_streams;i++) {
1921
        st = ic->streams[i];
1922
        if(st->codec->codec)
1923
            avcodec_close(st->codec);
1924
    }
1925
    for(i=0;i<ic->nb_streams;i++) {
1926
        st = ic->streams[i];
1927
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1928
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1929
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1930

    
1931
            if(duration_count[i]
1932
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
1933
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1934
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
1935
                int64_t num, den, error, best_error;
1936

    
1937
                num= st->time_base.den*duration_count[i];
1938
                den= st->time_base.num*duration_sum[i];
1939

    
1940
                best_error= INT64_MAX;
1941
                for(j=1; j<60*12; j++){
1942
                    error= FFABS(1001*12*num - 1001*j*den);
1943
                    if(error < best_error){
1944
                        best_error= error;
1945
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
1946
                    }
1947
                }
1948
                for(j=0; j<3; j++){
1949
                    static const int ticks[]= {24,30,60};
1950
                    error= FFABS(1001*12*num - 1000*12*den * ticks[j]);
1951
                    if(error < best_error){
1952
                        best_error= error;
1953
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, ticks[j]*1000, 1001, INT_MAX);
1954
                    }
1955
                }
1956
            }
1957

    
1958
            if (!st->r_frame_rate.num){
1959
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1960
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1961
                    st->r_frame_rate.num = st->codec->time_base.den;
1962
                    st->r_frame_rate.den = st->codec->time_base.num;
1963
                }else{
1964
                    st->r_frame_rate.num = st->time_base.den;
1965
                    st->r_frame_rate.den = st->time_base.num;
1966
                }
1967
            }
1968
        }
1969
    }
1970

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

    
1999
/*******************************************************/
2000

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

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

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

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

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

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

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

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

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

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

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

    
2106
/************************************************************/
2107
/* output media file */
2108

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2450
        av_free_packet(&pkt);
2451

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

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

    
2469
/* "user interface" functions */
2470

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2751
    t *= 1000000;
2752

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

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

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

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

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

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

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

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

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

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

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

    
2952
    port = -1;
2953

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

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

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

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

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

    
3029
/* fraction handling */
3030

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

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

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

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