Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 094d9df7

History | View | Annotate | Download (99.3 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 "metadata.h"
25
#include "libavutil/avstring.h"
26
#include "riff.h"
27
#include <sys/time.h>
28
#include <time.h>
29
#include <strings.h>
30

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

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

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

    
44
/* fraction handling */
45

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

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

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

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

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

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

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

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

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

    
134
    if(!filename)
135
        return 0;
136

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

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

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

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

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

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

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

    
209
    return fmt;
210
}
211

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

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

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

    
241
/* memory handling */
242

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

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

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

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

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

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

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

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

    
293
    return ret;
294
}
295

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

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

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

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

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

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

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

    
378
/************************************************************/
379
/* input media file */
380

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

    
392
#define OFFSET(x) offsetof(AVFormatContext,x)
393
#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
394
//these names are too long to be readable
395
#define E AV_OPT_FLAG_ENCODING_PARAM
396
#define D AV_OPT_FLAG_DECODING_PARAM
397

    
398
static const AVOption options[]={
399
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
400
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
401
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
402
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
403
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
404
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
405
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
406
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
407
{"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},
408
{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
409
{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
410
{"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 */
411
{"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E|D, "fdebug"},
412
{"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E|D, "fdebug"},
413
{NULL},
414
};
415

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

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

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

    
426
    s->av_class = &av_format_context_class;
427

    
428
    av_opt_set_defaults(s);
429
}
430

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
587
}
588

    
589
/*******************************************************/
590

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

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

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

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

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

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

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

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

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

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

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

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

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

    
667
/**********************************************************/
668

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

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

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

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

    
698

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
956
    av_init_packet(pkt);
957

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

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

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

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

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

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

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

    
1072
    return 0;
1073
}
1074

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

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

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

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

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

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

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

    
1144
/*******************************************************/
1145
/* seek support */
1146

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

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

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

    
1174
    flush_packet_queue(s);
1175

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

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

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

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

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

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

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

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

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

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

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

    
1240
    st->index_entries= entries;
1241

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

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

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

    
1265
    return index;
1266
}
1267

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

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

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

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

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

    
1300
#define DEBUG_SEEK
1301

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

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

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

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

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

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

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

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

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

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

    
1361
    av_update_cur_dts(s, st, ts);
1362

    
1363
    return 0;
1364
}
1365

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1554
    return 0;
1555
}
1556

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

    
1562
    av_read_frame_flush(s);
1563

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

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

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

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

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

    
1592
/*******************************************************/
1593

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

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

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

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

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

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

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

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

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

    
1712
#define DURATION_MAX_READ_SIZE 250000
1713

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

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

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

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

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

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

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

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

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

    
1798
    fill_all_stream_timings(ic);
1799

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2103
        read_size += pkt->size;
2104

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

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

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

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

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

    
2165
        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) {
2166
            break;
2167
        }
2168
        count++;
2169
    }
2170

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

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

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

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

    
2217
    av_estimate_timings(ic, old_offset);
2218

    
2219
    compute_chapters_end(ic);
2220

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

    
2246
    av_free(duration_error);
2247

    
2248
    return ret;
