Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 1694118b

History | View | Annotate | Download (92.2 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
    int index;
1167
    AVStream *st;
1168

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

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

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

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

    
1184
        index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non keyframe entries in index case, especially read_timestamp()
1185
        index= FFMAX(index, 0);
1186
        e= &st->index_entries[index];
1187

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

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

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

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

    
1221
    av_update_cur_dts(s, st, ts);
1222

    
1223
    return 0;
1224
}
1225

    
1226
/**
1227
 * Does a binary search using read_timestamp().
1228
 * this isnt supposed to be called directly by a user application, but by demuxers
1229
 * @param target_ts target timestamp in the time base of the given stream
1230
 * @param stream_index stream number
1231
 */
1232
int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1233
    int64_t pos, ts;
1234
    int64_t start_pos, filesize;
1235
    int no_change;
1236

    
1237
#ifdef DEBUG_SEEK
1238
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1239
#endif
1240

    
1241
    if(ts_min == AV_NOPTS_VALUE){
1242
        pos_min = s->data_offset;
1243
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1244
        if (ts_min == AV_NOPTS_VALUE)
1245
            return -1;
1246
    }
1247

    
1248
    if(ts_max == AV_NOPTS_VALUE){
1249
        int step= 1024;
1250
        filesize = url_fsize(&s->pb);
1251
        pos_max = filesize - 1;
1252
        do{
1253
            pos_max -= step;
1254
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1255
            step += step;
1256
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1257
        if (ts_max == AV_NOPTS_VALUE)
1258
            return -1;
1259

    
1260
        for(;;){
1261
            int64_t tmp_pos= pos_max + 1;
1262
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1263
            if(tmp_ts == AV_NOPTS_VALUE)
1264
                break;
1265
            ts_max= tmp_ts;
1266
            pos_max= tmp_pos;
1267
            if(tmp_pos >= filesize)
1268
                break;
1269
        }
1270
        pos_limit= pos_max;
1271
    }
1272

    
1273
    if(ts_min > ts_max){
1274
        return -1;
1275
    }else if(ts_min == ts_max){
1276
        pos_limit= pos_min;
1277
    }
1278

    
1279
    no_change=0;
1280
    while (pos_min < pos_limit) {
1281
#ifdef DEBUG_SEEK
1282
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1283
               pos_min, pos_max,
1284
               ts_min, ts_max);
1285
#endif
1286
        assert(pos_limit <= pos_max);
1287

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

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

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

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

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

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

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

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

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

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

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

    
1372
    if (!s->index_built) {
1373
        if (is_raw_stream(s)) {
1374
            av_build_index_raw(s);
1375
        } else {
1376
            return -1;
1377
        }
1378
        s->index_built = 1;
1379
    }
1380

    
1381
    st = s->streams[stream_index];
1382
    index = av_index_search_timestamp(st, timestamp, flags);
1383
    if (index < 0)
1384
        return -1;
1385

    
1386
    /* now we have found the index, we can seek */
1387
    ie = &st->index_entries[index];
1388
    av_read_frame_flush(s);
1389
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1390

    
1391
    av_update_cur_dts(s, st, ie->timestamp);
1392

    
1393
    return 0;
1394
}
1395

    
1396
/**
1397
 * Seek to the key frame at timestamp.
1398
 * 'timestamp' in 'stream_index'.
1399
 * @param stream_index If stream_index is (-1), a default
1400
 * stream is selected, and timestamp is automatically converted
1401
 * from AV_TIME_BASE units to the stream specific time_base.
1402
 * @param timestamp timestamp in AVStream.time_base units
1403
 *        or if there is no stream specified then in AV_TIME_BASE units
1404
 * @param flags flags which select direction and seeking mode
1405
 * @return >= 0 on success
1406
 */
1407
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1408
{
1409
    int ret;
1410
    AVStream *st;
1411

    
1412
    av_read_frame_flush(s);
1413

    
1414
    if(flags & AVSEEK_FLAG_BYTE)
1415
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1416

    
1417
    if(stream_index < 0){
1418
        stream_index= av_find_default_stream_index(s);
1419
        if(stream_index < 0)
1420
            return -1;
1421

    
1422
        st= s->streams[stream_index];
1423
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1424
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1425
    }
1426
    st= s->streams[stream_index];
1427

    
1428
    /* first, we try the format specific seek */
1429
    if (s->iformat->read_seek)
1430
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1431
    else
1432
        ret = -1;
1433
    if (ret >= 0) {
1434
        return 0;
1435
    }
1436

    
1437
    if(s->iformat->read_timestamp)
1438
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1439
    else
1440
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1441
}
1442

    
1443
/*******************************************************/
1444

    
1445
/**
1446
 * Returns TRUE if the stream has accurate timings in any stream.
1447
 *
1448
 * @return TRUE if the stream has accurate timings for at least one component.
1449
 */
1450
static int av_has_timings(AVFormatContext *ic)
1451
{
1452
    int i;
1453
    AVStream *st;
1454

    
1455
    for(i = 0;i < ic->nb_streams; i++) {
1456
        st = ic->streams[i];
1457
        if (st->start_time != AV_NOPTS_VALUE &&
1458
            st->duration != AV_NOPTS_VALUE)
1459
            return 1;
1460
    }
1461
    return 0;
1462
}
1463

    
1464
/**
1465
 * Estimate the stream timings from the one of each components.
1466
 *
1467
 * Also computes the global bitrate if possible.
1468
 */
