Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ aecf157e

History | View | Annotate | Download (97.8 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 "libavcodec/opt.h"
23
#include "libavutil/avstring.h"
24
#include "riff.h"
25
#include <sys/time.h>
26
#include <time.h>
27
#include <strings.h>
28

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

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

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

    
42
/* fraction handling */
43

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

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

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

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

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

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

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

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

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

    
132
    if(!filename)
133
        return 0;
134

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

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

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

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

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

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

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

    
207
    return fmt;
208
}
209

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

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

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

    
239
/* memory handling */
240

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

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

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

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

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

    
279
    if(ret<0)
280
        return ret;
281

    
282
    pkt->pos= url_ftell(s);
283

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

    
290
    return ret;
291
}
292

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

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

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

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

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

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

    
354
    if (fmt) {
355
        if (!strcmp(fmt->name, "mp3"))
356
            st->codec->codec_id = CODEC_ID_MP3;
357
        else if (!strcmp(fmt->name, "ac3"))
358
            st->codec->codec_id = CODEC_ID_AC3;
359
        else if (!strcmp(fmt->name, "mpegvideo"))
360
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
361
        else if (!strcmp(fmt->name, "h264"))
362
            st->codec->codec_id = CODEC_ID_H264;
363
    }
364
    return !!fmt;
365
}
366

    
367
/************************************************************/
368
/* input media file */
369

    
370
/**
371
 * Open a media file from an IO stream. 'fmt' must be specified.
372
 */
373
static const char* format_to_name(void* ptr)
374
{
375
    AVFormatContext* fc = (AVFormatContext*) ptr;
376
    if(fc->iformat) return fc->iformat->name;
377
    else if(fc->oformat) return fc->oformat->name;
378
    else return "NULL";
379
}
380

    
381
#define OFFSET(x) offsetof(AVFormatContext,x)
382
#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
383
//these names are too long to be readable
384
#define E AV_OPT_FLAG_ENCODING_PARAM
385
#define D AV_OPT_FLAG_DECODING_PARAM
386

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

    
405
#undef E
406
#undef D
407
#undef DEFAULT
408

    
409
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
410

    
411
static void avformat_get_context_defaults(AVFormatContext *s)
412
{
413
    memset(s, 0, sizeof(AVFormatContext));
414

    
415
    s->av_class = &av_format_context_class;
416

    
417
    av_opt_set_defaults(s);
418
}
419

    
420
AVFormatContext *av_alloc_format_context(void)
421
{
422
    AVFormatContext *ic;
423
    ic = av_malloc(sizeof(AVFormatContext));
424
    if (!ic) return ic;
425
    avformat_get_context_defaults(ic);
426
    ic->av_class = &av_format_context_class;
427
    return ic;
428
}
429

    
430
int av_open_input_stream(AVFormatContext **ic_ptr,
431
                         ByteIOContext *pb, const char *filename,
432
                         AVInputFormat *fmt, AVFormatParameters *ap)
433
{
434
    int err;
435
    AVFormatContext *ic;
436
    AVFormatParameters default_ap;
437

    
438
    if(!ap){
439
        ap=&default_ap;
440
        memset(ap, 0, sizeof(default_ap));
441
    }
442

    
443
    if(!ap->prealloced_context)
444
        ic = av_alloc_format_context();
445
    else
446
        ic = *ic_ptr;
447
    if (!ic) {
448
        err = AVERROR(ENOMEM);
449
        goto fail;
450
    }
451
    ic->iformat = fmt;
452
    ic->pb = pb;
453
    ic->duration = AV_NOPTS_VALUE;
454
    ic->start_time = AV_NOPTS_VALUE;
455
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
456

    
457
    /* allocate private data */
458
    if (fmt->priv_data_size > 0) {
459
        ic->priv_data = av_mallocz(fmt->priv_data_size);
460
        if (!ic->priv_data) {
461
            err = AVERROR(ENOMEM);
462
            goto fail;
463
        }
464
    } else {
465
        ic->priv_data = NULL;
466
    }
467

    
468
    if (ic->iformat->read_header) {
469
        err = ic->iformat->read_header(ic, ap);
470
        if (err < 0)
471
            goto fail;
472
    }
473

    
474
    if (pb && !ic->data_offset)
475
        ic->data_offset = url_ftell(ic->pb);
476

    
477
    *ic_ptr = ic;
478
    return 0;
479
 fail:
480
    if (ic) {
481
        int i;
482
        av_freep(&ic->priv_data);
483
        for(i=0;i<ic->nb_streams;i++) {
484
            AVStream *st = ic->streams[i];
485
            if (st) {
486
                av_free(st->priv_data);
487
                av_free(st->codec->extradata);
488
            }
489
            av_free(st);
490
        }
491
    }
492
    av_free(ic);
493
    *ic_ptr = NULL;
494
    return err;
495
}
496

    
497
/** size of probe buffer, for guessing file type from file contents */
498
#define PROBE_BUF_MIN 2048
499
#define PROBE_BUF_MAX (1<<20)
500

    
501
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
502
                       AVInputFormat *fmt,
503
                       int buf_size,
504
                       AVFormatParameters *ap)
505
{
506
    int err, probe_size;
507
    AVProbeData probe_data, *pd = &probe_data;
508
    ByteIOContext *pb = NULL;
509

    
510
    pd->filename = "";
511
    if (filename)
512
        pd->filename = filename;
513
    pd->buf = NULL;
514
    pd->buf_size = 0;
515

    
516
    if (!fmt) {
517
        /* guess format if no file can be opened */
518
        fmt = av_probe_input_format(pd, 0);
519
    }
520

    
521
    /* Do not open file if the format does not need it. XXX: specific
522
       hack needed to handle RTSP/TCP */
523
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
524
        /* if no file needed do not try to open one */
525
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
526
            goto fail;
527
        }
528
        if (buf_size > 0) {
529
            url_setbufsize(pb, buf_size);
530
        }
531

    
532
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
533
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
534
            /* read probe data */
535
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
536
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
537
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
538
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
539
                url_fclose(pb);
540
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
541
                    pb = NULL;
542
                    err = AVERROR(EIO);
543
                    goto fail;
544
                }
545
            }
546
            /* guess file format */
547
            fmt = av_probe_input_format2(pd, 1, &score);
548
        }
549
        av_freep(&pd->buf);
550
    }
551

    
552
    /* if still no format found, error */
553
    if (!fmt) {
554
        err = AVERROR_NOFMT;
555
        goto fail;
556
    }
557

    
558
    /* check filename in case an image number is expected */
559
    if (fmt->flags & AVFMT_NEEDNUMBER) {
560
        if (!av_filename_number_test(filename)) {
561
            err = AVERROR_NUMEXPECTED;
562
            goto fail;
563
        }
564
    }
565
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
566
    if (err)
567
        goto fail;
568
    return 0;
569
 fail:
570
    av_freep(&pd->buf);
571
    if (pb)
572
        url_fclose(pb);
573
    *ic_ptr = NULL;
574
    return err;
575

    
576
}
577

    
578
/*******************************************************/
579

    
580
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
581
                               AVPacketList **plast_pktl){
582
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
583
    if (!pktl)
584
        return NULL;
585

    
586
    if (*packet_buffer)
587
        (*plast_pktl)->next = pktl;
588
    else
589
        *packet_buffer = pktl;
590

    
591
    /* add the packet in the buffered packet list */
592
    *plast_pktl = pktl;
593
    pktl->pkt= *pkt;
594
    return &pktl->pkt;
595
}
596

    
597
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
598
{
599
    int ret;
600
    AVStream *st;
601

    
602
    for(;;){
603
        AVPacketList *pktl = s->raw_packet_buffer;
604

    
605
        if (pktl) {
606
            *pkt = pktl->pkt;
607
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
608
                s->raw_packet_buffer = pktl->next;
609
                av_free(pktl);
610
                return 0;
611
            }
612
        }
613

    
614
        av_init_packet(pkt);
615
        ret= s->iformat->read_packet(s, pkt);
616
        if (ret < 0)
617
            return ret;
618
        st= s->streams[pkt->stream_index];
619

    
620
        switch(st->codec->codec_type){
621
        case CODEC_TYPE_VIDEO:
622
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
623
            break;
624
        case CODEC_TYPE_AUDIO:
625
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
626
            break;
627
        case CODEC_TYPE_SUBTITLE:
628
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
629
            break;
630
        }
631

    
632
        if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
633
            return ret;
634

    
635
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
636

    
637
        if(st->codec->codec_id == CODEC_ID_PROBE){
638
            AVProbeData *pd = &st->probe_data;
639

    
640
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
641
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
642
            pd->buf_size += pkt->size;
643
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
644

    
645
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
646
                set_codec_from_probe_data(st, pd, 1);
647
                if(st->codec->codec_id != CODEC_ID_PROBE){
648
                    pd->buf_size=0;
649
                    av_freep(&pd->buf);
650
                }
651
            }
652
        }
653
    }
654
}
655

    
656
/**********************************************************/
657

    
658
/**
659
 * Get the number of samples of an audio frame. Return -1 on error.
660
 */
661
static int get_audio_frame_size(AVCodecContext *enc, int size)
662
{
663
    int frame_size;
664

    
665
    if(enc->codec_id == CODEC_ID_VORBIS)
666
        return -1;
667

    
668
    if (enc->frame_size <= 1) {
669
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
670

    
671
        if (bits_per_sample) {
672
            if (enc->channels == 0)
673
                return -1;
674
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
675
        } else {
676
            /* used for example by ADPCM codecs */
677
            if (enc->bit_rate == 0)
678
                return -1;
679
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
680
        }
681
    } else {
682
        frame_size = enc->frame_size;
683
    }
684
    return frame_size;
685
}
686

    
687

    
688
/**
689
 * Return the frame duration in seconds. Return 0 if not available.
690
 */
691
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
692
                                   AVCodecParserContext *pc, AVPacket *pkt)