2249
}
2250

    
2251
/*******************************************************/
2252

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

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

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

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

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

    
2316
void av_close_input_file(AVFormatContext *s)
2317
{
2318
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2319
    av_close_input_stream(s);
2320
    if (pb)
2321
        url_fclose(pb);
2322
}
2323

    
2324
AVStream *av_new_stream(AVFormatContext *s, int id)
2325
{
2326
    AVStream *st;
2327
    int i;
2328

    
2329
    if (s->nb_streams >= MAX_STREAMS)
2330
        return NULL;
2331

    
2332
    st = av_mallocz(sizeof(AVStream));
2333
    if (!st)
2334
        return NULL;
2335

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

    
2352
    /* default pts setting is MPEG-like */
2353
    av_set_pts_info(st, 33, 1, 90000);
2354
    st->last_IP_pts = AV_NOPTS_VALUE;
2355
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2356
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2357

    
2358
    st->sample_aspect_ratio = (AVRational){0,1};
2359

    
2360
    s->streams[s->nb_streams++] = st;
2361
    return st;
2362
}
2363

    
2364
AVProgram *av_new_program(AVFormatContext *ac, int id)
2365
{
2366
    AVProgram *program=NULL;
2367
    int i;
2368

    
2369
#ifdef DEBUG_SI
2370
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2371
#endif
2372

    
2373
    for(i=0; i<ac->nb_programs; i++)
2374
        if(ac->programs[i]->id == id)
2375
            program = ac->programs[i];
2376

    
2377
    if(!program){
2378
        program = av_mallocz(sizeof(AVProgram));
2379
        if (!program)
2380
            return NULL;
2381
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2382
        program->discard = AVDISCARD_NONE;
2383
    }
2384
    program->id = id;
2385

    
2386
    return program;
2387
}
2388

    
2389
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2390
{
2391
    assert(!provider_name == !name);
2392
    if(name){
2393
        av_free(program->provider_name);
2394
        av_free(program->         name);
2395
        program->provider_name = av_strdup(provider_name);
2396
        program->         name = av_strdup(         name);
2397
    }
2398
}
2399

    
2400
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2401
{
2402
    AVChapter *chapter = NULL;
2403
    int i;
2404

    
2405
    for(i=0; i<s->nb_chapters; i++)
2406
        if(s->chapters[i]->id == id)
2407
            chapter = s->chapters[i];
2408

    
2409
    if(!chapter){
2410
        chapter= av_mallocz(sizeof(AVChapter));
2411
        if(!chapter)
2412
            return NULL;
2413
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2414
    }
2415
    av_free(chapter->title);
2416
    chapter->title = av_strdup(title);
2417
    chapter->id    = id;
2418
    chapter->time_base= time_base;
2419
    chapter->start = start;
2420
    chapter->end   = end;
2421

    
2422
    return chapter;
2423
}
2424

    
2425
/************************************************************/
2426
/* output media file */
2427

    
2428
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2429
{
2430
    int ret;
2431

    
2432
    if (s->oformat->priv_data_size > 0) {
2433
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2434
        if (!s->priv_data)
2435
            return AVERROR(ENOMEM);
2436
    } else
2437
        s->priv_data = NULL;
2438

    
2439
    if (s->oformat->set_parameters) {
2440
        ret = s->oformat->set_parameters(s, ap);
2441
        if (ret < 0)
2442
            return ret;
2443
    }
2444
    return 0;
2445
}
2446

    
2447
int av_write_header(AVFormatContext *s)
2448
{
2449
    int ret, i;
2450
    AVStream *st;
2451

    
2452
    // some sanity checks
2453
    for(i=0;i<s->nb_streams;i++) {
2454
        st = s->streams[i];
2455

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

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

    
2494
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2495
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2496
        if (!s->priv_data)
2497
            return AVERROR(ENOMEM);
2498
    }
2499

    
2500
#if LIBAVFORMAT_VERSION_MAJOR < 53
2501
    ff_metadata_sync_compat(s);
2502
#endif
2503

    
2504
    if(s->oformat->write_header){
2505
        ret = s->oformat->write_header(s);
2506
        if (ret < 0)
2507
            return ret;
2508
    }
2509

    
2510
    /* init PTS generation */
2511
    for(i=0;i<s->nb_streams;i++) {
2512
        int64_t den = AV_NOPTS_VALUE;
2513
        st = s->streams[i];
2514

    
2515
        switch (st->codec->codec_type) {
2516
        case CODEC_TYPE_AUDIO:
2517
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2518
            break;
2519
        case CODEC_TYPE_VIDEO:
2520
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2521
            break;
2522
        default:
2523
            break;
2524
        }
2525
        if (den != AV_NOPTS_VALUE) {
2526
            if (den <= 0)
2527
                return AVERROR_INVALIDDATA;
2528
            av_frac_init(&st->pts, 0, 0, den);
2529
        }
2530
    }
2531
    return 0;
2532
}
2533

    
2534
//FIXME merge with compute_pkt_fields
2535
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2536
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2537
    int num, den, frame_size, i;
2538

    
2539
//    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);
2540

    
2541
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2542
        return -1;*/
2543

    
2544
    /* duration field */
2545
    if (pkt->duration == 0) {
2546
        compute_frame_duration(&num, &den, st, NULL, pkt);
2547
        if (den && num) {
2548
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2549
        }
2550
    }
2551

    
2552
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2553
        pkt->pts= pkt->dts;
2554

    
2555
    //XXX/FIXME this is a temporary hack until all encoders output pts