1469
static void av_update_stream_timings(AVFormatContext *ic)
1470
{
1471
    int64_t start_time, start_time1, end_time, end_time1;
1472
    int i;
1473
    AVStream *st;
1474

    
1475
    start_time = INT64_MAX;
1476
    end_time = INT64_MIN;
1477
    for(i = 0;i < ic->nb_streams; i++) {
1478
        st = ic->streams[i];
1479
        if (st->start_time != AV_NOPTS_VALUE) {
1480
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1481
            if (start_time1 < start_time)
1482
                start_time = start_time1;
1483
            if (st->duration != AV_NOPTS_VALUE) {
1484
                end_time1 = start_time1
1485
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1486
                if (end_time1 > end_time)
1487
                    end_time = end_time1;
1488
            }
1489
        }
1490
    }
1491
    if (start_time != INT64_MAX) {
1492
        ic->start_time = start_time;
1493
        if (end_time != INT64_MIN) {
1494
            ic->duration = end_time - start_time;
1495
            if (ic->file_size > 0) {
1496
                /* compute the bit rate */
1497
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1498
                    (double)ic->duration;
1499
            }
1500
        }
1501
    }
1502

    
1503
}
1504

    
1505
static void fill_all_stream_timings(AVFormatContext *ic)
1506
{
1507
    int i;
1508
    AVStream *st;
1509

    
1510
    av_update_stream_timings(ic);
1511
    for(i = 0;i < ic->nb_streams; i++) {
1512
        st = ic->streams[i];
1513
        if (st->start_time == AV_NOPTS_VALUE) {
1514
            if(ic->start_time != AV_NOPTS_VALUE)
1515
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1516
            if(ic->duration != AV_NOPTS_VALUE)
1517
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1518
        }
1519
    }
1520
}
1521

    
1522
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1523
{
1524
    int64_t filesize, duration;
1525
    int bit_rate, i;
1526
    AVStream *st;
1527

    
1528
    /* if bit_rate is already set, we believe it */
1529
    if (ic->bit_rate == 0) {
1530
        bit_rate = 0;
1531
        for(i=0;i<ic->nb_streams;i++) {
1532
            st = ic->streams[i];
1533
            bit_rate += st->codec->bit_rate;
1534
        }
1535
        ic->bit_rate = bit_rate;
1536
    }
1537

    
1538
    /* if duration is already set, we believe it */
1539
    if (ic->duration == AV_NOPTS_VALUE &&
1540
        ic->bit_rate != 0 &&
1541
        ic->file_size != 0)  {
1542
        filesize = ic->file_size;
1543
        if (filesize > 0) {
1544
            for(i = 0; i < ic->nb_streams; i++) {
1545
                st = ic->streams[i];
1546
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1547
                if (st->start_time == AV_NOPTS_VALUE ||
1548
                    st->duration == AV_NOPTS_VALUE) {
1549
                    st->start_time = 0;
1550
                    st->duration = duration;
1551
                }
1552
            }
1553
        }
1554
    }
1555
}
1556

    
1557
#define DURATION_MAX_READ_SIZE 250000
1558

    
1559
/* only usable for MPEG-PS streams */
1560
static void av_estimate_timings_from_pts(AVFormatContext *ic)
1561
{
1562
    AVPacket pkt1, *pkt = &pkt1;
1563
    AVStream *st;
1564
    int read_size, i, ret;
1565
    int64_t end_time;
1566
    int64_t filesize, offset, duration;
1567

    
1568
    /* free previous packet */
1569
    if (ic->cur_st && ic->cur_st->parser)
1570
        av_free_packet(&ic->cur_pkt);
1571
    ic->cur_st = NULL;
1572

    
1573
    /* flush packet queue */
1574
    flush_packet_queue(ic);
1575

    
1576
    for(i=0;i<ic->nb_streams;i++) {
1577
        st = ic->streams[i];
1578
        if (st->parser) {
1579
            av_parser_close(st->parser);
1580
            st->parser= NULL;
1581
        }
1582
    }
1583

    
1584
    /* we read the first packets to get the first PTS (not fully
1585
       accurate, but it is enough now) */
1586
    url_fseek(&ic->pb, 0, SEEK_SET);
1587
    read_size = 0;
1588
    for(;;) {
1589
        if (read_size >= DURATION_MAX_READ_SIZE)
1590
            break;
1591
        /* if all info is available, we can stop */
1592
        for(i = 0;i < ic->nb_streams; i++) {
1593
            st = ic->streams[i];
1594
            if (st->start_time == AV_NOPTS_VALUE)
1595
                break;
1596
        }
1597
        if (i == ic->nb_streams)
1598
            break;
1599

    
1600
        ret = av_read_packet(ic, pkt);
1601
        if (ret != 0)
1602
            break;
1603
        read_size += pkt->size;
1604
        st = ic->streams[pkt->stream_index];
1605
        if (pkt->pts != AV_NOPTS_VALUE) {
1606
            if (st->start_time == AV_NOPTS_VALUE)
1607
                st->start_time = pkt->pts;
1608
        }
1609
        av_free_packet(pkt);
1610
    }
1611

    
1612
    /* estimate the end time (duration) */
1613
    /* XXX: may need to support wrapping */
1614
    filesize = ic->file_size;
1615
    offset = filesize - DURATION_MAX_READ_SIZE;
1616
    if (offset < 0)
1617
        offset = 0;
1618

    
1619
    url_fseek(&ic->pb, offset, SEEK_SET);
1620
    read_size = 0;
1621
    for(;;) {
1622
        if (read_size >= DURATION_MAX_READ_SIZE)
1623
            break;
1624
        /* if all info is available, we can stop */
1625
        for(i = 0;i < ic->nb_streams; i++) {
1626
            st = ic->streams[i];
1627
            if (st->duration == AV_NOPTS_VALUE)
1628
                break;
1629
        }
1630
        if (i == ic->nb_streams)
1631
            break;
1632

    
1633
        ret = av_read_packet(ic, pkt);
1634
        if (ret != 0)
1635
            break;
1636
        read_size += pkt->size;
1637
        st = ic->streams[pkt->stream_index];
1638
        if (pkt->pts != AV_NOPTS_VALUE) {
1639
            end_time = pkt->pts;
1640
            duration = end_time - st->start_time;
1641
            if (duration > 0) {
1642
                if (st->duration == AV_NOPTS_VALUE ||
1643
                    st->duration < duration)
1644
                    st->duration = duration;
1645
            }
1646
        }
1647
        av_free_packet(pkt);
1648
    }
1649

    
1650
    fill_all_stream_timings(ic);
1651

    
1652
    url_fseek(&ic->pb, 0, SEEK_SET);
1653
}
1654

    
1655
static void av_estimate_timings(AVFormatContext *ic)
1656
{
1657
    int64_t file_size;
1658

    
1659
    /* get the file size, if possible */
1660
    if (ic->iformat->flags & AVFMT_NOFILE) {
1661
        file_size = 0;
1662
    } else {
1663
        file_size = url_fsize(&ic->pb);
1664
        if (file_size < 0)
1665
            file_size = 0;
1666
    }
1667
    ic->file_size = file_size;
1668

    
1669
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1670
         !strcmp(ic->iformat->name, "mpegts")) &&
1671
        file_size && !ic->pb.is_streamed) {
1672
        /* get accurate estimate from the PTSes */
1673
        av_estimate_timings_from_pts(ic);
1674
    } else if (av_has_timings(ic)) {
1675
        /* at least one components has timings - we use them for all
1676
           the components */
1677
        fill_all_stream_timings(ic);
1678
    } else {
1679
        /* less precise: use bit rate info */
1680
        av_estimate_timings_from_bit_rate(ic);
1681
    }
1682
    av_update_stream_timings(ic);
1683

    
1684
#if 0
1685
    {
1686
        int i;
1687
        AVStream *st;
1688
        for(i = 0;i < ic->nb_streams; i++) {
1689
            st = ic->streams[i];
1690
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1691
               i, (double)st->start_time / AV_TIME_BASE,
1692
               (double)st->duration / AV_TIME_BASE);
1693
        }
1694
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1695
               (double)ic->start_time / AV_TIME_BASE,
1696
               (double)ic->duration / AV_TIME_BASE,