693
{
694
    int frame_size;
695

    
696
    *pnum = 0;
697
    *pden = 0;
698
    switch(st->codec->codec_type) {
699
    case CODEC_TYPE_VIDEO:
700
        if(st->time_base.num*1000LL > st->time_base.den){
701
            *pnum = st->time_base.num;
702
            *pden = st->time_base.den;
703
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
704
            *pnum = st->codec->time_base.num;
705
            *pden = st->codec->time_base.den;
706
            if (pc && pc->repeat_pict) {
707
                *pden *= 2;
708
                *pnum = (*pnum) * (2 + pc->repeat_pict);
709
            }
710
        }
711
        break;
712
    case CODEC_TYPE_AUDIO:
713
        frame_size = get_audio_frame_size(st->codec, pkt->size);
714
        if (frame_size < 0)
715
            break;
716
        *pnum = frame_size;
717
        *pden = st->codec->sample_rate;
718
        break;
719
    default:
720
        break;
721
    }
722
}
723

    
724
static int is_intra_only(AVCodecContext *enc){
725
    if(enc->codec_type == CODEC_TYPE_AUDIO){
726
        return 1;
727
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
728
        switch(enc->codec_id){
729
        case CODEC_ID_MJPEG:
730
        case CODEC_ID_MJPEGB:
731
        case CODEC_ID_LJPEG:
732
        case CODEC_ID_RAWVIDEO:
733
        case CODEC_ID_DVVIDEO:
734
        case CODEC_ID_HUFFYUV:
735
        case CODEC_ID_FFVHUFF:
736
        case CODEC_ID_ASV1:
737
        case CODEC_ID_ASV2:
738
        case CODEC_ID_VCR1:
739
            return 1;
740
        default: break;
741
        }
742
    }
743
    return 0;
744
}
745

    
746
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
747
                                      int64_t dts, int64_t pts)
748
{
749
    AVStream *st= s->streams[stream_index];
750
    AVPacketList *pktl= s->packet_buffer;
751

    
752
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
753
        return;
754

    
755
    st->first_dts= dts - st->cur_dts;
756
    st->cur_dts= dts;
757

    
758
    for(; pktl; pktl= pktl->next){
759
        if(pktl->pkt.stream_index != stream_index)
760
            continue;
761
        //FIXME think more about this check
762
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
763
            pktl->pkt.pts += st->first_dts;
764

    
765
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
766
            pktl->pkt.dts += st->first_dts;
767

    
768
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
769
            st->start_time= pktl->pkt.pts;
770
    }
771
    if (st->start_time == AV_NOPTS_VALUE)
772
        st->start_time = pts;
773
}
774

    
775
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
776
{
777
    AVPacketList *pktl= s->packet_buffer;
778
    int64_t cur_dts= 0;
779

    
780
    if(st->first_dts != AV_NOPTS_VALUE){
781
        cur_dts= st->first_dts;
782
        for(; pktl; pktl= pktl->next){
783
            if(pktl->pkt.stream_index == pkt->stream_index){
784
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
785
                    break;
786
                cur_dts -= pkt->duration;
787
            }
788
        }
789
        pktl= s->packet_buffer;
790
        st->first_dts = cur_dts;
791
    }else if(st->cur_dts)
792
        return;
793

    
794
    for(; pktl; pktl= pktl->next){
795
        if(pktl->pkt.stream_index != pkt->stream_index)
796
            continue;
797
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
798
           && !pktl->pkt.duration){
799
            pktl->pkt.dts= cur_dts;
800
            if(!st->codec->has_b_frames)
801
                pktl->pkt.pts= cur_dts;
802
            cur_dts += pkt->duration;
803
            pktl->pkt.duration= pkt->duration;
804
        }else
805
            break;
806
    }
807
    if(st->first_dts == AV_NOPTS_VALUE)
808
        st->cur_dts= cur_dts;
809
}
810

    
811
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
812
                               AVCodecParserContext *pc, AVPacket *pkt)
813
{
814
    int num, den, presentation_delayed, delay, i;
815
    int64_t offset;
816

    
817
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
818
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
819
        pkt->dts -= 1LL<<st->pts_wrap_bits;
820
    }
821

    
822
    if (pkt->duration == 0) {
823
        compute_frame_duration(&num, &den, st, pc, pkt);
824
        if (den && num) {
825
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
826

    
827
            if(pkt->duration != 0 && s->packet_buffer)
828
                update_initial_durations(s, st, pkt);
829
        }
830
    }
831

    
832
    /* correct timestamps with byte offset if demuxers only have timestamps
833
       on packet boundaries */
834
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
835
        /* this will estimate bitrate based on this frame's duration and size */
836
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
837
        if(pkt->pts != AV_NOPTS_VALUE)
838
            pkt->pts += offset;
839
        if(pkt->dts != AV_NOPTS_VALUE)
840
            pkt->dts += offset;
841
    }
842

    
843
    /* do we have a video B-frame ? */
844
    delay= st->codec->has_b_frames;
845
    presentation_delayed = 0;
846
    /* XXX: need has_b_frame, but cannot get it if the codec is
847
        not initialized */
848
    if (delay &&
849
        pc && pc->pict_type != FF_B_TYPE)
850
        presentation_delayed = 1;
851
    /* This may be redundant, but it should not hurt. */
852
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
853
        presentation_delayed = 1;
854

    
855
//    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);
856
    /* interpolate PTS and DTS if they are not present */
857
    if(delay==0 || (delay==1 && pc)){
858
        if (presentation_delayed) {
859
            /* DTS = decompression timestamp */
860
            /* PTS = presentation timestamp */
861
            if (pkt->dts == AV_NOPTS_VALUE)
862
                pkt->dts = st->last_IP_pts;
863
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
864
            if (pkt->dts == AV_NOPTS_VALUE)
865
                pkt->dts = st->cur_dts;
866

    
867
            /* this is tricky: the dts must be incremented by the duration
868
            of the frame we are displaying, i.e. the last I- or P-frame */
869
            if (st->last_IP_duration == 0)
870
                st->last_IP_duration = pkt->duration;
871
            if(pkt->dts != AV_NOPTS_VALUE)
872
                st->cur_dts = pkt->dts + st->last_IP_duration;
873
            st->last_IP_duration  = pkt->duration;
874
            st->last_IP_pts= pkt->pts;
875
            /* cannot compute PTS if not present (we can compute it only
876
            by knowing the future */
877
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
878
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
879
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
880
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
881
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
882
                    pkt->pts += pkt->duration;
883
    //                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);
884
                }
885
            }
886

    
887
            /* presentation is not delayed : PTS and DTS are the same */
888
            if(pkt->pts == AV_NOPTS_VALUE)
889
                pkt->pts = pkt->dts;
890
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
891
            if(pkt->pts == AV_NOPTS_VALUE)
892
                pkt->pts = st->cur_dts;
893
            pkt->dts = pkt->pts;
894
            if(pkt->pts != AV_NOPTS_VALUE)
895
                st->cur_dts = pkt->pts + pkt->duration;
896
        }
897
    }
898

    
899
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
900
        st->pts_buffer[0]= pkt->pts;
901
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
902
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
903
        if(pkt->dts == AV_NOPTS_VALUE)
904
            pkt->dts= st->pts_buffer[0];
905
        if(delay>1){
906
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
907
        }
908
        if(pkt->dts > st->cur_dts)
909
            st->cur_dts = pkt->dts;
910
    }
911

    
912
//    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);
913

    
914
    /* update flags */
915
    if(is_intra_only(st->codec))
916
        pkt->flags |= PKT_FLAG_KEY;
917
    else if (pc) {
918
        pkt->flags = 0;
919
        /* keyframe computation */
920
            if (pc->pict_type == FF_I_TYPE)
921
                pkt->flags |= PKT_FLAG_KEY;
922
    }
923
}
924

    
925
void av_destruct_packet_nofree(AVPacket *pkt)
926
{
927
    pkt->data = NULL; pkt->size = 0;
928
}
929

    
930
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
931
{
932
    AVStream *st;
933
    int len, ret, i;
934

    
935
    av_init_packet(pkt);
936

    
937
    for(;;) {
938
        /* select current input stream component */
939
        st = s->cur_st;
940
        if (st) {
941
            if (!st->need_parsing || !st->parser) {
942
                /* no parsing needed: we just output the packet as is */
943
                /* raw data support */
944
                *pkt = s->cur_pkt;
945
                compute_pkt_fields(s, st, NULL, pkt);
946
                s->cur_st = NULL;
947
                break;
948
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
949
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
950
                                      s->cur_ptr, s->cur_len,
951
                                      s->cur_pkt.pts, s->cur_pkt.dts);
952
                s->cur_pkt.pts = AV_NOPTS_VALUE;
953
                s->cur_pkt.dts = AV_NOPTS_VALUE;
954
                /* increment read pointer */
955
                s->cur_ptr += len;
956
                s->cur_len -= len;
957

    
958
                /* return packet if any */
959
                if (pkt->size) {
960
                got_packet:
961
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
962
                    pkt->duration = 0;
963
                    pkt->stream_index = st->index;
964
                    pkt->pts = st->parser->pts;
965
                    pkt->dts = st->parser->dts;
966
                    pkt->destruct = av_destruct_packet_nofree;
967
                    compute_pkt_fields(s, st, st->parser, pkt);
968

    
969
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
970
                        ff_reduce_index(s, st->index);
971
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
972
                                           0, 0, AVINDEX_KEYFRAME);
973
                    }
974

    
975
                    break;
976
                }
977
            } else {
978
                /* free packet */
979
                av_free_packet(&s->cur_pkt);
980
                s->cur_st = NULL;
981
            }
982
        } else {
983
            /* read next packet */
984
            ret = av_read_packet(s, &s->cur_pkt);
985
            if (ret < 0) {
986
                if (ret == AVERROR(EAGAIN))
987
                    return ret;
988
                /* return the last frames, if any */
989
                for(i = 0; i < s->nb_streams; i++) {
990
                    st = s->streams[i];
991
                    if (st->parser && st->need_parsing) {
992
                        av_parser_parse(st->parser, st->codec,
993
                                        &pkt->data, &pkt->size,
994
                                        NULL, 0,
995
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
996
                        if (pkt->size)
997
                            goto got_packet;
998
                    }
999
                }
1000
                /* no more packets: really terminate parsing */
1001
                return ret;
1002
            }
1003

    
1004
            if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
1005
               s->cur_pkt.dts != AV_NOPTS_VALUE &&
1006
               s->cur_pkt.pts < s->cur_pkt.dts){
1007
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1008
                    s->cur_pkt.stream_index,
1009
                    s->cur_pkt.pts,
1010
                    s->cur_pkt.dts,
1011
                    s->cur_pkt.size);
1012
//                av_free_packet(&s->cur_pkt);
1013
//                return -1;
1014
            }
