Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 6cc65ab3

History | View | Annotate | Download (85.7 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

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

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

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

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

    
64
    if(!filename)
65
        return 0;
66

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

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

    
92
    /* specific test for image sequences */
93
#ifdef CONFIG_IMAGE2_MUXER
94
    if (!short_name && filename &&
95
        av_filename_number_test(filename) &&
96
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
97
        return guess_format("image2", NULL, NULL);
98
    }
99
#endif
100
    /* find the proper file type */
101
    fmt_found = NULL;
102
    score_max = 0;
103
    fmt = first_oformat;
104
    while (fmt != NULL) {
105
        score = 0;
106
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
107
            score += 100;
108
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
109
            score += 10;
110
        if (filename && fmt->extensions &&
111
            match_ext(filename, fmt->extensions)) {
112
            score += 5;
113
        }
114
        if (score > score_max) {
115
            score_max = score;
116
            fmt_found = fmt;
117
        }
118
        fmt = fmt->next;
119
    }
120
    return fmt_found;
121
}
122

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

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

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

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

    
139
    return fmt;
140
}
141

    
142
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
143
                            const char *filename, const char *mime_type, enum CodecType type){
144
    if(type == CODEC_TYPE_VIDEO){
145
        enum CodecID codec_id= CODEC_ID_NONE;
146

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

    
161
AVInputFormat *av_find_input_format(const char *short_name)
162
{
163
    AVInputFormat *fmt;
164
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
165
        if (!strcmp(fmt->name, short_name))
166
            return fmt;
167
    }
168
    return NULL;
169
}
170

    
171
/* memory handling */
172

    
173
void av_destruct_packet(AVPacket *pkt)
174
{
175
    av_free(pkt->data);
176
    pkt->data = NULL; pkt->size = 0;
177
}
178

    
179
int av_new_packet(AVPacket *pkt, int size)
180
{
181
    uint8_t *data;
182
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
183
        return AVERROR_NOMEM;
184
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
185
    if (!data)
186
        return AVERROR_NOMEM;
187
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
188

    
189
    av_init_packet(pkt);
190
    pkt->data = data;
191
    pkt->size = size;
192
    pkt->destruct = av_destruct_packet;
193
    return 0;
194
}
195

    
196
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
197
{
198
    int ret= av_new_packet(pkt, size);
199

    
200
    if(ret<0)
201
        return ret;
202

    
203
    pkt->pos= url_ftell(s);
204

    
205
    ret= get_buffer(s, pkt->data, size);
206
    if(ret<=0)
207
        av_free_packet(pkt);
208
    else
209
        pkt->size= ret;
210

    
211
    return ret;
212
}
213

    
214
int av_dup_packet(AVPacket *pkt)
215
{
216
    if (pkt->destruct != av_destruct_packet) {
217
        uint8_t *data;
218
        /* we duplicate the packet and don't forget to put the padding
219
           again */
220
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
221
            return AVERROR_NOMEM;
222
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
223
        if (!data) {
224
            return AVERROR_NOMEM;
225
        }
226
        memcpy(data, pkt->data, pkt->size);
227
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
228
        pkt->data = data;
229
        pkt->destruct = av_destruct_packet;
230
    }
231
    return 0;
232
}
233

    
234
int av_filename_number_test(const char *filename)
235
{
236
    char buf[1024];
237
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
238
}
239

    
240
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
241
{
242
    AVInputFormat *fmt1, *fmt;
243
    int score;
244

    
245
    fmt = NULL;
246
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
247
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
248
            continue;
249
        score = 0;
250
        if (fmt1->read_probe) {
251
            score = fmt1->read_probe(pd);
252
        } else if (fmt1->extensions) {
253
            if (match_ext(pd->filename, fmt1->extensions)) {
254
                score = 50;
255
            }
256
        }
257
        if (score > *score_max) {
258
            *score_max = score;
259
            fmt = fmt1;
260
        }
261
    }
262
    return fmt;
263
}
264

    
265
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
266
    int score=0;
267
    return av_probe_input_format2(pd, is_opened, &score);
268
}
269

    
270
/************************************************************/
271
/* input media file */
272

    
273
/**
274
 * Open a media file from an IO stream. 'fmt' must be specified.
275
 */
276
static const char* format_to_name(void* ptr)
277
{
278
    AVFormatContext* fc = (AVFormatContext*) ptr;
279
    if(fc->iformat) return fc->iformat->name;
280
    else if(fc->oformat) return fc->oformat->name;
281
    else return "NULL";
282
}
283

    
284
#define OFFSET(x) offsetof(AVFormatContext,x)
285
#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
286
//these names are too long to be readable
287
#define E AV_OPT_FLAG_ENCODING_PARAM
288
#define D AV_OPT_FLAG_DECODING_PARAM
289

    
290
static const AVOption options[]={
291
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
292
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
293
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
294
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
295
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
296
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
297
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
298
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
299
{"analyzeduration", NULL, OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
300
{NULL},
301
};
302

    
303
#undef E
304
#undef D
305
#undef DEFAULT
306

    
307
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
308

    
309
static void avformat_get_context_defaults(AVFormatContext *s)
310
{
311
    memset(s, 0, sizeof(AVFormatContext));
312

    
313
    s->av_class = &av_format_context_class;
314

    
315
    av_opt_set_defaults(s);
316
}
317

    
318
AVFormatContext *av_alloc_format_context(void)
319
{
320
    AVFormatContext *ic;
321
    ic = av_malloc(sizeof(AVFormatContext));
322
    if (!ic) return ic;
323
    avformat_get_context_defaults(ic);
324
    ic->av_class = &av_format_context_class;
325
    return ic;
326
}
327

    
328
int av_open_input_stream(AVFormatContext **ic_ptr,
329
                         ByteIOContext *pb, const char *filename,
330
                         AVInputFormat *fmt, AVFormatParameters *ap)
331
{
332
    int err;
333
    AVFormatContext *ic;
334
    AVFormatParameters default_ap;
335

    
336
    if(!ap){
337
        ap=&default_ap;
338
        memset(ap, 0, sizeof(default_ap));
339
    }
340

    
341
    if(!ap->prealloced_context)
342
        ic = av_alloc_format_context();
343
    else
344
        ic = *ic_ptr;
345
    if (!ic) {
346
        err = AVERROR_NOMEM;
347
        goto fail;
348
    }
349
    ic->iformat = fmt;
350
    if (pb)
351
        ic->pb = *pb;
352
    ic->duration = AV_NOPTS_VALUE;
353
    ic->start_time = AV_NOPTS_VALUE;
354
    pstrcpy(ic->filename, sizeof(ic->filename), filename);
355

    
356
    /* allocate private data */
357
    if (fmt->priv_data_size > 0) {
358
        ic->priv_data = av_mallocz(fmt->priv_data_size);
359
        if (!ic->priv_data) {
360
            err = AVERROR_NOMEM;
361
            goto fail;
362
        }
363
    } else {
364
        ic->priv_data = NULL;
365
    }
366

    
367
    err = ic->iformat->read_header(ic, ap);
368
    if (err < 0)
369
        goto fail;
370

    
371
    if (pb && !ic->data_offset)
372
        ic->data_offset = url_ftell(&ic->pb);
373

    
374
    *ic_ptr = ic;
375
    return 0;
376
 fail:
377
    if (ic) {
378
        av_freep(&ic->priv_data);
379
    }
380
    av_free(ic);
381
    *ic_ptr = NULL;
382
    return err;
383
}
384

    
385
/** Size of probe buffer, for guessing file type from file contents. */
386
#define PROBE_BUF_MIN 2048
387
#define PROBE_BUF_MAX (1<<20)
388

    
389
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
390
                       AVInputFormat *fmt,
391
                       int buf_size,
392
                       AVFormatParameters *ap)
393
{
394
    int err, must_open_file, file_opened, probe_size;
395
    AVProbeData probe_data, *pd = &probe_data;
396
    ByteIOContext pb1, *pb = &pb1;
397

    
398
    file_opened = 0;
399
    pd->filename = "";
400
    if (filename)
401
        pd->filename = filename;
402
    pd->buf = NULL;
403
    pd->buf_size = 0;
404

    
405
    if (!fmt) {
406
        /* guess format if no file can be opened  */
407
        fmt = av_probe_input_format(pd, 0);
408
    }
409

    
410
    /* do not open file if the format does not need it. XXX: specific
411
       hack needed to handle RTSP/TCP */
412
    must_open_file = 1;
413
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
414
        must_open_file = 0;
415
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
416
    }
417

    
418
    if (!fmt || must_open_file) {
419
        /* if no file needed do not try to open one */
420
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
421
            err = AVERROR_IO;
422
            goto fail;
423
        }
424
        file_opened = 1;
425
        if (buf_size > 0) {
426
            url_setbufsize(pb, buf_size);
427
        }
428

    
429
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
430
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
431
            /* read probe data */
432
            pd->buf= av_realloc(pd->buf, probe_size);
433
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
434
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
435
                url_fclose(pb);
436
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
437
                    file_opened = 0;
438
                    err = AVERROR_IO;
439
                    goto fail;
440
                }
441
            }
442
            /* guess file format */
443
            fmt = av_probe_input_format2(pd, 1, &score);
444
        }
445
        av_freep(&pd->buf);
446
    }
447

    
448
    /* if still no format found, error */
449
    if (!fmt) {
450
        err = AVERROR_NOFMT;
451
        goto fail;
452
    }
453

    
454
    /* XXX: suppress this hack for redirectors */
455
#ifdef CONFIG_NETWORK
456
    if (fmt == &redir_demuxer) {
457
        err = redir_open(ic_ptr, pb);
458
        url_fclose(pb);
459
        return err;
460
    }
461
#endif
462

    
463
    /* check filename in case of an image number is expected */
464
    if (fmt->flags & AVFMT_NEEDNUMBER) {
465
        if (!av_filename_number_test(filename)) {
466
            err = AVERROR_NUMEXPECTED;
467
            goto fail;
468
        }
469
    }
470
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
471
    if (err)
472
        goto fail;
473
    return 0;
474
 fail:
475
    av_freep(&pd->buf);
476
    if (file_opened)
477
        url_fclose(pb);
478
    *ic_ptr = NULL;
479
    return err;
480

    
481
}
482

    
483
/*******************************************************/
484

    
485
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
486
{
487
    return s->iformat->read_packet(s, pkt);
488
}
489

    
490
/**********************************************************/
491

    
492
/**
493
 * Get the number of samples of an audio frame. Return (-1) if error.
494
 */
