Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ d7fb5a18

History | View | Annotate | Download (99 KB)

1
/*
2
 * various utility functions for use within FFmpeg
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 "internal.h"
23
#include "libavcodec/opt.h"
24
#include "libavutil/avstring.h"
25
#include "riff.h"
26
#include <sys/time.h>
27
#include <time.h>
28
#include <strings.h>
29

    
30
#undef NDEBUG
31
#include <assert.h>
32

    
33
/**
34
 * @file libavformat/utils.c
35
 * various utility functions for use within FFmpeg
36
 */
37

    
38
unsigned avformat_version(void)
39
{
40
    return LIBAVFORMAT_VERSION_INT;
41
}
42

    
43
/* fraction handling */
44

    
45
/**
46
 * f = val + (num / den) + 0.5.
47
 *
48
 * 'num' is normalized so that it is such as 0 <= num < den.
49
 *
50
 * @param f fractional number
51
 * @param val integer value
52
 * @param num must be >= 0
53
 * @param den must be >= 1
54
 */
55
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
56
{
57
    num += (den >> 1);
58
    if (num >= den) {
59
        val += num / den;
60
        num = num % den;
61
    }
62
    f->val = val;
63
    f->num = num;
64
    f->den = den;
65
}
66

    
67
/**
68
 * Fractional addition to f: f = f + (incr / f->den).
69
 *
70
 * @param f fractional number
71
 * @param incr increment, can be positive or negative
72
 */
73
static void av_frac_add(AVFrac *f, int64_t incr)
74
{
75
    int64_t num, den;
76

    
77
    num = f->num + incr;
78
    den = f->den;
79
    if (num < 0) {
80
        f->val += num / den;
81
        num = num % den;
82
        if (num < 0) {
83
            num += den;
84
            f->val--;
85
        }
86
    } else if (num >= den) {
87
        f->val += num / den;
88
        num = num % den;
89
    }
90
    f->num = num;
91
}
92

    
93
/** head of registered input format linked list */
94
AVInputFormat *first_iformat = NULL;
95
/** head of registered output format linked list */
96
AVOutputFormat *first_oformat = NULL;
97

    
98
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
99
{
100
    if(f) return f->next;
101
    else  return first_iformat;
102
}
103

    
104
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
105
{
106
    if(f) return f->next;
107
    else  return first_oformat;
108
}
109

    
110
void av_register_input_format(AVInputFormat *format)
111
{
112
    AVInputFormat **p;
113
    p = &first_iformat;
114
    while (*p != NULL) p = &(*p)->next;
115
    *p = format;
116
    format->next = NULL;
117
}
118

    
119
void av_register_output_format(AVOutputFormat *format)
120
{
121
    AVOutputFormat **p;
122
    p = &first_oformat;
123
    while (*p != NULL) p = &(*p)->next;
124
    *p = format;
125
    format->next = NULL;
126
}
127

    
128
int match_ext(const char *filename, const char *extensions)
129
{
130
    const char *ext, *p;
131
    char ext1[32], *q;
132

    
133
    if(!filename)
134
        return 0;
135

    
136
    ext = strrchr(filename, '.');
137
    if (ext) {
138
        ext++;
139
        p = extensions;
140
        for(;;) {
141
            q = ext1;
142
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
143
                *q++ = *p++;
144
            *q = '\0';
145
            if (!strcasecmp(ext1, ext))
146
                return 1;
147
            if (*p == '\0')
148
                break;
149
            p++;
150
        }
151
    }
152
    return 0;
153
}
154

    
155
AVOutputFormat *guess_format(const char *short_name, const char *filename,
156
                             const char *mime_type)
157
{
158
    AVOutputFormat *fmt, *fmt_found;
159
    int score_max, score;
160

    
161
    /* specific test for image sequences */
162
#ifdef CONFIG_IMAGE2_MUXER
163
    if (!short_name && filename &&
164
        av_filename_number_test(filename) &&
165
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
166
        return guess_format("image2", NULL, NULL);
167
    }
168
#endif
169
    /* Find the proper file type. */
170
    fmt_found = NULL;
171
    score_max = 0;
172
    fmt = first_oformat;
173
    while (fmt != NULL) {
174
        score = 0;
175
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
176
            score += 100;
177
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
178
            score += 10;
179
        if (filename && fmt->extensions &&
180
            match_ext(filename, fmt->extensions)) {
181
            score += 5;
182
        }
183
        if (score > score_max) {
184
            score_max = score;
185
            fmt_found = fmt;
186
        }
187
        fmt = fmt->next;
188
    }
189
    return fmt_found;
190
}
191

    
192
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
193
                             const char *mime_type)
194
{
195
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
196

    
197
    if (fmt) {
198
        AVOutputFormat *stream_fmt;
199
        char stream_format_name[64];
200

    
201
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
202
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
203

    
204
        if (stream_fmt)
205
            fmt = stream_fmt;
206
    }
207

    
208
    return fmt;
209
}
210

    
211
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
212
                            const char *filename, const char *mime_type, enum CodecType type){
213
    if(type == CODEC_TYPE_VIDEO){
214
        enum CodecID codec_id= CODEC_ID_NONE;
215

    
216
#ifdef CONFIG_IMAGE2_MUXER
217
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
218
            codec_id= av_guess_image2_codec(filename);
219
        }
220
#endif
221
        if(codec_id == CODEC_ID_NONE)
222
            codec_id= fmt->video_codec;
223
        return codec_id;
224
    }else if(type == CODEC_TYPE_AUDIO)
225
        return fmt->audio_codec;
226
    else
227
        return CODEC_ID_NONE;
228
}
229

    
230
AVInputFormat *av_find_input_format(const char *short_name)
231
{
232
    AVInputFormat *fmt;
233
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
234
        if (!strcmp(fmt->name, short_name))
235
            return fmt;
236
    }
237
    return NULL;
238
}
239

    
240
/* memory handling */
241

    
242
void av_destruct_packet(AVPacket *pkt)
243
{
244
    av_free(pkt->data);
245
    pkt->data = NULL; pkt->size = 0;
246
}
247

    
248
void av_init_packet(AVPacket *pkt)
249
{
250
    pkt->pts   = AV_NOPTS_VALUE;
251
    pkt->dts   = AV_NOPTS_VALUE;
252
    pkt->pos   = -1;
253
    pkt->duration = 0;
254
    pkt->convergence_duration = 0;
255
    pkt->flags = 0;
256
    pkt->stream_index = 0;
257
    pkt->destruct= av_destruct_packet_nofree;
258
}
259

    
260
int av_new_packet(AVPacket *pkt, int size)
261
{
262
    uint8_t *data;
263
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
264
        return AVERROR(ENOMEM);
265
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
266
    if (!data)
267
        return AVERROR(ENOMEM);
268
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
269

    
270
    av_init_packet(pkt);
271
    pkt->data = data;
272
    pkt->size = size;
273
    pkt->destruct = av_destruct_packet;
274
    return 0;
275
}
276

    
277
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
278
{
279
    int ret= av_new_packet(pkt, size);
280

    
281
    if(ret<0)
282
        return ret;
283

    
284
    pkt->pos= url_ftell(s);
285

    
286
    ret= get_buffer(s, pkt->data, size);
287
    if(ret<=0)
288
        av_free_packet(pkt);
289
    else
290
        pkt->size= ret;
291

    
292
    return ret;
293
}
294

    
295
int av_dup_packet(AVPacket *pkt)
296
{
297
    if (pkt->destruct != av_destruct_packet) {
298
        uint8_t *data;
299
        /* We duplicate the packet and don't forget to add the padding again. */
300
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
301
            return AVERROR(ENOMEM);
302
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
303
        if (!data) {
304
            return AVERROR(ENOMEM);
305
        }
306
        memcpy(data, pkt->data, pkt->size);
307
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
308
        pkt->data = data;
309
        pkt->destruct = av_destruct_packet;
310
    }
311
    return 0;
312
}
313

    
314
int av_filename_number_test(const char *filename)
315
{
316
    char buf[1024];
317
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
318
}
319

    
320
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
321
{
322
    AVInputFormat *fmt1, *fmt;
323
    int score;
324

    
325
    fmt = NULL;
326
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
327
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
328
            continue;
329
        score = 0;
330
        if (fmt1->read_probe) {
331
            score = fmt1->read_probe(pd);
332
        } else if (fmt1->extensions) {
333
            if (match_ext(pd->filename, fmt1->extensions)) {
334
                score = 50;
335
            }
336
        }
337
        if (score > *score_max) {
338
            *score_max = score;
339
            fmt = fmt1;
340
        }else if (score == *score_max)
341
            fmt = NULL;
342
    }
343
    return fmt;
344
}
345

    
346
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
347
    int score=0;
348
    return av_probe_input_format2(pd, is_opened, &score);
349
}
350

    
351
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
352
{
353
    AVInputFormat *fmt;
354
    fmt = av_probe_input_format2(pd, 1, &score);
355

    
356
    if (fmt) {
357
        if (!strcmp(fmt->name, "mp3")) {
358
            st->codec->codec_id = CODEC_ID_MP3;
359
            st->codec->codec_type = CODEC_TYPE_AUDIO;
360
        } else if (!strcmp(fmt->name, "ac3")) {
361
            st->codec->codec_id = CODEC_ID_AC3;
362
            st->codec->codec_type = CODEC_TYPE_AUDIO;
363
        } else if (!strcmp(fmt->name, "mpegvideo")) {
364
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
365
            st->codec->codec_type = CODEC_TYPE_VIDEO;
366
        } else if (!strcmp(fmt->name, "m4v")) {
367
            st->codec->codec_id = CODEC_ID_MPEG4;
368
            st->codec->codec_type = CODEC_TYPE_VIDEO;
369
        } else if (!strcmp(fmt->name, "h264")) {
370
            st->codec->codec_id = CODEC_ID_H264;
371
            st->codec->codec_type = CODEC_TYPE_VIDEO;
372
        }
373
    }
374
    return !!fmt;
375
}
376

    
377
/************************************************************/
378
/* input media file */
379

    
380
/**
381
 * Open a media file from an IO stream. 'fmt' must be specified.
382
 */