1015

    
1016
            st = s->streams[s->cur_pkt.stream_index];
1017
            if(s->debug & FF_FDEBUG_TS)
1018
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
1019
                    s->cur_pkt.stream_index,
1020
                    s->cur_pkt.pts,
1021
                    s->cur_pkt.dts,
1022
                    s->cur_pkt.size,
1023
                    s->cur_pkt.flags);
1024

    
1025
            s->cur_st = st;
1026
            s->cur_ptr = s->cur_pkt.data;
1027
            s->cur_len = s->cur_pkt.size;
1028
            if (st->need_parsing && !st->parser) {
1029
                st->parser = av_parser_init(st->codec->codec_id);
1030
                if (!st->parser) {
1031
                    /* no parser available: just output the raw packets */
1032
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1033
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1034
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1035
                }
1036
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1037
                    st->parser->next_frame_offset=
1038
                    st->parser->cur_offset= s->cur_pkt.pos;
1039
                }
1040
            }
1041
        }
1042
    }
1043
    if(s->debug & FF_FDEBUG_TS)
1044
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1045
            pkt->stream_index,
1046
            pkt->pts,
1047
            pkt->dts,
1048
            pkt->size,
1049
            pkt->flags);
1050

    
1051
    return 0;
1052
}
1053

    
1054
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1055
{
1056
    AVPacketList *pktl;
1057
    int eof=0;
1058
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1059

    
1060
    for(;;){
1061
        pktl = s->packet_buffer;
1062
        if (pktl) {
1063
            AVPacket *next_pkt= &pktl->pkt;
1064

    
1065
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1066
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1067
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1068
                       && next_pkt->dts < pktl->pkt.dts
1069
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1070
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1071
                        next_pkt->pts= pktl->pkt.dts;
1072
                    }
1073
                    pktl= pktl->next;
1074
                }
1075
                pktl = s->packet_buffer;
1076
            }
1077

    
1078
            if(   next_pkt->pts != AV_NOPTS_VALUE
1079
               || next_pkt->dts == AV_NOPTS_VALUE
1080
               || !genpts || eof){
1081
                /* read packet from packet buffer, if there is data */
1082
                *pkt = *next_pkt;
1083
                s->packet_buffer = pktl->next;
1084
                av_free(pktl);
1085
                return 0;
1086
            }
1087
        }
1088
        if(genpts){
1089
            int ret= av_read_frame_internal(s, pkt);
1090
            if(ret<0){
1091
                if(pktl && ret != AVERROR(EAGAIN)){
1092
                    eof=1;
1093
                    continue;
1094
                }else
1095
                    return ret;
1096
            }
1097

    
1098
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1099
                                           &s->packet_buffer_end)) < 0)
1100
                return AVERROR(ENOMEM);
1101
        }else{
1102
            assert(!s->packet_buffer);
1103
            return av_read_frame_internal(s, pkt);
1104
        }
1105
    }
1106
}
1107

    
1108
/* XXX: suppress the packet queue */
1109
static void flush_packet_queue(AVFormatContext *s)
1110
{
1111
    AVPacketList *pktl;
1112

    
1113
    for(;;) {
1114
        pktl = s->packet_buffer;
1115
        if (!pktl)
1116
            break;
1117
        s->packet_buffer = pktl->next;
1118
        av_free_packet(&pktl->pkt);
1119
        av_free(pktl);
1120
    }
1121
}
1122

    
1123
/*******************************************************/
1124
/* seek support */
1125

    
1126
int av_find_default_stream_index(AVFormatContext *s)
1127
{
1128
    int first_audio_index = -1;
1129
    int i;
1130
    AVStream *st;
1131

    
1132
    if (s->nb_streams <= 0)
1133
        return -1;
1134
    for(i = 0; i < s->nb_streams; i++) {
1135
        st = s->streams[i];
1136
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1137
            return i;
1138
        }
1139
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1140
            first_audio_index = i;
1141
    }
1142
    return first_audio_index >= 0 ? first_audio_index : 0;
1143
}
1144

    
1145
/**
1146
 * Flush the frame reader.
1147
 */
1148
static void av_read_frame_flush(AVFormatContext *s)
1149
{
1150
    AVStream *st;
1151
    int i;
1152

    
1153
    flush_packet_queue(s);
1154

    
1155
    /* free previous packet */
1156
    if (s->cur_st) {
1157
        if (s->cur_st->parser)
1158
            av_free_packet(&s->cur_pkt);
1159
        s->cur_st = NULL;
1160
    }
1161
    /* fail safe */
1162
    s->cur_ptr = NULL;
1163
    s->cur_len = 0;
1164

    
1165
    /* for each stream, reset read state */
1166
    for(i = 0; i < s->nb_streams; i++) {
1167
        st = s->streams[i];
1168

    
1169
        if (st->parser) {
1170
            av_parser_close(st->parser);
1171
            st->parser = NULL;
1172
        }
1173
        st->last_IP_pts = AV_NOPTS_VALUE;
1174
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1175
    }
1176
}
1177

    
1178
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1179
    int i;
1180

    
1181
    for(i = 0; i < s->nb_streams; i++) {
1182
        AVStream *st = s->streams[i];
1183

    
1184
        st->cur_dts = av_rescale(timestamp,
1185
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1186
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1187
    }
1188
}
1189

    
1190
void ff_reduce_index(AVFormatContext *s, int stream_index)
1191
{
1192
    AVStream *st= s->streams[stream_index];
1193
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1194

    
1195
    if((unsigned)st->nb_index_entries >= max_entries){
1196
        int i;
1197
        for(i=0; 2*i<st->nb_index_entries; i++)
1198
            st->index_entries[i]= st->index_entries[2*i];
1199
        st->nb_index_entries= i;
1200
    }
1201
}
1202

    
1203
int av_add_index_entry(AVStream *st,
1204
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1205
{
1206
    AVIndexEntry *entries, *ie;
1207
    int index;
1208

    
1209
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1210
        return -1;
1211

    
1212
    entries = av_fast_realloc(st->index_entries,
1213
                              &st->index_entries_allocated_size,
1214
                              (st->nb_index_entries + 1) *
1215
                              sizeof(AVIndexEntry));
1216
    if(!entries)
1217
        return -1;
1218

    
1219
    st->index_entries= entries;
1220

    
1221
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1222

    
1223
    if(index<0){
1224
        index= st->nb_index_entries++;
1225
        ie= &entries[index];
1226
        assert(index==0 || ie[-1].timestamp < timestamp);
1227
    }else{
1228
        ie= &entries[index];
1229
        if(ie->timestamp != timestamp){
1230
            if(ie->timestamp <= timestamp)
1231
                return -1;
1232
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1233
            st->nb_index_entries++;
1234
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1235
            distance= ie->min_distance;
1236
    }
1237

    
1238
    ie->pos = pos;
1239
    ie->timestamp = timestamp;
1240
    ie->min_distance= distance;
1241
    ie->size= size;
1242
    ie->flags = flags;
1243

    
1244
    return index;
1245
}
1246

    
1247
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1248
                              int flags)
1249
{
1250
    AVIndexEntry *entries= st->index_entries;
1251
    int nb_entries= st->nb_index_entries;
1252
    int a, b, m;
1253
    int64_t timestamp;
1254

    
1255
    a = - 1;
1256
    b = nb_entries;
1257

    
1258
    while (b - a > 1) {
1259
        m = (a + b) >> 1;
1260
        timestamp = entries[m].timestamp;
1261
        if(timestamp >= wanted_timestamp)
1262
            b = m;
1263
        if(timestamp <= wanted_timestamp)
1264
            a = m;
1265
    }
1266
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1267

    
1268
    if(!(flags & AVSEEK_FLAG_ANY)){
1269
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1270
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1271
        }
1272
    }
1273

    
1274
    if(m == nb_entries)
1275
        return -1;
1276
    return  m;
1277
}
1278

    
1279
#define DEBUG_SEEK
1280

    
1281
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1282
    AVInputFormat *avif= s->iformat;
1283
    int64_t pos_min, pos_max, pos, pos_limit;
1284
    int64_t ts_min, ts_max, ts;
1285
    int index;
1286
    AVStream *st;
1287

    
1288
    if (stream_index < 0)
1289
        return -1;
1290

    
1291
#ifdef DEBUG_SEEK
1292
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1293
#endif
1294

    
1295
    ts_max=
1296
    ts_min= AV_NOPTS_VALUE;
1297
    pos_limit= -1; //gcc falsely says it may be uninitialized
1298

    
1299
    st= s->streams[stream_index];
1300
    if(st->index_entries){
1301
        AVIndexEntry *e;
1302

    
1303
        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()
1304
        index= FFMAX(index, 0);
1305
        e= &st->index_entries[index];
1306

    
1307
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1308
            pos_min= e->pos;
1309
            ts_min= e->timestamp;
1310
#ifdef DEBUG_SEEK
1311
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1312
               pos_min,ts_min);
1313
#endif
1314
        }else{
1315
            assert(index==0);
1316
        }
1317

    
1318
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1319
        assert(index < st->nb_index_entries);
1320
        if(index >= 0){
1321
            e= &st->index_entries[index];
1322
            assert(e->timestamp >= target_ts);
1323
            pos_max= e->pos;
1324
            ts_max= e->timestamp;
1325
            pos_limit= pos_max - e->min_distance;
1326
#ifdef DEBUG_SEEK
1327
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1328
               pos_max,pos_limit, ts_max);
1329
#endif
1330
        }
1331
    }
1332

    
1333
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1334
    if(pos<0)
1335
        return -1;
1336

    
1337
    /* do the seek */
1338
    url_fseek(s->pb, pos, SEEK_SET);
1339

    
1340
    av_update_cur_dts(s, st, ts);
1341

    
1342
    return 0;