2556
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2557
        pkt->dts=
2558
//        pkt->pts= st->cur_dts;
2559
        pkt->pts= st->pts.val;
2560
    }
2561

    
2562
    //calculate dts from pts
2563
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2564
        st->pts_buffer[0]= pkt->pts;
2565
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2566
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2567
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2568
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2569

    
2570
        pkt->dts= st->pts_buffer[0];
2571
    }
2572

    
2573
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2574
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2575
        return -1;
2576
    }
2577
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2578
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2579
        return -1;
2580
    }
2581

    
2582
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2583
    st->cur_dts= pkt->dts;
2584
    st->pts.val= pkt->dts;
2585

    
2586
    /* update pts */
2587
    switch (st->codec->codec_type) {
2588
    case CODEC_TYPE_AUDIO:
2589
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2590

    
2591
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2592
           likely equal to the encoder delay, but it would be better if we
2593
           had the real timestamps from the encoder */
2594
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2595
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2596
        }
2597
        break;
2598
    case CODEC_TYPE_VIDEO:
2599
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2600
        break;
2601
    default:
2602
        break;
2603
    }
2604
    return 0;
2605
}
2606

    
2607
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2608
{
2609
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2610

    
2611
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2612
        return ret;
2613

    
2614
    ret= s->oformat->write_packet(s, pkt);
2615
    if(!ret)
2616
        ret= url_ferror(s->pb);
2617
    return ret;
2618
}
2619

    
2620
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2621
    AVPacketList *pktl, **next_point, *this_pktl;
2622
    int stream_count=0;
2623
    int streams[MAX_STREAMS];
2624

    
2625
    if(pkt){
2626
        AVStream *st= s->streams[ pkt->stream_index];
2627

    
2628
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2629

    
2630
        this_pktl = av_mallocz(sizeof(AVPacketList));
2631
        this_pktl->pkt= *pkt;
2632
        if(pkt->destruct == av_destruct_packet)
2633
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2634
        else
2635
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2636

    
2637
        next_point = &s->packet_buffer;
2638
        while(*next_point){
2639
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2640
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2641
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2642
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2643
                break;
2644
            next_point= &(*next_point)->next;
2645
        }
2646
        this_pktl->next= *next_point;
2647
        *next_point= this_pktl;
2648
    }
2649

    
2650
    memset(streams, 0, sizeof(streams));
2651
    pktl= s->packet_buffer;
2652
    while(pktl){
2653
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2654
        if(streams[ pktl->pkt.stream_index ] == 0)
2655
            stream_count++;
2656
        streams[ pktl->pkt.stream_index ]++;
2657
        pktl= pktl->next;
2658
    }
2659

    
2660
    if(stream_count && (s->nb_streams == stream_count || flush)){
2661
        pktl= s->packet_buffer;
2662
        *out= pktl->pkt;
2663

    
2664
        s->packet_buffer= pktl->next;
2665
        av_freep(&pktl);
2666
        return 1;
2667
    }else{
2668
        av_init_packet(out);
2669
        return 0;
2670
    }
2671
}
2672

    
2673
/**
2674
 * Interleaves an AVPacket correctly so it can be muxed.
2675
 * @param out the interleaved packet will be output here
2676
 * @param in the input packet
2677
 * @param flush 1 if no further packets are available as input and all
2678
 *              remaining packets should be output
2679
 * @return 1 if a packet was output, 0 if no packet could be output,
2680
 *         < 0 if an error occurred
2681
 */
2682
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2683
    if(s->oformat->interleave_packet)
2684
        return s->oformat->interleave_packet(s, out, in, flush);
2685
    else
2686
        return av_interleave_packet_per_dts(s, out, in, flush);
2687
}
2688

    
2689
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2690
    AVStream *st= s->streams[ pkt->stream_index];
2691

    
2692
    //FIXME/XXX/HACK drop zero sized packets
2693
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2694
        return 0;
2695

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

    
2700
    if(pkt->dts == AV_NOPTS_VALUE)
2701
        return -1;
2702

    
2703
    for(;;){
2704
        AVPacket opkt;
2705
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2706
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2707
            return ret;
2708

    
2709
        ret= s->oformat->write_packet(s, &opkt);
2710

    
2711
        av_free_packet(&opkt);
2712
        pkt= NULL;
2713

    
2714
        if(ret<0)
2715
            return ret;
2716
        if(url_ferror(s->pb))
2717
            return url_ferror(s->pb);
2718
    }