495
static int get_audio_frame_size(AVCodecContext *enc, int size)
496
{
497
    int frame_size;
498

    
499
    if (enc->frame_size <= 1) {
500
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
501

    
502
        if (bits_per_sample) {
503
            if (enc->channels == 0)
504
                return -1;
505
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
506
        } else {
507
            /* used for example by ADPCM codecs */
508
            if (enc->bit_rate == 0)
509
                return -1;
510
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
511
        }
512
    } else {
513
        frame_size = enc->frame_size;
514
    }
515
    return frame_size;
516
}
517

    
518

    
519
/**
520
 * Return the frame duration in seconds, return 0 if not available.
521
 */
522
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
523
                                   AVCodecParserContext *pc, AVPacket *pkt)
524
{
525
    int frame_size;
526

    
527
    *pnum = 0;
528
    *pden = 0;
529
    switch(st->codec->codec_type) {
530
    case CODEC_TYPE_VIDEO:
531
        if(st->time_base.num*1000LL > st->time_base.den){
532
            *pnum = st->time_base.num;
533
            *pden = st->time_base.den;
534
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
535
            *pnum = st->codec->time_base.num;
536
            *pden = st->codec->time_base.den;
537
            if (pc && pc->repeat_pict) {
538
                *pden *= 2;
539
                *pnum = (*pnum) * (2 + pc->repeat_pict);
540
            }
541
        }
542
        break;
543
    case CODEC_TYPE_AUDIO:
544
        frame_size = get_audio_frame_size(st->codec, pkt->size);
545
        if (frame_size < 0)
546
            break;
547
        *pnum = frame_size;
548
        *pden = st->codec->sample_rate;
549
        break;
550
    default:
551
        break;
552
    }
553
}
554

    
555
static int is_intra_only(AVCodecContext *enc){
556
    if(enc->codec_type == CODEC_TYPE_AUDIO){
557
        return 1;
558
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
559
        switch(enc->codec_id){
560
        case CODEC_ID_MJPEG:
561
        case CODEC_ID_MJPEGB:
562
        case CODEC_ID_LJPEG:
563
        case CODEC_ID_RAWVIDEO:
564
        case CODEC_ID_DVVIDEO:
565
        case CODEC_ID_HUFFYUV:
566
        case CODEC_ID_FFVHUFF:
567
        case CODEC_ID_ASV1:
568
        case CODEC_ID_ASV2:
569
        case CODEC_ID_VCR1:
570
            return 1;
571
        default: break;
572
        }
573
    }
574
    return 0;
575
}
576

    
577
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
578
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
579
    int64_t delta= last_ts - mask/2;
580
    return  ((lsb - delta)&mask) + delta;
581
}
582

    
583
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
584
                               AVCodecParserContext *pc, AVPacket *pkt)
585
{
586
    int num, den, presentation_delayed, delay, i;
587
    /* handle wrapping */
588
    if(st->cur_dts != AV_NOPTS_VALUE){
589
        if(pkt->pts != AV_NOPTS_VALUE)
590
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
591
        if(pkt->dts != AV_NOPTS_VALUE)
592
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
593
    }
594

    
595
    if (pkt->duration == 0) {
596
        compute_frame_duration(&num, &den, st, pc, pkt);
597
        if (den && num) {
598
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
599
        }
600
    }
601

    
602
    if(is_intra_only(st->codec))
603
        pkt->flags |= PKT_FLAG_KEY;
604

    
605
    /* do we have a video B frame ? */
606
    delay= st->codec->has_b_frames;
607
    presentation_delayed = 0;
608
    /* XXX: need has_b_frame, but cannot get it if the codec is
609
        not initialized */
610
    if (delay &&
611
        pc && pc->pict_type != FF_B_TYPE)
612
        presentation_delayed = 1;
613
    /* this may be redundant, but it shouldnt hurt */
614
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
615
        presentation_delayed = 1;
616

    
617
    if(st->cur_dts == AV_NOPTS_VALUE){
618
        st->cur_dts = -delay * pkt->duration;
619
    }
620

    
621
//    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);
622
    /* interpolate PTS and DTS if they are not present */
623
    if(delay <=1){
624
        if (presentation_delayed) {
625
            /* DTS = decompression time stamp */
626
            /* PTS = presentation time stamp */
627
            if (pkt->dts == AV_NOPTS_VALUE)
628
                pkt->dts = st->last_IP_pts;
629
            if (pkt->dts == AV_NOPTS_VALUE)
630
                pkt->dts = st->cur_dts;
631

    
632
            /* this is tricky: the dts must be incremented by the duration
633
            of the frame we are displaying, i.e. the last I or P frame */
634
            if (st->last_IP_duration == 0)
635
                st->last_IP_duration = pkt->duration;
636
            st->cur_dts = pkt->dts + st->last_IP_duration;
637
            st->last_IP_duration  = pkt->duration;
638
            st->last_IP_pts= pkt->pts;
639
            /* cannot compute PTS if not present (we can compute it only
640
            by knowing the futur */
641
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
642
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
643
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
644
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
645
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
646
                    pkt->pts += pkt->duration;
647
    //                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);
648
                }
649
            }
650

    
651
            /* presentation is not delayed : PTS and DTS are the same */
652
            if(pkt->pts == AV_NOPTS_VALUE)
653
                pkt->pts = pkt->dts;
654
            if(pkt->pts == AV_NOPTS_VALUE)
655
                pkt->pts = st->cur_dts;
656
            pkt->dts = pkt->pts;
657
            st->cur_dts = pkt->pts + pkt->duration;
658
        }
659
    }
660

    
661
    if(pkt->pts != AV_NOPTS_VALUE){
662
        st->pts_buffer[0]= pkt->pts;
663
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
664
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
665
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
666
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
667
        if(pkt->dts == AV_NOPTS_VALUE)
668
            pkt->dts= st->pts_buffer[0];
669
        if(pkt->dts > st->cur_dts)
670
            st->cur_dts = pkt->dts;
671
    }
672

    
673
//    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
674

    
675
    /* update flags */
676
    if (pc) {
677
        pkt->flags = 0;
678
        /* key frame computation */
679
            if (pc->pict_type == FF_I_TYPE)
680
                pkt->flags |= PKT_FLAG_KEY;
681
    }
682
}
683

    
684
void av_destruct_packet_nofree(AVPacket *pkt)
685
{
686
    pkt->data = NULL; pkt->size = 0;
687
}
688

    
689
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
690
{
691
    AVStream *st;
692
    int len, ret, i;
693

    
694
    for(;;) {
695
        /* select current input stream component */
696
        st = s->cur_st;
697
        if (st) {
698
            if (!st->need_parsing || !st->parser) {
699
                /* no parsing needed: we just output the packet as is */
700
                /* raw data support */
701
                *pkt = s->cur_pkt;
702
                compute_pkt_fields(s, st, NULL, pkt);
703
                s->cur_st = NULL;
704
                break;
705
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
706
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
707
                                      s->cur_ptr, s->cur_len,
708
                                      s->cur_pkt.pts, s->cur_pkt.dts);
709
                s->cur_pkt.pts = AV_NOPTS_VALUE;
710
                s->cur_pkt.dts = AV_NOPTS_VALUE;
711
                /* increment read pointer */
712
                s->cur_ptr += len;
713
                s->cur_len -= len;
714

    
715
                /* return packet if any */
716
                if (pkt->size) {
717
                got_packet:
718
                    pkt->duration = 0;
719
                    pkt->stream_index = st->index;
720
                    pkt->pts = st->parser->pts;
721
                    pkt->dts = st->parser->dts;
722
                    pkt->destruct = av_destruct_packet_nofree;
723
                    compute_pkt_fields(s, st, st->parser, pkt);
724

    
725
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
726
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
727
                                           0, 0, AVINDEX_KEYFRAME);
728
                    }
729

    
730
                    break;
731
                }
732
            } else {
733
                /* free packet */
734
                av_free_packet(&s->cur_pkt);
735
                s->cur_st = NULL;
736
            }
737
        } else {
738
            /* read next packet */
739
            ret = av_read_packet(s, &s->cur_pkt);
740
            if (ret < 0) {
741
                if (ret == AVERROR(EAGAIN))
742
                    return ret;
743
                /* return the last frames, if any */
744
                for(i = 0; i < s->nb_streams; i++) {
745
                    st = s->streams[i];
746
                    if (st->parser && st->need_parsing) {
747
                        av_parser_parse(st->parser, st->codec,
748
                                        &pkt->data, &pkt->size,
749
                                        NULL, 0,
750
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
751
                        if (pkt->size)
752
                            goto got_packet;
753
                    }
754
                }
755
                /* no more packets: really terminates parsing */
756
                return ret;
757
            }
758

    
759
            st = s->streams[s->cur_pkt.stream_index];
760
            if(st->codec->debug & FF_DEBUG_PTS)
761
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
762
                    s->cur_pkt.stream_index,
763
                    s->cur_pkt.pts,
764
                    s->cur_pkt.dts,
765
                    s->cur_pkt.size);
766

    
767
            s->cur_st = st;
768
            s->cur_ptr = s->cur_pkt.data;
769
            s->cur_len = s->cur_pkt.size;
770
            if (st->need_parsing && !st->parser) {
771
                st->parser = av_parser_init(st->codec->codec_id);
772
                if (!st->parser) {
773
                    /* no parser available : just output the raw packets */
774
                    st->need_parsing = 0;
775
                }else if(st->need_parsing == 2){
776
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
777
                }
778
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
779
                    st->parser->last_frame_offset=
780
                    st->parser->cur_offset= s->cur_pkt.pos;
781
                }
782
            }
783
        }
784
    }
785
    if(st->codec->debug & FF_DEBUG_PTS)
786
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
787
            pkt->stream_index,
788
            pkt->pts,
789
            pkt->dts,
790
            pkt->size);
791

    
792
    return 0;
793
}
794

    
795
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
796
{
797
    AVPacketList *pktl;
798
    int eof=0;
799
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
800

    
801
    for(;;){
802
        pktl = s->packet_buffer;
803
        if (pktl) {
804
            AVPacket *next_pkt= &pktl->pkt;
805

    
806
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
807
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
808
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
809
                       && next_pkt->dts < pktl->pkt.dts
810
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
811
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
812
                        next_pkt->pts= pktl->pkt.dts;
813
                    }
814
                    pktl= pktl->next;
815
                }
816
                pktl = s->packet_buffer;
817
            }
818

    
819
            if(   next_pkt->pts != AV_NOPTS_VALUE
820
               || next_pkt->dts == AV_NOPTS_VALUE
821
               || !genpts || eof){
822
                /* read packet from packet buffer, if there is data */
823
                *pkt = *next_pkt;
824
                s->packet_buffer = pktl->next;
825
                av_free(pktl);
826
                return 0;
827
            }