1343
}
1344

    
1345
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 )){
1346
    int64_t pos, ts;
1347
    int64_t start_pos, filesize;
1348
    int no_change;
1349

    
1350
#ifdef DEBUG_SEEK
1351
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1352
#endif
1353

    
1354
    if(ts_min == AV_NOPTS_VALUE){
1355
        pos_min = s->data_offset;
1356
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1357
        if (ts_min == AV_NOPTS_VALUE)
1358
            return -1;
1359
    }
1360

    
1361
    if(ts_max == AV_NOPTS_VALUE){
1362
        int step= 1024;
1363
        filesize = url_fsize(s->pb);
1364
        pos_max = filesize - 1;
1365
        do{
1366
            pos_max -= step;
1367
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1368
            step += step;
1369
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1370
        if (ts_max == AV_NOPTS_VALUE)
1371
            return -1;
1372

    
1373
        for(;;){
1374
            int64_t tmp_pos= pos_max + 1;
1375
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1376
            if(tmp_ts == AV_NOPTS_VALUE)
1377
                break;
1378
            ts_max= tmp_ts;
1379
            pos_max= tmp_pos;
1380
            if(tmp_pos >= filesize)
1381
                break;
1382
        }
1383
        pos_limit= pos_max;
1384
    }
1385

    
1386
    if(ts_min > ts_max){
1387
        return -1;
1388
    }else if(ts_min == ts_max){
1389
        pos_limit= pos_min;
1390
    }
1391

    
1392
    no_change=0;
1393
    while (pos_min < pos_limit) {
1394
#ifdef DEBUG_SEEK
1395
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1396
               pos_min, pos_max,
1397
               ts_min, ts_max);
1398
#endif
1399
        assert(pos_limit <= pos_max);
1400

    
1401
        if(no_change==0){
1402
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1403
            // interpolate position (better than dichotomy)
1404
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1405
                + pos_min - approximate_keyframe_distance;
1406
        }else if(no_change==1){
1407
            // bisection, if interpolation failed to change min or max pos last time
1408
            pos = (pos_min + pos_limit)>>1;
1409
        }else{
1410
            /* linear search if bisection failed, can only happen if there
1411
               are very few or no keyframes between min/max */
1412
            pos=pos_min;
1413
        }
1414
        if(pos <= pos_min)
1415
            pos= pos_min + 1;
1416
        else if(pos > pos_limit)
1417
            pos= pos_limit;
1418
        start_pos= pos;
1419

    
1420
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1421
        if(pos == pos_max)
1422
            no_change++;
1423
        else
1424
            no_change=0;
1425
#ifdef DEBUG_SEEK
1426
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);
1427
#endif
1428
        if(ts == AV_NOPTS_VALUE){
1429
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1430
            return -1;
1431
        }
1432
        assert(ts != AV_NOPTS_VALUE);
1433
        if (target_ts <= ts) {
1434
            pos_limit = start_pos - 1;
1435
            pos_max = pos;
1436
            ts_max = ts;
1437
        }
1438
        if (target_ts >= ts) {
1439
            pos_min = pos;
1440
            ts_min = ts;
1441
        }
1442
    }
1443

    
1444
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1445
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1446
#ifdef DEBUG_SEEK
1447
    pos_min = pos;
1448
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1449
    pos_min++;
1450
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1451
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1452
           pos, ts_min, target_ts, ts_max);
1453
#endif
1454
    *ts_ret= ts;
1455
    return pos;
1456
}
1457

    
1458
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1459
    int64_t pos_min, pos_max;
1460
#if 0
1461
    AVStream *st;
1462

1463
    if (stream_index < 0)
1464
        return -1;
1465

1466
    st= s->streams[stream_index];
1467
#endif
1468

    
1469
    pos_min = s->data_offset;
1470
    pos_max = url_fsize(s->pb) - 1;
1471

    
1472
    if     (pos < pos_min) pos= pos_min;
1473
    else if(pos > pos_max) pos= pos_max;
1474

    
1475
    url_fseek(s->pb, pos, SEEK_SET);
1476

    
1477
#if 0
1478
    av_update_cur_dts(s, st, ts);
1479
#endif
1480
    return 0;
1481
}
1482

    
1483
static int av_seek_frame_generic(AVFormatContext *s,
1484
                                 int stream_index, int64_t timestamp, int flags)
1485
{
1486
    int index, ret;
1487
    AVStream *st;
1488
    AVIndexEntry *ie;
1489

    
1490
    st = s->streams[stream_index];
1491

    
1492
    index = av_index_search_timestamp(st, timestamp, flags);
1493

    
1494
    if(index < 0 || index==st->nb_index_entries-1){
1495
        int i;
1496
        AVPacket pkt;
1497

    
1498
        if(st->nb_index_entries){
1499
            assert(st->index_entries);
1500
            ie= &st->index_entries[st->nb_index_entries-1];
1501
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1502
                return ret;
1503
            av_update_cur_dts(s, st, ie->timestamp);
1504
        }else{
1505
            if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1506
                return ret;
1507
        }
1508
        for(i=0;; i++) {
1509
            int ret = av_read_frame(s, &pkt);
1510
            if(ret<0)
1511
                break;
1512
            av_free_packet(&pkt);
1513
            if(stream_index == pkt.stream_index){
1514
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1515
                    break;
1516
            }
1517
        }
1518
        index = av_index_search_timestamp(st, timestamp, flags);
1519
    }
1520
    if (index < 0)
1521
        return -1;
1522

    
1523
    av_read_frame_flush(s);
1524
    if (s->iformat->read_seek){
1525
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1526
            return 0;
1527
    }
1528
    ie = &st->index_entries[index];
1529
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1530
        return ret;
1531
    av_update_cur_dts(s, st, ie->timestamp);
1532

    
1533
    return 0;
1534
}
1535

    
1536
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1537
{
1538
    int ret;
1539
    AVStream *st;
1540

    
1541
    av_read_frame_flush(s);
1542

    
1543
    if(flags & AVSEEK_FLAG_BYTE)
1544
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1545

    
1546
    if(stream_index < 0){
1547
        stream_index= av_find_default_stream_index(s);
1548
        if(stream_index < 0)
1549
            return -1;
1550

    
1551
        st= s->streams[stream_index];
1552
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1553
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1554
    }
1555
    st= s->streams[stream_index];
1556

    
1557
    /* first, we try the format specific seek */
1558
    if (s->iformat->read_seek)
1559
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1560
    else
1561
        ret = -1;
1562
    if (ret >= 0) {
1563
        return 0;
1564
    }
1565

    
1566
    if(s->iformat->read_timestamp)
1567
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1568
    else
1569
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1570
}
1571

    
1572
/*******************************************************/
1573

    
1574
/**
1575
 * Returns TRUE if the stream has accurate duration in any stream.
1576
 *
1577
 * @return TRUE if the stream has accurate duration for at least one component.
1578
 */
1579
static int av_has_duration(AVFormatContext *ic)
1580
{
1581
    int i;
1582
    AVStream *st;
1583

    
1584
    for(i = 0;i < ic->nb_streams; i++) {
1585
        st = ic->streams[i];
1586
        if (st->duration != AV_NOPTS_VALUE)
1587
            return 1;
1588
    }
1589
    return 0;
1590
}
1591

    
1592
/**
1593
 * Estimate the stream timings from the one of each components.
1594
 *
1595
 * Also computes the global bitrate if possible.
1596
 */
1597
static void av_update_stream_timings(AVFormatContext *ic)
1598
{
1599
    int64_t start_time, start_time1, end_time, end_time1;
1600
    int64_t duration, duration1;
1601
    int i;
1602
    AVStream *st;
1603

    
1604
    start_time = INT64_MAX;
1605
    end_time = INT64_MIN;
1606
    duration = INT64_MIN;
1607
    for(i = 0;i < ic->nb_streams; i++) {
1608
        st = ic->streams[i];
1609
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1610
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1611
            if (start_time1 < start_time)
1612
                start_time = start_time1;
1613
            if (st->duration != AV_NOPTS_VALUE) {
1614
                end_time1 = start_time1
1615
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1616
                if (end_time1 > end_time)
1617
                    end_time = end_time1;
1618
            }
1619
        }
1620
        if (st->duration != AV_NOPTS_VALUE) {
1621
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1622
            if (duration1 > duration)
1623
                duration = duration1;
1624
        }
1625
    }
1626
    if (start_time != INT64_MAX) {
1627
        ic->start_time = start_time;
1628
        if (end_time != INT64_MIN) {
1629
            if (end_time - start_time > duration)
1630
                duration = end_time - start_time;
1631
        }
1632
    }
1633
    if (duration != INT64_MIN) {
1634
        ic->duration = duration;
1635
        if (ic->file_size > 0) {
1636
            /* compute the bitrate */
1637
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1638
                (double)ic->duration;
1639
        }
1640
    }