2719
}
2720

    
2721
int av_write_trailer(AVFormatContext *s)
2722
{
2723
    int ret, i;
2724

    
2725
    for(;;){
2726
        AVPacket pkt;
2727
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2728
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2729
            goto fail;
2730
        if(!ret)
2731
            break;
2732

    
2733
        ret= s->oformat->write_packet(s, &pkt);
2734

    
2735
        av_free_packet(&pkt);
2736

    
2737
        if(ret<0)
2738
            goto fail;
2739
        if(url_ferror(s->pb))
2740
            goto fail;
2741
    }
2742

    
2743
    if(s->oformat->write_trailer)
2744
        ret = s->oformat->write_trailer(s);
2745
fail:
2746
    if(ret == 0)
2747
       ret=url_ferror(s->pb);
2748
    for(i=0;i<s->nb_streams;i++)
2749
        av_freep(&s->streams[i]->priv_data);
2750
    av_freep(&s->priv_data);
2751
    return ret;
2752
}
2753

    
2754
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2755
{
2756
    int i, j;
2757
    AVProgram *program=NULL;
2758
    void *tmp;
2759

    
2760
    for(i=0; i<ac->nb_programs; i++){
2761
        if(ac->programs[i]->id != progid)
2762
            continue;
2763
        program = ac->programs[i];
2764
        for(j=0; j<program->nb_stream_indexes; j++)
2765
            if(program->stream_index[j] == idx)
2766
                return;
2767

    
2768
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2769
        if(!tmp)
2770
            return;
2771
        program->stream_index = tmp;
2772
        program->stream_index[program->nb_stream_indexes++] = idx;
2773
        return;
2774
    }
2775
}
2776

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

    
2805
void dump_format(AVFormatContext *ic,
2806
                 int index,
2807
                 const char *url,
2808
                 int is_output)
2809
{
2810
    int i;
2811

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

    
2861
#if LIBAVFORMAT_VERSION_MAJOR < 53
2862
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2863
{
2864
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2865
}
2866

    
2867
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2868
{
2869
    AVRational frame_rate;
2870
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2871
    *frame_rate_num= frame_rate.num;
2872
    *frame_rate_den= frame_rate.den;
2873
    return ret;
2874
}
2875
#endif
2876

    
2877
int64_t av_gettime(void)
2878
{
2879
    struct timeval tv;
2880
    gettimeofday(&tv,NULL);
2881
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2882
}
2883

    
2884
int64_t parse_date(const char *datestr, int duration)
2885
{
2886
    const char *p;
2887
    int64_t t;
2888
    struct tm dt;
2889
    int i;
2890
    static const char * const date_fmt[] = {
2891
        "%Y-%m-%d",
2892
        "%Y%m%d",
2893
    };
2894
    static const char * const time_fmt[] = {
2895
        "%H:%M:%S",
2896
        "%H%M%S",
2897
    };
2898
    const char *q;
2899
    int is_utc, len;
2900
    char lastch;
2901
    int negative = 0;
2902

    
2903
#undef time
2904
    time_t now = time(0);
2905

    
2906
    len = strlen(datestr);
2907
    if (len > 0)
2908
        lastch = datestr[len - 1];
2909
    else
2910
        lastch = '\0';
2911
    is_utc = (lastch == 'z' || lastch == 'Z');
2912

    
2913
    memset(&dt, 0, sizeof(dt));
2914

    
2915
    p = datestr;
2916
    q = NULL;
2917
    if (!duration) {
2918
        /* parse the year-month-day part */
2919
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2920
            q = small_strptime(p, date_fmt[i], &dt);
2921
            if (q) {
2922
                break;
2923
            }
2924
        }
2925

    
2926
        /* if the year-month-day part is missing, then take the
2927
         * current year-month-day time */
2928
        if (!q) {
2929
            if (is_utc) {
2930
                dt = *gmtime(&now);
2931
            } else {
2932
                dt = *localtime(&now);
2933
            }
2934
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2935
        } else {
2936
            p = q;
2937
        }
2938

    
2939
        if (*p == 'T' || *p == 't' || *p == ' ')
2940
            p++;
2941

    
2942
        /* parse the hour-minute-second part */
2943
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2944
            q = small_strptime(p, time_fmt[i], &dt);
2945
            if (q) {
2946
                break;
2947
            }
2948
        }
2949
    } else {
2950
        /* parse datestr as a duration */
2951
        if (p[0] == '-') {
2952
            negative = 1;
2953
            ++p;
2954
        }
2955
        /* parse datestr as HH:MM:SS */
2956
        q = small_strptime(p, time_fmt[0], &dt);
2957
        if (!q) {
2958
            /* parse datestr as S+ */
2959
            dt.tm_sec = strtol(p, (char **)&q, 10);
2960
            if (q == p)
2961
                /* the parsing didn't succeed */
2962
                return INT64_MIN;
2963
            dt.tm_min = 0;
2964
            dt.tm_hour = 0;
2965
        }
2966
    }