828
        }
829
        if(genpts){
830
            AVPacketList **plast_pktl= &s->packet_buffer;
831
            int ret= av_read_frame_internal(s, pkt);
832
            if(ret<0){
833
                if(pktl && ret != AVERROR(EAGAIN)){
834
                    eof=1;
835
                    continue;
836
                }else
837
                    return ret;
838
            }
839

    
840
            /* duplicate the packet */
841
            if (av_dup_packet(pkt) < 0)
842
                return AVERROR_NOMEM;
843

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

    
846
            pktl = av_mallocz(sizeof(AVPacketList));
847
            if (!pktl)
848
                return AVERROR_NOMEM;
849

    
850
            /* add the packet in the buffered packet list */
851
            *plast_pktl = pktl;
852
            pktl->pkt= *pkt;
853
        }else{
854
            assert(!s->packet_buffer);
855
            return av_read_frame_internal(s, pkt);
856
        }
857
    }
858
}
859

    
860
/* XXX: suppress the packet queue */
861
static void flush_packet_queue(AVFormatContext *s)
862
{
863
    AVPacketList *pktl;
864

    
865
    for(;;) {
866
        pktl = s->packet_buffer;
867
        if (!pktl)
868
            break;
869
        s->packet_buffer = pktl->next;
870
        av_free_packet(&pktl->pkt);
871
        av_free(pktl);
872
    }
873
}
874

    
875
/*******************************************************/
876
/* seek support */
877

    
878
int av_find_default_stream_index(AVFormatContext *s)
879
{
880
    int i;
881
    AVStream *st;
882

    
883
    if (s->nb_streams <= 0)
884
        return -1;
885
    for(i = 0; i < s->nb_streams; i++) {
886
        st = s->streams[i];
887
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
888
            return i;
889
        }
890
    }
891
    return 0;
892
}
893

    
894
/**
895
 * Flush the frame reader.
896
 */
897
static void av_read_frame_flush(AVFormatContext *s)
898
{
899
    AVStream *st;
900
    int i;
901

    
902
    flush_packet_queue(s);
903

    
904
    /* free previous packet */
905
    if (s->cur_st) {
906
        if (s->cur_st->parser)
907
            av_free_packet(&s->cur_pkt);
908
        s->cur_st = NULL;
909
    }
910
    /* fail safe */
911
    s->cur_ptr = NULL;
912
    s->cur_len = 0;
913

    
914
    /* for each stream, reset read state */
915
    for(i = 0; i < s->nb_streams; i++) {
916
        st = s->streams[i];
917

    
918
        if (st->parser) {
919
            av_parser_close(st->parser);
920
            st->parser = NULL;
921
        }
922
        st->last_IP_pts = AV_NOPTS_VALUE;
923
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
924
    }
925
}
926

    
927
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
928
    int i;
929

    
930
    for(i = 0; i < s->nb_streams; i++) {
931
        AVStream *st = s->streams[i];
932

    
933
        st->cur_dts = av_rescale(timestamp,
934
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
935
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
936
    }
937
}
938

    
939
int av_add_index_entry(AVStream *st,
940
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
941
{
942
    AVIndexEntry *entries, *ie;
943
    int index;
944

    
945
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
946
        return -1;
947

    
948
    entries = av_fast_realloc(st->index_entries,
949
                              &st->index_entries_allocated_size,
950
                              (st->nb_index_entries + 1) *
951
                              sizeof(AVIndexEntry));
952
    if(!entries)
953
        return -1;
954

    
955
    st->index_entries= entries;
956

    
957
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
958

    
959
    if(index<0){
960
        index= st->nb_index_entries++;
961
        ie= &entries[index];
962
        assert(index==0 || ie[-1].timestamp < timestamp);
963
    }else{
964
        ie= &entries[index];
965
        if(ie->timestamp != timestamp){
966
            if(ie->timestamp <= timestamp)
967
                return -1;
968
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
969
            st->nb_index_entries++;
970
        }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
971
            distance= ie->min_distance;
972
    }
973

    
974
    ie->pos = pos;
975
    ie->timestamp = timestamp;
976
    ie->min_distance= distance;
977
    ie->size= size;
978
    ie->flags = flags;
979

    
980
    return index;
981
}
982

    
983
/**
984
 * build an index for raw streams using a parser.
985
 */
986
static void av_build_index_raw(AVFormatContext *s)
987
{
988
    AVPacket pkt1, *pkt = &pkt1;
989
    int ret;
990
    AVStream *st;
991

    
992
    st = s->streams[0];
993
    av_read_frame_flush(s);
994
    url_fseek(&s->pb, s->data_offset, SEEK_SET);
995

    
996
    for(;;) {
997
        ret = av_read_frame(s, pkt);
998
        if (ret < 0)
999
            break;
1000
        if (pkt->stream_index == 0 && st->parser &&
1001
            (pkt->flags & PKT_FLAG_KEY)) {
1002
            av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1003
                            0, 0, AVINDEX_KEYFRAME);
1004
        }
1005
        av_free_packet(pkt);
1006
    }
1007
}
1008

    
1009
/**
1010
 * Returns TRUE if we deal with a raw stream.
1011
 *
1012
 * Raw codec data and parsing needed.
1013
 */
1014
static int is_raw_stream(AVFormatContext *s)
1015
{
1016
    AVStream *st;
1017

    
1018
    if (s->nb_streams != 1)
1019
        return 0;
1020
    st = s->streams[0];
1021
    if (!st->need_parsing)
1022
        return 0;
1023
    return 1;
1024
}
1025

    
1026
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1027
                              int flags)
1028
{
1029
    AVIndexEntry *entries= st->index_entries;
1030
    int nb_entries= st->nb_index_entries;
1031
    int a, b, m;
1032
    int64_t timestamp;
1033

    
1034
    a = - 1;
1035
    b = nb_entries;
1036

    
1037
    while (b - a > 1) {
1038
        m = (a + b) >> 1;
1039
        timestamp = entries[m].timestamp;
1040
        if(timestamp >= wanted_timestamp)
1041
            b = m;
1042
        if(timestamp <= wanted_timestamp)
1043
            a = m;
1044
    }
1045
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1046

    
1047
    if(!(flags & AVSEEK_FLAG_ANY)){
1048
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1049
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1050
        }
1051
    }
1052

    
1053
    if(m == nb_entries)
1054
        return -1;
1055
    return  m;
1056
}
1057

    
1058
#define DEBUG_SEEK
1059

    
1060
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1061
    AVInputFormat *avif= s->iformat;
1062
    int64_t pos_min, pos_max, pos, pos_limit;
1063
    int64_t ts_min, ts_max, ts;
1064
    int index;
1065
    AVStream *st;
1066

    
1067
    if (stream_index < 0)
1068
        return -1;
1069

    
1070
#ifdef DEBUG_SEEK
1071
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1072
#endif
1073

    
1074
    ts_max=
1075
    ts_min= AV_NOPTS_VALUE;
1076
    pos_limit= -1; //gcc falsely says it may be uninitalized
1077

    
1078
    st= s->streams[stream_index];
1079
    if(st->index_entries){
1080
        AVIndexEntry *e;
1081

    
1082
        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()
1083
        index= FFMAX(index, 0);
1084
        e= &st->index_entries[index];
1085

    
1086
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1087
            pos_min= e->pos;
1088
            ts_min= e->timestamp;
1089
#ifdef DEBUG_SEEK
1090
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1091
               pos_min,ts_min);
1092
#endif
1093
        }else{
1094
            assert(index==0);
1095
        }
1096

    
1097
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1098
        assert(index < st->nb_index_entries);
1099
        if(index >= 0){
1100
            e= &st->index_entries[index];
1101
            assert(e->timestamp >= target_ts);
1102
            pos_max= e->pos;
1103
            ts_max= e->timestamp;
1104
            pos_limit= pos_max - e->min_distance;
1105
#ifdef DEBUG_SEEK
1106
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1107
               pos_max,pos_limit, ts_max);
1108
#endif
1109
        }
1110
    }
1111

    
1112
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1113
    if(pos<0)
1114
        return -1;
1115

    
1116
    /* do the seek */
1117
    url_fseek(&s->pb, pos, SEEK_SET);
1118

    
1119
    av_update_cur_dts(s, st, ts);
1120

    
1121
    return 0;
1122
}
1123

    
1124
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 )){
1125
    int64_t pos, ts;
1126
    int64_t start_pos, filesize;
1127
    int no_change;
1128

    
1129
#ifdef DEBUG_SEEK
1130
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1131
#endif
1132

    
1133
    if(ts_min == AV_NOPTS_VALUE){
1134
        pos_min = s->data_offset;
1135
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1136
        if (ts_min == AV_NOPTS_VALUE)
1137
            return -1;
1138
    }
1139

    
1140
    if(ts_max == AV_NOPTS_VALUE){
1141
        int step= 1024;
1142
        filesize = url_fsize(&s->pb);
1143
        pos_max = filesize - 1;
1144
        do{
1145
            pos_max -= step;
1146
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1147
            step += step;
1148
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1149
        if (ts_max == AV_NOPTS_VALUE)
1150
            return -1;
1151

    
1152
        for(;;){
1153
            int64_t tmp_pos= pos_max + 1;
1154
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1155
            if(tmp_ts == AV_NOPTS_VALUE)
1156
                break;
1157
            ts_max= tmp_ts;
1158
            pos_max= tmp_pos;
1159
            if(tmp_pos >= filesize)
1160
                break;
1161
        }
1162
        pos_limit= pos_max;
1163
    }
1164

    
1165
    if(ts_min > ts_max){
1166
        return -1;
1167
    }else if(ts_min == ts_max){
1168
        pos_limit= pos_min;
1169
    }
1170

    
1171
    no_change=0;
1172
    while (pos_min < pos_limit) {
1173
#ifdef DEBUG_SEEK
1174
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1175
               pos_min, pos_max,
1176
               ts_min, ts_max);
1177
#endif
1178
        assert(pos_limit <= pos_max);
1179

    
1180
        if(no_change==0){
1181
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1182
            // interpolate position (better than dichotomy)
1183
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1184
                + pos_min - approximate_keyframe_distance;
1185
        }else if(no_change==1){
1186
            // bisection, if interpolation failed to change min or max pos last time
1187
            pos = (pos_min + pos_limit)>>1;
1188
        }else{
1189
            // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1190
            pos=pos_min;
1191
        }
1192
        if(pos <= pos_min)
1193
            pos= pos_min + 1;
1194
        else if(pos > pos_limit)
1195
            pos= pos_limit;
1196
        start_pos= pos;
1197

    
1198
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1199
        if(pos == pos_max)
1200
            no_change++;
1201
        else
1202
            no_change=0;
1203
#ifdef DEBUG_SEEK
1204
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);
1205
#endif
1206
        assert(ts != AV_NOPTS_VALUE);
1207
        if (target_ts <= ts) {
1208
            pos_limit = start_pos - 1;
1209
            pos_max = pos;
1210
            ts_max = ts;
1211
        }
1212
        if (target_ts >= ts) {
1213
            pos_min = pos;
1214
            ts_min = ts;
1215
        }
1216
    }