1697
               ic->bit_rate / 1000);
1698
    }
1699
#endif
1700
}
1701

    
1702
static int has_codec_parameters(AVCodecContext *enc)
1703
{
1704
    int val;
1705
    switch(enc->codec_type) {
1706
    case CODEC_TYPE_AUDIO:
1707
        val = enc->sample_rate;
1708
        break;
1709
    case CODEC_TYPE_VIDEO:
1710
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1711
        break;
1712
    default:
1713
        val = 1;
1714
        break;
1715
    }
1716
    return (val != 0);
1717
}
1718

    
1719
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1720
{
1721
    int16_t *samples;
1722
    AVCodec *codec;
1723
    int got_picture, ret=0;
1724
    AVFrame picture;
1725

    
1726
  if(!st->codec->codec){
1727
    codec = avcodec_find_decoder(st->codec->codec_id);
1728
    if (!codec)
1729
        return -1;
1730
    ret = avcodec_open(st->codec, codec);
1731
    if (ret < 0)
1732
        return ret;
1733
  }
1734

    
1735
  if(!has_codec_parameters(st->codec)){
1736
    switch(st->codec->codec_type) {
1737
    case CODEC_TYPE_VIDEO:
1738
        ret = avcodec_decode_video(st->codec, &picture,
1739
                                   &got_picture, (uint8_t *)data, size);
1740
        break;
1741
    case CODEC_TYPE_AUDIO:
1742
        samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1743
        if (!samples)
1744
            goto fail;
1745
        ret = avcodec_decode_audio(st->codec, samples,
1746
                                   &got_picture, (uint8_t *)data, size);
1747
        av_free(samples);
1748
        break;
1749
    default:
1750
        break;
1751
    }
1752
  }
1753
 fail:
1754
    return ret;
1755
}
1756

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

    
1760
/* maximum duration until we stop analysing the stream */
1761
#define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 3.0))
1762

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

    
1769
/**
1770
 * Read the beginning of a media file to get stream information. This
1771
 * is useful for file formats with no headers such as MPEG. This
1772
 * function also compute the real frame rate in case of mpeg2 repeat
1773
 * frame mode.
1774
 *
1775
 * @param ic media file handle
1776
 * @return >=0 if OK. AVERROR_xxx if error.
1777
 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1778
 */
1779
int av_find_stream_info(AVFormatContext *ic)
1780
{
1781
    int i, count, ret, read_size, j;
1782
    AVStream *st;
1783
    AVPacket pkt1, *pkt;
1784
    AVPacketList *pktl=NULL, **ppktl;
1785
    int64_t last_dts[MAX_STREAMS];
1786
    int duration_count[MAX_STREAMS]={0};
1787
    double duration_error[MAX_STREAMS][MAX_STD_TIMEBASES]={{0}}; //FIXME malloc()?
1788

    
1789
    for(i=0;i<ic->nb_streams;i++) {
1790
        st = ic->streams[i];
1791
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1792
/*            if(!st->time_base.num)
1793
                st->time_base= */
1794
            if(!st->codec->time_base.num)
1795
                st->codec->time_base= st->time_base;
1796
        }
1797
        //only for the split stuff
1798
        if (!st->parser) {
1799
            st->parser = av_parser_init(st->codec->codec_id);
1800
            if(st->need_parsing == 2 && st->parser){
1801
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1802
            }
1803
        }
1804
    }
1805

    
1806
    for(i=0;i<MAX_STREAMS;i++){
1807
        last_dts[i]= AV_NOPTS_VALUE;
1808
    }
1809

    
1810
    count = 0;
1811
    read_size = 0;
1812
    ppktl = &ic->packet_buffer;
1813
    for(;;) {
1814
        /* check if one codec still needs to be handled */
1815
        for(i=0;i<ic->nb_streams;i++) {
1816
            st = ic->streams[i];
1817
            if (!has_codec_parameters(st->codec))
1818
                break;
1819
            /* variable fps and no guess at the real fps */
1820
            if(   st->codec->time_base.den >= 101LL*st->codec->time_base.num
1821
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1822
                break;
1823
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1824
                break;
1825
        }
1826
        if (i == ic->nb_streams) {
1827
            /* NOTE: if the format has no header, then we need to read
1828
               some packets to get most of the streams, so we cannot
1829
               stop here */
1830
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1831
                /* if we found the info for all the codecs, we can stop */
1832
                ret = count;
1833
                break;
1834
            }
1835
        }
1836
        /* we did not get all the codec info, but we read too much data */
1837
        if (read_size >= MAX_READ_SIZE) {
1838
            ret = count;
1839
            break;
1840
        }
1841

    
1842
        /* NOTE: a new stream can be added there if no header in file
1843
           (AVFMTCTX_NOHEADER) */
1844
        ret = av_read_frame_internal(ic, &pkt1);
1845
        if (ret < 0) {
1846
            /* EOF or error */
1847
            ret = -1; /* we could not have all the codec parameters before EOF */
1848
            for(i=0;i<ic->nb_streams;i++) {
1849
                st = ic->streams[i];
1850
                if (!has_codec_parameters(st->codec)){
1851
                    char buf[256];
1852
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1853
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1854
                } else {
1855
                    ret = 0;
1856
                }
1857
            }
1858
            break;
1859
        }
1860

    
1861
        pktl = av_mallocz(sizeof(AVPacketList));
1862
        if (!pktl) {
1863
            ret = AVERROR_NOMEM;
1864
            break;
1865
        }
1866

    
1867
        /* add the packet in the buffered packet list */
1868
        *ppktl = pktl;
1869
        ppktl = &pktl->next;
1870

    
1871
        pkt = &pktl->pkt;
1872
        *pkt = pkt1;
1873

    
1874
        /* duplicate the packet */
1875
        if (av_dup_packet(pkt) < 0) {
1876
            ret = AVERROR_NOMEM;
1877
            break;
1878
        }
1879

    
1880
        read_size += pkt->size;
1881

    
1882
        st = ic->streams[pkt->stream_index];
1883
        if(st->codec_info_nb_frames>1) //FIXME move codec_info_nb_frames and codec_info_duration from AVStream into this func
1884
            st->codec_info_duration += pkt->duration;
1885
        if (pkt->duration != 0)
1886
            st->codec_info_nb_frames++;
1887

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

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

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

    
1908
                if(st->codec_info_nb_frames == 0 && 0)
1909
                    st->codec_info_duration += duration;
1910
            }
1911
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1912
                last_dts[pkt->stream_index]= pkt->dts;
1913
        }
1914
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1915
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1916
            if(i){
1917
                st->codec->extradata_size= i;
1918
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1919
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1920
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1921
            }
1922
        }
1923

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

    
1945
        if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
1946
            break;
1947
        }
1948
        count++;
1949
    }