2967

    
2968
    /* Now we have all the fields that we can get */
2969
    if (!q) {
2970
        return INT64_MIN;
2971
    }
2972

    
2973
    if (duration) {
2974
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2975
    } else {
2976
        dt.tm_isdst = -1;       /* unknown */
2977
        if (is_utc) {
2978
            t = mktimegm(&dt);
2979
        } else {
2980
            t = mktime(&dt);
2981
        }
2982
    }
2983

    
2984
    t *= 1000000;
2985

    
2986
    /* parse the .m... part */
2987
    if (*q == '.') {
2988
        int val, n;
2989
        q++;
2990
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2991
            if (!isdigit(*q))
2992
                break;
2993
            val += n * (*q - '0');
2994
        }
2995
        t += val;
2996
    }
2997
    return negative ? -t : t;
2998
}
2999

    
3000
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3001
{
3002
    const char *p;
3003
    char tag[128], *q;
3004

    
3005
    p = info;
3006
    if (*p == '?')
3007
        p++;
3008
    for(;;) {
3009
        q = tag;
3010
        while (*p != '\0' && *p != '=' && *p != '&') {
3011
            if ((q - tag) < sizeof(tag) - 1)
3012
                *q++ = *p;
3013
            p++;
3014
        }
3015
        *q = '\0';
3016
        q = arg;
3017
        if (*p == '=') {
3018
            p++;
3019
            while (*p != '&' && *p != '\0') {
3020
                if ((q - arg) < arg_size - 1) {
3021
                    if (*p == '+')
3022
                        *q++ = ' ';
3023
                    else
3024
                        *q++ = *p;
3025
                }
3026
                p++;
3027
            }
3028
            *q = '\0';
3029
        }
3030
        if (!strcmp(tag, tag1))
3031
            return 1;
3032
        if (*p != '&')
3033
            break;
3034
        p++;
3035
    }
3036
    return 0;
3037
}
3038

    
3039
int av_get_frame_filename(char *buf, int buf_size,
3040
                          const char *path, int number)
3041
{
3042
    const char *p;
3043
    char *q, buf1[20], c;
3044
    int nd, len, percentd_found;
3045

    
3046
    q = buf;
3047
    p = path;
3048
    percentd_found = 0;
3049
    for(;;) {
3050
        c = *p++;
3051
        if (c == '\0')
3052
            break;
3053
        if (c == '%') {
3054
            do {
3055
                nd = 0;
3056
                while (isdigit(*p)) {
3057
                    nd = nd * 10 + *p++ - '0';
3058
                }
3059
                c = *p++;
3060
            } while (isdigit(c));
3061

    
3062
            switch(c) {
3063
            case '%':
3064
                goto addchar;
3065
            case 'd':
3066
                if (percentd_found)
3067
                    goto fail;
3068
                percentd_found = 1;
3069
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3070
                len = strlen(buf1);
3071
                if ((q - buf + len) > buf_size - 1)
3072
                    goto fail;
3073
                memcpy(q, buf1, len);
3074
                q += len;
3075
                break;
3076
            default:
3077
                goto fail;
3078
            }
3079
        } else {
3080
        addchar:
3081
            if ((q - buf) < buf_size - 1)
3082
                *q++ = c;
3083
        }
3084
    }
3085
    if (!percentd_found)
3086
        goto fail;
3087
    *q = '\0';
3088
    return 0;
3089
 fail:
3090
    *q = '\0';
3091
    return -1;
3092
}
3093

    
3094
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3095
{
3096
    int len, i, j, c;
3097
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3098

    
3099
    for(i=0;i<size;i+=16) {
3100
        len = size - i;
3101
        if (len > 16)
3102
            len = 16;
3103
        PRINT("%08x ", i);
3104
        for(j=0;j<16;j++) {
3105
            if (j < len)
3106
                PRINT(" %02x", buf[i+j]);
3107
            else
3108
                PRINT("   ");
3109
        }
3110
        PRINT(" ");
3111
        for(j=0;j<len;j++) {
3112
            c = buf[i+j];
3113
            if (c < ' ' || c > '~')
3114
                c = '.';
3115
            PRINT("%c", c);
3116
        }
3117
        PRINT("\n");
3118
    }
3119
#undef PRINT
3120
}
3121

    
3122
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3123
{
3124
    hex_dump_internal(NULL, f, 0, buf, size);
3125
}
3126

    
3127
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3128
{
3129
    hex_dump_internal(avcl, NULL, level, buf, size);
3130
}
3131

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

    
3158
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3159
{
3160
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3161
}
3162

    
3163
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3164
{
3165
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3166
}
3167

    
3168
void url_split(char *proto, int proto_size,
3169
               char *authorization, int authorization_size,
3170
               char *hostname, int hostname_size,
3171
               int *port_ptr,
3172
               char *path, int path_size,
3173
               const char *url)