383
static const char* format_to_name(void* ptr)
384
{
385
    AVFormatContext* fc = (AVFormatContext*) ptr;
386
    if(fc->iformat) return fc->iformat->name;
387
    else if(fc->oformat) return fc->oformat->name;
388
    else return "NULL";
389
}
390

    
391
#define OFFSET(x) offsetof(AVFormatContext,x)
392
#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
393
//these names are too long to be readable
394
#define E AV_OPT_FLAG_ENCODING_PARAM
395
#define D AV_OPT_FLAG_DECODING_PARAM
396

    
397
static const AVOption options[]={
398
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
399
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
400
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
401
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
402
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
403
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
404
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
405
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
406
{"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
407
{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
408
{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
409
{"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, 3041280, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
410
{"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E|D, "fdebug"},
411
{"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E|D, "fdebug"},
412
{NULL},
413
};
414

    
415
#undef E
416
#undef D
417
#undef DEFAULT
418

    
419
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
420

    
421
static void avformat_get_context_defaults(AVFormatContext *s)
422
{
423
    memset(s, 0, sizeof(AVFormatContext));
424

    
425
    s->av_class = &av_format_context_class;
426

    
427
    av_opt_set_defaults(s);
428
}
429

    
430
AVFormatContext *av_alloc_format_context(void)
431
{
432
    AVFormatContext *ic;
433
    ic = av_malloc(sizeof(AVFormatContext));
434
    if (!ic) return ic;
435
    avformat_get_context_defaults(ic);
436
    ic->av_class = &av_format_context_class;
437
    return ic;
438
}
439

    
440
int av_open_input_stream(AVFormatContext **ic_ptr,
441
                         ByteIOContext *pb, const char *filename,
442
                         AVInputFormat *fmt, AVFormatParameters *ap)
443
{
444
    int err;
445
    AVFormatContext *ic;
446
    AVFormatParameters default_ap;
447

    
448
    if(!ap){
449
        ap=&default_ap;
450
        memset(ap, 0, sizeof(default_ap));
451
    }
452

    
453
    if(!ap->prealloced_context)
454
        ic = av_alloc_format_context();
455
    else
456
        ic = *ic_ptr;
457
    if (!ic) {
458
        err = AVERROR(ENOMEM);
459
        goto fail;
460
    }
461
    ic->iformat = fmt;
462
    ic->pb = pb;
463
    ic->duration = AV_NOPTS_VALUE;
464
    ic->start_time = AV_NOPTS_VALUE;
465
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
466

    
467
    /* allocate private data */
468
    if (fmt->priv_data_size > 0) {
469
        ic->priv_data = av_mallocz(fmt->priv_data_size);
470
        if (!ic->priv_data) {
471
            err = AVERROR(ENOMEM);
472
            goto fail;
473
        }
474
    } else {
475
        ic->priv_data = NULL;
476
    }
477

    
478
    if (ic->iformat->read_header) {
479
        err = ic->iformat->read_header(ic, ap);
480
        if (err < 0)
481
            goto fail;
482
    }
483

    
484
    if (pb && !ic->data_offset)
485
        ic->data_offset = url_ftell(ic->pb);
486

    
487
    *ic_ptr = ic;
488
    return 0;
489
 fail:
490
    if (ic) {
491
        int i;
492
        av_freep(&ic->priv_data);
493
        for(i=0;i<ic->nb_streams;i++) {
494
            AVStream *st = ic->streams[i];
495
            if (st) {
496
                av_free(st->priv_data);
497
                av_free(st->codec->extradata);
498
            }
499
            av_free(st);
500
        }
501
    }
502
    av_free(ic);
503
    *ic_ptr = NULL;
504
    return err;
505
}
506

    
507
/** size of probe buffer, for guessing file type from file contents */
508
#define PROBE_BUF_MIN 2048
509
#define PROBE_BUF_MAX (1<<20)
510

    
511
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
512
                       AVInputFormat *fmt,
513
                       int buf_size,
514
                       AVFormatParameters *ap)
515
{
516
    int err, probe_size;
517
    AVProbeData probe_data, *pd = &probe_data;
518
    ByteIOContext *pb = NULL;
519

    
520
    pd->filename = "";
521
    if (filename)
522
        pd->filename = filename;
523
    pd->buf = NULL;
524
    pd->buf_size = 0;
525

    
526
    if (!fmt) {
527
        /* guess format if no file can be opened */
528
        fmt = av_probe_input_format(pd, 0);
529
    }
530

    
531
    /* Do not open file if the format does not need it. XXX: specific
532
       hack needed to handle RTSP/TCP */
533
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
534
        /* if no file needed do not try to open one */
535
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
536
            goto fail;
537
        }
538
        if (buf_size > 0) {
539
            url_setbufsize(pb, buf_size);
540
        }
541

    
542
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
543
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
544
            /* read probe data */
545
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
546
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
547
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
548
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
549
                url_fclose(pb);
550
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
551
                    pb = NULL;
552
                    err = AVERROR(EIO);
553
                    goto fail;
554
                }
555
            }
556
            /* guess file format */
557
            fmt = av_probe_input_format2(pd, 1, &score);
558
        }
559
        av_freep(&pd->buf);
560
    }
561

    
562
    /* if still no format found, error */
563
    if (!fmt) {
564
        err = AVERROR_NOFMT;
565
        goto fail;
566
    }
567

    
568
    /* check filename in case an image number is expected */
569
    if (fmt->flags & AVFMT_NEEDNUMBER) {
570
        if (!av_filename_number_test(filename)) {
571
            err = AVERROR_NUMEXPECTED;
572
            goto fail;
573
        }
574
    }
575
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
576
    if (err)
577
        goto fail;
578
    return 0;
579
 fail:
580
    av_freep(&pd->buf);
581
    if (pb)
582
        url_fclose(pb);
583
    *ic_ptr = NULL;
584
    return err;
585

    
586
}
587

    
588
/*******************************************************/
589

    
590
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
591
                               AVPacketList **plast_pktl){
592
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
593
    if (!pktl)
594
        return NULL;
595

    
596
    if (*packet_buffer)
597
        (*plast_pktl)->next = pktl;
598
    else
599
        *packet_buffer = pktl;
600

    
601
    /* add the packet in the buffered packet list */
602
    *plast_pktl = pktl;
603
    pktl->pkt= *pkt;
604
    return &pktl->pkt;
605
}
606

    
607
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
608
{
609
    int ret;
610
    AVStream *st;
611

    
612
    for(;;){
613
        AVPacketList *pktl = s->raw_packet_buffer;
614

    
615
        if (pktl) {
616
            *pkt = pktl->pkt;
617
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
618
                s->raw_packet_buffer = pktl->next;
619
                av_free(pktl);
620
                return 0;
621
            }
622
        }
623

    
624
        av_init_packet(pkt);
625
        ret= s->iformat->read_packet(s, pkt);
626
        if (ret < 0)
627
            return ret;
628
        st= s->streams[pkt->stream_index];
629

    
630
        switch(st->codec->codec_type){
631
        case CODEC_TYPE_VIDEO:
632
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
633
            break;
634
        case CODEC_TYPE_AUDIO:
635
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
636
            break;
637
        case CODEC_TYPE_SUBTITLE:
638
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
639
            break;
640
        }
641

    
642
        if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
643
            return ret;
644

    
645
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
646

    
647
        if(st->codec->codec_id == CODEC_ID_PROBE){
648
            AVProbeData *pd = &st->probe_data;
649

    
650
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
651
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
652
            pd->buf_size += pkt->size;
653
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
654

    
655
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
656
                set_codec_from_probe_data(st, pd, 1);
657
                if(st->codec->codec_id != CODEC_ID_PROBE){
658
                    pd->buf_size=0;
659
                    av_freep(&pd->buf);
660
                }
661
            }
662
        }
663
    }
664
}
665

    
666
/**********************************************************/
667

    
668
/**
669
 * Get the number of samples of an audio frame. Return -1 on error.
670
 */
671
static int get_audio_frame_size(AVCodecContext *enc, int size)
672
{
673
    int frame_size;
674

    
675
    if(enc->codec_id == CODEC_ID_VORBIS)
676
        return -1;
677

    
678
    if (enc->frame_size <= 1) {
679
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
680

    
681
        if (bits_per_sample) {
682
            if (enc->channels == 0)
683
                return -1;
684
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
685
        } else {
686
            /* used for example by ADPCM codecs */
687
            if (enc->bit_rate == 0)
688
                return -1;
689
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
690
        }
691
    } else {
692
        frame_size = enc->frame_size;
693
    }
694
    return frame_size;
695
}
696

    
697

    
698
/**
699
 * Return the frame duration in seconds. Return 0 if not available.
700
 */
701
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
702
                                   AVCodecParserContext *pc, AVPacket *pkt)
703
{
704
    int frame_size;
705

    
706
    *pnum = 0;
707
    *pden = 0;
708
    switch(st->codec->codec_type) {
709
    case CODEC_TYPE_VIDEO:
710
        if(st->time_base.num*1000LL > st->time_base.den){
711
            *pnum = st->time_base.num;
712
            *pden = st->time_base.den;
713
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
714
            *pnum = st->codec->time_base.num;
715
            *pden = st->codec->time_base.den;
716
            if (pc && pc->repeat_pict) {
717
                *pden *= 2;
718
                *pnum = (*pnum) * (2 + pc->repeat_pict);
719
            }
720
        }
721
        break;
722
    case CODEC_TYPE_AUDIO:
723
        frame_size = get_audio_frame_size(st->codec, pkt->size);
724
        if (frame_size < 0)
725
            break;
726
        *pnum = frame_size;
727
        *pden = st->codec->sample_rate;
728
        break;
729
    default:
730
        break;
731
    }
732
}
733

    
734
static int is_intra_only(AVCodecContext *enc){
735
    if(enc->codec_type == CODEC_TYPE_AUDIO){
736
        return 1;
737
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
738
        switch(enc->codec_id){
739
        case CODEC_ID_MJPEG:
740
        case CODEC_ID_MJPEGB:
741
        case CODEC_ID_LJPEG:
742
        case CODEC_ID_RAWVIDEO:
743
        case CODEC_ID_DVVIDEO:
744
        case CODEC_ID_HUFFYUV:
745
        case CODEC_ID_FFVHUFF:
746
        case CODEC_ID_ASV1:
747
        case CODEC_ID_ASV2:
748
        case CODEC_ID_VCR1:
749
        case CODEC_ID_DNXHD:
750
            return 1;
751
        default: break;
752
        }
753
    }
754
    return 0;
755
}
756

    
757
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
758
                                      int64_t dts, int64_t pts)
759
{
760
    AVStream *st= s->streams[stream_index];
761
    AVPacketList *pktl= s->packet_buffer;
762

    
763
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
764
        return;
765

    
766
    st->first_dts= dts - st->cur_dts;
767
    st->cur_dts= dts;
768

    
769
    for(; pktl; pktl= pktl->next){
770
        if(pktl->pkt.stream_index != stream_index)
771
            continue;
772
        //FIXME think more about this check
773
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
774
            pktl->pkt.pts += st->first_dts;
775

    
776
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
777
            pktl->pkt.dts += st->first_dts;
778

    
779
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
780
            st->start_time= pktl->pkt.pts;
781
    }
782
    if (st->start_time == AV_NOPTS_VALUE)
783
        st->start_time = pts;
784
}
785

    
786
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
787
{
788
    AVPacketList *pktl= s->packet_buffer;
789
    int64_t cur_dts= 0;
790

    
791
    if(st->first_dts != AV_NOPTS_VALUE){
792
        cur_dts= st->first_dts;
793
        for(; pktl; pktl= pktl->next){
794
            if(pktl->pkt.stream_index == pkt->stream_index){
795
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
796
                    break;
797
                cur_dts -= pkt->duration;
798
            }
799
        }
800
        pktl= s->packet_buffer;
801
        st->first_dts = cur_dts;
802
    }else if(st->cur_dts)
803
        return;
804

    
805
    for(; pktl; pktl= pktl->next){
806
        if(pktl->pkt.stream_index != pkt->stream_index)
807
            continue;
808
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
809
           && !pktl->pkt.duration){
810
            pktl->pkt.dts= cur_dts;
811
            if(!st->codec->has_b_frames)
812
                pktl->pkt.pts= cur_dts;
813
            cur_dts += pkt->duration;
814
            pktl->pkt.duration= pkt->duration;
815
        }else
816
            break;
817
    }
818
    if(st->first_dts == AV_NOPTS_VALUE)
819
        st->cur_dts= cur_dts;
820
}
821

    
822
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
823
                               AVCodecParserContext *pc, AVPacket *pkt)
824
{
825
    int num, den, presentation_delayed, delay, i;
826
    int64_t offset;
827

    
828
    /* do we have a video B-frame ? */
829
    delay= st->codec->has_b_frames;
830
    presentation_delayed = 0;
831
    /* XXX: need has_b_frame, but cannot get it if the codec is
832
        not initialized */
833
    if (delay &&
834
        pc && pc->pict_type != FF_B_TYPE)
835
        presentation_delayed = 1;
836

    
837
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
838
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
839
        pkt->dts -= 1LL<<st->pts_wrap_bits;
840
    }
841

    
842
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
843
    // we take the conservative approach and discard both
844
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
845
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
846
        av_log(s, AV_LOG_ERROR, "invalid dts/pts combination\n");
847
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
848
    }
849

    
850
    if (pkt->duration == 0) {
851
        compute_frame_duration(&num, &den, st, pc, pkt);
852
        if (den && num) {
853
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
854

    
855
            if(pkt->duration != 0 && s->packet_buffer)
856
                update_initial_durations(s, st, pkt);
857
        }
858
    }
859

    
860
    /* correct timestamps with byte offset if demuxers only have timestamps
861
       on packet boundaries */
862
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
863
        /* this will estimate bitrate based on this frame's duration and size */
864
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
865
        if(pkt->pts != AV_NOPTS_VALUE)
866
            pkt->pts += offset;
867
        if(pkt->dts != AV_NOPTS_VALUE)
868
            pkt->dts += offset;
869
    }
870

    
871
    /* This may be redundant, but it should not hurt. */