1641
}
1642

    
1643
static void fill_all_stream_timings(AVFormatContext *ic)
1644
{
1645
    int i;
1646
    AVStream *st;
1647

    
1648
    av_update_stream_timings(ic);
1649
    for(i = 0;i < ic->nb_streams; i++) {
1650
        st = ic->streams[i];
1651
        if (st->start_time == AV_NOPTS_VALUE) {
1652
            if(ic->start_time != AV_NOPTS_VALUE)
1653
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1654
            if(ic->duration != AV_NOPTS_VALUE)
1655
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1656
        }
1657
    }
1658
}
1659

    
1660
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1661
{
1662
    int64_t filesize, duration;
1663
    int bit_rate, i;
1664
    AVStream *st;
1665

    
1666
    /* if bit_rate is already set, we believe it */
1667
    if (ic->bit_rate == 0) {
1668
        bit_rate = 0;
1669
        for(i=0;i<ic->nb_streams;i++) {
1670
            st = ic->streams[i];
1671
            bit_rate += st->codec->bit_rate;
1672
        }
1673
        ic->bit_rate = bit_rate;
1674
    }
1675

    
1676
    /* if duration is already set, we believe it */
1677
    if (ic->duration == AV_NOPTS_VALUE &&
1678
        ic->bit_rate != 0 &&
1679
        ic->file_size != 0)  {
1680
        filesize = ic->file_size;
1681
        if (filesize > 0) {
1682
            for(i = 0; i < ic->nb_streams; i++) {
1683
                st = ic->streams[i];
1684
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1685
                if (st->duration == AV_NOPTS_VALUE)
1686
                    st->duration = duration;
1687
            }
1688
        }
1689
    }
1690
}
1691

    
1692
#define DURATION_MAX_READ_SIZE 250000
1693

    
1694
/* only usable for MPEG-PS streams */
1695
static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1696
{
1697
    AVPacket pkt1, *pkt = &pkt1;
1698
    AVStream *st;
1699
    int read_size, i, ret;
1700
    int64_t end_time;
1701
    int64_t filesize, offset, duration;
1702

    
1703
    /* free previous packet */
1704
    if (ic->cur_st && ic->cur_st->parser)
1705
        av_free_packet(&ic->cur_pkt);
1706
    ic->cur_st = NULL;
1707

    
1708
    /* flush packet queue */
1709
    flush_packet_queue(ic);
1710

    
1711
    for(i=0;i<ic->nb_streams;i++) {
1712
        st = ic->streams[i];
1713
        if (st->parser) {
1714
            av_parser_close(st->parser);
1715
            st->parser= NULL;
1716
        }
1717
    }
1718

    
1719
    /* we read the first packets to get the first PTS (not fully
1720
       accurate, but it is enough now) */
1721
    url_fseek(ic->pb, 0, SEEK_SET);
1722
    read_size = 0;
1723
    for(;;) {
1724
        if (read_size >= DURATION_MAX_READ_SIZE)
1725
            break;
1726
        /* if all info is available, we can stop */
1727
        for(i = 0;i < ic->nb_streams; i++) {
1728
            st = ic->streams[i];
1729
            if (st->start_time == AV_NOPTS_VALUE)
1730
                break;
1731
        }
1732
        if (i == ic->nb_streams)
1733
            break;
1734

    
1735
        ret = av_read_packet(ic, pkt);
1736
        if (ret != 0)
1737
            break;
1738
        read_size += pkt->size;
1739
        st = ic->streams[pkt->stream_index];
1740
        if (pkt->pts != AV_NOPTS_VALUE) {
1741
            if (st->start_time == AV_NOPTS_VALUE)
1742
                st->start_time = pkt->pts;
1743
        }
1744
        av_free_packet(pkt);
1745
    }
1746

    
1747
    /* estimate the end time (duration) */
1748
    /* XXX: may need to support wrapping */
1749
    filesize = ic->file_size;
1750
    offset = filesize - DURATION_MAX_READ_SIZE;
1751
    if (offset < 0)
1752
        offset = 0;
1753

    
1754
    url_fseek(ic->pb, offset, SEEK_SET);
1755
    read_size = 0;
1756
    for(;;) {
1757
        if (read_size >= DURATION_MAX_READ_SIZE)
1758
            break;
1759

    
1760
        ret = av_read_packet(ic, pkt);
1761
        if (ret != 0)
1762
            break;
1763
        read_size += pkt->size;
1764
        st = ic->streams[pkt->stream_index];
1765
        if (pkt->pts != AV_NOPTS_VALUE &&
1766
            st->start_time != AV_NOPTS_VALUE) {
1767
            end_time = pkt->pts;
1768
            duration = end_time - st->start_time;
1769
            if (duration > 0) {
1770
                if (st->duration == AV_NOPTS_VALUE ||
1771
                    st->duration < duration)
1772
                    st->duration = duration;
1773
            }
1774
        }
1775
        av_free_packet(pkt);
1776
    }
1777

    
1778
    fill_all_stream_timings(ic);
1779

    
1780
    url_fseek(ic->pb, old_offset, SEEK_SET);
1781
    for(i=0; i<ic->nb_streams; i++){
1782
        st= ic->streams[i];
1783
        st->cur_dts= st->first_dts;
1784
        st->last_IP_pts = AV_NOPTS_VALUE;
1785
    }
1786
}
1787

    
1788
static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1789
{
1790
    int64_t file_size;
1791

    
1792
    /* get the file size, if possible */
1793
    if (ic->iformat->flags & AVFMT_NOFILE) {
1794
        file_size = 0;
1795
    } else {
1796
        file_size = url_fsize(ic->pb);
1797
        if (file_size < 0)
1798
            file_size = 0;
1799
    }
1800
    ic->file_size = file_size;
1801

    
1802
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1803
         !strcmp(ic->iformat->name, "mpegts")) &&
1804
        file_size && !url_is_streamed(ic->pb)) {
1805
        /* get accurate estimate from the PTSes */
1806
        av_estimate_timings_from_pts(ic, old_offset);
1807
    } else if (av_has_duration(ic)) {
1808
        /* at least one component has timings - we use them for all
1809
           the components */
1810
        fill_all_stream_timings(ic);
1811
    } else {
1812
        /* less precise: use bitrate info */
1813
        av_estimate_timings_from_bit_rate(ic);
1814
    }
1815
    av_update_stream_timings(ic);
1816

    
1817
#if 0
1818
    {
1819
        int i;
1820
        AVStream *st;
1821
        for(i = 0;i < ic->nb_streams; i++) {
1822
            st = ic->streams[i];
1823
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1824
               i, (double)st->start_time / AV_TIME_BASE,
1825
               (double)st->duration / AV_TIME_BASE);
1826
        }
1827
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1828
               (double)ic->start_time / AV_TIME_BASE,
1829
               (double)ic->duration / AV_TIME_BASE,
1830
               ic->bit_rate / 1000);
1831
    }
1832
#endif
1833
}
1834

    
1835
static int has_codec_parameters(AVCodecContext *enc)
1836
{
1837
    int val;
1838
    switch(enc->codec_type) {
1839
    case CODEC_TYPE_AUDIO:
1840
        val = enc->sample_rate && enc->channels;
1841
        if(!enc->frame_size &&
1842
           (enc->codec_id == CODEC_ID_VORBIS ||
1843
            enc->codec_id == CODEC_ID_AAC))
1844
            return 0;
1845
        break;
1846
    case CODEC_TYPE_VIDEO:
1847
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1848
        break;
1849
    default:
1850
        val = 1;
1851
        break;
1852
    }
1853
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1854
}
1855

    
1856
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1857
{
1858
    int16_t *samples;
1859
    AVCodec *codec;
1860
    int got_picture, data_size, ret=0;
1861
    AVFrame picture;
1862

    
1863
  if(!st->codec->codec){
1864
    codec = avcodec_find_decoder(st->codec->codec_id);
1865
    if (!codec)
1866
        return -1;
1867
    ret = avcodec_open(st->codec, codec);
1868
    if (ret < 0)
1869
        return ret;
1870
  }
1871

    
1872
  if(!has_codec_parameters(st->codec)){
1873
    switch(st->codec->codec_type) {
1874
    case CODEC_TYPE_VIDEO:
1875
        ret = avcodec_decode_video(st->codec, &picture,
1876
                                   &got_picture, data, size);
1877
        break;
1878
    case CODEC_TYPE_AUDIO:
1879
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1880
        samples = av_malloc(data_size);
1881
        if (!samples)
1882
            goto fail;
1883
        ret = avcodec_decode_audio2(st->codec, samples,
1884
                                    &data_size, data, size);
1885
        av_free(samples);
1886
        break;
1887
    default:
1888
        break;
1889
    }
1890
  }
1891
 fail:
1892
    return ret;
1893
}
1894

    
1895
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1896
{
1897
    while (tags->id != CODEC_ID_NONE) {
1898
        if (tags->id == id)
1899
            return tags->tag;
1900
        tags++;
1901
    }
1902
    return 0;
1903
}
1904

    
1905
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1906
{
1907
    int i;
1908
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1909
        if(tag == tags[i].tag)
1910
            return tags[i].id;
1911
    }
1912
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1913
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1914
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1915
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1916
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1917
            return tags[i].id;
1918
    }
1919
    return CODEC_ID_NONE;
1920
}
1921

    
1922
unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1923
{
1924
    int i;
1925
    for(i=0; tags && tags[i]; i++){
1926
        int tag= codec_get_tag(tags[i], id);
1927
        if(tag) return tag;
1928
    }
1929
    return 0;
1930
}
1931

    
1932
enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1933
{
1934
    int i;
1935
    for(i=0; tags && tags[i]; i++){
1936
        enum CodecID id= codec_get_id(tags[i], tag);
1937
        if(id!=CODEC_ID_NONE) return id;
1938
    }
1939
    return CODEC_ID_NONE;
1940
}
1941

    
1942
static void compute_chapters_end(AVFormatContext *s)
1943
{
1944
    unsigned int i;
1945

    
1946
    for (i=0; i+1<s->nb_chapters; i++)
1947
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1948
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1949
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1950
            s->chapters[i]->end = s->chapters[i+1]->start;
1951
        }
1952

    
1953
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1954
        assert(s->start_time != AV_NOPTS_VALUE);
1955
        assert(s->duration > 0);
1956
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1957
                                           AV_TIME_BASE_Q,
1958
                                           s->chapters[i]->time_base);
1959
    }
1960
}
1961

    
1962
/* absolute maximum size we read until we abort */
1963
#define MAX_READ_SIZE        5000000
1964

    
1965
#define MAX_STD_TIMEBASES (60*12+5)
1966
static int get_std_framerate(int i){
1967
    if(i<60*12) return i*1001;
1968
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1969
}
1970

    
1971
/*
1972
 * Is the time base unreliable.
1973
 * This is a heuristic to balance between quick acceptance of the values in
1974
 * the headers vs. some extra checks.
1975
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1976
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1977
 * And there are "variable" fps files this needs to detect as well.
1978
 */
1979
static int tb_unreliable(AVCodecContext *c){
1980
    if(   c->time_base.den >= 101L*c->time_base.num
1981
       || c->time_base.den <    5L*c->time_base.num
1982
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1983
       || c->codec_tag == ff_get_fourcc("XVID")*/
1984
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1985
        return 1;
1986
    return 0;
1987
}
1988

    
1989
int av_find_stream_info(AVFormatContext *ic)
1990
{
1991
    int i, count, ret, read_size, j;
1992
    AVStream *st;
1993
    AVPacket pkt1, *pkt;
1994
    int64_t last_dts[MAX_STREAMS];
1995
    int duration_count[MAX_STREAMS]={0};
1996
    double (*duration_error)[MAX_STD_TIMEBASES];
1997
    offset_t old_offset = url_ftell(ic->pb);
1998
    int64_t codec_info_duration[MAX_STREAMS]={0};
1999
    int codec_info_nb_frames[MAX_STREAMS]={0};
2000

    
2001
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2002
    if (!duration_error) return AVERROR(ENOMEM);
2003

    
2004
    for(i=0;i<ic->nb_streams;i++) {
2005
        st = ic->streams[i];
2006
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2007
/*            if(!st->time_base.num)
2008
                st->time_base= */
2009
            if(!st->codec->time_base.num)
2010
                st->codec->time_base= st->time_base;
2011
        }
2012
        //only for the split stuff
2013
        if (!st->parser) {
2014
            st->parser = av_parser_init(st->codec->codec_id);
2015
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2016
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2017
            }
2018
        }
2019
    }