1217

    
1218
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1219
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1220
#ifdef DEBUG_SEEK
1221
    pos_min = pos;
1222
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1223
    pos_min++;
1224
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1225
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1226
           pos, ts_min, target_ts, ts_max);
1227
#endif
1228
    *ts_ret= ts;
1229
    return pos;
1230
}
1231

    
1232
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1233
    int64_t pos_min, pos_max;
1234
#if 0
1235
    AVStream *st;
1236

1237
    if (stream_index < 0)
1238
        return -1;
1239

1240
    st= s->streams[stream_index];
1241
#endif
1242

    
1243
    pos_min = s->data_offset;
1244
    pos_max = url_fsize(&s->pb) - 1;
1245

    
1246
    if     (pos < pos_min) pos= pos_min;
1247
    else if(pos > pos_max) pos= pos_max;
1248

    
1249
    url_fseek(&s->pb, pos, SEEK_SET);
1250

    
1251
#if 0
1252
    av_update_cur_dts(s, st, ts);
1253
#endif
1254
    return 0;
1255
}
1256

    
1257
static int av_seek_frame_generic(AVFormatContext *s,
1258
                                 int stream_index, int64_t timestamp, int flags)
1259
{
1260
    int index;
1261
    AVStream *st;
1262
    AVIndexEntry *ie;
1263

    
1264
    st = s->streams[stream_index];
1265

    
1266
    index = av_index_search_timestamp(st, timestamp, flags);
1267

    
1268
    if(index < 0){
1269
        int i;
1270
        AVPacket pkt;
1271

    
1272
        if(st->index_entries && st->nb_index_entries){
1273
            ie= &st->index_entries[st->nb_index_entries-1];
1274
            url_fseek(&s->pb, ie->pos, SEEK_SET);
1275
            av_update_cur_dts(s, st, ie->timestamp);
1276
        }else
1277
            url_fseek(&s->pb, 0, SEEK_SET);
1278

    
1279
        for(i=0;; i++) {
1280
            int ret = av_read_frame(s, &pkt);
1281
            if(ret<0)
1282
                break;
1283
            av_free_packet(&pkt);
1284
            if(stream_index == pkt.stream_index){
1285
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1286
                    break;
1287
            }
1288
        }
1289
        index = av_index_search_timestamp(st, timestamp, flags);
1290
    }
1291
    if (index < 0)
1292
        return -1;
1293

    
1294
    av_read_frame_flush(s);
1295
    if (s->iformat->read_seek){
1296
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1297
            return 0;
1298
    }
1299
    ie = &st->index_entries[index];
1300
    url_fseek(&s->pb, ie->pos, SEEK_SET);
1301

    
1302
    av_update_cur_dts(s, st, ie->timestamp);
1303

    
1304
    return 0;
1305
}
1306

    
1307
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1308
{
1309
    int ret;
1310
    AVStream *st;
1311

    
1312
    av_read_frame_flush(s);
1313

    
1314
    if(flags & AVSEEK_FLAG_BYTE)
1315
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1316

    
1317
    if(stream_index < 0){
1318
        stream_index= av_find_default_stream_index(s);
1319
        if(stream_index < 0)
1320
            return -1;
1321

    
1322
        st= s->streams[stream_index];
1323
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1324
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1325
    }
1326
    st= s->streams[stream_index];
1327

    
1328
    /* first, we try the format specific seek */
1329
    if (s->iformat->read_seek)
1330
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1331
    else
1332
        ret = -1;
1333
    if (ret >= 0) {
1334
        return 0;
1335
    }
1336

    
1337
    if(s->iformat->read_timestamp)
1338
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1339
    else
1340
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1341
}
1342

    
1343
/*******************************************************/
1344

    
1345
/**
1346
 * Returns TRUE if the stream has accurate timings in any stream.
1347
 *
1348
 * @return TRUE if the stream has accurate timings for at least one component.
1349
 */
1350
static int av_has_timings(AVFormatContext *ic)
1351
{
1352
    int i;
1353
    AVStream *st;
1354

    
1355
    for(i = 0;i < ic->nb_streams; i++) {
1356
        st = ic->streams[i];
1357
        if (st->start_time != AV_NOPTS_VALUE &&
1358
            st->duration != AV_NOPTS_VALUE)
1359
            return 1;
1360
    }
1361
    return 0;
1362
}
1363

    
1364
/**
1365
 * Estimate the stream timings from the one of each components.
1366
 *
1367
 * Also computes the global bitrate if possible.
1368
 */
1369
static void av_update_stream_timings(AVFormatContext *ic)
1370
{
1371
    int64_t start_time, start_time1, end_time, end_time1;
1372
    int i;
1373
    AVStream *st;
1374

    
1375
    start_time = INT64_MAX;
1376
    end_time = INT64_MIN;
1377
    for(i = 0;i < ic->nb_streams; i++) {
1378
        st = ic->streams[i];
1379
        if (st->start_time != AV_NOPTS_VALUE) {
1380
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1381
            if (start_time1 < start_time)
1382
                start_time = start_time1;
1383
            if (st->duration != AV_NOPTS_VALUE) {
1384
                end_time1 = start_time1
1385
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1386
                if (end_time1 > end_time)
1387
                    end_time = end_time1;
1388
            }
1389
        }
1390
    }
1391
    if (start_time != INT64_MAX) {
1392
        ic->start_time = start_time;
1393
        if (end_time != INT64_MIN) {
1394
            ic->duration = end_time - start_time;
1395
            if (ic->file_size > 0) {
1396
                /* compute the bit rate */
1397
                ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1398
                    (double)ic->duration;
1399
            }
1400
        }
1401
    }
1402

    
1403
}
1404

    
1405
static void fill_all_stream_timings(AVFormatContext *ic)
1406
{
1407
    int i;
1408
    AVStream *st;
1409

    
1410
    av_update_stream_timings(ic);
1411
    for(i = 0;i < ic->nb_streams; i++) {
1412
        st = ic->streams[i];
1413
        if (st->start_time == AV_NOPTS_VALUE) {
1414
            if(ic->start_time != AV_NOPTS_VALUE)
1415
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1416
            if(ic->duration != AV_NOPTS_VALUE)
1417
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1418
        }
1419
    }
1420
}
1421

    
1422
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1423
{
1424
    int64_t filesize, duration;
1425
    int bit_rate, i;
1426
    AVStream *st;
1427

    
1428
    /* if bit_rate is already set, we believe it */
1429
    if (ic->bit_rate == 0) {
1430
        bit_rate = 0;
1431
        for(i=0;i<ic->nb_streams;i++) {
1432
            st = ic->streams[i];
1433
            bit_rate += st->codec->bit_rate;
1434
        }
1435
        ic->bit_rate = bit_rate;
1436
    }
1437

    
1438
    /* if duration is already set, we believe it */
1439
    if (ic->duration == AV_NOPTS_VALUE &&
1440
        ic->bit_rate != 0 &&
1441
        ic->file_size != 0)  {
1442
        filesize = ic->file_size;
1443
        if (filesize > 0) {
1444
            for(i = 0; i < ic->nb_streams; i++) {
1445
                st = ic->streams[i];
1446
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1447
                if (st->start_time == AV_NOPTS_VALUE ||
1448
                    st->duration == AV_NOPTS_VALUE) {
1449
                    st->start_time = 0;
1450
                    st->duration = duration;
1451
                }
1452
            }
1453
        }
1454
    }
1455
}
1456

    
1457
#define DURATION_MAX_READ_SIZE 250000
1458

    
1459
/* only usable for MPEG-PS streams */
1460
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1461
{
1462
    AVPacket pkt1, *pkt = &pkt1;
1463
    AVStream *st;
1464
    int read_size, i, ret;
1465
    int64_t end_time;
1466
    int64_t filesize, offset, duration;
1467

    
1468
    av_read_frame_flush(ic);
1469

    
1470
    /* we read the first packets to get the first PTS (not fully
1471
       accurate, but it is enough now) */
1472
    url_fseek(&ic->pb, 0, SEEK_SET);
1473
    read_size = 0;
1474
    for(;;) {
1475
        if (read_size >= DURATION_MAX_READ_SIZE)
1476
            break;
1477
        /* if all info is available, we can stop */
1478
        for(i = 0;i < ic->nb_streams; i++) {
1479
            st = ic->streams[i];
1480
            if (st->start_time == AV_NOPTS_VALUE)
1481
                break;
1482
        }
1483
        if (i == ic->nb_streams)
1484
            break;
1485

    
1486
        ret = av_read_packet(ic, pkt);
1487
        if (ret != 0)
1488
            break;
1489
        read_size += pkt->size;
1490
        st = ic->streams[pkt->stream_index];
1491
        if (pkt->pts != AV_NOPTS_VALUE) {
1492
            if (st->start_time == AV_NOPTS_VALUE)
1493
                st->start_time = pkt->pts;
1494
        }
1495
        av_free_packet(pkt);
1496
    }
1497

    
1498
    /* estimate the end time (duration) */
1499
    /* XXX: may need to support wrapping */
1500
    filesize = ic->file_size;
1501
    offset = filesize - DURATION_MAX_READ_SIZE;
1502
    if (offset < 0)
1503
        offset = 0;
1504

    
1505
    url_fseek(&ic->pb, offset, SEEK_SET);
1506
    read_size = 0;
1507
    for(;;) {
1508
        if (read_size >= DURATION_MAX_READ_SIZE)
1509
            break;
1510
        /* if all info is available, we can stop */
1511
        for(i = 0;i < ic->nb_streams; i++) {
1512
            st = ic->streams[i];
1513
            if (st->duration == AV_NOPTS_VALUE)
1514
                break;
1515
        }
1516
        if (i == ic->nb_streams)
1517
            break;
1518

    
1519
        ret = av_read_packet(ic, pkt);
1520
        if (ret != 0)
1521
            break;
1522
        read_size += pkt->size;
1523
        st = ic->streams[pkt->stream_index];
1524
        if (pkt->pts != AV_NOPTS_VALUE) {
1525
            end_time = pkt->pts;
1526
            duration = end_time - st->start_time;
1527
            if (duration > 0) {
1528
                if (st->duration == AV_NOPTS_VALUE ||
1529
                    st->duration < duration)
1530
                    st->duration = duration;
1531
            }
1532
        }
1533
        av_free_packet(pkt);
1534
    }
1535

    
1536
    fill_all_stream_timings(ic);
1537

    
1538
    url_fseek(&ic->pb, old_offset, SEEK_SET);
1539
}
1540

    
1541
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1542
{
1543
    int64_t file_size;
1544

    
1545
    /* get the file size, if possible */
1546
    if (ic->iformat->flags & AVFMT_NOFILE) {
1547
        file_size = 0;
1548
    } else {
1549
        file_size = url_fsize(&ic->pb);
1550
        if (file_size < 0)
1551
            file_size = 0;
1552
    }
1553
    ic->file_size = file_size;
1554

    
1555
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1556
         !strcmp(ic->iformat->name, "mpegts")) &&