872
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
873
        presentation_delayed = 1;
874

    
875
//    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);
876
    /* interpolate PTS and DTS if they are not present */
877
    if(delay==0 || (delay==1 && pc)){
878
        if (presentation_delayed) {
879
            /* DTS = decompression timestamp */
880
            /* PTS = presentation timestamp */
881
            if (pkt->dts == AV_NOPTS_VALUE)
882
                pkt->dts = st->last_IP_pts;
883
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
884
            if (pkt->dts == AV_NOPTS_VALUE)
885
                pkt->dts = st->cur_dts;
886

    
887
            /* this is tricky: the dts must be incremented by the duration
888
            of the frame we are displaying, i.e. the last I- or P-frame */
889
            if (st->last_IP_duration == 0)
890
                st->last_IP_duration = pkt->duration;
891
            if(pkt->dts != AV_NOPTS_VALUE)
892
                st->cur_dts = pkt->dts + st->last_IP_duration;
893
            st->last_IP_duration  = pkt->duration;
894
            st->last_IP_pts= pkt->pts;
895
            /* cannot compute PTS if not present (we can compute it only
896
            by knowing the future */
897
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
898
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
899
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
900
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
901
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
902
                    pkt->pts += pkt->duration;
903
    //                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);
904
                }
905
            }
906

    
907
            /* presentation is not delayed : PTS and DTS are the same */
908
            if(pkt->pts == AV_NOPTS_VALUE)
909
                pkt->pts = pkt->dts;
910
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
911
            if(pkt->pts == AV_NOPTS_VALUE)
912
                pkt->pts = st->cur_dts;
913
            pkt->dts = pkt->pts;
914
            if(pkt->pts != AV_NOPTS_VALUE)
915
                st->cur_dts = pkt->pts + pkt->duration;
916
        }
917
    }
918

    
919
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
920
        st->pts_buffer[0]= pkt->pts;
921
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
922
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
923
        if(pkt->dts == AV_NOPTS_VALUE)
924
            pkt->dts= st->pts_buffer[0];
925
        if(delay>1){
926
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
927
        }
928
        if(pkt->dts > st->cur_dts)
929
            st->cur_dts = pkt->dts;
930
    }
931

    
932
//    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);
933

    
934
    /* update flags */
935
    if(is_intra_only(st->codec))
936
        pkt->flags |= PKT_FLAG_KEY;
937
    else if (pc) {
938
        pkt->flags = 0;
939
        /* keyframe computation */
940
            if (pc->pict_type == FF_I_TYPE)
941
                pkt->flags |= PKT_FLAG_KEY;
942
    }
943
}
944

    
945
void av_destruct_packet_nofree(AVPacket *pkt)
946
{
947
    pkt->data = NULL; pkt->size = 0;
948
}
949

    
950
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
951
{
952
    AVStream *st;
953
    int len, ret, i;
954

    
955
    av_init_packet(pkt);
956

    
957
    for(;;) {
958
        /* select current input stream component */
959
        st = s->cur_st;
960
        if (st) {
961
            if (!st->need_parsing || !st->parser) {
962
                /* no parsing needed: we just output the packet as is */
963
                /* raw data support */
964
                *pkt = s->cur_pkt;
965
                compute_pkt_fields(s, st, NULL, pkt);
966
                s->cur_st = NULL;
967
                break;
968
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
969
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
970
                                      s->cur_ptr, s->cur_len,
971
                                      s->cur_pkt.pts, s->cur_pkt.dts);
972
                s->cur_pkt.pts = AV_NOPTS_VALUE;
973
                s->cur_pkt.dts = AV_NOPTS_VALUE;
974
                /* increment read pointer */
975
                s->cur_ptr += len;
976
                s->cur_len -= len;
977

    
978
                /* return packet if any */
979
                if (pkt->size) {
980
                got_packet:
981
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
982
                    pkt->duration = 0;
983
                    pkt->stream_index = st->index;
984
                    pkt->pts = st->parser->pts;
985
                    pkt->dts = st->parser->dts;
986
                    pkt->destruct = av_destruct_packet_nofree;
987
                    compute_pkt_fields(s, st, st->parser, pkt);
988

    
989
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
990
                        ff_reduce_index(s, st->index);
991
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
992
                                           0, 0, AVINDEX_KEYFRAME);
993
                    }
994

    
995
                    break;
996
                }
997
            } else {
998
                /* free packet */
999
                av_free_packet(&s->cur_pkt);
1000
                s->cur_st = NULL;
1001
            }
1002
        } else {
1003
            /* read next packet */
1004
            ret = av_read_packet(s, &s->cur_pkt);
1005
            if (ret < 0) {
1006
                if (ret == AVERROR(EAGAIN))
1007
                    return ret;
1008
                /* return the last frames, if any */
1009
                for(i = 0; i < s->nb_streams; i++) {
1010
                    st = s->streams[i];
1011
                    if (st->parser && st->need_parsing) {
1012
                        av_parser_parse(st->parser, st->codec,
1013
                                        &pkt->data, &pkt->size,
1014
                                        NULL, 0,
1015
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1016
                        if (pkt->size)
1017
                            goto got_packet;
1018
                    }
1019
                }
1020
                /* no more packets: really terminate parsing */
1021
                return ret;
1022
            }
1023

    
1024
            if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
1025
               s->cur_pkt.dts != AV_NOPTS_VALUE &&
1026
               s->cur_pkt.pts < s->cur_pkt.dts){
1027
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1028
                    s->cur_pkt.stream_index,
1029
                    s->cur_pkt.pts,
1030
                    s->cur_pkt.dts,
1031
                    s->cur_pkt.size);
1032
//                av_free_packet(&s->cur_pkt);
1033
//                return -1;
1034
            }
1035

    
1036
            st = s->streams[s->cur_pkt.stream_index];
1037
            if(s->debug & FF_FDEBUG_TS)
1038
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
1039
                    s->cur_pkt.stream_index,
1040
                    s->cur_pkt.pts,
1041
                    s->cur_pkt.dts,
1042
                    s->cur_pkt.size,
1043
                    s->cur_pkt.flags);
1044

    
1045
            s->cur_st = st;
1046
            s->cur_ptr = s->cur_pkt.data;
1047
            s->cur_len = s->cur_pkt.size;
1048
            if (st->need_parsing && !st->parser) {
1049
                st->parser = av_parser_init(st->codec->codec_id);
1050
                if (!st->parser) {
1051
                    /* no parser available: just output the raw packets */
1052
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1053
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1054
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1055
                }
1056
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1057
                    st->parser->next_frame_offset=
1058
                    st->parser->cur_offset= s->cur_pkt.pos;
1059
                }
1060
            }
1061
        }
1062
    }
1063
    if(s->debug & FF_FDEBUG_TS)
1064
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1065
            pkt->stream_index,
1066
            pkt->pts,
1067
            pkt->dts,
1068
            pkt->size,
1069
            pkt->flags);
1070

    
1071
    return 0;
1072
}
1073

    
1074
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1075
{
1076
    AVPacketList *pktl;
1077
    int eof=0;
1078
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1079

    
1080
    for(;;){
1081
        pktl = s->packet_buffer;
1082
        if (pktl) {
1083
            AVPacket *next_pkt= &pktl->pkt;
1084

    
1085
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1086
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1087
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1088
                       && next_pkt->dts < pktl->pkt.dts
1089
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1090
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1091
                        next_pkt->pts= pktl->pkt.dts;
1092
                    }
1093
                    pktl= pktl->next;
1094
                }
1095
                pktl = s->packet_buffer;
1096
            }
1097

    
1098
            if(   next_pkt->pts != AV_NOPTS_VALUE
1099
               || next_pkt->dts == AV_NOPTS_VALUE
1100
               || !genpts || eof){
1101
                /* read packet from packet buffer, if there is data */
1102
                *pkt = *next_pkt;
1103
                s->packet_buffer = pktl->next;
1104
                av_free(pktl);
1105
                return 0;
1106
            }
1107
        }
1108
        if(genpts){
1109
            int ret= av_read_frame_internal(s, pkt);
1110
            if(ret<0){
1111
                if(pktl && ret != AVERROR(EAGAIN)){
1112
                    eof=1;
1113
                    continue;
1114
                }else
1115
                    return ret;
1116
            }
1117

    
1118
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1119
                                           &s->packet_buffer_end)) < 0)
1120
                return AVERROR(ENOMEM);
1121
        }else{
1122
            assert(!s->packet_buffer);
1123
            return av_read_frame_internal(s, pkt);
1124
        }
1125
    }
1126
}
1127

    
1128
/* XXX: suppress the packet queue */
1129
static void flush_packet_queue(AVFormatContext *s)
1130
{
1131
    AVPacketList *pktl;
1132

    
1133
    for(;;) {
1134
        pktl = s->packet_buffer;
1135
        if (!pktl)
1136
            break;
1137
        s->packet_buffer = pktl->next;
1138
        av_free_packet(&pktl->pkt);
1139
        av_free(pktl);
1140
    }
1141
}
1142

    
1143
/*******************************************************/
1144
/* seek support */
1145

    
1146
int av_find_default_stream_index(AVFormatContext *s)
1147
{
1148
    int first_audio_index = -1;
1149
    int i;
1150
    AVStream *st;
1151

    
1152
    if (s->nb_streams <= 0)
1153
        return -1;
1154
    for(i = 0; i < s->nb_streams; i++) {
1155
        st = s->streams[i];
1156
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1157
            return i;
1158
        }
1159
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1160
            first_audio_index = i;
1161
    }
1162
    return first_audio_index >= 0 ? first_audio_index : 0;
1163
}
1164

    
1165
/**
1166
 * Flush the frame reader.
1167
 */
1168
static void av_read_frame_flush(AVFormatContext *s)
1169
{
1170
    AVStream *st;
1171
    int i;
1172

    
1173
    flush_packet_queue(s);
1174

    
1175
    /* free previous packet */
1176
    if (s->cur_st) {
1177
        if (s->cur_st->parser)
1178
            av_free_packet(&s->cur_pkt);
1179
        s->cur_st = NULL;
1180
    }
1181
    /* fail safe */
1182
    s->cur_ptr = NULL;
1183
    s->cur_len = 0;
1184

    
1185
    /* for each stream, reset read state */
1186
    for(i = 0; i < s->nb_streams; i++) {
1187
        st = s->streams[i];
1188

    
1189
        if (st->parser) {
1190
            av_parser_close(st->parser);
1191
            st->parser = NULL;
1192
        }
1193
        st->last_IP_pts = AV_NOPTS_VALUE;
1194
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1195
    }
1196
}
1197

    
1198
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1199
    int i;
1200

    
1201
    for(i = 0; i < s->nb_streams; i++) {
1202
        AVStream *st = s->streams[i];
1203

    
1204
        st->cur_dts = av_rescale(timestamp,
1205
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1206
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1207
    }
1208
}
1209

    
1210
void ff_reduce_index(AVFormatContext *s, int stream_index)
1211
{
1212
    AVStream *st= s->streams[stream_index];
1213
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1214

    
1215
    if((unsigned)st->nb_index_entries >= max_entries){
1216
        int i;
1217
        for(i=0; 2*i<st->nb_index_entries; i++)
1218
            st->index_entries[i]= st->index_entries[2*i];
1219
        st->nb_index_entries= i;
1220
    }
1221
}
1222

    
1223
int av_add_index_entry(AVStream *st,
1224
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1225
{
1226
    AVIndexEntry *entries, *ie;
1227
    int index;
1228

    
1229
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1230
        return -1;
1231

    
1232
    entries = av_fast_realloc(st->index_entries,
1233
                              &st->index_entries_allocated_size,
1234
                              (st->nb_index_entries + 1) *
1235
                              sizeof(AVIndexEntry));
1236
    if(!entries)
1237
        return -1;
1238

    
1239
    st->index_entries= entries;
1240

    
1241
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1242

    
1243
    if(index<0){
1244
        index= st->nb_index_entries++;
1245
        ie= &entries[index];
1246
        assert(index==0 || ie[-1].timestamp < timestamp);
1247
    }else{
1248
        ie= &entries[index];
1249
        if(ie->timestamp != timestamp){
1250
            if(ie->timestamp <= timestamp)
1251
                return -1;
1252
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1253
            st->nb_index_entries++;
1254
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1255
            distance= ie->min_distance;
1256
    }
1257

    
1258
    ie->pos = pos;
1259
    ie->timestamp = timestamp;
1260
    ie->min_distance= distance;
1261
    ie->size= size;
1262
    ie->flags = flags;
1263

    
1264
    return index;
1265
}
1266

    
1267
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1268
                              int flags)
1269
{
1270
    AVIndexEntry *entries= st->index_entries;
1271
    int nb_entries= st->nb_index_entries;
1272
    int a, b, m;
1273
    int64_t timestamp;
1274

    
1275
    a = - 1;
1276
    b = nb_entries;
1277

    
1278
    while (b - a > 1) {
1279
        m = (a + b) >> 1;
1280
        timestamp = entries[m].timestamp;
1281
        if(timestamp >= wanted_timestamp)
1282
            b = m;
1283
        if(timestamp <= wanted_timestamp)
1284
            a = m;
1285
    }
1286
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1287

    
1288
    if(!(flags & AVSEEK_FLAG_ANY)){
1289
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1290
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1291
        }
1292
    }
1293

    
1294
    if(m == nb_entries)
1295
        return -1;
1296
    return  m;
1297
}
1298

    
1299
#define DEBUG_SEEK
1300

    
1301
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1302
    AVInputFormat *avif= s->iformat;