2020

    
2021
    for(i=0;i<MAX_STREAMS;i++){
2022
        last_dts[i]= AV_NOPTS_VALUE;
2023
    }
2024

    
2025
    count = 0;
2026
    read_size = 0;
2027
    for(;;) {
2028
        /* check if one codec still needs to be handled */
2029
        for(i=0;i<ic->nb_streams;i++) {
2030
            st = ic->streams[i];
2031
            if (!has_codec_parameters(st->codec))
2032
                break;
2033
            /* variable fps and no guess at the real fps */
2034
            if(   tb_unreliable(st->codec)
2035
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2036
                break;
2037
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2038
                break;
2039
            if(st->first_dts == AV_NOPTS_VALUE)
2040
                break;
2041
        }
2042
        if (i == ic->nb_streams) {
2043
            /* NOTE: if the format has no header, then we need to read
2044
               some packets to get most of the streams, so we cannot
2045
               stop here */
2046
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2047
                /* if we found the info for all the codecs, we can stop */
2048
                ret = count;
2049
                break;
2050
            }
2051
        }
2052
        /* we did not get all the codec info, but we read too much data */
2053
        if (read_size >= MAX_READ_SIZE) {
2054
            ret = count;
2055
            break;
2056
        }
2057

    
2058
        /* NOTE: a new stream can be added there if no header in file
2059
           (AVFMTCTX_NOHEADER) */
2060
        ret = av_read_frame_internal(ic, &pkt1);
2061
        if (ret < 0) {
2062
            /* EOF or error */
2063
            ret = -1; /* we could not have all the codec parameters before EOF */
2064
            for(i=0;i<ic->nb_streams;i++) {
2065
                st = ic->streams[i];
2066
                if (!has_codec_parameters(st->codec)){
2067
                    char buf[256];
2068
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2069
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2070
                } else {
2071
                    ret = 0;
2072
                }
2073
            }
2074
            break;
2075
        }
2076

    
2077
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2078
        if(av_dup_packet(pkt) < 0) {
2079
            av_free(duration_error);
2080
            return AVERROR(ENOMEM);
2081
        }
2082

    
2083
        read_size += pkt->size;
2084

    
2085
        st = ic->streams[pkt->stream_index];
2086
        if(codec_info_nb_frames[st->index]>1)
2087
            codec_info_duration[st->index] += pkt->duration;
2088
        if (pkt->duration != 0)
2089
            codec_info_nb_frames[st->index]++;
2090

    
2091
        {
2092
            int index= pkt->stream_index;
2093
            int64_t last= last_dts[index];
2094
            int64_t duration= pkt->dts - last;
2095

    
2096
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2097
                double dur= duration * av_q2d(st->time_base);
2098

    
2099
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2100
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2101
                if(duration_count[index] < 2)
2102
                    memset(duration_error[index], 0, sizeof(*duration_error));
2103
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2104
                    int framerate= get_std_framerate(i);
2105
                    int ticks= lrintf(dur*framerate/(1001*12));
2106
                    double error= dur - ticks*1001*12/(double)framerate;
2107
                    duration_error[index][i] += error*error;
2108
                }
2109
                duration_count[index]++;
2110
            }
2111
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2112
                last_dts[pkt->stream_index]= pkt->dts;
2113
        }
2114
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2115
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2116
            if(i){
2117
                st->codec->extradata_size= i;
2118
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2119
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2120
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2121
            }
2122
        }
2123

    
2124
        /* if still no information, we try to open the codec and to
2125
           decompress the frame. We try to avoid that in most cases as
2126
           it takes longer and uses more memory. For MPEG-4, we need to
2127
           decompress for QuickTime. */
2128
        if (!has_codec_parameters(st->codec) /*&&
2129
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2130
             st->codec->codec_id == CODEC_ID_H264 ||
2131
             st->codec->codec_id == CODEC_ID_H263 ||
2132
             st->codec->codec_id == CODEC_ID_H261 ||
2133
             st->codec->codec_id == CODEC_ID_VORBIS ||
2134
             st->codec->codec_id == CODEC_ID_MJPEG ||
2135
             st->codec->codec_id == CODEC_ID_PNG ||
2136
             st->codec->codec_id == CODEC_ID_PAM ||
2137
             st->codec->codec_id == CODEC_ID_PGM ||
2138
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2139
             st->codec->codec_id == CODEC_ID_PBM ||
2140
             st->codec->codec_id == CODEC_ID_PPM ||
2141
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2142
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2143
            try_decode_frame(st, pkt->data, pkt->size);
2144

    
2145
        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) {
2146
            break;
2147
        }
2148
        count++;
2149
    }
2150

    
2151
    // close codecs which were opened in try_decode_frame()
2152
    for(i=0;i<ic->nb_streams;i++) {
2153
        st = ic->streams[i];
2154
        if(st->codec->codec)
2155
            avcodec_close(st->codec);
2156
    }
2157
    for(i=0;i<ic->nb_streams;i++) {
2158
        st = ic->streams[i];
2159
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2160
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2161
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2162

    
2163
            if(duration_count[i]
2164
               && tb_unreliable(st->codec) /*&&
2165
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2166
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2167
                double best_error= 2*av_q2d(st->time_base);
2168
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2169

    
2170
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2171
                    double error= duration_error[i][j] * get_std_framerate(j);
2172
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2173
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2174
                    if(error < best_error){
2175
                        best_error= error;
2176
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2177
                    }
2178
                }
2179
            }
2180

    
2181
            if (!st->r_frame_rate.num){
2182
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2183
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2184
                    st->r_frame_rate.num = st->codec->time_base.den;
2185
                    st->r_frame_rate.den = st->codec->time_base.num;
2186
                }else{
2187
                    st->r_frame_rate.num = st->time_base.den;
2188
                    st->r_frame_rate.den = st->time_base.num;
2189
                }
2190
            }
2191
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2192
            if(!st->codec->bits_per_sample)
2193
                st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2194
        }
2195
    }
2196

    
2197
    av_estimate_timings(ic, old_offset);
2198

    
2199
    compute_chapters_end(ic);
2200

    
2201
#if 0
2202
    /* correct DTS for B-frame streams with no timestamps */
2203
    for(i=0;i<ic->nb_streams;i++) {
2204
        st = ic->streams[i];
2205
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2206
            if(b-frames){
2207
                ppktl = &ic->packet_buffer;
2208
                while(ppkt1){
2209
                    if(ppkt1->stream_index != i)
2210
                        continue;
2211
                    if(ppkt1->pkt->dts < 0)
2212
                        break;
2213
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2214
                        break;
2215
                    ppkt1->pkt->dts -= delta;
2216
                    ppkt1= ppkt1->next;
2217
                }
2218
                if(ppkt1)
2219
                    continue;
2220
                st->cur_dts -= delta;
2221
            }
2222
        }
2223
    }
2224
#endif
2225

    
2226
    av_free(duration_error);
2227

    
2228
    return ret;