1950

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

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

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

    
1981
            if (!st->r_frame_rate.num){
1982
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1983
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1984
                    st->r_frame_rate.num = st->codec->time_base.den;
1985
                    st->r_frame_rate.den = st->codec->time_base.num;
1986
                }else{
1987
                    st->r_frame_rate.num = st->time_base.den;
1988
                    st->r_frame_rate.den = st->time_base.num;
1989
                }
1990
            }
1991
        }
1992
    }
1993

    
1994
    av_estimate_timings(ic);
1995
#if 0
1996
    /* correct DTS for b frame streams with no timestamps */
1997
    for(i=0;i<ic->nb_streams;i++) {
1998
        st = ic->streams[i];
1999
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2000
            if(b-frames){
2001
                ppktl = &ic->packet_buffer;
2002
                while(ppkt1){
2003
                    if(ppkt1->stream_index != i)
2004
                        continue;
2005
                    if(ppkt1->pkt->dts < 0)
2006
                        break;
2007
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2008
                        break;
2009
                    ppkt1->pkt->dts -= delta;
2010
                    ppkt1= ppkt1->next;
2011
                }
2012
                if(ppkt1)
2013
                    continue;
2014
                st->cur_dts -= delta;
2015
            }
2016
        }
2017
    }
2018
#endif
2019
    return ret;
2020
}
2021

    
2022
/*******************************************************/
2023

    
2024
/**
2025
 * start playing a network based stream (e.g. RTSP stream) at the
2026
 * current position
2027
 */
2028
int av_read_play(AVFormatContext *s)
2029
{
2030
    if (!s->iformat->read_play)
2031
        return AVERROR_NOTSUPP;
2032
    return s->iformat->read_play(s);
2033
}
2034

    
2035
/**
2036
 * Pause a network based stream (e.g. RTSP stream).
2037
 *
2038
 * Use av_read_play() to resume it.
2039
 */
2040
int av_read_pause(AVFormatContext *s)
2041
{
2042
    if (!s->iformat->read_pause)
2043
        return AVERROR_NOTSUPP;
2044
    return s->iformat->read_pause(s);
2045
}
2046

    
2047
/**
2048
 * Close a media file (but not its codecs).
2049
 *
2050
 * @param s media file handle
2051
 */
2052
void av_close_input_file(AVFormatContext *s)
2053
{
2054
    int i, must_open_file;
2055
    AVStream *st;
2056

    
2057
    /* free previous packet */
2058
    if (s->cur_st && s->cur_st->parser)
2059
        av_free_packet(&s->cur_pkt);
2060

    
2061
    if (s->iformat->read_close)
2062
        s->iformat->read_close(s);
2063
    for(i=0;i<s->nb_streams;i++) {
2064
        /* free all data in a stream component */
2065
        st = s->streams[i];
2066
        if (st->parser) {
2067
            av_parser_close(st->parser);
2068
        }
2069
        av_free(st->index_entries);
2070
        av_free(st->codec->extradata);
2071
        av_free(st->codec);
2072
        av_free(st);
2073
    }
2074
    flush_packet_queue(s);
2075
    must_open_file = 1;
2076
    if (s->iformat->flags & AVFMT_NOFILE) {
2077
        must_open_file = 0;
2078
    }
2079
    if (must_open_file) {
2080
        url_fclose(&s->pb);
2081
    }
2082
    av_freep(&s->priv_data);
2083
    av_free(s);
2084
}
2085

    
2086
/**
2087
 * Add a new stream to a media file.
2088
 *
2089
 * Can only be called in the read_header() function. If the flag
2090
 * AVFMTCTX_NOHEADER is in the format context, then new streams
2091
 * can be added in read_packet too.
2092
 *
2093
 * @param s media file handle
2094
 * @param id file format dependent stream id
2095
 */
2096
AVStream *av_new_stream(AVFormatContext *s, int id)
2097
{
2098
    AVStream *st;
2099
    int i;
2100

    
2101
    if (s->nb_streams >= MAX_STREAMS)
2102
        return NULL;
2103

    
2104
    st = av_mallocz(sizeof(AVStream));
2105
    if (!st)
2106
        return NULL;
2107

    
2108
    st->codec= avcodec_alloc_context();
2109
    if (s->iformat) {
2110
        /* no default bitrate if decoding */
2111
        st->codec->bit_rate = 0;
2112
    }
2113
    st->index = s->nb_streams;
2114
    st->id = id;
2115
    st->start_time = AV_NOPTS_VALUE;
2116
    st->duration = AV_NOPTS_VALUE;
2117
    st->cur_dts = AV_NOPTS_VALUE;
2118

    
2119
    /* default pts settings is MPEG like */
2120
    av_set_pts_info(st, 33, 1, 90000);
2121
    st->last_IP_pts = AV_NOPTS_VALUE;
2122
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2123
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2124

    
2125
    s->streams[s->nb_streams++] = st;
2126
    return st;
2127
}
2128

    
2129
/************************************************************/
2130
/* output media file */
2131

    
2132
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2133
{
2134
    int ret;
2135

    
2136
    if (s->oformat->priv_data_size > 0) {
2137
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2138
        if (!s->priv_data)
2139
            return AVERROR_NOMEM;
2140
    } else
2141
        s->priv_data = NULL;
2142

    
2143
    if (s->oformat->set_parameters) {
2144
        ret = s->oformat->set_parameters(s, ap);
2145
        if (ret < 0)
2146
            return ret;
2147
    }
2148
    return 0;
2149
}
2150

    
2151
/**
2152
 * allocate the stream private data and write the stream header to an
2153
 * output media file
2154
 *
2155
 * @param s media file handle
2156
 * @return 0 if OK. AVERROR_xxx if error.
2157
 */
2158
int av_write_header(AVFormatContext *s)
2159
{
2160
    int ret, i;
2161
    AVStream *st;
2162

    
2163
    // some sanity checks
2164
    for(i=0;i<s->nb_streams;i++) {
2165
        st = s->streams[i];
2166

    
2167
        switch (st->codec->codec_type) {
2168
        case CODEC_TYPE_AUDIO:
2169
            if(st->codec->sample_rate<=0){
2170
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2171
                return -1;
2172
            }
2173
            break;
2174
        case CODEC_TYPE_VIDEO:
2175
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2176
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2177
                return -1;
2178
            }
2179
            if(st->codec->width<=0 || st->codec->height<=0){
2180
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2181
                return -1;
2182
            }
2183
            break;
2184
        }
2185
    }
2186

    
2187
    if(s->oformat->write_header){
2188
        ret = s->oformat->write_header(s);
2189
        if (ret < 0)
2190
            return ret;
2191
    }
2192

    
2193
    /* init PTS generation */