1303
    int64_t pos_min, pos_max, pos, pos_limit;
1304
    int64_t ts_min, ts_max, ts;
1305
    int index;
1306
    AVStream *st;
1307

    
1308
    if (stream_index < 0)
1309
        return -1;
1310

    
1311
#ifdef DEBUG_SEEK
1312
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1313
#endif
1314

    
1315
    ts_max=
1316
    ts_min= AV_NOPTS_VALUE;
1317
    pos_limit= -1; //gcc falsely says it may be uninitialized
1318

    
1319
    st= s->streams[stream_index];
1320
    if(st->index_entries){
1321
        AVIndexEntry *e;
1322

    
1323
        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()
1324
        index= FFMAX(index, 0);
1325
        e= &st->index_entries[index];
1326

    
1327
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1328
            pos_min= e->pos;
1329
            ts_min= e->timestamp;
1330
#ifdef DEBUG_SEEK
1331
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1332
               pos_min,ts_min);
1333
#endif
1334
        }else{
1335
            assert(index==0);
1336
        }
1337

    
1338
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1339
        assert(index < st->nb_index_entries);
1340
        if(index >= 0){
1341
            e= &st->index_entries[index];
1342
            assert(e->timestamp >= target_ts);
1343
            pos_max= e->pos;
1344
            ts_max= e->timestamp;
1345
            pos_limit= pos_max - e->min_distance;
1346
#ifdef DEBUG_SEEK
1347
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1348
               pos_max,pos_limit, ts_max);
1349
#endif
1350
        }
1351
    }
1352

    
1353
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1354
    if(pos<0)
1355
        return -1;
1356

    
1357
    /* do the seek */
1358
    url_fseek(s->pb, pos, SEEK_SET);
1359

    
1360
    av_update_cur_dts(s, st, ts);
1361

    
1362
    return 0;
1363
}
1364

    
1365
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 )){
1366
    int64_t pos, ts;
1367
    int64_t start_pos, filesize;
1368
    int no_change;
1369

    
1370
#ifdef DEBUG_SEEK
1371
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1372
#endif
1373

    
1374
    if(ts_min == AV_NOPTS_VALUE){
1375
        pos_min = s->data_offset;
1376
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1377
        if (ts_min == AV_NOPTS_VALUE)
1378
            return -1;
1379
    }
1380

    
1381
    if(ts_max == AV_NOPTS_VALUE){
1382
        int step= 1024;
1383
        filesize = url_fsize(s->pb);
1384
        pos_max = filesize - 1;
1385
        do{
1386
            pos_max -= step;
1387
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1388
            step += step;
1389
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1390
        if (ts_max == AV_NOPTS_VALUE)
1391
            return -1;
1392

    
1393
        for(;;){
1394
            int64_t tmp_pos= pos_max + 1;
1395
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1396
            if(tmp_ts == AV_NOPTS_VALUE)
1397
                break;
1398
            ts_max= tmp_ts;
1399
            pos_max= tmp_pos;
1400
            if(tmp_pos >= filesize)
1401
                break;
1402
        }
1403
        pos_limit= pos_max;
1404
    }
1405

    
1406
    if(ts_min > ts_max){
1407
        return -1;
1408
    }else if(ts_min == ts_max){
1409
        pos_limit= pos_min;
1410
    }
1411

    
1412
    no_change=0;
1413
    while (pos_min < pos_limit) {
1414
#ifdef DEBUG_SEEK
1415
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1416
               pos_min, pos_max,
1417
               ts_min, ts_max);
1418
#endif
1419
        assert(pos_limit <= pos_max);
1420

    
1421
        if(no_change==0){
1422
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1423
            // interpolate position (better than dichotomy)
1424
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1425
                + pos_min - approximate_keyframe_distance;
1426
        }else if(no_change==1){
1427
            // bisection, if interpolation failed to change min or max pos last time
1428
            pos = (pos_min + pos_limit)>>1;
1429
        }else{
1430
            /* linear search if bisection failed, can only happen if there
1431
               are very few or no keyframes between min/max */
1432
            pos=pos_min;
1433
        }
1434
        if(pos <= pos_min)
1435
            pos= pos_min + 1;
1436
        else if(pos > pos_limit)
1437
            pos= pos_limit;
1438
        start_pos= pos;
1439

    
1440
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1441
        if(pos == pos_max)
1442
            no_change++;
1443
        else
1444
            no_change=0;
1445
#ifdef DEBUG_SEEK
1446
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);
1447
#endif
1448
        if(ts == AV_NOPTS_VALUE){
1449
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1450
            return -1;
1451
        }
1452
        assert(ts != AV_NOPTS_VALUE);
1453
        if (target_ts <= ts) {
1454
            pos_limit = start_pos - 1;
1455
            pos_max = pos;
1456
            ts_max = ts;
1457
        }
1458
        if (target_ts >= ts) {
1459
            pos_min = pos;
1460
            ts_min = ts;
1461
        }
1462
    }
1463

    
1464
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1465
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1466
#ifdef DEBUG_SEEK
1467
    pos_min = pos;
1468
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1469
    pos_min++;
1470
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1471
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1472
           pos, ts_min, target_ts, ts_max);
1473
#endif
1474
    *ts_ret= ts;
1475
    return pos;
1476
}
1477

    
1478
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1479
    int64_t pos_min, pos_max;
1480
#if 0
1481
    AVStream *st;
1482

1483
    if (stream_index < 0)
1484
        return -1;
1485

1486
    st= s->streams[stream_index];
1487
#endif
1488

    
1489
    pos_min = s->data_offset;
1490
    pos_max = url_fsize(s->pb) - 1;
1491

    
1492
    if     (pos < pos_min) pos= pos_min;
1493
    else if(pos > pos_max) pos= pos_max;
1494

    
1495
    url_fseek(s->pb, pos, SEEK_SET);
1496

    
1497
#if 0
1498
    av_update_cur_dts(s, st, ts);
1499
#endif
1500
    return 0;
1501
}
1502

    
1503
static int av_seek_frame_generic(AVFormatContext *s,
1504
                                 int stream_index, int64_t timestamp, int flags)
1505
{
1506
    int index, ret;
1507
    AVStream *st;
1508
    AVIndexEntry *ie;
1509

    
1510
    st = s->streams[stream_index];
1511

    
1512
    index = av_index_search_timestamp(st, timestamp, flags);
1513

    
1514
    if(index < 0 || index==st->nb_index_entries-1){
1515
        int i;
1516
        AVPacket pkt;
1517

    
1518
        if(st->nb_index_entries){
1519
            assert(st->index_entries);
1520
            ie= &st->index_entries[st->nb_index_entries-1];
1521
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1522
                return ret;
1523
            av_update_cur_dts(s, st, ie->timestamp);
1524
        }else{
1525
            if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1526
                return ret;
1527
        }
1528
        for(i=0;; i++) {
1529
            int ret = av_read_frame(s, &pkt);
1530
            if(ret<0)
1531
                break;
1532
            av_free_packet(&pkt);
1533
            if(stream_index == pkt.stream_index){
1534
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1535
                    break;
1536
            }
1537
        }
1538
        index = av_index_search_timestamp(st, timestamp, flags);
1539
    }
1540
    if (index < 0)
1541
        return -1;
1542

    
1543
    av_read_frame_flush(s);
1544
    if (s->iformat->read_seek){
1545
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1546
            return 0;
1547
    }
1548
    ie = &st->index_entries[index];
1549
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1550
        return ret;
1551
    av_update_cur_dts(s, st, ie->timestamp);
1552

    
1553
    return 0;
1554
}
1555

    
1556
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1557
{
1558
    int ret;
1559
    AVStream *st;
1560

    
1561
    av_read_frame_flush(s);
1562

    
1563
    if(flags & AVSEEK_FLAG_BYTE)
1564
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1565

    
1566
    if(stream_index < 0){
1567
        stream_index= av_find_default_stream_index(s);
1568
        if(stream_index < 0)
1569
            return -1;
1570

    
1571
        st= s->streams[stream_index];
1572
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1573
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1574
    }
1575

    
1576
    /* first, we try the format specific seek */
1577
    if (s->iformat->read_seek)
1578
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1579
    else
1580
        ret = -1;
1581
    if (ret >= 0) {
1582
        return 0;
1583
    }
1584

    
1585
    if(s->iformat->read_timestamp)
1586
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1587
    else
1588
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1589
}
1590

    
1591
/*******************************************************/
1592

    
1593
/**
1594
 * Returns TRUE if the stream has accurate duration in any stream.
1595
 *
1596
 * @return TRUE if the stream has accurate duration for at least one component.
1597
 */
1598
static int av_has_duration(AVFormatContext *ic)
1599
{
1600
    int i;
1601
    AVStream *st;
1602

    
1603
    for(i = 0;i < ic->nb_streams; i++) {
1604
        st = ic->streams[i];
1605
        if (st->duration != AV_NOPTS_VALUE)
1606
            return 1;
1607
    }
1608
    return 0;
1609
}
1610

    
1611
/**
1612
 * Estimate the stream timings from the one of each components.
1613
 *
1614
 * Also computes the global bitrate if possible.
1615
 */
1616
static void av_update_stream_timings(AVFormatContext *ic)
1617
{
1618
    int64_t start_time, start_time1, end_time, end_time1;
1619
    int64_t duration, duration1;
1620
    int i;
1621
    AVStream *st;
1622

    
1623
    start_time = INT64_MAX;
1624
    end_time = INT64_MIN;
1625
    duration = INT64_MIN;
1626
    for(i = 0;i < ic->nb_streams; i++) {
1627
        st = ic->streams[i];
1628
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1629
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1630
            if (start_time1 < start_time)
1631
                start_time = start_time1;
1632
            if (st->duration != AV_NOPTS_VALUE) {
1633
                end_time1 = start_time1
1634
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1635
                if (end_time1 > end_time)
1636
                    end_time = end_time1;
1637
            }
1638
        }
1639
        if (st->duration != AV_NOPTS_VALUE) {
1640
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1641
            if (duration1 > duration)
1642
                duration = duration1;
1643
        }
1644
    }
1645
    if (start_time != INT64_MAX) {
1646
        ic->start_time = start_time;
1647
        if (end_time != INT64_MIN) {
1648
            if (end_time - start_time > duration)
1649
                duration = end_time - start_time;
1650
        }
1651
    }
1652
    if (duration != INT64_MIN) {
1653
        ic->duration = duration;
1654
        if (ic->file_size > 0) {
1655
            /* compute the bitrate */
1656
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1657
                (double)ic->duration;
1658
        }
1659
    }