1557
        file_size && !ic->pb.is_streamed) {
1558
        /* get accurate estimate from the PTSes */
1559
        av_estimate_timings_from_pts(ic, old_offset);
1560
    } else if (av_has_timings(ic)) {
1561
        /* at least one components has timings - we use them for all
1562
           the components */
1563
        fill_all_stream_timings(ic);
1564
    } else {
1565
        /* less precise: use bit rate info */
1566
        av_estimate_timings_from_bit_rate(ic);
1567
    }
1568
    av_update_stream_timings(ic);
1569

    
1570
#if 0
1571
    {
1572
        int i;
1573
        AVStream *st;
1574
        for(i = 0;i < ic->nb_streams; i++) {
1575
            st = ic->streams[i];
1576
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1577
               i, (double)st->start_time / AV_TIME_BASE,
1578
               (double)st->duration / AV_TIME_BASE);
1579
        }
1580
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1581
               (double)ic->start_time / AV_TIME_BASE,
1582
               (double)ic->duration / AV_TIME_BASE,
1583
               ic->bit_rate / 1000);
1584
    }
1585
#endif
1586
}
1587

    
1588
static int has_codec_parameters(AVCodecContext *enc)
1589
{
1590
    int val;
1591
    switch(enc->codec_type) {
1592
    case CODEC_TYPE_AUDIO:
1593
        val = enc->sample_rate;
1594
        break;
1595
    case CODEC_TYPE_VIDEO:
1596
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1597
        break;
1598
    default:
1599
        val = 1;
1600
        break;
1601
    }
1602
    return (val != 0);
1603
}
1604

    
1605
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1606
{
1607
    int16_t *samples;
1608
    AVCodec *codec;
1609
    int got_picture, data_size, ret=0;
1610
    AVFrame picture;
1611

    
1612
  if(!st->codec->codec){
1613
    codec = avcodec_find_decoder(st->codec->codec_id);
1614
    if (!codec)
1615
        return -1;
1616
    ret = avcodec_open(st->codec, codec);
1617
    if (ret < 0)
1618
        return ret;
1619
  }
1620

    
1621
  if(!has_codec_parameters(st->codec)){
1622
    switch(st->codec->codec_type) {
1623
    case CODEC_TYPE_VIDEO:
1624
        ret = avcodec_decode_video(st->codec, &picture,
1625
                                   &got_picture, (uint8_t *)data, size);
1626
        break;
1627
    case CODEC_TYPE_AUDIO:
1628
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1629
        samples = av_malloc(data_size);
1630
        if (!samples)
1631
            goto fail;
1632
        ret = avcodec_decode_audio2(st->codec, samples,
1633
                                    &data_size, (uint8_t *)data, size);
1634
        av_free(samples);
1635
        break;
1636
    default:
1637
        break;
1638
    }
1639
  }
1640
 fail:
1641
    return ret;
1642
}
1643

    
1644
/* absolute maximum size we read until we abort */
1645
#define MAX_READ_SIZE        5000000
1646

    
1647
#define MAX_STD_TIMEBASES (60*12+5)
1648
static int get_std_framerate(int i){
1649
    if(i<60*12) return i*1001;
1650
    else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1651
}
1652

    
1653
int av_find_stream_info(AVFormatContext *ic)
1654
{
1655
    int i, count, ret, read_size, j;
1656
    AVStream *st;
1657
    AVPacket pkt1, *pkt;
1658
    AVPacketList *pktl=NULL, **ppktl;
1659
    int64_t last_dts[MAX_STREAMS];
1660
    int duration_count[MAX_STREAMS]={0};
1661
    double (*duration_error)[MAX_STD_TIMEBASES];
1662
    offset_t old_offset = url_ftell(&ic->pb);
1663
    int64_t codec_info_duration[MAX_STREAMS]={0};
1664
    int codec_info_nb_frames[MAX_STREAMS]={0};
1665

    
1666
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1667
    if (!duration_error) return AVERROR_NOMEM;
1668

    
1669
    for(i=0;i<ic->nb_streams;i++) {
1670
        st = ic->streams[i];
1671
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1672
/*            if(!st->time_base.num)
1673
                st->time_base= */
1674
            if(!st->codec->time_base.num)
1675
                st->codec->time_base= st->time_base;
1676
        }
1677
        //only for the split stuff
1678
        if (!st->parser) {
1679
            st->parser = av_parser_init(st->codec->codec_id);
1680
            if(st->need_parsing == 2 && st->parser){
1681
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1682
            }
1683
        }
1684
    }
1685

    
1686
    for(i=0;i<MAX_STREAMS;i++){
1687
        last_dts[i]= AV_NOPTS_VALUE;
1688
    }
1689

    
1690
    count = 0;
1691
    read_size = 0;
1692
    ppktl = &ic->packet_buffer;
1693
    for(;;) {
1694
        /* check if one codec still needs to be handled */
1695
        for(i=0;i<ic->nb_streams;i++) {
1696
            st = ic->streams[i];
1697
            if (!has_codec_parameters(st->codec))
1698
                break;
1699
            /* variable fps and no guess at the real fps */
1700
            if(   (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1701
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1702
                break;
1703
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
1704
                break;
1705
        }
1706
        if (i == ic->nb_streams) {
1707
            /* NOTE: if the format has no header, then we need to read
1708
               some packets to get most of the streams, so we cannot
1709
               stop here */
1710
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1711
                /* if we found the info for all the codecs, we can stop */
1712
                ret = count;
1713
                break;
1714
            }
1715
        }
1716
        /* we did not get all the codec info, but we read too much data */
1717
        if (read_size >= MAX_READ_SIZE) {
1718
            ret = count;
1719
            break;
1720
        }
1721

    
1722
        /* NOTE: a new stream can be added there if no header in file
1723
           (AVFMTCTX_NOHEADER) */
1724
        ret = av_read_frame_internal(ic, &pkt1);
1725
        if (ret < 0) {
1726
            /* EOF or error */
1727
            ret = -1; /* we could not have all the codec parameters before EOF */
1728
            for(i=0;i<ic->nb_streams;i++) {
1729
                st = ic->streams[i];
1730
                if (!has_codec_parameters(st->codec)){
1731
                    char buf[256];
1732
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
1733
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1734
                } else {
1735
                    ret = 0;
1736
                }
1737
            }
1738
            break;
1739
        }
1740

    
1741
        pktl = av_mallocz(sizeof(AVPacketList));
1742
        if (!pktl) {
1743
            ret = AVERROR_NOMEM;
1744
            break;
1745
        }
1746

    
1747
        /* add the packet in the buffered packet list */
1748
        *ppktl = pktl;
1749
        ppktl = &pktl->next;
1750

    
1751
        pkt = &pktl->pkt;
1752
        *pkt = pkt1;
1753

    
1754
        /* duplicate the packet */
1755
        if (av_dup_packet(pkt) < 0) {
1756
            ret = AVERROR_NOMEM;
1757
            break;
1758
        }
1759

    
1760
        read_size += pkt->size;
1761

    
1762
        st = ic->streams[pkt->stream_index];
1763
        if(codec_info_nb_frames[st->index]>1)
1764
            codec_info_duration[st->index] += pkt->duration;
1765
        if (pkt->duration != 0)
1766
            codec_info_nb_frames[st->index]++;
1767

    
1768
        {
1769
            int index= pkt->stream_index;
1770
            int64_t last= last_dts[index];
1771
            int64_t duration= pkt->dts - last;
1772

    
1773
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1774
                double dur= duration * av_q2d(st->time_base);
1775

    
1776
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1777
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1778
                if(duration_count[index] < 2)
1779
                    memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1780
                for(i=1; i<MAX_STD_TIMEBASES; i++){
1781
                    int framerate= get_std_framerate(i);
1782
                    int ticks= lrintf(dur*framerate/(1001*12));
1783
                    double error= dur - ticks*1001*12/(double)framerate;
1784
                    duration_error[index][i] += error*error;
1785
                }
1786
                duration_count[index]++;
1787
            }
1788
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1789
                last_dts[pkt->stream_index]= pkt->dts;
1790
        }
1791
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
1792
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1793
            if(i){
1794
                st->codec->extradata_size= i;
1795
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1796
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1797
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1798
            }
1799
        }
1800

    
1801
        /* if still no information, we try to open the codec and to
1802
           decompress the frame. We try to avoid that in most cases as
1803
           it takes longer and uses more memory. For MPEG4, we need to
1804
           decompress for Quicktime. */