2194
    for(i=0;i<s->nb_streams;i++) {
2195
        int64_t den = AV_NOPTS_VALUE;
2196
        st = s->streams[i];
2197

    
2198
        switch (st->codec->codec_type) {
2199
        case CODEC_TYPE_AUDIO:
2200
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2201
            break;
2202
        case CODEC_TYPE_VIDEO:
2203
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2204
            break;
2205
        default:
2206
            break;
2207
        }
2208
        if (den != AV_NOPTS_VALUE) {
2209
            if (den <= 0)
2210
                return AVERROR_INVALIDDATA;
2211
            av_frac_init(&st->pts, 0, 0, den);
2212
        }
2213
    }
2214
    return 0;
2215
}
2216

    
2217
//FIXME merge with compute_pkt_fields
2218
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2219
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2220
    int num, den, frame_size, i;
2221

    
2222
//    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);
2223

    
2224
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2225
        return -1;*/
2226

    
2227
    /* duration field */
2228
    if (pkt->duration == 0) {
2229
        compute_frame_duration(&num, &den, st, NULL, pkt);
2230
        if (den && num) {
2231
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2232
        }
2233
    }
2234

    
2235
    //XXX/FIXME this is a temporary hack until all encoders output pts
2236
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2237
        pkt->dts=
2238
//        pkt->pts= st->cur_dts;
2239
        pkt->pts= st->pts.val;
2240
    }
2241

    
2242
    //calculate dts from pts
2243
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2244
        st->pts_buffer[0]= pkt->pts;
2245
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2246
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2247
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2248
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2249

    
2250
        pkt->dts= st->pts_buffer[0];
2251
    }
2252

    
2253
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2254
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2255
        return -1;
2256
    }
2257
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2258
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2259
        return -1;
2260
    }
2261

    
2262
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2263
    st->cur_dts= pkt->dts;
2264
    st->pts.val= pkt->dts;
2265

    
2266
    /* update pts */
2267
    switch (st->codec->codec_type) {
2268
    case CODEC_TYPE_AUDIO:
2269
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2270

    
2271
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2272
           but it would be better if we had the real timestamps from the encoder */
2273
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2274
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2275
        }
2276
        break;
2277
    case CODEC_TYPE_VIDEO:
2278
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2279
        break;
2280
    default:
2281
        break;
2282
    }
2283
    return 0;
2284
}
2285

    
2286
static void truncate_ts(AVStream *st, AVPacket *pkt){
2287
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2288

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

    
2292
    if (pkt->pts != AV_NOPTS_VALUE)
2293
        pkt->pts &= pts_mask;
2294
    if (pkt->dts != AV_NOPTS_VALUE)
2295
        pkt->dts &= pts_mask;
2296
}
2297

    
2298
/**
2299
 * Write a packet to an output media file.
2300
 *
2301
 * The packet shall contain one audio or video frame.
2302
 *
2303
 * @param s media file handle
2304
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2305
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2306
 */
2307
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2308
{
2309
    int ret;
2310

    
2311
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2312
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2313
        return ret;
2314

    
2315
    truncate_ts(s->streams[pkt->stream_index], pkt);
2316

    
2317
    ret= s->oformat->write_packet(s, pkt);
2318
    if(!ret)
2319
        ret= url_ferror(&s->pb);
2320
    return ret;
2321
}
2322

    
2323
/**
2324
 * Interleave a packet per DTS in an output media file.
2325
 *
2326
 * Packets with pkt->destruct == av_destruct_packet will be freed inside this function,
2327
 * so they cannot be used after it, note calling av_free_packet() on them is still safe.
2328
 *
2329
 * @param s media file handle
2330
 * @param out the interleaved packet will be output here
2331
 * @param in the input packet
2332
 * @param flush 1 if no further packets are available as input and all
2333
 *              remaining packets should be output
2334
 * @return 1 if a packet was output, 0 if no packet could be output,
2335
 *         < 0 if an error occured
2336
 */
2337
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2338
    AVPacketList *pktl, **next_point, *this_pktl;
2339
    int stream_count=0;
2340
    int streams[MAX_STREAMS];
2341

    
2342
    if(pkt){
2343
        AVStream *st= s->streams[ pkt->stream_index];
2344

    
2345
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2346

    
2347
        this_pktl = av_mallocz(sizeof(AVPacketList));
2348
        this_pktl->pkt= *pkt;
2349
        if(pkt->destruct == av_destruct_packet)
2350
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2351
        else
2352
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2353

    
2354
        next_point = &s->packet_buffer;
2355
        while(*next_point){
2356
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2357
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2358
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2359
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2360
                break;
2361
            next_point= &(*next_point)->next;
2362
        }
2363
        this_pktl->next= *next_point;
2364
        *next_point= this_pktl;
2365
    }
2366

    
2367
    memset(streams, 0, sizeof(streams));
2368
    pktl= s->packet_buffer;
2369
    while(pktl){
2370
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2371
        if(streams[ pktl->pkt.stream_index ] == 0)
2372
            stream_count++;
2373
        streams[ pktl->pkt.stream_index ]++;
2374
        pktl= pktl->next;
2375
    }
2376

    
2377
    if(s->nb_streams == stream_count || (flush && stream_count)){
2378
        pktl= s->packet_buffer;
2379
        *out= pktl->pkt;
2380

    
2381
        s->packet_buffer= pktl->next;
2382
        av_freep(&pktl);
2383
        return 1;
2384
    }else{
2385
        av_init_packet(out);
2386
        return 0;
2387
    }
2388
}
2389

    
2390
/**
2391
 * Interleaves a AVPacket correctly so it can be muxed.
2392
 * @param out the interleaved packet will be output here
2393
 * @param in the input packet
2394
 * @param flush 1 if no further packets are available as input and all
2395
 *              remaining packets should be output
2396
 * @return 1 if a packet was output, 0 if no packet could be output,
2397
 *         < 0 if an error occured
2398
 */
2399
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2400
    if(s->oformat->interleave_packet)
2401
        return s->oformat->interleave_packet(s, out, in, flush);
2402
    else
2403
        return av_interleave_packet_per_dts(s, out, in, flush);
2404
}
2405

    
2406
/**
2407
 * Writes a packet to an output media file ensuring correct interleaving.
2408
 *
2409
 * The packet must contain one audio or video frame.
2410
 * If the packets are already correctly interleaved the application should
2411
 * call av_write_frame() instead as its slightly faster, its also important
2412
 * to keep in mind that completly non interleaved input will need huge amounts
2413
 * of memory to interleave with this, so its prefereable to interleave at the
2414
 * demuxer level
2415
 *
2416
 * @param s media file handle
2417
 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2418
 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2419
 */
2420
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2421
    AVStream *st= s->streams[ pkt->stream_index];
2422

    
2423
    //FIXME/XXX/HACK drop zero sized packets
2424
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2425
        return 0;
2426

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

    
2431
    if(pkt->dts == AV_NOPTS_VALUE)
2432
        return -1;