1660
}
1661

    
1662
static void fill_all_stream_timings(AVFormatContext *ic)
1663
{
1664
    int i;
1665
    AVStream *st;
1666

    
1667
    av_update_stream_timings(ic);
1668
    for(i = 0;i < ic->nb_streams; i++) {
1669
        st = ic->streams[i];
1670
        if (st->start_time == AV_NOPTS_VALUE) {
1671
            if(ic->start_time != AV_NOPTS_VALUE)
1672
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1673
            if(ic->duration != AV_NOPTS_VALUE)
1674
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1675
        }
1676
    }
1677
}
1678

    
1679
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1680
{
1681
    int64_t filesize, duration;
1682
    int bit_rate, i;
1683
    AVStream *st;
1684

    
1685
    /* if bit_rate is already set, we believe it */
1686
    if (ic->bit_rate == 0) {
1687
        bit_rate = 0;
1688
        for(i=0;i<ic->nb_streams;i++) {
1689
            st = ic->streams[i];
1690
            bit_rate += st->codec->bit_rate;
1691
        }
1692
        ic->bit_rate = bit_rate;
1693
    }
1694

    
1695
    /* if duration is already set, we believe it */
1696
    if (ic->duration == AV_NOPTS_VALUE &&
1697
        ic->bit_rate != 0 &&
1698
        ic->file_size != 0)  {
1699
        filesize = ic->file_size;
1700
        if (filesize > 0) {
1701
            for(i = 0; i < ic->nb_streams; i++) {
1702
                st = ic->streams[i];
1703
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1704
                if (st->duration == AV_NOPTS_VALUE)
1705
                    st->duration = duration;
1706
            }
1707
        }
1708
    }
1709
}
1710

    
1711
#define DURATION_MAX_READ_SIZE 250000
1712

    
1713
/* only usable for MPEG-PS streams */
1714
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1715
{
1716
    AVPacket pkt1, *pkt = &pkt1;
1717
    AVStream *st;
1718
    int read_size, i, ret;
1719
    int64_t end_time;
1720
    int64_t filesize, offset, duration;
1721

    
1722
    /* free previous packet */
1723
    if (ic->cur_st && ic->cur_st->parser)
1724
        av_free_packet(&ic->cur_pkt);
1725
    ic->cur_st = NULL;
1726

    
1727
    /* flush packet queue */
1728
    flush_packet_queue(ic);
1729

    
1730
    for(i=0;i<ic->nb_streams;i++) {
1731
        st = ic->streams[i];
1732
        if (st->parser) {
1733
            av_parser_close(st->parser);
1734
            st->parser= NULL;
1735
        }
1736
    }
1737

    
1738
    /* we read the first packets to get the first PTS (not fully
1739
       accurate, but it is enough now) */
1740
    url_fseek(ic->pb, 0, SEEK_SET);
1741
    read_size = 0;
1742
    for(;;) {
1743
        if (read_size >= DURATION_MAX_READ_SIZE)
1744
            break;
1745
        /* if all info is available, we can stop */
1746
        for(i = 0;i < ic->nb_streams; i++) {
1747
            st = ic->streams[i];
1748
            if (st->start_time == AV_NOPTS_VALUE)
1749
                break;
1750
        }
1751
        if (i == ic->nb_streams)
1752
            break;
1753

    
1754
        ret = av_read_packet(ic, pkt);
1755
        if (ret != 0)
1756
            break;
1757
        read_size += pkt->size;
1758
        st = ic->streams[pkt->stream_index];
1759
        if (pkt->pts != AV_NOPTS_VALUE) {
1760
            if (st->start_time == AV_NOPTS_VALUE)
1761
                st->start_time = pkt->pts;
1762
        }
1763
        av_free_packet(pkt);
1764
    }
1765

    
1766
    /* estimate the end time (duration) */
1767
    /* XXX: may need to support wrapping */
1768
    filesize = ic->file_size;
1769
    offset = filesize - DURATION_MAX_READ_SIZE;
1770
    if (offset < 0)
1771
        offset = 0;
1772

    
1773
    url_fseek(ic->pb, offset, SEEK_SET);
1774
    read_size = 0;
1775
    for(;;) {
1776
        if (read_size >= DURATION_MAX_READ_SIZE)
1777
            break;
1778

    
1779
        ret = av_read_packet(ic, pkt);
1780
        if (ret != 0)
1781
            break;
1782
        read_size += pkt->size;
1783
        st = ic->streams[pkt->stream_index];
1784
        if (pkt->pts != AV_NOPTS_VALUE &&
1785
            st->start_time != AV_NOPTS_VALUE) {
1786
            end_time = pkt->pts;
1787
            duration = end_time - st->start_time;
1788
            if (duration > 0) {
1789
                if (st->duration == AV_NOPTS_VALUE ||
1790
                    st->duration < duration)
1791
                    st->duration = duration;
1792
            }
1793
        }
1794
        av_free_packet(pkt);
1795
    }
1796

    
1797
    fill_all_stream_timings(ic);
1798

    
1799
    url_fseek(ic->pb, old_offset, SEEK_SET);
1800
    for(i=0; i<ic->nb_streams; i++){
1801
        st= ic->streams[i];
1802
        st->cur_dts= st->first_dts;
1803
        st->last_IP_pts = AV_NOPTS_VALUE;
1804
    }
1805
}
1806

    
1807
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1808
{
1809
    int64_t file_size;
1810

    
1811
    /* get the file size, if possible */
1812
    if (ic->iformat->flags & AVFMT_NOFILE) {
1813
        file_size = 0;
1814
    } else {
1815
        file_size = url_fsize(ic->pb);
1816
        if (file_size < 0)
1817
            file_size = 0;
1818
    }
1819
    ic->file_size = file_size;
1820

    
1821
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1822
         !strcmp(ic->iformat->name, "mpegts")) &&
1823
        file_size && !url_is_streamed(ic->pb)) {
1824
        /* get accurate estimate from the PTSes */
1825
        av_estimate_timings_from_pts(ic, old_offset);
1826
    } else if (av_has_duration(ic)) {
1827
        /* at least one component has timings - we use them for all
1828
           the components */
1829
        fill_all_stream_timings(ic);
1830
    } else {
1831
        /* less precise: use bitrate info */
1832
        av_estimate_timings_from_bit_rate(ic);
1833
    }
1834
    av_update_stream_timings(ic);
1835

    
1836
#if 0
1837
    {
1838
        int i;
1839
        AVStream *st;
1840
        for(i = 0;i < ic->nb_streams; i++) {
1841
            st = ic->streams[i];
1842
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1843
               i, (double)st->start_time / AV_TIME_BASE,
1844
               (double)st->duration / AV_TIME_BASE);
1845
        }
1846
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1847
               (double)ic->start_time / AV_TIME_BASE,
1848
               (double)ic->duration / AV_TIME_BASE,
1849
               ic->bit_rate / 1000);
1850
    }
1851
#endif
1852
}
1853

    
1854
static int has_codec_parameters(AVCodecContext *enc)
1855
{
1856
    int val;
1857
    switch(enc->codec_type) {
1858
    case CODEC_TYPE_AUDIO:
1859
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1860
        if(!enc->frame_size &&
1861
           (enc->codec_id == CODEC_ID_VORBIS ||
1862
            enc->codec_id == CODEC_ID_AAC))
1863
            return 0;
1864
        break;
1865
    case CODEC_TYPE_VIDEO:
1866
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1867
        break;
1868
    default:
1869
        val = 1;
1870
        break;
1871
    }
1872
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1873
}
1874

    
1875
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1876
{
1877
    int16_t *samples;
1878
    AVCodec *codec;
1879
    int got_picture, data_size, ret=0;
1880
    AVFrame picture;
1881

    
1882
  if(!st->codec->codec){
1883
    codec = avcodec_find_decoder(st->codec->codec_id);
1884
    if (!codec)
1885
        return -1;
1886
    ret = avcodec_open(st->codec, codec);
1887
    if (ret < 0)
1888
        return ret;
1889
  }
1890

    
1891
  if(!has_codec_parameters(st->codec)){
1892
    switch(st->codec->codec_type) {
1893
    case CODEC_TYPE_VIDEO:
1894
        ret = avcodec_decode_video(st->codec, &picture,
1895
                                   &got_picture, data, size);
1896
        break;
1897
    case CODEC_TYPE_AUDIO:
1898
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1899
        samples = av_malloc(data_size);
1900
        if (!samples)
1901
            goto fail;
1902
        ret = avcodec_decode_audio2(st->codec, samples,
1903
                                    &data_size, data, size);
1904
        av_free(samples);
1905
        break;
1906
    default:
1907
        break;
1908
    }
1909
  }
1910
 fail:
1911
    return ret;
1912
}
1913

    
1914
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1915
{
1916
    while (tags->id != CODEC_ID_NONE) {
1917
        if (tags->id == id)
1918
            return tags->tag;
1919
        tags++;
1920
    }
1921
    return 0;
1922
}
1923

    
1924
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1925
{
1926
    int i;
1927
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1928
        if(tag == tags[i].tag)
1929
            return tags[i].id;
1930
    }
1931
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1932
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1933
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1934
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1935
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1936
            return tags[i].id;
1937
    }
1938
    return CODEC_ID_NONE;
1939
}
1940

    
1941
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1942
{
1943
    int i;
1944
    for(i=0; tags && tags[i]; i++){
1945
        int tag= codec_get_tag(tags[i], id);
1946
        if(tag) return tag;
1947
    }
1948
    return 0;
1949
}
1950

    
1951
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1952
{
1953
    int i;
1954
    for(i=0; tags && tags[i]; i++){
1955
        enum CodecID id= codec_get_id(tags[i], tag);
1956
        if(id!=CODEC_ID_NONE) return id;
1957
    }
1958
    return CODEC_ID_NONE;
1959
}
1960

    
1961
static void compute_chapters_end(AVFormatContext *s)
1962
{
1963
    unsigned int i;
1964

    
1965
    for (i=0; i+1<s->nb_chapters; i++)
1966
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1967
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1968
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1969
            s->chapters[i]->end = s->chapters[i+1]->start;
1970
        }
1971

    
1972
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1973
        assert(s->start_time != AV_NOPTS_VALUE);
1974
        assert(s->duration > 0);
1975
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1976
                                           AV_TIME_BASE_Q,
1977
                                           s->chapters[i]->time_base);
1978
    }
1979
}
1980

    
1981
/* absolute maximum size we read until we abort */
1982
#define MAX_READ_SIZE        5000000
1983

    
1984
#define MAX_STD_TIMEBASES (60*12+5)
1985
static int get_std_framerate(int i){
1986
    if(i<60*12) return i*1001;
1987
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1988
}
1989

    
1990
/*
1991
 * Is the time base unreliable.
1992
 * This is a heuristic to balance between quick acceptance of the values in
1993
 * the headers vs. some extra checks.
1994
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1995
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1996
 * And there are "variable" fps files this needs to detect as well.
1997
 */
1998
static int tb_unreliable(AVCodecContext *c){
1999
    if(   c->time_base.den >= 101L*c->time_base.num
2000
       || c->time_base.den <    5L*c->time_base.num
2001
/*       || c->codec_tag == ff_get_fourcc("DIVX")
2002
       || c->codec_tag == ff_get_fourcc("XVID")*/
2003
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
2004
        return 1;
2005
    return 0;
2006
}
2007

    
2008
int av_find_stream_info(AVFormatContext *ic)
2009
{
2010
    int i, count, ret, read_size, j;
2011
    AVStream *st;
2012
    AVPacket pkt1, *pkt;
2013
    int64_t last_dts[MAX_STREAMS];
2014
    int duration_count[MAX_STREAMS]={0};
2015
    double (*duration_error)[MAX_STD_TIMEBASES];
2016
    int64_t old_offset = url_ftell(ic->pb);
2017
    int64_t codec_info_duration[MAX_STREAMS]={0};
2018
    int codec_info_nb_frames[MAX_STREAMS]={0};
2019

    
2020
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2021
    if (!duration_error) return AVERROR(ENOMEM);
2022

    
2023
    for(i=0;i<ic->nb_streams;i++) {
2024
        st = ic->streams[i];
2025
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2026
/*            if(!st->time_base.num)
2027
                st->time_base= */
2028
            if(!st->codec->time_base.num)
2029
                st->codec->time_base= st->time_base;
2030
        }
2031
        //only for the split stuff
2032
        if (!st->parser) {
2033
            st->parser = av_parser_init(st->codec->codec_id);
2034
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2035
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2036
            }
2037
        }
2038
    }