1805
        if (!has_codec_parameters(st->codec) /*&&
1806
            (st->codec->codec_id == CODEC_ID_FLV1 ||
1807
             st->codec->codec_id == CODEC_ID_H264 ||
1808
             st->codec->codec_id == CODEC_ID_H263 ||
1809
             st->codec->codec_id == CODEC_ID_H261 ||
1810
             st->codec->codec_id == CODEC_ID_VORBIS ||
1811
             st->codec->codec_id == CODEC_ID_MJPEG ||
1812
             st->codec->codec_id == CODEC_ID_PNG ||
1813
             st->codec->codec_id == CODEC_ID_PAM ||
1814
             st->codec->codec_id == CODEC_ID_PGM ||
1815
             st->codec->codec_id == CODEC_ID_PGMYUV ||
1816
             st->codec->codec_id == CODEC_ID_PBM ||
1817
             st->codec->codec_id == CODEC_ID_PPM ||
1818
             st->codec->codec_id == CODEC_ID_SHORTEN ||
1819
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1820
            try_decode_frame(st, pkt->data, pkt->size);
1821

    
1822
        if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1823
            break;
1824
        }
1825
        count++;
1826
    }
1827

    
1828
    // close codecs which where opened in try_decode_frame()
1829
    for(i=0;i<ic->nb_streams;i++) {
1830
        st = ic->streams[i];
1831
        if(st->codec->codec)
1832
            avcodec_close(st->codec);
1833
    }
1834
    for(i=0;i<ic->nb_streams;i++) {
1835
        st = ic->streams[i];
1836
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1837
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1838
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1839

    
1840
            if(duration_count[i]
1841
               && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1842
               //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1843
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1844
                double best_error= 2*av_q2d(st->time_base);
1845
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
1846

    
1847
                for(j=1; j<MAX_STD_TIMEBASES; j++){
1848
                    double error= duration_error[i][j] * get_std_framerate(j);
1849
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1850
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1851
                    if(error < best_error){
1852
                        best_error= error;
1853
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1854
                    }
1855
                }
1856
            }
1857

    
1858
            if (!st->r_frame_rate.num){
1859
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
1860
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
1861
                    st->r_frame_rate.num = st->codec->time_base.den;
1862
                    st->r_frame_rate.den = st->codec->time_base.num;
1863
                }else{
1864
                    st->r_frame_rate.num = st->time_base.den;
1865
                    st->r_frame_rate.den = st->time_base.num;
1866
                }
1867
            }
1868
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1869
            if(!st->codec->bits_per_sample)
1870
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1871
        }
1872
    }
1873

    
1874
    av_estimate_timings(ic, old_offset);
1875
#if 0
1876
    /* correct DTS for b frame streams with no timestamps */
1877
    for(i=0;i<ic->nb_streams;i++) {
1878
        st = ic->streams[i];
1879
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1880
            if(b-frames){
1881
                ppktl = &ic->packet_buffer;
1882
                while(ppkt1){
1883
                    if(ppkt1->stream_index != i)
1884
                        continue;
1885
                    if(ppkt1->pkt->dts < 0)
1886
                        break;
1887
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1888
                        break;
1889
                    ppkt1->pkt->dts -= delta;
1890
                    ppkt1= ppkt1->next;
1891
                }
1892
                if(ppkt1)
1893
                    continue;
1894
                st->cur_dts -= delta;
1895
            }
1896
        }
1897
    }
1898
#endif
1899

    
1900
    av_free(duration_error);
1901

    
1902
    return ret;
1903
}
1904

    
1905
/*******************************************************/
1906

    
1907
int av_read_play(AVFormatContext *s)
1908
{
1909
    if (!s->iformat->read_play)
1910
        return AVERROR_NOTSUPP;
1911
    return s->iformat->read_play(s);
1912
}
1913

    
1914
int av_read_pause(AVFormatContext *s)
1915
{
1916
    if (!s->iformat->read_pause)
1917
        return AVERROR_NOTSUPP;
1918
    return s->iformat->read_pause(s);
1919
}
1920

    
1921
void av_close_input_file(AVFormatContext *s)
1922
{
1923
    int i, must_open_file;
1924
    AVStream *st;
1925

    
1926
    /* free previous packet */
1927
    if (s->cur_st && s->cur_st->parser)
1928
        av_free_packet(&s->cur_pkt);
1929

    
1930
    if (s->iformat->read_close)
1931
        s->iformat->read_close(s);
1932
    for(i=0;i<s->nb_streams;i++) {
1933
        /* free all data in a stream component */
1934
        st = s->streams[i];
1935
        if (st->parser) {
1936
            av_parser_close(st->parser);
1937
        }
1938
        av_free(st->index_entries);
1939
        av_free(st->codec->extradata);
1940
        av_free(st->codec);
1941
        av_free(st);
1942
    }
1943
    flush_packet_queue(s);
1944
    must_open_file = 1;
1945
    if (s->iformat->flags & AVFMT_NOFILE) {
1946
        must_open_file = 0;
1947
    }
1948
    if (must_open_file) {
1949
        url_fclose(&s->pb);
1950
    }
1951
    av_freep(&s->priv_data);
1952
    av_free(s);
1953
}
1954

    
1955
AVStream *av_new_stream(AVFormatContext *s, int id)
1956
{
1957
    AVStream *st;
1958
    int i;
1959

    
1960
    if (s->nb_streams >= MAX_STREAMS)
1961
        return NULL;
1962

    
1963
    st = av_mallocz(sizeof(AVStream));
1964
    if (!st)
1965
        return NULL;
1966

    
1967
    st->codec= avcodec_alloc_context();
1968
    if (s->iformat) {
1969
        /* no default bitrate if decoding */
1970
        st->codec->bit_rate = 0;
1971
    }
1972
    st->index = s->nb_streams;
1973
    st->id = id;
1974
    st->start_time = AV_NOPTS_VALUE;
1975
    st->duration = AV_NOPTS_VALUE;
1976
    st->cur_dts = AV_NOPTS_VALUE;
1977

    
1978
    /* default pts settings is MPEG like */
1979
    av_set_pts_info(st, 33, 1, 90000);
1980
    st->last_IP_pts = AV_NOPTS_VALUE;
1981
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
1982
        st->pts_buffer[i]= AV_NOPTS_VALUE;
1983

    
1984
    s->streams[s->nb_streams++] = st;
1985
    return st;
1986
}
1987

    
1988
/************************************************************/
1989
/* output media file */
1990

    
1991
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1992
{
1993
    int ret;
1994

    
1995
    if (s->oformat->priv_data_size > 0) {
1996
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
1997
        if (!s->priv_data)
1998
            return AVERROR_NOMEM;
1999
    } else
2000
        s->priv_data = NULL;
2001

    
2002
    if (s->oformat->set_parameters) {
2003
        ret = s->oformat->set_parameters(s, ap);
2004
        if (ret < 0)
2005
            return ret;
2006
    }
2007
    return 0;
2008
}
2009

    
2010
int av_write_header(AVFormatContext *s)
2011
{
2012
    int ret, i;
2013
    AVStream *st;
2014

    
2015
    // some sanity checks
2016
    for(i=0;i<s->nb_streams;i++) {
2017
        st = s->streams[i];
2018

    
2019
        switch (st->codec->codec_type) {
2020
        case CODEC_TYPE_AUDIO:
2021
            if(st->codec->sample_rate<=0){
2022
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2023
                return -1;
2024
            }
2025
            break;
2026
        case CODEC_TYPE_VIDEO:
2027
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2028
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2029
                return -1;
2030
            }
2031
            if(st->codec->width<=0 || st->codec->height<=0){
2032
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2033
                return -1;
2034
            }
2035
            break;
2036
        }
2037

    
2038
        if(s->oformat->codec_tag){
2039
            if(st->codec->codec_tag){
2040
                //FIXME
2041
                //check that tag + id is in the table
2042
                //if neither is in the table -> ok
2043
                //if tag is in the table with another id -> FAIL
2044
                //if id is in the table with another tag -> FAIL unless strict < ?
2045
            }else
2046
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2047
        }
2048
    }
2049

    
2050
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2051
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2052
        if (!s->priv_data)
2053
            return AVERROR_NOMEM;
2054
    }
2055

    
2056
    if(s->oformat->write_header){
2057
        ret = s->oformat->write_header(s);
2058
        if (ret < 0)
2059
            return ret;
2060
    }
2061

    
2062
    /* init PTS generation */
2063
    for(i=0;i<s->nb_streams;i++) {
2064
        int64_t den = AV_NOPTS_VALUE;
2065
        st = s->streams[i];
2066

    
2067
        switch (st->codec->codec_type) {
2068
        case CODEC_TYPE_AUDIO:
2069
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2070
            break;
2071
        case CODEC_TYPE_VIDEO:
2072
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2073
            break;
2074
        default:
2075
            break;
2076
        }
2077
        if (den != AV_NOPTS_VALUE) {
2078
            if (den <= 0)
2079
                return AVERROR_INVALIDDATA;
2080
            av_frac_init(&st->pts, 0, 0, den);
2081
        }
2082
    }
2083
    return 0;
2084
}
2085

    
2086
//FIXME merge with compute_pkt_fields
2087
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2088
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2089
    int num, den, frame_size, i;
2090

    
2091
//    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);
2092

    
2093
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2094
        return -1;*/
2095

    
2096
    /* duration field */
2097
    if (pkt->duration == 0) {
2098
        compute_frame_duration(&num, &den, st, NULL, pkt);
2099
        if (den && num) {
2100
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2101
        }
2102
    }
2103

    
2104
    //XXX/FIXME this is a temporary hack until all encoders output pts
2105
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2106
        pkt->dts=
2107
//        pkt->pts= st->cur_dts;
2108
        pkt->pts= st->pts.val;
2109
    }
2110

    
2111
    //calculate dts from pts
2112
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2113
        st->pts_buffer[0]= pkt->pts;
2114
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2115
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2116
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2117
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2118

    
2119
        pkt->dts= st->pts_buffer[0];
2120
    }
2121

    
2122
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2123
        av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64" st:%d\n", st->cur_dts, pkt->dts, st->index);
2124
        return -1;
2125
    }
2126
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2127
        av_log(NULL, AV_LOG_ERROR, "error, pts < dts (%"PRId64" < %"PRId64")\n",
2128
               pkt->pts, pkt->dts);
2129
        return -1;
2130
    }
2131

    
2132
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2133
    st->cur_dts= pkt->dts;
2134
    st->pts.val= pkt->dts;
2135

    
2136
    /* update pts */
2137
    switch (st->codec->codec_type) {
2138
    case CODEC_TYPE_AUDIO:
2139
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2140

    
2141
        /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2142
           but it would be better if we had the real timestamps from the encoder */
2143
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2144
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2145
        }
2146
        break;
2147
    case CODEC_TYPE_VIDEO:
2148
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2149
        break;
2150
    default:
2151
        break;
2152
    }
2153
    return 0;
2154
}
2155

    
2156
static void truncate_ts(AVStream *st, AVPacket *pkt){
2157
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2158

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

    
2162
    if (pkt->pts != AV_NOPTS_VALUE)
2163
        pkt->pts &= pts_mask;
2164
    if (pkt->dts != AV_NOPTS_VALUE)
2165
        pkt->dts &= pts_mask;
2166
}
2167

    
2168
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2169
{
2170
    int ret;
2171

    
2172
    ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2173
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2174
        return ret;
2175

    
2176
    truncate_ts(s->streams[pkt->stream_index], pkt);
2177

    
2178
    ret= s->oformat->write_packet(s, pkt);
2179
    if(!ret)
2180
        ret= url_ferror(&s->pb);
2181
    return ret;
2182
}
2183

    
2184
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2185
    AVPacketList *pktl, **next_point, *this_pktl;