2433

    
2434
    for(;;){
2435
        AVPacket opkt;
2436
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2437
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2438
            return ret;
2439

    
2440
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2441
        ret= s->oformat->write_packet(s, &opkt);
2442

    
2443
        av_free_packet(&opkt);
2444
        pkt= NULL;
2445

    
2446
        if(ret<0)
2447
            return ret;
2448
        if(url_ferror(&s->pb))
2449
            return url_ferror(&s->pb);
2450
    }
2451
}
2452

    
2453
/**
2454
 * @brief Write the stream trailer to an output media file and
2455
 *        free the file private data.
2456
 *
2457
 * @param s media file handle
2458
 * @return 0 if OK. AVERROR_xxx if error.
2459
 */
2460
int av_write_trailer(AVFormatContext *s)
2461
{
2462
    int ret, i;
2463

    
2464
    for(;;){
2465
        AVPacket pkt;
2466
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2467
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2468
            goto fail;
2469
        if(!ret)
2470
            break;
2471

    
2472
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2473
        ret= s->oformat->write_packet(s, &pkt);
2474

    
2475
        av_free_packet(&pkt);
2476

    
2477
        if(ret<0)
2478
            goto fail;
2479
        if(url_ferror(&s->pb))
2480
            goto fail;
2481
    }
2482

    
2483
    if(s->oformat->write_trailer)
2484
        ret = s->oformat->write_trailer(s);
2485
fail:
2486
    if(ret == 0)
2487
       ret=url_ferror(&s->pb);
2488
    for(i=0;i<s->nb_streams;i++)
2489
        av_freep(&s->streams[i]->priv_data);
2490
    av_freep(&s->priv_data);
2491
    return ret;
2492
}
2493

    
2494
/* "user interface" functions */
2495

    
2496
void dump_format(AVFormatContext *ic,
2497
                 int index,
2498
                 const char *url,
2499
                 int is_output)
2500
{
2501
    int i, flags;
2502
    char buf[256];
2503

    
2504
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2505
            is_output ? "Output" : "Input",
2506
            index,
2507
            is_output ? ic->oformat->name : ic->iformat->name,
2508
            is_output ? "to" : "from", url);
2509
    if (!is_output) {
2510
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2511
        if (ic->duration != AV_NOPTS_VALUE) {
2512
            int hours, mins, secs, us;
2513
            secs = ic->duration / AV_TIME_BASE;
2514
            us = ic->duration % AV_TIME_BASE;
2515
            mins = secs / 60;
2516
            secs %= 60;
2517
            hours = mins / 60;
2518
            mins %= 60;
2519
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2520
                   (10 * us) / AV_TIME_BASE);
2521
        } else {
2522
            av_log(NULL, AV_LOG_INFO, "N/A");
2523
        }
2524
        if (ic->start_time != AV_NOPTS_VALUE) {
2525
            int secs, us;
2526
            av_log(NULL, AV_LOG_INFO, ", start: ");
2527
            secs = ic->start_time / AV_TIME_BASE;
2528
            us = ic->start_time % AV_TIME_BASE;
2529
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2530
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2531
        }
2532
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2533
        if (ic->bit_rate) {
2534
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2535
        } else {
2536
            av_log(NULL, AV_LOG_INFO, "N/A");
2537
        }
2538
        av_log(NULL, AV_LOG_INFO, "\n");
2539
    }
2540
    for(i=0;i<ic->nb_streams;i++) {
2541
        AVStream *st = ic->streams[i];
2542
        int g= ff_gcd(st->time_base.num, st->time_base.den);
2543
        avcodec_string(buf, sizeof(buf), st->codec, is_output);
2544
        av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2545
        /* the pid is an important information, so we display it */
2546
        /* XXX: add a generic system */
2547
        if (is_output)
2548
            flags = ic->oformat->flags;
2549
        else
2550
            flags = ic->iformat->flags;
2551
        if (flags & AVFMT_SHOW_IDS) {
2552
            av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2553
        }
2554
        if (strlen(st->language) > 0) {
2555
            av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2556
        }
2557
        av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2558
        av_log(NULL, AV_LOG_INFO, ": %s", buf);
2559
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2560
            if(st->r_frame_rate.den && st->r_frame_rate.num)
2561
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2562
/*            else if(st->time_base.den && st->time_base.num)
2563
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2564
            else
2565
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2566
        }
2567
        av_log(NULL, AV_LOG_INFO, "\n");
2568
    }
2569
}
2570

    
2571
typedef struct {
2572
    const char *abv;
2573
    int width, height;
2574
    int frame_rate, frame_rate_base;
2575
} AbvEntry;
2576

    
2577
static AbvEntry frame_abvs[] = {
2578
    { "ntsc",      720, 480, 30000, 1001 },
2579
    { "pal",       720, 576,    25,    1 },
2580
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2581
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2582
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2583
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2584
    { "film",      352, 240,    24,    1 },
2585
    { "ntsc-film", 352, 240, 24000, 1001 },
2586
    { "sqcif",     128,  96,     0,    0 },
2587
    { "qcif",      176, 144,     0,    0 },
2588
    { "cif",       352, 288,     0,    0 },
2589
    { "4cif",      704, 576,     0,    0 },
2590
};
2591

    
2592
/**
2593
 * parses width and height out of string str.
2594
 */
2595
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2596
{
2597
    int i;
2598
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2599
    const char *p;
2600
    int frame_width = 0, frame_height = 0;
2601

    
2602
    for(i=0;i<n;i++) {
2603
        if (!strcmp(frame_abvs[i].abv, str)) {
2604
            frame_width = frame_abvs[i].width;
2605
            frame_height = frame_abvs[i].height;
2606
            break;
2607
        }
2608
    }
2609
    if (i == n) {
2610
        p = str;
2611
        frame_width = strtol(p, (char **)&p, 10);
2612
        if (*p)
2613
            p++;
2614
        frame_height = strtol(p, (char **)&p, 10);
2615
    }
2616
    if (frame_width <= 0 || frame_height <= 0)
2617
        return -1;
2618
    *width_ptr = frame_width;
2619
    *height_ptr = frame_height;
2620
    return 0;
2621
}
2622

    
2623
/**
2624
 * Converts frame rate from string to a fraction.
2625
 *
2626
 * First we try to get an exact integer or fractional frame rate.
2627
 * If this fails we convert the frame rate to a double and return
2628
 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2629
 */
2630
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2631
{
2632
    int i;
2633
    char* cp;
2634

    
2635
    /* First, we check our abbreviation table */
2636
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2637
         if (!strcmp(frame_abvs[i].abv, arg)) {
2638
             *frame_rate = frame_abvs[i].frame_rate;
2639
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2640
             return 0;
2641
         }
2642

    
2643
    /* Then, we try to parse it as fraction */
2644
    cp = strchr(arg, '/');
2645
    if (!cp)
2646
        cp = strchr(arg, ':');
2647
    if (cp) {
2648
        char* cpp;
2649
        *frame_rate = strtol(arg, &cpp, 10);
2650
        if (cpp != arg || cpp == cp)
2651
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2652
        else
2653
           *frame_rate = 0;
2654
    }
2655
    else {
2656
        /* Finally we give up and parse it as double */
2657
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2658
        *frame_rate_base = time_base.den;
2659
        *frame_rate = time_base.num;
2660
    }
2661
    if (!*frame_rate || !*frame_rate_base)
2662
        return -1;
2663
    else
2664
        return 0;
2665
}
2666

    
2667
/**
2668
 * Converts date string to number of seconds since Jan 1st, 1970.
2669
 *
2670
 * @code
2671
 * Syntax:
2672
 * - If not a duration:
2673
 *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2674
 * Time is localtime unless Z is suffixed to the end. In this case GMT
2675
 * Return the date in micro seconds since 1970
2676
 *
2677
 * - If a duration:
2678
 *  HH[:MM[:SS[.m...]]]
2679
 *  S+[.m...]
2680
 * @endcode
2681
 */
2682
#ifndef CONFIG_WINCE
2683
int64_t parse_date(const char *datestr, int duration)
2684
{
2685
    const char *p;
2686
    int64_t t;
2687
    struct tm dt;
2688
    int i;
2689
    static const char *date_fmt[] = {
2690
        "%Y-%m-%d",
2691
        "%Y%m%d",
2692
    };
2693
    static const char *time_fmt[] = {
2694
        "%H:%M:%S",
2695
        "%H%M%S",
2696
    };
2697
    const char *q;
2698
    int is_utc, len;
2699
    char lastch;
2700
    int negative = 0;
2701

    
2702
#undef time
2703
    time_t now = time(0);
2704

    
2705
    len = strlen(datestr);
2706
    if (len > 0)
2707
        lastch = datestr[len - 1];
2708
    else
2709
        lastch = '\0';
2710
    is_utc = (lastch == 'z' || lastch == 'Z');
2711

    
2712
    memset(&dt, 0, sizeof(dt));
2713

    
2714
    p = datestr;
2715
    q = NULL;
2716
    if (!duration) {
2717
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2718
            q = small_strptime(p, date_fmt[i], &dt);
2719
            if (q) {
2720
                break;
2721
            }
2722
        }
2723

    
2724
        if (!q) {
2725
            if (is_utc) {
2726
                dt = *gmtime(&now);
2727
            } else {
2728
                dt = *localtime(&now);
2729
            }
2730
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2731
        } else {
2732
            p = q;
2733
        }
2734

    
2735
        if (*p == 'T' || *p == 't' || *p == ' ')
2736
            p++;
2737

    
2738
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2739
            q = small_strptime(p, time_fmt[i], &dt);
2740
            if (q) {
2741
                break;
2742
            }
2743
        }
2744
    } else {
2745
        if (p[0] == '-') {
2746
            negative = 1;
2747
            ++p;
2748
        }
2749
        q = small_strptime(p, time_fmt[0], &dt);
2750
        if (!q) {
2751
            dt.tm_sec = strtol(p, (char **)&q, 10);
2752
            dt.tm_min = 0;
2753
            dt.tm_hour = 0;
2754
        }
2755
    }