2039

    
2040
    for(i=0;i<MAX_STREAMS;i++){
2041
        last_dts[i]= AV_NOPTS_VALUE;
2042
    }
2043

    
2044
    count = 0;
2045
    read_size = 0;
2046
    for(;;) {
2047
        /* check if one codec still needs to be handled */
2048
        for(i=0;i<ic->nb_streams;i++) {
2049
            st = ic->streams[i];
2050
            if (!has_codec_parameters(st->codec))
2051
                break;
2052
            /* variable fps and no guess at the real fps */
2053
            if(   tb_unreliable(st->codec)
2054
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2055
                break;
2056
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2057
                break;
2058
            if(st->first_dts == AV_NOPTS_VALUE)
2059
                break;
2060
        }
2061
        if (i == ic->nb_streams) {
2062
            /* NOTE: if the format has no header, then we need to read
2063
               some packets to get most of the streams, so we cannot
2064
               stop here */
2065
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2066
                /* if we found the info for all the codecs, we can stop */
2067
                ret = count;
2068
                break;
2069
            }
2070
        }
2071
        /* we did not get all the codec info, but we read too much data */
2072
        if (read_size >= MAX_READ_SIZE) {
2073
            ret = count;
2074
            break;
2075
        }
2076

    
2077
        /* NOTE: a new stream can be added there if no header in file
2078
           (AVFMTCTX_NOHEADER) */
2079
        ret = av_read_frame_internal(ic, &pkt1);
2080
        if (ret < 0) {
2081
            /* EOF or error */
2082
            ret = -1; /* we could not have all the codec parameters before EOF */
2083
            for(i=0;i<ic->nb_streams;i++) {
2084
                st = ic->streams[i];
2085
                if (!has_codec_parameters(st->codec)){
2086
                    char buf[256];
2087
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2088
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2089
                } else {
2090
                    ret = 0;
2091
                }
2092
            }
2093
            break;
2094
        }
2095

    
2096
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2097
        if(av_dup_packet(pkt) < 0) {
2098
            av_free(duration_error);
2099
            return AVERROR(ENOMEM);
2100
        }
2101

    
2102
        read_size += pkt->size;
2103

    
2104
        st = ic->streams[pkt->stream_index];
2105
        if(codec_info_nb_frames[st->index]>1)
2106
            codec_info_duration[st->index] += pkt->duration;
2107
        if (pkt->duration != 0)
2108
            codec_info_nb_frames[st->index]++;
2109

    
2110
        {
2111
            int index= pkt->stream_index;
2112
            int64_t last= last_dts[index];
2113
            int64_t duration= pkt->dts - last;
2114

    
2115
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2116
                double dur= duration * av_q2d(st->time_base);
2117

    
2118
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2119
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2120
                if(duration_count[index] < 2)
2121
                    memset(duration_error[index], 0, sizeof(*duration_error));
2122
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2123
                    int framerate= get_std_framerate(i);
2124
                    int ticks= lrintf(dur*framerate/(1001*12));
2125
                    double error= dur - ticks*1001*12/(double)framerate;
2126
                    duration_error[index][i] += error*error;
2127
                }
2128
                duration_count[index]++;
2129
            }
2130
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2131
                last_dts[pkt->stream_index]= pkt->dts;
2132
        }
2133
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2134
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2135
            if(i){
2136
                st->codec->extradata_size= i;
2137
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2138
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2139
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2140
            }
2141
        }
2142

    
2143
        /* if still no information, we try to open the codec and to
2144
           decompress the frame. We try to avoid that in most cases as
2145
           it takes longer and uses more memory. For MPEG-4, we need to
2146
           decompress for QuickTime. */
2147
        if (!has_codec_parameters(st->codec) /*&&
2148
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2149
             st->codec->codec_id == CODEC_ID_H264 ||
2150
             st->codec->codec_id == CODEC_ID_H263 ||
2151
             st->codec->codec_id == CODEC_ID_H261 ||
2152
             st->codec->codec_id == CODEC_ID_VORBIS ||
2153
             st->codec->codec_id == CODEC_ID_MJPEG ||
2154
             st->codec->codec_id == CODEC_ID_PNG ||
2155
             st->codec->codec_id == CODEC_ID_PAM ||
2156
             st->codec->codec_id == CODEC_ID_PGM ||
2157
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2158
             st->codec->codec_id == CODEC_ID_PBM ||
2159
             st->codec->codec_id == CODEC_ID_PPM ||
2160
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2161
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2162
            try_decode_frame(st, pkt->data, pkt->size);
2163

    
2164
        if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2165
            break;
2166
        }
2167
        count++;
2168
    }
2169

    
2170
    // close codecs which were opened in try_decode_frame()
2171
    for(i=0;i<ic->nb_streams;i++) {
2172
        st = ic->streams[i];
2173
        if(st->codec->codec)
2174
            avcodec_close(st->codec);
2175
    }
2176
    for(i=0;i<ic->nb_streams;i++) {
2177
        st = ic->streams[i];
2178
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2179
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2180
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2181

    
2182
            if(duration_count[i]
2183
               && tb_unreliable(st->codec) /*&&
2184
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2185
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2186
                double best_error= 2*av_q2d(st->time_base);
2187
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2188

    
2189
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2190
                    double error= duration_error[i][j] * get_std_framerate(j);
2191
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2192
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2193
                    if(error < best_error){
2194
                        best_error= error;
2195
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2196
                    }
2197
                }
2198
            }
2199

    
2200
            if (!st->r_frame_rate.num){
2201
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2202
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2203
                    st->r_frame_rate.num = st->codec->time_base.den;
2204
                    st->r_frame_rate.den = st->codec->time_base.num;
2205
                }else{
2206
                    st->r_frame_rate.num = st->time_base.den;
2207
                    st->r_frame_rate.den = st->time_base.num;
2208
                }
2209
            }
2210
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2211
            if(!st->codec->bits_per_coded_sample)
2212
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2213
        }
2214
    }
2215

    
2216
    av_estimate_timings(ic, old_offset);
2217

    
2218
    compute_chapters_end(ic);
2219

    
2220
#if 0
2221
    /* correct DTS for B-frame streams with no timestamps */
2222
    for(i=0;i<ic->nb_streams;i++) {
2223
        st = ic->streams[i];
2224
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2225
            if(b-frames){
2226
                ppktl = &ic->packet_buffer;
2227
                while(ppkt1){
2228
                    if(ppkt1->stream_index != i)
2229
                        continue;
2230
                    if(ppkt1->pkt->dts < 0)
2231
                        break;
2232
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2233
                        break;
2234
                    ppkt1->pkt->dts -= delta;
2235
                    ppkt1= ppkt1->next;
2236
                }
2237
                if(ppkt1)
2238
                    continue;
2239
                st->cur_dts -= delta;
2240
            }
2241
        }
2242
    }
2243
#endif
2244

    
2245
    av_free(duration_error);
2246

    
2247
    return ret;
2248
}
2249

    
2250
/*******************************************************/
2251

    
2252
int av_read_play(AVFormatContext *s)
2253
{
2254
    if (s->iformat->read_play)
2255
        return s->iformat->read_play(s);
2256
    if (s->pb)
2257
        return av_url_read_fpause(s->pb, 0);
2258
    return AVERROR(ENOSYS);
2259
}
2260

    
2261
int av_read_pause(AVFormatContext *s)
2262
{
2263
    if (s->iformat->read_pause)
2264
        return s->iformat->read_pause(s);
2265
    if (s->pb)
2266
        return av_url_read_fpause(s->pb, 1);
2267
    return AVERROR(ENOSYS);
2268
}
2269

    
2270
void av_close_input_stream(AVFormatContext *s)
2271
{
2272
    int i;
2273
    AVStream *st;
2274

    
2275
    /* free previous packet */
2276
    if (s->cur_st && s->cur_st->parser)
2277
        av_free_packet(&s->cur_pkt);
2278

    
2279
    if (s->iformat->read_close)
2280
        s->iformat->read_close(s);
2281
    for(i=0;i<s->nb_streams;i++) {
2282
        /* free all data in a stream component */
2283
        st = s->streams[i];
2284
        if (st->parser) {
2285
            av_parser_close(st->parser);
2286
        }
2287
        av_free(st->index_entries);
2288
        av_free(st->codec->extradata);
2289
        av_free(st->codec);
2290
        av_free(st->filename);
2291
        av_free(st->priv_data);
2292
        av_free(st);
2293
    }
2294
    for(i=s->nb_programs-1; i>=0; i--) {
2295
        av_freep(&s->programs[i]->provider_name);
2296
        av_freep(&s->programs[i]->name);
2297
        av_freep(&s->programs[i]->stream_index);
2298
        av_freep(&s->programs[i]);
2299
    }
2300
    av_freep(&s->programs);
2301
    flush_packet_queue(s);
2302
    av_freep(&s->priv_data);
2303
    while(s->nb_chapters--) {
2304
        av_free(s->chapters[s->nb_chapters]->title);
2305
        av_free(s->chapters[s->nb_chapters]);
2306
    }
2307
    av_freep(&s->chapters);
2308
    av_free(s);
2309
}
2310

    
2311
void av_close_input_file(AVFormatContext *s)
2312
{
2313
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2314
    av_close_input_stream(s);
2315
    if (pb)
2316
        url_fclose(pb);
2317
}
2318

    
2319
AVStream *av_new_stream(AVFormatContext *s, int id)
2320
{
2321
    AVStream *st;
2322
    int i;
2323

    
2324
    if (s->nb_streams >= MAX_STREAMS)
2325
        return NULL;
2326

    
2327
    st = av_mallocz(sizeof(AVStream));
2328
    if (!st)
2329
        return NULL;
2330

    
2331
    st->codec= avcodec_alloc_context();
2332
    if (s->iformat) {
2333
        /* no default bitrate if decoding */
2334
        st->codec->bit_rate = 0;
2335
    }
2336
    st->index = s->nb_streams;
2337
    st->id = id;
2338
    st->start_time = AV_NOPTS_VALUE;
2339
    st->duration = AV_NOPTS_VALUE;
2340
        /* we set the current DTS to 0 so that formats without any timestamps
2341
           but durations get some timestamps, formats with some unknown
2342
           timestamps have their first few packets buffered and the
2343
           timestamps corrected before they are returned to the user */
2344
    st->cur_dts = 0;
2345
    st->first_dts = AV_NOPTS_VALUE;
2346

    
2347
    /* default pts setting is MPEG-like */
2348
    av_set_pts_info(st, 33, 1, 90000);
2349
    st->last_IP_pts = AV_NOPTS_VALUE;
2350
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2351
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2352

    
2353
    st->sample_aspect_ratio = (AVRational){0,1};
2354

    
2355
    s->streams[s->nb_streams++] = st;
2356
    return st;
2357
}
2358

    
2359
AVProgram *av_new_program(AVFormatContext *ac, int id)
2360
{
2361
    AVProgram *program=NULL;
2362
    int i;
2363

    
2364
#ifdef DEBUG_SI
2365
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2366
#endif
2367

    
2368
    for(i=0; i<ac->nb_programs; i++)
2369
        if(ac->programs[i]->id == id)
2370
            program = ac->programs[i];
2371

    
2372
    if(!program){
2373
        program = av_mallocz(sizeof(AVProgram));
2374
        if (!program)
2375
            return NULL;
2376
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2377
        program->discard = AVDISCARD_NONE;
2378
    }
2379
    program->id = id;
2380

    
2381
    return program;
2382
}
2383

    
2384
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2385
{
2386
    assert(!provider_name == !name);
2387
    if(name){
2388
        av_free(program->provider_name);
2389
        av_free(program->         name);
2390
        program->provider_name = av_strdup(provider_name);
2391
        program->         name = av_strdup(         name);
2392
    }
2393
}
2394

    
2395
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2396
{
2397
    AVChapter *chapter = NULL;
2398
    int i;
2399

    
2400
    for(i=0; i<s->nb_chapters; i++)
2401
        if(s->chapters[i]->id == id)
2402
            chapter = s->chapters[i];
2403

    
2404
    if(!chapter){
2405
        chapter= av_mallocz(sizeof(AVChapter));
2406
        if(!chapter)
2407
            return NULL;
2408
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2409
    }
2410
    av_free(chapter->title);
2411
    chapter->title = av_strdup(title);
2412
    chapter->id    = id;
2413
    chapter->time_base= time_base;
2414
    chapter->start = start;
2415
    chapter->end   = end;
2416

    
2417
    return chapter;
2418
}
2419

    
2420
/************************************************************/
2421
/* output media file */
2422

    
2423
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2424
{
2425
    int ret;
2426

    
2427
    if (s->oformat->priv_data_size > 0) {
2428
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2429
        if (!s->priv_data)
2430
            return AVERROR(ENOMEM);
2431
    } else
2432
        s->priv_data = NULL;
2433

    
2434
    if (s->oformat->set_parameters) {
2435
        ret = s->oformat->set_parameters(s, ap);
2436
        if (ret < 0)
2437
            return ret;
2438
    }
2439
    return 0;
2440
}
2441

    
2442
int av_write_header(AVFormatContext *s)
2443
{
2444
    int ret, i;
2445
    AVStream *st;
2446

    
2447
    // some sanity checks
2448
    for(i=0;i<s->nb_streams;i++) {
2449
        st = s->streams[i];
2450

    
2451
        switch (st->codec->codec_type) {
2452
        case CODEC_TYPE_AUDIO:
2453
            if(st->codec->sample_rate<=0){
2454
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2455
                return -1;
2456
            }
2457
            if(!st->codec->block_align)
2458
                st->codec->block_align = st->codec->channels *
2459
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2460
            break;
2461
        case CODEC_TYPE_VIDEO:
2462
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2463
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2464
                return -1;
2465
            }
2466
            if(st->codec->width<=0 || st->codec->height<=0){
2467
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2468
                return -1;
2469
            }
2470
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2471
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2472
                return -1;
2473
            }
2474
            break;
2475
        }