2186
    int stream_count=0;
2187
    int streams[MAX_STREAMS];
2188

    
2189
    if(pkt){
2190
        AVStream *st= s->streams[ pkt->stream_index];
2191

    
2192
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2193

    
2194
        this_pktl = av_mallocz(sizeof(AVPacketList));
2195
        this_pktl->pkt= *pkt;
2196
        if(pkt->destruct == av_destruct_packet)
2197
            pkt->destruct= NULL; // non shared -> must keep original from being freed
2198
        else
2199
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2200

    
2201
        next_point = &s->packet_buffer;
2202
        while(*next_point){
2203
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2204
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2205
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2206
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2207
                break;
2208
            next_point= &(*next_point)->next;
2209
        }
2210
        this_pktl->next= *next_point;
2211
        *next_point= this_pktl;
2212
    }
2213

    
2214
    memset(streams, 0, sizeof(streams));
2215
    pktl= s->packet_buffer;
2216
    while(pktl){
2217
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2218
        if(streams[ pktl->pkt.stream_index ] == 0)
2219
            stream_count++;
2220
        streams[ pktl->pkt.stream_index ]++;
2221
        pktl= pktl->next;
2222
    }
2223

    
2224
    if(s->nb_streams == stream_count || (flush && stream_count)){
2225
        pktl= s->packet_buffer;
2226
        *out= pktl->pkt;
2227

    
2228
        s->packet_buffer= pktl->next;
2229
        av_freep(&pktl);
2230
        return 1;
2231
    }else{
2232
        av_init_packet(out);
2233
        return 0;
2234
    }
2235
}
2236

    
2237
/**
2238
 * Interleaves a AVPacket correctly so it can be muxed.
2239
 * @param out the interleaved packet will be output here
2240
 * @param in the input packet
2241
 * @param flush 1 if no further packets are available as input and all
2242
 *              remaining packets should be output
2243
 * @return 1 if a packet was output, 0 if no packet could be output,
2244
 *         < 0 if an error occured
2245
 */
2246
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2247
    if(s->oformat->interleave_packet)
2248
        return s->oformat->interleave_packet(s, out, in, flush);
2249
    else
2250
        return av_interleave_packet_per_dts(s, out, in, flush);
2251
}
2252

    
2253
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2254
    AVStream *st= s->streams[ pkt->stream_index];
2255

    
2256
    //FIXME/XXX/HACK drop zero sized packets
2257
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2258
        return 0;
2259

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

    
2264
    if(pkt->dts == AV_NOPTS_VALUE)
2265
        return -1;
2266

    
2267
    for(;;){
2268
        AVPacket opkt;
2269
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2270
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2271
            return ret;
2272

    
2273
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2274
        ret= s->oformat->write_packet(s, &opkt);
2275

    
2276
        av_free_packet(&opkt);
2277
        pkt= NULL;
2278

    
2279
        if(ret<0)
2280
            return ret;
2281
        if(url_ferror(&s->pb))
2282
            return url_ferror(&s->pb);
2283
    }
2284
}
2285

    
2286
int av_write_trailer(AVFormatContext *s)
2287
{
2288
    int ret, i;
2289

    
2290
    for(;;){
2291
        AVPacket pkt;
2292
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2293
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2294
            goto fail;
2295
        if(!ret)
2296
            break;
2297

    
2298
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2299
        ret= s->oformat->write_packet(s, &pkt);
2300

    
2301
        av_free_packet(&pkt);
2302

    
2303
        if(ret<0)
2304
            goto fail;
2305
        if(url_ferror(&s->pb))
2306
            goto fail;
2307
    }
2308

    
2309
    if(s->oformat->write_trailer)
2310
        ret = s->oformat->write_trailer(s);
2311
fail:
2312
    if(ret == 0)
2313
       ret=url_ferror(&s->pb);
2314
    for(i=0;i<s->nb_streams;i++)
2315
        av_freep(&s->streams[i]->priv_data);
2316
    av_freep(&s->priv_data);
2317
    return ret;
2318
}
2319

    
2320
/* "user interface" functions */
2321

    
2322
void dump_format(AVFormatContext *ic,
2323
                 int index,
2324
                 const char *url,
2325
                 int is_output)
2326
{
2327
    int i, flags;
2328
    char buf[256];
2329

    
2330
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2331
            is_output ? "Output" : "Input",
2332
            index,
2333
            is_output ? ic->oformat->name : ic->iformat->name,
2334
            is_output ? "to" : "from", url);
2335
    if (!is_output) {
2336
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2337
        if (ic->duration != AV_NOPTS_VALUE) {
2338
            int hours, mins, secs, us;
2339
            secs = ic->duration / AV_TIME_BASE;
2340
            us = ic->duration % AV_TIME_BASE;
2341
            mins = secs / 60;
2342
            secs %= 60;
2343
            hours = mins / 60;
2344
            mins %= 60;
2345
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2346
                   (10 * us) / AV_TIME_BASE);
2347
        } else {
2348
            av_log(NULL, AV_LOG_INFO, "N/A");
2349
        }
2350
        if (ic->start_time != AV_NOPTS_VALUE) {
2351
            int secs, us;
2352
            av_log(NULL, AV_LOG_INFO, ", start: ");
2353
            secs = ic->start_time / AV_TIME_BASE;
2354
            us = ic->start_time % AV_TIME_BASE;
2355
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2356
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2357
        }
2358
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2359
        if (ic->bit_rate) {
2360
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2361
        } else {
2362
            av_log(NULL, AV_LOG_INFO, "N/A");
2363
        }
2364
        av_log(NULL, AV_LOG_INFO, "\n");
2365
    }
2366
    for(i=0;i<ic->nb_streams;i++) {
2367
        AVStream *st = ic->streams[i];
2368
        int g= ff_gcd(st->time_base.num, st->time_base.den);
2369
        avcodec_string(buf, sizeof(buf), st->codec, is_output);
2370
        av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2371
        /* the pid is an important information, so we display it */
2372
        /* XXX: add a generic system */
2373
        if (is_output)
2374
            flags = ic->oformat->flags;
2375
        else
2376
            flags = ic->iformat->flags;
2377
        if (flags & AVFMT_SHOW_IDS) {
2378
            av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2379
        }
2380
        if (strlen(st->language) > 0) {
2381
            av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2382
        }
2383
        av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2384
        av_log(NULL, AV_LOG_INFO, ": %s", buf);
2385
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2386
            if(st->r_frame_rate.den && st->r_frame_rate.num)
2387
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2388
/*            else if(st->time_base.den && st->time_base.num)
2389
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2390
            else
2391
                av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2392
        }
2393
        av_log(NULL, AV_LOG_INFO, "\n");
2394
    }
2395
}
2396

    
2397
typedef struct {
2398
    const char *abv;
2399
    int width, height;
2400
    int frame_rate, frame_rate_base;
2401
} AbvEntry;
2402

    
2403
static AbvEntry frame_abvs[] = {
2404
    { "ntsc",      720, 480, 30000, 1001 },
2405
    { "pal",       720, 576,    25,    1 },
2406
    { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2407
    { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2408
    { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2409
    { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2410
    { "film",      352, 240,    24,    1 },
2411
    { "ntsc-film", 352, 240, 24000, 1001 },
2412
    { "sqcif",     128,  96,     0,    0 },
2413
    { "qcif",      176, 144,     0,    0 },
2414
    { "cif",       352, 288,     0,    0 },
2415
    { "4cif",      704, 576,     0,    0 },
2416
};
2417

    
2418
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2419
{
2420
    int i;
2421
    int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2422
    const char *p;
2423
    int frame_width = 0, frame_height = 0;
2424

    
2425
    for(i=0;i<n;i++) {
2426
        if (!strcmp(frame_abvs[i].abv, str)) {
2427
            frame_width = frame_abvs[i].width;
2428
            frame_height = frame_abvs[i].height;
2429
            break;
2430
        }
2431
    }
2432
    if (i == n) {
2433
        p = str;
2434
        frame_width = strtol(p, (char **)&p, 10);
2435
        if (*p)
2436
            p++;
2437
        frame_height = strtol(p, (char **)&p, 10);
2438
    }
2439
    if (frame_width <= 0 || frame_height <= 0)
2440
        return -1;
2441
    *width_ptr = frame_width;
2442
    *height_ptr = frame_height;
2443
    return 0;
2444
}
2445

    
2446
int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2447
{
2448
    int i;
2449
    char* cp;
2450

    
2451
    /* First, we check our abbreviation table */
2452
    for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2453
         if (!strcmp(frame_abvs[i].abv, arg)) {
2454
             *frame_rate = frame_abvs[i].frame_rate;
2455
             *frame_rate_base = frame_abvs[i].frame_rate_base;
2456
             return 0;
2457
         }
2458

    
2459
    /* Then, we try to parse it as fraction */
2460
    cp = strchr(arg, '/');
2461
    if (!cp)
2462
        cp = strchr(arg, ':');
2463
    if (cp) {
2464
        char* cpp;
2465
        *frame_rate = strtol(arg, &cpp, 10);
2466
        if (cpp != arg || cpp == cp)
2467
            *frame_rate_base = strtol(cp+1, &cpp, 10);
2468
        else
2469
           *frame_rate = 0;
2470
    }
2471
    else {
2472
        /* Finally we give up and parse it as double */
2473
        AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2474
        *frame_rate_base = time_base.den;
2475
        *frame_rate = time_base.num;
2476
    }
2477
    if (!*frame_rate || !*frame_rate_base)
2478
        return -1;
2479
    else
2480
        return 0;
2481
}
2482

    
2483
#ifndef CONFIG_WINCE
2484
int64_t parse_date(const char *datestr, int duration)
2485
{
2486
    const char *p;
2487
    int64_t t;
2488
    struct tm dt;
2489
    int i;
2490
    static const char *date_fmt[] = {
2491
        "%Y-%m-%d",
2492
        "%Y%m%d",
2493
    };
2494
    static const char *time_fmt[] = {
2495
        "%H:%M:%S",
2496
        "%H%M%S",
2497
    };
2498
    const char *q;
2499
    int is_utc, len;
2500
    char lastch;
2501
    int negative = 0;
2502

    
2503
#undef time
2504
    time_t now = time(0);
2505

    
2506
    len = strlen(datestr);
2507
    if (len > 0)
2508
        lastch = datestr[len - 1];
2509
    else
2510
        lastch = '\0';
2511
    is_utc = (lastch == 'z' || lastch == 'Z');
2512

    
2513
    memset(&dt, 0, sizeof(dt));
2514

    
2515
    p = datestr;
2516
    q = NULL;
2517
    if (!duration) {
2518
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2519
            q = small_strptime(p, date_fmt[i], &dt);
2520
            if (q) {
2521
                break;
2522
            }
2523
        }
2524

    
2525
        if (!q) {
2526
            if (is_utc) {
2527
                dt = *gmtime(&now);
2528
            } else {
2529
                dt = *localtime(&now);
2530
            }
2531
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2532
        } else {
2533
            p = q;
2534
        }
2535

    
2536
        if (*p == 'T' || *p == 't' || *p == ' ')
2537
            p++;
2538

    
2539
        for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2540
            q = small_strptime(p, time_fmt[i], &dt);
2541
            if (q) {
2542
                break;
2543
            }
2544
        }