2756

    
2757
    /* Now we have all the fields that we can get */
2758
    if (!q) {
2759
        if (duration)
2760
            return 0;
2761
        else
2762
            return now * INT64_C(1000000);
2763
    }
2764

    
2765
    if (duration) {
2766
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2767
    } else {
2768
        dt.tm_isdst = -1;       /* unknown */
2769
        if (is_utc) {
2770
            t = mktimegm(&dt);
2771
        } else {
2772
            t = mktime(&dt);
2773
        }
2774
    }
2775

    
2776
    t *= 1000000;
2777

    
2778
    if (*q == '.') {
2779
        int val, n;
2780
        q++;
2781
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2782
            if (!isdigit(*q))
2783
                break;
2784
            val += n * (*q - '0');
2785
        }
2786
        t += val;
2787
    }
2788
    return negative ? -t : t;
2789
}
2790
#endif /* CONFIG_WINCE */
2791

    
2792
/**
2793
 * Attempts to find a specific tag in a URL.
2794
 *
2795
 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2796
 * Return 1 if found.
2797
 */
2798
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2799
{
2800
    const char *p;
2801
    char tag[128], *q;
2802

    
2803
    p = info;
2804
    if (*p == '?')
2805
        p++;
2806
    for(;;) {
2807
        q = tag;
2808
        while (*p != '\0' && *p != '=' && *p != '&') {
2809
            if ((q - tag) < sizeof(tag) - 1)
2810
                *q++ = *p;
2811
            p++;
2812
        }
2813
        *q = '\0';
2814
        q = arg;
2815
        if (*p == '=') {
2816
            p++;
2817
            while (*p != '&' && *p != '\0') {
2818
                if ((q - arg) < arg_size - 1) {
2819
                    if (*p == '+')
2820
                        *q++ = ' ';
2821
                    else
2822
                        *q++ = *p;
2823
                }
2824
                p++;
2825
            }
2826
            *q = '\0';
2827
        }
2828
        if (!strcmp(tag, tag1))
2829
            return 1;
2830
        if (*p != '&')
2831
            break;
2832
        p++;
2833
    }
2834
    return 0;
2835
}
2836

    
2837
/**
2838
 * Returns in 'buf' the path with '%d' replaced by number.
2839

2840
 * Also handles the '%0nd' format where 'n' is the total number
2841
 * of digits and '%%'.
2842
 *
2843
 * @param buf destination buffer
2844
 * @param buf_size destination buffer size
2845
 * @param path numbered sequence string
2846
 * @number frame number
2847
 * @return 0 if OK, -1 if format error.
2848
 */
2849
int av_get_frame_filename(char *buf, int buf_size,
2850
                          const char *path, int number)
2851
{
2852
    const char *p;
2853
    char *q, buf1[20], c;
2854
    int nd, len, percentd_found;
2855

    
2856
    q = buf;
2857
    p = path;
2858
    percentd_found = 0;
2859
    for(;;) {
2860
        c = *p++;
2861
        if (c == '\0')
2862
            break;
2863
        if (c == '%') {
2864
            do {
2865
                nd = 0;
2866
                while (isdigit(*p)) {
2867
                    nd = nd * 10 + *p++ - '0';
2868
                }
2869
                c = *p++;
2870
            } while (isdigit(c));
2871

    
2872
            switch(c) {
2873
            case '%':
2874
                goto addchar;
2875
            case 'd':
2876
                if (percentd_found)
2877
                    goto fail;
2878
                percentd_found = 1;
2879
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2880
                len = strlen(buf1);
2881
                if ((q - buf + len) > buf_size - 1)
2882
                    goto fail;
2883
                memcpy(q, buf1, len);
2884
                q += len;
2885
                break;
2886
            default:
2887
                goto fail;
2888
            }
2889
        } else {
2890
        addchar:
2891
            if ((q - buf) < buf_size - 1)
2892
                *q++ = c;
2893
        }
2894
    }
2895
    if (!percentd_found)
2896
        goto fail;
2897
    *q = '\0';
2898
    return 0;
2899
 fail:
2900
    *q = '\0';
2901
    return -1;
2902
}
2903

    
2904
/**
2905
 * Print  nice hexa dump of a buffer
2906
 * @param f stream for output
2907
 * @param buf buffer
2908
 * @param size buffer size
2909
 */