2476

    
2477
        if(s->oformat->codec_tag){
2478
            if(st->codec->codec_tag){
2479
                //FIXME
2480
                //check that tag + id is in the table
2481
                //if neither is in the table -> OK
2482
                //if tag is in the table with another id -> FAIL
2483
                //if id is in the table with another tag -> FAIL unless strict < ?
2484
            }else
2485
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2486
        }
2487
    }
2488

    
2489
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2490
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2491
        if (!s->priv_data)
2492
            return AVERROR(ENOMEM);
2493
    }
2494

    
2495
    if(s->oformat->write_header){
2496
        ret = s->oformat->write_header(s);
2497
        if (ret < 0)
2498
            return ret;
2499
    }
2500

    
2501
    /* init PTS generation */
2502
    for(i=0;i<s->nb_streams;i++) {
2503
        int64_t den = AV_NOPTS_VALUE;
2504
        st = s->streams[i];
2505

    
2506
        switch (st->codec->codec_type) {
2507
        case CODEC_TYPE_AUDIO:
2508
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2509
            break;
2510
        case CODEC_TYPE_VIDEO:
2511
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2512
            break;
2513
        default:
2514
            break;
2515
        }
2516
        if (den != AV_NOPTS_VALUE) {
2517
            if (den <= 0)
2518
                return AVERROR_INVALIDDATA;
2519
            av_frac_init(&st->pts, 0, 0, den);
2520
        }
2521
    }
2522
    return 0;
2523
}
2524

    
2525
//FIXME merge with compute_pkt_fields
2526
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2527
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2528
    int num, den, frame_size, i;
2529

    
2530
//    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);
2531

    
2532
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2533
        return -1;*/
2534

    
2535
    /* duration field */
2536
    if (pkt->duration == 0) {
2537
        compute_frame_duration(&num, &den, st, NULL, pkt);
2538
        if (den && num) {
2539
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2540
        }
2541
    }
2542

    
2543
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2544
        pkt->pts= pkt->dts;
2545

    
2546
    //XXX/FIXME this is a temporary hack until all encoders output pts
2547
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2548
        pkt->dts=
2549
//        pkt->pts= st->cur_dts;
2550
        pkt->pts= st->pts.val;
2551
    }
2552

    
2553
    //calculate dts from pts
2554
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2555
        st->pts_buffer[0]= pkt->pts;
2556
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2557
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2558
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2559
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2560

    
2561
        pkt->dts= st->pts_buffer[0];
2562
    }
2563

    
2564
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2565
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2566
        return -1;
2567
    }
2568
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2569
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2570
        return -1;
2571
    }
2572

    
2573
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2574
    st->cur_dts= pkt->dts;
2575
    st->pts.val= pkt->dts;
2576

    
2577
    /* update pts */
2578
    switch (st->codec->codec_type) {
2579
    case CODEC_TYPE_AUDIO:
2580
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2581

    
2582
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2583
           likely equal to the encoder delay, but it would be better if we
2584
           had the real timestamps from the encoder */
2585
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2586
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2587
        }
2588
        break;
2589
    case CODEC_TYPE_VIDEO:
2590
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2591
        break;
2592
    default:
2593
        break;
2594
    }
2595
    return 0;
2596
}
2597

    
2598
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2599
{
2600
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2601

    
2602
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2603
        return ret;
2604

    
2605
    ret= s->oformat->write_packet(s, pkt);
2606
    if(!ret)
2607
        ret= url_ferror(s->pb);
2608
    return ret;
2609
}
2610

    
2611
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2612
    AVPacketList *pktl, **next_point, *this_pktl;
2613
    int stream_count=0;
2614
    int streams[MAX_STREAMS];
2615

    
2616
    if(pkt){
2617
        AVStream *st= s->streams[ pkt->stream_index];
2618

    
2619
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2620

    
2621
        this_pktl = av_mallocz(sizeof(AVPacketList));
2622
        this_pktl->pkt= *pkt;
2623
        if(pkt->destruct == av_destruct_packet)
2624
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2625
        else
2626
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2627

    
2628
        next_point = &s->packet_buffer;
2629
        while(*next_point){
2630
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2631
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2632
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2633
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2634
                break;
2635
            next_point= &(*next_point)->next;
2636
        }
2637
        this_pktl->next= *next_point;
2638
        *next_point= this_pktl;
2639
    }
2640

    
2641
    memset(streams, 0, sizeof(streams));
2642
    pktl= s->packet_buffer;
2643
    while(pktl){
2644
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2645
        if(streams[ pktl->pkt.stream_index ] == 0)
2646
            stream_count++;
2647
        streams[ pktl->pkt.stream_index ]++;
2648
        pktl= pktl->next;
2649
    }
2650

    
2651
    if(stream_count && (s->nb_streams == stream_count || flush)){
2652
        pktl= s->packet_buffer;
2653
        *out= pktl->pkt;
2654

    
2655
        s->packet_buffer= pktl->next;
2656
        av_freep(&pktl);
2657
        return 1;
2658
    }else{
2659
        av_init_packet(out);
2660
        return 0;
2661
    }
2662
}
2663

    
2664
/**
2665
 * Interleaves an AVPacket correctly so it can be muxed.
2666
 * @param out the interleaved packet will be output here
2667
 * @param in the input packet
2668
 * @param flush 1 if no further packets are available as input and all
2669
 *              remaining packets should be output
2670
 * @return 1 if a packet was output, 0 if no packet could be output,
2671
 *         < 0 if an error occurred
2672
 */
2673
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2674
    if(s->oformat->interleave_packet)
2675
        return s->oformat->interleave_packet(s, out, in, flush);
2676
    else
2677
        return av_interleave_packet_per_dts(s, out, in, flush);
2678
}
2679

    
2680
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2681
    AVStream *st= s->streams[ pkt->stream_index];
2682

    
2683
    //FIXME/XXX/HACK drop zero sized packets
2684
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2685
        return 0;
2686

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

    
2691
    if(pkt->dts == AV_NOPTS_VALUE)
2692
        return -1;
2693

    
2694
    for(;;){
2695
        AVPacket opkt;
2696
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2697
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2698
            return ret;
2699

    
2700
        ret= s->oformat->write_packet(s, &opkt);
2701

    
2702
        av_free_packet(&opkt);
2703
        pkt= NULL;
2704

    
2705
        if(ret<0)
2706
            return ret;
2707
        if(url_ferror(s->pb))
2708
            return url_ferror(s->pb);
2709
    }
2710
}
2711

    
2712
int av_write_trailer(AVFormatContext *s)
2713
{
2714
    int ret, i;
2715

    
2716
    for(;;){
2717
        AVPacket pkt;
2718
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2719
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2720
            goto fail;
2721
        if(!ret)
2722
            break;
2723

    
2724
        ret= s->oformat->write_packet(s, &pkt);
2725

    
2726
        av_free_packet(&pkt);
2727

    
2728
        if(ret<0)
2729
            goto fail;
2730
        if(url_ferror(s->pb))
2731
            goto fail;
2732
    }
2733

    
2734
    if(s->oformat->write_trailer)
2735
        ret = s->oformat->write_trailer(s);
2736
fail:
2737
    if(ret == 0)
2738
       ret=url_ferror(s->pb);
2739
    for(i=0;i<s->nb_streams;i++)
2740
        av_freep(&s->streams[i]->priv_data);
2741
    av_freep(&s->priv_data);
2742
    return ret;
2743
}
2744

    
2745
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2746
{
2747
    int i, j;
2748
    AVProgram *program=NULL;
2749
    void *tmp;
2750

    
2751
    for(i=0; i<ac->nb_programs; i++){
2752
        if(ac->programs[i]->id != progid)
2753
            continue;
2754
        program = ac->programs[i];
2755
        for(j=0; j<program->nb_stream_indexes; j++)
2756
            if(program->stream_index[j] == idx)
2757
                return;
2758

    
2759
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2760
        if(!tmp)
2761
            return;
2762
        program->stream_index = tmp;
2763
        program->stream_index[program->nb_stream_indexes++] = idx;
2764
        return;
2765
    }
2766
}
2767

    
2768
/* "user interface" functions */
2769
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2770
{
2771
    char buf[256];
2772
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2773
    AVStream *st = ic->streams[i];
2774
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2775
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2776
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2777
    /* the pid is an important information, so we display it */
2778
    /* XXX: add a generic system */
2779
    if (flags & AVFMT_SHOW_IDS)
2780
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2781
    if (strlen(st->language) > 0)
2782
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2783
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2784
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2785
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2786
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2787
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2788
/*      else if(st->time_base.den && st->time_base.num)
2789
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2790
        else
2791
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2792
    }
2793
    av_log(NULL, AV_LOG_INFO, "\n");
2794
}
2795

    
2796
void dump_format(AVFormatContext *ic,
2797
                 int index,
2798
                 const char *url,
2799
                 int is_output)
2800
{
2801
    int i;
2802

    
2803
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2804
            is_output ? "Output" : "Input",
2805
            index,
2806
            is_output ? ic->oformat->name : ic->iformat->name,
2807
            is_output ? "to" : "from", url);
2808
    if (!is_output) {
2809
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2810
        if (ic->duration != AV_NOPTS_VALUE) {
2811
            int hours, mins, secs, us;
2812
            secs = ic->duration / AV_TIME_BASE;
2813
            us = ic->duration % AV_TIME_BASE;
2814
            mins = secs / 60;
2815
            secs %= 60;
2816
            hours = mins / 60;
2817
            mins %= 60;
2818
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2819
                   (100 * us) / AV_TIME_BASE);
2820
        } else {
2821
            av_log(NULL, AV_LOG_INFO, "N/A");
2822
        }
2823
        if (ic->start_time != AV_NOPTS_VALUE) {
2824
            int secs, us;
2825
            av_log(NULL, AV_LOG_INFO, ", start: ");
2826
            secs = ic->start_time / AV_TIME_BASE;
2827
            us = ic->start_time % AV_TIME_BASE;
2828
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2829
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2830
        }
2831
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2832
        if (ic->bit_rate) {
2833
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2834
        } else {
2835
            av_log(NULL, AV_LOG_INFO, "N/A");
2836
        }
2837
        av_log(NULL, AV_LOG_INFO, "\n");
2838
    }
2839
    if(ic->nb_programs) {
2840
        int j, k;
2841
        for(j=0; j<ic->nb_programs; j++) {
2842
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2843
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2844
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2845
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2846
         }
2847
    } else
2848
    for(i=0;i<ic->nb_streams;i++)
2849
        dump_stream_format(ic, i, index, is_output);
2850
}
2851

    
2852
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2853
{
2854
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2855
}
2856

    
2857
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2858
{
2859
    AVRational frame_rate;
2860
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2861
    *frame_rate_num= frame_rate.num;
2862
    *frame_rate_den= frame_rate.den;
2863
    return ret;
2864
}
2865

    
2866
int64_t av_gettime(void)
2867
{
2868
    struct timeval tv;
2869
    gettimeofday(&tv,NULL);
2870
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2871
}
2872

    
2873
int64_t parse_date(const char *datestr, int duration)
2874
{
2875
    const char *p;
2876
    int64_t t;
2877
    struct tm dt;
2878
    int i;
2879
    static const char * const date_fmt[] = {
2880
        "%Y-%m-%d",
2881
        "%Y%m%d",
2882
    };
2883
    static const char * const time_fmt[] = {
2884
        "%H:%M:%S",
2885
        "%H%M%S",
2886
    };
2887
    const char *q;
2888
    int is_utc, len;
2889
    char lastch;
2890
    int negative = 0;
2891

    
2892
#undef time
2893
    time_t now = time(0);
2894

    
2895
    len = strlen(datestr);
2896
    if (len > 0)
2897
        lastch = datestr[len - 1];
2898
    else
2899
        lastch = '\0';
2900
    is_utc = (lastch == 'z' || lastch == 'Z');
2901

    
2902
    memset(&dt, 0, sizeof(dt));
2903

    
2904
    p = datestr;
2905
    q = NULL;
2906
    if (!duration) {
2907
        /* parse the year-month-day part */
2908
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2909
            q = small_strptime(p, date_fmt[i], &dt);
2910
            if (q) {
2911
                break;
2912
            }
2913
        }