2545
    } else {
2546
        if (p[0] == '-') {
2547
            negative = 1;
2548
            ++p;
2549
        }
2550
        q = small_strptime(p, time_fmt[0], &dt);
2551
        if (!q) {
2552
            dt.tm_sec = strtol(p, (char **)&q, 10);
2553
            dt.tm_min = 0;
2554
            dt.tm_hour = 0;
2555
        }
2556
    }
2557

    
2558
    /* Now we have all the fields that we can get */
2559
    if (!q) {
2560
        if (duration)
2561
            return 0;
2562
        else
2563
            return now * INT64_C(1000000);
2564
    }
2565

    
2566
    if (duration) {
2567
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2568
    } else {
2569
        dt.tm_isdst = -1;       /* unknown */
2570
        if (is_utc) {
2571
            t = mktimegm(&dt);
2572
        } else {
2573
            t = mktime(&dt);
2574
        }
2575
    }
2576

    
2577
    t *= 1000000;
2578

    
2579
    if (*q == '.') {
2580
        int val, n;
2581
        q++;
2582
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2583
            if (!isdigit(*q))
2584
                break;
2585
            val += n * (*q - '0');
2586
        }
2587
        t += val;
2588
    }
2589
    return negative ? -t : t;
2590
}
2591
#endif /* CONFIG_WINCE */
2592

    
2593
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2594
{
2595
    const char *p;
2596
    char tag[128], *q;
2597

    
2598
    p = info;
2599
    if (*p == '?')
2600
        p++;
2601
    for(;;) {
2602
        q = tag;
2603
        while (*p != '\0' && *p != '=' && *p != '&') {
2604
            if ((q - tag) < sizeof(tag) - 1)
2605
                *q++ = *p;
2606
            p++;
2607
        }
2608
        *q = '\0';
2609
        q = arg;
2610
        if (*p == '=') {
2611
            p++;
2612
            while (*p != '&' && *p != '\0') {
2613
                if ((q - arg) < arg_size - 1) {
2614
                    if (*p == '+')
2615
                        *q++ = ' ';
2616
                    else
2617
                        *q++ = *p;
2618
                }
2619
                p++;
2620
            }
2621
            *q = '\0';
2622
        }
2623
        if (!strcmp(tag, tag1))
2624
            return 1;
2625
        if (*p != '&')
2626
            break;
2627
        p++;
2628
    }
2629
    return 0;
2630
}
2631

    
2632
int av_get_frame_filename(char *buf, int buf_size,
2633
                          const char *path, int number)
2634
{
2635
    const char *p;
2636
    char *q, buf1[20], c;
2637
    int nd, len, percentd_found;
2638

    
2639
    q = buf;
2640
    p = path;
2641
    percentd_found = 0;
2642
    for(;;) {
2643
        c = *p++;
2644
        if (c == '\0')
2645
            break;
2646
        if (c == '%') {
2647
            do {
2648
                nd = 0;
2649
                while (isdigit(*p)) {
2650
                    nd = nd * 10 + *p++ - '0';
2651
                }
2652
                c = *p++;
2653
            } while (isdigit(c));
2654

    
2655
            switch(c) {
2656
            case '%':
2657
                goto addchar;
2658
            case 'd':
2659
                if (percentd_found)
2660
                    goto fail;
2661
                percentd_found = 1;
2662
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2663
                len = strlen(buf1);
2664
                if ((q - buf + len) > buf_size - 1)
2665
                    goto fail;
2666
                memcpy(q, buf1, len);
2667
                q += len;
2668
                break;
2669
            default:
2670
                goto fail;
2671
            }
2672
        } else {
2673
        addchar:
2674
            if ((q - buf) < buf_size - 1)
2675
                *q++ = c;
2676
        }
2677
    }
2678
    if (!percentd_found)
2679
        goto fail;
2680
    *q = '\0';
2681
    return 0;
2682
 fail:
2683
    *q = '\0';
2684
    return -1;
2685
}
2686

    
2687
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2688
{
2689
    int len, i, j, c;
2690
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2691

    
2692
    for(i=0;i<size;i+=16) {
2693
        len = size - i;
2694
        if (len > 16)
2695
            len = 16;
2696
        PRINT("%08x ", i);
2697
        for(j=0;j<16;j++) {
2698
            if (j < len)
2699
                PRINT(" %02x", buf[i+j]);
2700
            else
2701
                PRINT("   ");
2702
        }
2703
        PRINT(" ");
2704
        for(j=0;j<len;j++) {
2705
            c = buf[i+j];
2706
            if (c < ' ' || c > '~')
2707
                c = '.';
2708
            PRINT("%c", c);
2709
        }
2710
        PRINT("\n");
2711
    }
2712
#undef PRINT
2713
}
2714

    
2715
void av_hex_dump(FILE *f, uint8_t *buf, int size)
2716
{
2717
    hex_dump_internal(NULL, f, 0, buf, size);
2718
}
2719

    
2720
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2721
{
2722
    hex_dump_internal(avcl, NULL, level, buf, size);
2723
}
2724

    
2725
 //FIXME needs to know the time_base
2726
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2727
{
2728
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2729
    PRINT("stream #%d:\n", pkt->stream_index);
2730
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2731
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2732
    /* DTS is _always_ valid after av_read_frame() */
2733
    PRINT("  dts=");
2734
    if (pkt->dts == AV_NOPTS_VALUE)
2735
        PRINT("N/A");
2736
    else
2737
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2738
    /* PTS may be not known if B frames are present */
2739
    PRINT("  pts=");
2740
    if (pkt->pts == AV_NOPTS_VALUE)
2741
        PRINT("N/A");
2742
    else
2743
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2744
    PRINT("\n");
2745
    PRINT("  size=%d\n", pkt->size);
2746
#undef PRINT
2747
    if (dump_payload)
2748
        av_hex_dump(f, pkt->data, pkt->size);
2749
}
2750

    
2751
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2752
{
2753
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2754
}
2755

    
2756
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2757
{
2758
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2759
}
2760

    
2761
void url_split(char *proto, int proto_size,
2762
               char *authorization, int authorization_size,
2763
               char *hostname, int hostname_size,
2764
               int *port_ptr,
2765
               char *path, int path_size,
2766
               const char *url)
2767
{
2768
    const char *p;
2769
    char *q;
2770
    int port;
2771

    
2772
    port = -1;
2773

    
2774
    p = url;
2775
    q = proto;
2776
    while (*p != ':' && *p != '\0') {
2777
        if ((q - proto) < proto_size - 1)
2778
            *q++ = *p;
2779
        p++;
2780
    }
2781
    if (proto_size > 0)
2782
        *q = '\0';
2783
    if (authorization_size > 0)
2784
        authorization[0] = '\0';
2785
    if (*p == '\0') {
2786
        if (proto_size > 0)
2787
            proto[0] = '\0';
2788
        if (hostname_size > 0)
2789
            hostname[0] = '\0';
2790
        p = url;
2791
    } else {
2792
        char *at,*slash; // PETR: position of '@' character and '/' character
2793

    
2794
        p++;
2795
        if (*p == '/')
2796
            p++;
2797
        if (*p == '/')
2798
            p++;
2799
        at = strchr(p,'@'); // PETR: get the position of '@'
2800
        slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2801
        if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2802

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

    
2805
         while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2806
            if (*p == '@') {    // PETR: passed '@'
2807
              if (authorization_size > 0)
2808
                  *q = '\0';
2809
              q = hostname;
2810
              at = NULL;
2811
            } else if (!at) {   // PETR: hostname
2812
              if ((q - hostname) < hostname_size - 1)
2813
                  *q++ = *p;
2814
            } else {
2815
              if ((q - authorization) < authorization_size - 1)
2816
                *q++ = *p;
2817
            }
2818
            p++;
2819
        }
2820
        if (hostname_size > 0)
2821
            *q = '\0';
2822
        if (*p == ':') {
2823
            p++;
2824
            port = strtoul(p, (char **)&p, 10);
2825
        }
2826
    }
2827
    if (port_ptr)
2828
        *port_ptr = port;
2829
    pstrcpy(path, path_size, p);
2830
}
2831

    
2832
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2833
                     int pts_num, int pts_den)
2834
{
2835
    s->pts_wrap_bits = pts_wrap_bits;
2836
    s->time_base.num = pts_num;
2837
    s->time_base.den = pts_den;
2838
}
2839

    
2840
/* fraction handling */
2841

    
2842
/**
2843
 * f = val + (num / den) + 0.5.
2844
 *
2845
 * 'num' is normalized so that it is such as 0 <= num < den.
2846
 *
2847
 * @param f fractional number
2848
 * @param val integer value
2849
 * @param num must be >= 0
2850
 * @param den must be >= 1
2851
 */
2852
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2853
{
2854
    num += (den >> 1);
2855
    if (num >= den) {
2856
        val += num / den;
2857
        num = num % den;
2858
    }
2859
    f->val = val;
2860
    f->num = num;
2861
    f->den = den;
2862
}
2863

    
2864
/**
2865
 * Fractionnal addition to f: f = f + (incr / f->den).
2866
 *
2867
 * @param f fractional number
2868
 * @param incr increment, can be positive or negative
2869
 */
2870
static void av_frac_add(AVFrac *f, int64_t incr)
2871
{
2872
    int64_t num, den;
2873

    
2874
    num = f->num + incr;
2875
    den = f->den;
2876
    if (num < 0) {
2877
        f->val += num / den;
2878
        num = num % den;
2879
        if (num < 0) {
2880
            num += den;
2881
            f->val--;
2882
        }
2883
    } else if (num >= den) {
2884
        f->val += num / den;
2885
        num = num % den;
2886
    }
2887
    f->num = num;
2888
}