2910
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2911
{
2912
    int len, i, j, c;
2913

    
2914
    for(i=0;i<size;i+=16) {
2915
        len = size - i;
2916
        if (len > 16)
2917
            len = 16;
2918
        fprintf(f, "%08x ", i);
2919
        for(j=0;j<16;j++) {
2920
            if (j < len)
2921
                fprintf(f, " %02x", buf[i+j]);
2922
            else
2923
                fprintf(f, "   ");
2924
        }
2925
        fprintf(f, " ");
2926
        for(j=0;j<len;j++) {
2927
            c = buf[i+j];
2928
            if (c < ' ' || c > '~')
2929
                c = '.';
2930
            fprintf(f, "%c", c);
2931
        }
2932
        fprintf(f, "\n");
2933
    }
2934
}
2935

    
2936
/**
2937
 * Print on 'f' a nice dump of a packet
2938
 * @param f stream for output
2939
 * @param pkt packet to dump
2940
 * @param dump_payload true if the payload must be displayed too
2941
 */
2942
 //FIXME needs to know the time_base
2943
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2944
{
2945
    fprintf(f, "stream #%d:\n", pkt->stream_index);
2946
    fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2947
    fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2948
    /* DTS is _always_ valid after av_read_frame() */
2949
    fprintf(f, "  dts=");
2950
    if (pkt->dts == AV_NOPTS_VALUE)
2951
        fprintf(f, "N/A");
2952
    else
2953
        fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2954
    /* PTS may be not known if B frames are present */
2955
    fprintf(f, "  pts=");
2956
    if (pkt->pts == AV_NOPTS_VALUE)
2957
        fprintf(f, "N/A");
2958
    else
2959
        fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2960
    fprintf(f, "\n");
2961
    fprintf(f, "  size=%d\n", pkt->size);
2962
    if (dump_payload)
2963
        av_hex_dump(f, pkt->data, pkt->size);
2964
}
2965

    
2966
void url_split(char *proto, int proto_size,
2967
               char *authorization, int authorization_size,
2968
               char *hostname, int hostname_size,
2969
               int *port_ptr,
2970
               char *path, int path_size,
2971
               const char *url)
2972
{
2973
    const char *p;
2974
    char *q;
2975
    int port;
2976

    
2977
    port = -1;
2978

    
2979
    p = url;
2980
    q = proto;
2981
    while (*p != ':' && *p != '\0') {
2982
        if ((q - proto) < proto_size - 1)
2983
            *q++ = *p;
2984
        p++;
2985
    }
2986
    if (proto_size > 0)
2987
        *q = '\0';
2988
    if (authorization_size > 0)
2989
        authorization[0] = '\0';
2990
    if (*p == '\0') {
2991
        if (proto_size > 0)
2992
            proto[0] = '\0';
2993
        if (hostname_size > 0)
2994
            hostname[0] = '\0';
2995
        p = url;
2996
    } else {
2997
        char *at,*slash; // PETR: position of '@' character and '/' character
2998

    
2999
        p++;
3000
        if (*p == '/')
3001
            p++;
3002
        if (*p == '/')
3003
            p++;
3004
        at = strchr(p,'@'); // PETR: get the position of '@'
3005
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
3006
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3007

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

    
3010
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3011
            if (*p == '@') {    // PETR: passed '@'
3012
              if (authorization_size > 0)
3013
                  *q = '\0';
3014
              q = hostname;
3015
              at = NULL;
3016
            } else if (!at) {   // PETR: hostname
3017
              if ((q - hostname) < hostname_size - 1)
3018
                  *q++ = *p;
3019
            } else {
3020
              if ((q - authorization) < authorization_size - 1)
3021
                *q++ = *p;
3022
            }
3023
            p++;
3024
        }
3025
        if (hostname_size > 0)
3026
            *q = '\0';
3027
        if (*p == ':') {
3028
            p++;
3029
            port = strtoul(p, (char **)&p, 10);
3030
        }
3031
    }
3032
    if (port_ptr)
3033
        *port_ptr = port;
3034
    pstrcpy(path, path_size, p);
3035
}
3036

    
3037
/**
3038
 * Set the pts for a given stream.
3039
 *
3040
 * @param s stream
3041
 * @param pts_wrap_bits number of bits effectively used by the pts
3042
 *        (used for wrap control, 33 is the value for MPEG)
3043
 * @param pts_num numerator to convert to seconds (MPEG: 1)
3044
 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3045
 */
3046
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3047
                     int pts_num, int pts_den)
3048
{
3049
    s->pts_wrap_bits = pts_wrap_bits;
3050
    s->time_base.num = pts_num;
3051
    s->time_base.den = pts_den;
3052
}
3053

    
3054
/* fraction handling */
3055

    
3056
/**
3057
 * f = val + (num / den) + 0.5.
3058
 *
3059
 * 'num' is normalized so that it is such as 0 <= num < den.
3060
 *
3061
 * @param f fractional number
3062
 * @param val integer value
3063
 * @param num must be >= 0
3064
 * @param den must be >= 1
3065
 */
3066
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3067
{
3068
    num += (den >> 1);
3069
    if (num >= den) {
3070
        val += num / den;
3071
        num = num % den;
3072
    }
3073
    f->val = val;
3074
    f->num = num;
3075
    f->den = den;
3076
}
3077

    
3078
/**
3079
 * Set f to (val + 0.5).
3080
 */
3081
static void av_frac_set(AVFrac *f, int64_t val)
3082
{
3083
    f->val = val;
3084
    f->num = f->den >> 1;
3085
}
3086

    
3087
/**
3088
 * Fractionnal addition to f: f = f + (incr / f->den).
3089
 *
3090
 * @param f fractional number
3091
 * @param incr increment, can be positive or negative
3092
 */
3093
static void av_frac_add(AVFrac *f, int64_t incr)
3094
{
3095
    int64_t num, den;
3096

    
3097
    num = f->num + incr;
3098
    den = f->den;
3099
    if (num < 0) {
3100
        f->val += num / den;
3101
        num = num % den;
3102
        if (num < 0) {
3103
            num += den;
3104
            f->val--;
3105
        }
3106
    } else if (num >= den) {
3107
        f->val += num / den;
3108
        num = num % den;
3109
    }
3110
    f->num = num;
3111
}