2229
}
2230

    
2231
/*******************************************************/
2232

    
2233
int av_read_play(AVFormatContext *s)
2234
{
2235
    if (s->iformat->read_play)
2236
        return s->iformat->read_play(s);
2237
    if (s->pb)
2238
        return av_url_read_fpause(s->pb, 0);
2239
    return AVERROR(ENOSYS);
2240
}
2241

    
2242
int av_read_pause(AVFormatContext *s)
2243
{
2244
    if (s->iformat->read_pause)
2245
        return s->iformat->read_pause(s);
2246
    if (s->pb)
2247
        return av_url_read_fpause(s->pb, 1);
2248
    return AVERROR(ENOSYS);
2249
}
2250

    
2251
void av_close_input_stream(AVFormatContext *s)
2252
{
2253
    int i;
2254
    AVStream *st;
2255

    
2256
    /* free previous packet */
2257
    if (s->cur_st && s->cur_st->parser)
2258
        av_free_packet(&s->cur_pkt);
2259

    
2260
    if (s->iformat->read_close)
2261
        s->iformat->read_close(s);
2262
    for(i=0;i<s->nb_streams;i++) {
2263
        /* free all data in a stream component */
2264
        st = s->streams[i];
2265
        if (st->parser) {
2266
            av_parser_close(st->parser);
2267
        }
2268
        av_free(st->index_entries);
2269
        av_free(st->codec->extradata);
2270
        av_free(st->codec);
2271
        av_free(st->filename);
2272
        av_free(st->priv_data);
2273
        av_free(st);
2274
    }
2275
    for(i=s->nb_programs-1; i>=0; i--) {
2276
        av_freep(&s->programs[i]->provider_name);
2277
        av_freep(&s->programs[i]->name);
2278
        av_freep(&s->programs[i]->stream_index);
2279
        av_freep(&s->programs[i]);
2280
    }
2281
    av_freep(&s->programs);
2282
    flush_packet_queue(s);
2283
    av_freep(&s->priv_data);
2284
    while(s->nb_chapters--) {
2285
        av_free(s->chapters[s->nb_chapters]->title);
2286
        av_free(s->chapters[s->nb_chapters]);
2287
    }
2288
    av_freep(&s->chapters);
2289
    av_free(s);
2290
}
2291

    
2292
void av_close_input_file(AVFormatContext *s)
2293
{
2294
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2295
    av_close_input_stream(s);
2296
    if (pb)
2297
        url_fclose(pb);
2298
}
2299

    
2300
AVStream *av_new_stream(AVFormatContext *s, int id)
2301
{
2302
    AVStream *st;
2303
    int i;
2304

    
2305
    if (s->nb_streams >= MAX_STREAMS)
2306
        return NULL;
2307

    
2308
    st = av_mallocz(sizeof(AVStream));
2309
    if (!st)
2310
        return NULL;
2311

    
2312
    st->codec= avcodec_alloc_context();
2313
    if (s->iformat) {
2314
        /* no default bitrate if decoding */
2315
        st->codec->bit_rate = 0;
2316
    }
2317
    st->index = s->nb_streams;
2318
    st->id = id;
2319
    st->start_time = AV_NOPTS_VALUE;
2320
    st->duration = AV_NOPTS_VALUE;
2321
        /* we set the current DTS to 0 so that formats without any timestamps
2322
           but durations get some timestamps, formats with some unknown
2323
           timestamps have their first few packets buffered and the
2324
           timestamps corrected before they are returned to the user */
2325
    st->cur_dts = 0;
2326
    st->first_dts = AV_NOPTS_VALUE;
2327

    
2328
    /* default pts setting is MPEG-like */
2329
    av_set_pts_info(st, 33, 1, 90000);
2330
    st->last_IP_pts = AV_NOPTS_VALUE;
2331
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2332
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2333

    
2334
    st->sample_aspect_ratio = (AVRational){0,1};
2335

    
2336
    s->streams[s->nb_streams++] = st;
2337
    return st;
2338
}
2339

    
2340
AVProgram *av_new_program(AVFormatContext *ac, int id)
2341
{
2342
    AVProgram *program=NULL;
2343
    int i;
2344

    
2345
#ifdef DEBUG_SI
2346
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2347
#endif
2348

    
2349
    for(i=0; i<ac->nb_programs; i++)
2350
        if(ac->programs[i]->id == id)
2351
            program = ac->programs[i];
2352

    
2353
    if(!program){
2354
        program = av_mallocz(sizeof(AVProgram));
2355
        if (!program)
2356
            return NULL;
2357
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2358
        program->discard = AVDISCARD_NONE;
2359
    }
2360
    program->id = id;
2361

    
2362
    return program;
2363
}
2364

    
2365
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2366
{
2367
    assert(!provider_name == !name);
2368
    if(name){
2369
        av_free(program->provider_name);
2370
        av_free(program->         name);
2371
        program->provider_name = av_strdup(provider_name);
2372
        program->         name = av_strdup(         name);
2373
    }
2374
}
2375

    
2376
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2377
{
2378
    AVChapter *chapter = NULL;
2379
    int i;
2380

    
2381
    for(i=0; i<s->nb_chapters; i++)
2382
        if(s->chapters[i]->id == id)
2383
            chapter = s->chapters[i];
2384

    
2385
    if(!chapter){
2386
        chapter= av_mallocz(sizeof(AVChapter));
2387
        if(!chapter)
2388
            return NULL;
2389
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2390
    }
2391
    av_free(chapter->title);
2392
    chapter->title = av_strdup(title);
2393
    chapter->id    = id;
2394
    chapter->time_base= time_base;
2395
    chapter->start = start;
2396
    chapter->end   = end;
2397

    
2398
    return chapter;
2399
}
2400

    
2401
/************************************************************/
2402
/* output media file */
2403

    
2404
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2405
{
2406
    int ret;
2407

    
2408
    if (s->oformat->priv_data_size > 0) {
2409
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2410
        if (!s->priv_data)
2411
            return AVERROR(ENOMEM);
2412
    } else
2413
        s->priv_data = NULL;
2414

    
2415
    if (s->oformat->set_parameters) {
2416
        ret = s->oformat->set_parameters(s, ap);
2417
        if (ret < 0)
2418
            return ret;
2419
    }
2420
    return 0;
2421
}
2422

    
2423
int av_write_header(AVFormatContext *s)
2424
{
2425
    int ret, i;
2426
    AVStream *st;
2427

    
2428
    // some sanity checks
2429
    for(i=0;i<s->nb_streams;i++) {
2430
        st = s->streams[i];
2431

    
2432
        switch (st->codec->codec_type) {
2433
        case CODEC_TYPE_AUDIO:
2434
            if(st->codec->sample_rate<=0){
2435
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2436
                return -1;
2437
            }
2438
            break;
2439
        case CODEC_TYPE_VIDEO:
2440
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2441
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2442
                return -1;
2443
            }
2444
            if(st->codec->width<=0 || st->codec->height<=0){
2445
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2446
                return -1;
2447
            }
2448
            break;
2449
        }
2450

    
2451
        if(s->oformat->codec_tag){
2452
            if(st->codec->codec_tag){
2453
                //FIXME
2454
                //check that tag + id is in the table
2455
                //if neither is in the table -> OK
2456
                //if tag is in the table with another id -> FAIL
2457
                //if id is in the table with another tag -> FAIL unless strict < ?
2458
            }else
2459
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2460
        }
2461
    }
2462

    
2463
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2464
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2465
        if (!s->priv_data)
2466
            return AVERROR(ENOMEM);
2467
    }
2468

    
2469
    if(s->oformat->write_header){
2470
        ret = s->oformat->write_header(s);
2471
        if (ret < 0)
2472
            return ret;
2473
    }
2474

    
2475
    /* init PTS generation */
2476
    for(i=0;i<s->nb_streams;i++) {
2477
        int64_t den = AV_NOPTS_VALUE;
2478
        st = s->streams[i];
2479

    
2480
        switch (st->codec->codec_type) {
2481
        case CODEC_TYPE_AUDIO:
2482
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2483
            break;
2484
        case CODEC_TYPE_VIDEO:
2485
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2486
            break;
2487
        default:
2488
            break;
2489
        }
2490
        if (den != AV_NOPTS_VALUE) {
2491
            if (den <= 0)
2492
                return AVERROR_INVALIDDATA;
2493
            av_frac_init(&st->pts, 0, 0, den);
2494
        }
2495
    }
2496
    return 0;
2497
}
2498

    
2499
//FIXME merge with compute_pkt_fields
2500
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2501
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2502
    int num, den, frame_size, i;
2503

    
2504
//    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);
2505

    
2506
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2507
        return -1;*/
2508

    
2509
    /* duration field */
2510
    if (pkt->duration == 0) {
2511
        compute_frame_duration(&num, &den, st, NULL, pkt);
2512
        if (den && num) {
2513
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2514
        }
2515
    }
2516

    
2517
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2518
        pkt->pts= pkt->dts;
2519

    
2520
    //XXX/FIXME this is a temporary hack until all encoders output pts
2521
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2522
        pkt->dts=
2523
//        pkt->pts= st->cur_dts;
2524
        pkt->pts= st->pts.val;
2525
    }
2526

    
2527
    //calculate dts from pts
2528
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2529
        st->pts_buffer[0]= pkt->pts;
2530
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2531
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2532
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2533
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2534

    
2535
        pkt->dts= st->pts_buffer[0];
2536
    }
2537

    
2538
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2539
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2540
        return -1;
2541
    }
2542
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2543
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2544
        return -1;
2545
    }
2546

    
2547
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2548
    st->cur_dts= pkt->dts;
2549
    st->pts.val= pkt->dts;
2550

    
2551
    /* update pts */
2552
    switch (st->codec->codec_type) {
2553
    case CODEC_TYPE_AUDIO:
2554
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2555

    
2556
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2557
           likely equal to the encoder delay, but it would be better if we
2558
           had the real timestamps from the encoder */
2559
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2560
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2561
        }
2562
        break;
2563
    case CODEC_TYPE_VIDEO:
2564
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2565
        break;
2566
    default:
2567
        break;
2568
    }
2569
    return 0;
2570
}
2571

    
2572
static void truncate_ts(AVStream *st, AVPacket *pkt){
2573
    int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2574

    
2575
//    if(pkt->dts < 0)
2576
//        pkt->dts= 0;  //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
2577

    
2578
    if (pkt->pts != AV_NOPTS_VALUE)
2579
        pkt->pts &= pts_mask;
2580
    if (pkt->dts != AV_NOPTS_VALUE)
2581
        pkt->dts &= pts_mask;
2582
}
2583

    
2584
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2585
{
2586
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2587

    
2588
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2589
        return ret;
2590

    
2591
    truncate_ts(s->streams[pkt->stream_index], pkt);
2592

    
2593
    ret= s->oformat->write_packet(s, pkt);
2594
    if(!ret)
2595
        ret= url_ferror(s->pb);
2596
    return ret;
2597
}
2598

    
2599
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2600
    AVPacketList *pktl, **next_point, *this_pktl;
2601
    int stream_count=0;
2602
    int streams[MAX_STREAMS];
2603

    
2604
    if(pkt){
2605
        AVStream *st= s->streams[ pkt->stream_index];
2606

    
2607
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2608

    
2609
        this_pktl = av_mallocz(sizeof(AVPacketList));
2610
        this_pktl->pkt= *pkt;
2611
        if(pkt->destruct == av_destruct_packet)
2612
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2613
        else
2614
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2615

    
2616
        next_point = &s->packet_buffer;
2617
        while(*next_point){
2618
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2619
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2620
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2621
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2622
                break;
2623
            next_point= &(*next_point)->next;
2624
        }
2625
        this_pktl->next= *next_point;
2626
        *next_point= this_pktl;
2627
    }
2628

    
2629
    memset(streams, 0, sizeof(streams));
2630
    pktl= s->packet_buffer;
2631
    while(pktl){
2632
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2633
        if(streams[ pktl->pkt.stream_index ] == 0)
2634
            stream_count++;
2635
        streams[ pktl->pkt.stream_index ]++;
2636
        pktl= pktl->next;
2637
    }
2638

    
2639
    if(stream_count && (s->nb_streams == stream_count || flush)){
2640
        pktl= s->packet_buffer;
2641
        *out= pktl->pkt;
2642

    
2643
        s->packet_buffer= pktl->next;
2644
        av_freep(&pktl);
2645
        return 1;
2646
    }else{
2647
        av_init_packet(out);
2648
        return 0;
2649
    }
2650
}
2651

    
2652
/**
2653
 * Interleaves an AVPacket correctly so it can be muxed.
2654
 * @param out the interleaved packet will be output here
2655
 * @param in the input packet
2656
 * @param flush 1 if no further packets are available as input and all
2657
 *              remaining packets should be output
2658
 * @return 1 if a packet was output, 0 if no packet could be output,
2659
 *         < 0 if an error occurred
2660
 */
2661
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2662
    if(s->oformat->interleave_packet)
2663
        return s->oformat->interleave_packet(s, out, in, flush);
2664
    else
2665
        return av_interleave_packet_per_dts(s, out, in, flush);
2666
}
2667

    
2668
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2669
    AVStream *st= s->streams[ pkt->stream_index];
2670

    
2671
    //FIXME/XXX/HACK drop zero sized packets