2914

    
2915
        /* if the year-month-day part is missing, then take the
2916
         * current year-month-day time */
2917
        if (!q) {
2918
            if (is_utc) {
2919
                dt = *gmtime(&now);
2920
            } else {
2921
                dt = *localtime(&now);
2922
            }
2923
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2924
        } else {
2925
            p = q;
2926
        }
2927

    
2928
        if (*p == 'T' || *p == 't' || *p == ' ')
2929
            p++;
2930

    
2931
        /* parse the hour-minute-second part */
2932
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2933
            q = small_strptime(p, time_fmt[i], &dt);
2934
            if (q) {
2935
                break;
2936
            }
2937
        }
2938
    } else {
2939
        /* parse datestr as a duration */
2940
        if (p[0] == '-') {
2941
            negative = 1;
2942
            ++p;
2943
        }
2944
        /* parse datestr as HH:MM:SS */
2945
        q = small_strptime(p, time_fmt[0], &dt);
2946
        if (!q) {
2947
            /* parse datestr as S+ */
2948
            dt.tm_sec = strtol(p, (char **)&q, 10);
2949
            if (q == p)
2950
                /* the parsing didn't succeed */
2951
                return INT64_MIN;
2952
            dt.tm_min = 0;
2953
            dt.tm_hour = 0;
2954
        }
2955
    }
2956

    
2957
    /* Now we have all the fields that we can get */
2958
    if (!q) {
2959
        return INT64_MIN;
2960
    }
2961

    
2962
    if (duration) {
2963
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2964
    } else {
2965
        dt.tm_isdst = -1;       /* unknown */
2966
        if (is_utc) {
2967
            t = mktimegm(&dt);
2968
        } else {
2969
            t = mktime(&dt);
2970
        }
2971
    }
2972

    
2973
    t *= 1000000;
2974

    
2975
    /* parse the .m... part */
2976
    if (*q == '.') {
2977
        int val, n;
2978
        q++;
2979
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2980
            if (!isdigit(*q))
2981
                break;
2982
            val += n * (*q - '0');
2983
        }
2984
        t += val;
2985
    }
2986
    return negative ? -t : t;
2987
}
2988

    
2989
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2990
{
2991
    const char *p;
2992
    char tag[128], *q;
2993

    
2994
    p = info;
2995
    if (*p == '?')
2996
        p++;
2997
    for(;;) {
2998
        q = tag;
2999
        while (*p != '\0' && *p != '=' && *p != '&') {
3000
            if ((q - tag) < sizeof(tag) - 1)
3001
                *q++ = *p;
3002
            p++;
3003
        }
3004
        *q = '\0';
3005
        q = arg;
3006
        if (*p == '=') {
3007
            p++;
3008
            while (*p != '&' && *p != '\0') {
3009
                if ((q - arg) < arg_size - 1) {
3010
                    if (*p == '+')
3011
                        *q++ = ' ';
3012
                    else
3013
                        *q++ = *p;
3014
                }
3015
                p++;
3016
            }
3017
            *q = '\0';
3018
        }
3019
        if (!strcmp(tag, tag1))
3020
            return 1;
3021
        if (*p != '&')
3022
            break;
3023
        p++;
3024
    }
3025
    return 0;
3026
}
3027

    
3028
int av_get_frame_filename(char *buf, int buf_size,
3029
                          const char *path, int number)
3030
{
3031
    const char *p;
3032
    char *q, buf1[20], c;
3033
    int nd, len, percentd_found;
3034

    
3035
    q = buf;
3036
    p = path;
3037
    percentd_found = 0;
3038
    for(;;) {
3039
        c = *p++;
3040
        if (c == '\0')
3041
            break;
3042
        if (c == '%') {
3043
            do {
3044
                nd = 0;
3045
                while (isdigit(*p)) {
3046
                    nd = nd * 10 + *p++ - '0';
3047
                }
3048
                c = *p++;
3049
            } while (isdigit(c));
3050

    
3051
            switch(c) {
3052
            case '%':
3053
                goto addchar;
3054
            case 'd':
3055
                if (percentd_found)
3056
                    goto fail;
3057
                percentd_found = 1;
3058
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3059
                len = strlen(buf1);
3060
                if ((q - buf + len) > buf_size - 1)
3061
                    goto fail;
3062
                memcpy(q, buf1, len);
3063
                q += len;
3064
                break;
3065
            default:
3066
                goto fail;
3067
            }
3068
        } else {
3069
        addchar:
3070
            if ((q - buf) < buf_size - 1)
3071
                *q++ = c;
3072
        }
3073
    }
3074
    if (!percentd_found)
3075
        goto fail;
3076
    *q = '\0';
3077
    return 0;
3078
 fail:
3079
    *q = '\0';
3080
    return -1;
3081
}
3082

    
3083
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3084
{
3085
    int len, i, j, c;
3086
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3087

    
3088
    for(i=0;i<size;i+=16) {
3089
        len = size - i;
3090
        if (len > 16)
3091
            len = 16;
3092
        PRINT("%08x ", i);
3093
        for(j=0;j<16;j++) {
3094
            if (j < len)
3095
                PRINT(" %02x", buf[i+j]);
3096
            else
3097
                PRINT("   ");
3098
        }
3099
        PRINT(" ");
3100
        for(j=0;j<len;j++) {
3101
            c = buf[i+j];
3102
            if (c < ' ' || c > '~')
3103
                c = '.';
3104
            PRINT("%c", c);
3105
        }
3106
        PRINT("\n");
3107
    }
3108
#undef PRINT
3109
}
3110

    
3111
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3112
{
3113
    hex_dump_internal(NULL, f, 0, buf, size);
3114
}
3115

    
3116
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3117
{
3118
    hex_dump_internal(avcl, NULL, level, buf, size);
3119
}
3120

    
3121
 //FIXME needs to know the time_base
3122
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3123
{
3124
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3125
    PRINT("stream #%d:\n", pkt->stream_index);
3126
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3127
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3128
    /* DTS is _always_ valid after av_read_frame() */
3129
    PRINT("  dts=");
3130
    if (pkt->dts == AV_NOPTS_VALUE)
3131
        PRINT("N/A");
3132
    else
3133
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3134
    /* PTS may not be known if B-frames are present. */
3135
    PRINT("  pts=");
3136
    if (pkt->pts == AV_NOPTS_VALUE)
3137
        PRINT("N/A");
3138
    else
3139
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3140
    PRINT("\n");
3141
    PRINT("  size=%d\n", pkt->size);
3142
#undef PRINT
3143
    if (dump_payload)
3144
        av_hex_dump(f, pkt->data, pkt->size);
3145
}
3146

    
3147
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3148
{
3149
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3150
}
3151

    
3152
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3153
{
3154
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3155
}
3156

    
3157
void url_split(char *proto, int proto_size,
3158
               char *authorization, int authorization_size,
3159
               char *hostname, int hostname_size,
3160
               int *port_ptr,
3161
               char *path, int path_size,
3162
               const char *url)
3163
{
3164
    const char *p, *ls, *at, *col, *brk;
3165

    
3166
    if (port_ptr)               *port_ptr = -1;
3167
    if (proto_size > 0)         proto[0] = 0;
3168
    if (authorization_size > 0) authorization[0] = 0;
3169
    if (hostname_size > 0)      hostname[0] = 0;
3170
    if (path_size > 0)          path[0] = 0;
3171

    
3172
    /* parse protocol */
3173
    if ((p = strchr(url, ':'))) {
3174
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3175
        p++; /* skip ':' */
3176
        if (*p == '/') p++;
3177
        if (*p == '/') p++;
3178
    } else {
3179
        /* no protocol means plain filename */
3180
        av_strlcpy(path, url, path_size);
3181
        return;
3182
    }
3183

    
3184
    /* separate path from hostname */
3185
    ls = strchr(p, '/');
3186
    if(!ls)
3187
        ls = strchr(p, '?');
3188
    if(ls)
3189
        av_strlcpy(path, ls, path_size);
3190
    else
3191
        ls = &p[strlen(p)]; // XXX
3192

    
3193
    /* the rest is hostname, use that to parse auth/port */
3194
    if (ls != p) {
3195
        /* authorization (user[:pass]@hostname) */
3196
        if ((at = strchr(p, '@')) && at < ls) {
3197
            av_strlcpy(authorization, p,
3198
                       FFMIN(authorization_size, at + 1 - p));
3199
            p = at + 1; /* skip '@' */
3200
        }
3201

    
3202
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3203
            /* [host]:port */
3204
            av_strlcpy(hostname, p + 1,
3205
                       FFMIN(hostname_size, brk - p));
3206
            if (brk[1] == ':' && port_ptr)
3207
                *port_ptr = atoi(brk + 2);
3208
        } else if ((col = strchr(p, ':')) && col < ls) {
3209
            av_strlcpy(hostname, p,
3210
                       FFMIN(col + 1 - p, hostname_size));
3211
            if (port_ptr) *port_ptr = atoi(col + 1);
3212
        } else
3213
            av_strlcpy(hostname, p,
3214
                       FFMIN(ls + 1 - p, hostname_size));
3215
    }
3216
}
3217

    
3218
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3219
{
3220
    int i;
3221
    static const char hex_table[16] = { '0', '1', '2', '3',
3222
                                        '4', '5', '6', '7',
3223
                                        '8', '9', 'A', 'B',
3224
                                        'C', 'D', 'E', 'F' };
3225

    
3226
    for(i = 0; i < s; i++) {
3227
        buff[i * 2]     = hex_table[src[i] >> 4];
3228
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3229
    }
3230

    
3231
    return buff;
3232
}
3233

    
3234
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3235
                     int pts_num, int pts_den)
3236
{
3237
    unsigned int gcd= ff_gcd(pts_num, pts_den);
3238
    s->pts_wrap_bits = pts_wrap_bits;
3239
    s->time_base.num = pts_num/gcd;
3240
    s->time_base.den = pts_den/gcd;
3241

    
3242
    if(gcd>1)
3243
        av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);
3244
}