3174
{
3175
    const char *p, *ls, *at, *col, *brk;
3176

    
3177
    if (port_ptr)               *port_ptr = -1;
3178
    if (proto_size > 0)         proto[0] = 0;
3179
    if (authorization_size > 0) authorization[0] = 0;
3180
    if (hostname_size > 0)      hostname[0] = 0;
3181
    if (path_size > 0)          path[0] = 0;
3182

    
3183
    /* parse protocol */
3184
    if ((p = strchr(url, ':'))) {
3185
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3186
        p++; /* skip ':' */
3187
        if (*p == '/') p++;
3188
        if (*p == '/') p++;
3189
    } else {
3190
        /* no protocol means plain filename */
3191
        av_strlcpy(path, url, path_size);
3192
        return;
3193
    }
3194

    
3195
    /* separate path from hostname */
3196
    ls = strchr(p, '/');
3197
    if(!ls)
3198
        ls = strchr(p, '?');
3199
    if(ls)
3200
        av_strlcpy(path, ls, path_size);
3201
    else
3202
        ls = &p[strlen(p)]; // XXX
3203

    
3204
    /* the rest is hostname, use that to parse auth/port */
3205
    if (ls != p) {
3206
        /* authorization (user[:pass]@hostname) */
3207
        if ((at = strchr(p, '@')) && at < ls) {
3208
            av_strlcpy(authorization, p,
3209
                       FFMIN(authorization_size, at + 1 - p));
3210
            p = at + 1; /* skip '@' */
3211
        }
3212

    
3213
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3214
            /* [host]:port */
3215
            av_strlcpy(hostname, p + 1,
3216
                       FFMIN(hostname_size, brk - p));
3217
            if (brk[1] == ':' && port_ptr)
3218
                *port_ptr = atoi(brk + 2);
3219
        } else if ((col = strchr(p, ':')) && col < ls) {
3220
            av_strlcpy(hostname, p,
3221
                       FFMIN(col + 1 - p, hostname_size));
3222
            if (port_ptr) *port_ptr = atoi(col + 1);
3223
        } else
3224
            av_strlcpy(hostname, p,
3225
                       FFMIN(ls + 1 - p, hostname_size));
3226
    }
3227
}
3228

    
3229
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3230
{
3231
    int i;
3232
    static const char hex_table[16] = { '0', '1', '2', '3',
3233
                                        '4', '5', '6', '7',
3234
                                        '8', '9', 'A', 'B',
3235
                                        'C', 'D', 'E', 'F' };
3236

    
3237
    for(i = 0; i < s; i++) {
3238
        buff[i * 2]     = hex_table[src[i] >> 4];
3239
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3240
    }
3241

    
3242
    return buff;
3243
}
3244

    
3245
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3246
                     int pts_num, int pts_den)
3247
{
3248
    unsigned int gcd= ff_gcd(pts_num, pts_den);
3249
    s->pts_wrap_bits = pts_wrap_bits;
3250
    s->time_base.num = pts_num/gcd;
3251
    s->time_base.den = pts_den/gcd;
3252

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