2672
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2673
        return 0;
2674

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

    
2679
    if(pkt->dts == AV_NOPTS_VALUE)
2680
        return -1;
2681

    
2682
    for(;;){
2683
        AVPacket opkt;
2684
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2685
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2686
            return ret;
2687

    
2688
        truncate_ts(s->streams[opkt.stream_index], &opkt);
2689
        ret= s->oformat->write_packet(s, &opkt);
2690

    
2691
        av_free_packet(&opkt);
2692
        pkt= NULL;
2693

    
2694
        if(ret<0)
2695
            return ret;
2696
        if(url_ferror(s->pb))
2697
            return url_ferror(s->pb);
2698
    }
2699
}
2700

    
2701
int av_write_trailer(AVFormatContext *s)
2702
{
2703
    int ret, i;
2704

    
2705
    for(;;){
2706
        AVPacket pkt;
2707
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2708
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2709
            goto fail;
2710
        if(!ret)
2711
            break;
2712

    
2713
        truncate_ts(s->streams[pkt.stream_index], &pkt);
2714
        ret= s->oformat->write_packet(s, &pkt);
2715

    
2716
        av_free_packet(&pkt);
2717

    
2718
        if(ret<0)
2719
            goto fail;
2720
        if(url_ferror(s->pb))
2721
            goto fail;
2722
    }
2723

    
2724
    if(s->oformat->write_trailer)
2725
        ret = s->oformat->write_trailer(s);
2726
fail:
2727
    if(ret == 0)
2728
       ret=url_ferror(s->pb);
2729
    for(i=0;i<s->nb_streams;i++)
2730
        av_freep(&s->streams[i]->priv_data);
2731
    av_freep(&s->priv_data);
2732
    return ret;
2733
}
2734

    
2735
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2736
{
2737
    int i, j;
2738
    AVProgram *program=NULL;
2739
    void *tmp;
2740

    
2741
    for(i=0; i<ac->nb_programs; i++){
2742
        if(ac->programs[i]->id != progid)
2743
            continue;
2744
        program = ac->programs[i];
2745
        for(j=0; j<program->nb_stream_indexes; j++)
2746
            if(program->stream_index[j] == idx)
2747
                return;
2748

    
2749
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2750
        if(!tmp)
2751
            return;
2752
        program->stream_index = tmp;
2753
        program->stream_index[program->nb_stream_indexes++] = idx;
2754
        return;
2755
    }
2756
}
2757

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

    
2786
void dump_format(AVFormatContext *ic,
2787
                 int index,
2788
                 const char *url,
2789
                 int is_output)
2790
{
2791
    int i;
2792

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

    
2842
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2843
{
2844
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2845
}
2846

    
2847
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2848
{
2849
    AVRational frame_rate;
2850
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2851
    *frame_rate_num= frame_rate.num;
2852
    *frame_rate_den= frame_rate.den;
2853
    return ret;
2854
}
2855

    
2856
/**
2857
 * Gets the current time in microseconds.
2858
 */
2859
int64_t av_gettime(void)
2860
{
2861
    struct timeval tv;
2862
    gettimeofday(&tv,NULL);
2863
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2864
}
2865

    
2866
int64_t parse_date(const char *datestr, int duration)
2867
{
2868
    const char *p;
2869
    int64_t t;
2870
    struct tm dt;
2871
    int i;
2872
    static const char * const date_fmt[] = {
2873
        "%Y-%m-%d",
2874
        "%Y%m%d",
2875
    };
2876
    static const char * const time_fmt[] = {
2877
        "%H:%M:%S",
2878
        "%H%M%S",
2879
    };
2880
    const char *q;
2881
    int is_utc, len;
2882
    char lastch;
2883
    int negative = 0;
2884

    
2885
#undef time
2886
    time_t now = time(0);
2887

    
2888
    len = strlen(datestr);
2889
    if (len > 0)
2890
        lastch = datestr[len - 1];
2891
    else
2892
        lastch = '\0';
2893
    is_utc = (lastch == 'z' || lastch == 'Z');
2894

    
2895
    memset(&dt, 0, sizeof(dt));
2896

    
2897
    p = datestr;
2898
    q = NULL;
2899
    if (!duration) {
2900
        /* parse the year-month-day part */
2901
        for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2902
            q = small_strptime(p, date_fmt[i], &dt);
2903
            if (q) {
2904
                break;
2905
            }
2906
        }
2907

    
2908
        /* if the year-month-day part is missing, then take the
2909
         * current year-month-day time */
2910
        if (!q) {
2911
            if (is_utc) {
2912
                dt = *gmtime(&now);
2913
            } else {
2914
                dt = *localtime(&now);
2915
            }
2916
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2917
        } else {
2918
            p = q;
2919
        }
2920

    
2921
        if (*p == 'T' || *p == 't' || *p == ' ')
2922
            p++;
2923

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

    
2950
    /* Now we have all the fields that we can get */
2951
    if (!q) {
2952
        return INT64_MIN;
2953
    }
2954

    
2955
    if (duration) {
2956
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2957
    } else {
2958
        dt.tm_isdst = -1;       /* unknown */
2959
        if (is_utc) {
2960
            t = mktimegm(&dt);
2961
        } else {
2962
            t = mktime(&dt);
2963
        }
2964
    }
2965

    
2966
    t *= 1000000;
2967

    
2968
    /* parse the .m... part */
2969
    if (*q == '.') {
2970
        int val, n;
2971
        q++;
2972
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2973
            if (!isdigit(*q))
2974
                break;
2975
            val += n * (*q - '0');
2976
        }
2977
        t += val;
2978
    }
2979
    return negative ? -t : t;
2980
}
2981

    
2982
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2983
{
2984
    const char *p;
2985
    char tag[128], *q;
2986

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

    
3021
int av_get_frame_filename(char *buf, int buf_size,
3022
                          const char *path, int number)
3023
{
3024
    const char *p;
3025
    char *q, buf1[20], c;
3026
    int nd, len, percentd_found;
3027

    
3028
    q = buf;
3029
    p = path;
3030
    percentd_found = 0;
3031
    for(;;) {
3032
        c = *p++;
3033
        if (c == '\0')
3034
            break;
3035
        if (c == '%') {
3036
            do {
3037
                nd = 0;
3038
                while (isdigit(*p)) {
3039
                    nd = nd * 10 + *p++ - '0';
3040
                }
3041
                c = *p++;
3042
            } while (isdigit(c));
3043

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

    
3076
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3077
{
3078
    int len, i, j, c;
3079
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3080

    
3081
    for(i=0;i<size;i+=16) {
3082
        len = size - i;
3083
        if (len > 16)
3084
            len = 16;
3085
        PRINT("%08x ", i);
3086
        for(j=0;j<16;j++) {
3087
            if (j < len)
3088
                PRINT(" %02x", buf[i+j]);
3089
            else
3090
                PRINT("   ");
3091
        }
3092
        PRINT(" ");
3093
        for(j=0;j<len;j++) {
3094
            c = buf[i+j];
3095
            if (c < ' ' || c > '~')
3096
                c = '.';
3097
            PRINT("%c", c);
3098
        }
3099
        PRINT("\n");
3100
    }
3101
#undef PRINT
3102
}
3103

    
3104
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3105
{
3106
    hex_dump_internal(NULL, f, 0, buf, size);
3107
}
3108

    
3109
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3110
{
3111
    hex_dump_internal(avcl, NULL, level, buf, size);
3112
}
3113

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

    
3140
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3141
{
3142
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3143
}
3144

    
3145
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3146
{
3147
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3148
}
3149

    
3150
void url_split(char *proto, int proto_size,
3151
               char *authorization, int authorization_size,
3152
               char *hostname, int hostname_size,
3153
               int *port_ptr,
3154
               char *path, int path_size,
3155
               const char *url)
3156
{
3157
    const char *p, *ls, *at, *col, *brk;
3158

    
3159
    if (port_ptr)               *port_ptr = -1;
3160
    if (proto_size > 0)         proto[0] = 0;
3161
    if (authorization_size > 0) authorization[0] = 0;
3162
    if (hostname_size > 0)      hostname[0] = 0;
3163
    if (path_size > 0)          path[0] = 0;
3164

    
3165
    /* parse protocol */
3166
    if ((p = strchr(url, ':'))) {
3167
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3168
        p++; /* skip ':' */
3169
        if (*p == '/') p++;
3170
        if (*p == '/') p++;
3171
    } else {
3172
        /* no protocol means plain filename */
3173
        av_strlcpy(path, url, path_size);
3174
        return;
3175
    }
3176

    
3177
    /* separate path from hostname */
3178
    ls = strchr(p, '/');
3179
    if(!ls)
3180
        ls = strchr(p, '?');
3181
    if(ls)
3182
        av_strlcpy(path, ls, path_size);
3183
    else
3184
        ls = &p[strlen(p)]; // XXX
3185

    
3186
    /* the rest is hostname, use that to parse auth/port */
3187
    if (ls != p) {
3188
        /* authorization (user[:pass]@hostname) */
3189
        if ((at = strchr(p, '@')) && at < ls) {
3190
            av_strlcpy(authorization, p,
3191
                       FFMIN(authorization_size, at + 1 - p));
3192
            p = at + 1; /* skip '@' */
3193
        }
3194

    
3195
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3196
            /* [host]:port */
3197
            av_strlcpy(hostname, p + 1,
3198
                       FFMIN(hostname_size, brk - p));
3199
            if (brk[1] == ':' && port_ptr)
3200
                *port_ptr = atoi(brk + 2);
3201
        } else if ((col = strchr(p, ':')) && col < ls) {
3202
            av_strlcpy(hostname, p,
3203
                       FFMIN(col + 1 - p, hostname_size));
3204
            if (port_ptr) *port_ptr = atoi(col + 1);
3205
        } else
3206
            av_strlcpy(hostname, p,
3207
                       FFMIN(ls + 1 - p, hostname_size));
3208
    }
3209
}
3210

    
3211
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3212
                     int pts_num, int pts_den)
3213
{
3214
    unsigned int gcd= ff_gcd(pts_num, pts_den);
3215
    s->pts_wrap_bits = pts_wrap_bits;
3216
    s->time_base.num = pts_num/gcd;
3217
    s->time_base.den = pts_den/gcd;
3218

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