Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ fa0e036d

History | View | Annotate | Download (98.6 KB)

1
/*
2
 * various utility functions for use within FFmpeg
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
#include "avformat.h"
22
#include "internal.h"
23
#include "libavcodec/opt.h"
24
#include "metadata.h"
25
#include "libavutil/avstring.h"
26
#include "riff.h"
27
#include <sys/time.h>
28
#include <time.h>
29
#include <strings.h>
30

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

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

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

    
44
/* fraction handling */
45

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

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

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

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

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

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

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

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

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

    
134
    if(!filename)
135
        return 0;
136

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

    
156
static int match_format(const char *name, const char *names)
157
{
158
    const char *p;
159
    int len, namelen;
160

    
161
    if (!name || !names)
162
        return 0;
163

    
164
    namelen = strlen(name);
165
    while ((p = strchr(names, ','))) {
166
        len = FFMAX(p - names, namelen);
167
        if (!strncasecmp(name, names, len))
168
            return 1;
169
        names = p+1;
170
    }
171
    return !strcasecmp(name, names);
172
}
173

    
174
AVOutputFormat *guess_format(const char *short_name, const char *filename,
175
                             const char *mime_type)
176
{
177
    AVOutputFormat *fmt, *fmt_found;
178
    int score_max, score;
179

    
180
    /* specific test for image sequences */
181
#if CONFIG_IMAGE2_MUXER
182
    if (!short_name && filename &&
183
        av_filename_number_test(filename) &&
184
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
185
        return guess_format("image2", NULL, NULL);
186
    }
187
#endif
188
    /* Find the proper file type. */
189
    fmt_found = NULL;
190
    score_max = 0;
191
    fmt = first_oformat;
192
    while (fmt != NULL) {
193
        score = 0;
194
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
195
            score += 100;
196
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
197
            score += 10;
198
        if (filename && fmt->extensions &&
199
            match_ext(filename, fmt->extensions)) {
200
            score += 5;
201
        }
202
        if (score > score_max) {
203
            score_max = score;
204
            fmt_found = fmt;
205
        }
206
        fmt = fmt->next;
207
    }
208
    return fmt_found;
209
}
210

    
211
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
212
                             const char *mime_type)
213
{
214
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
215

    
216
    if (fmt) {
217
        AVOutputFormat *stream_fmt;
218
        char stream_format_name[64];
219

    
220
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
221
        stream_fmt = guess_format(stream_format_name, NULL, NULL);
222

    
223
        if (stream_fmt)
224
            fmt = stream_fmt;
225
    }
226

    
227
    return fmt;
228
}
229

    
230
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
231
                            const char *filename, const char *mime_type, enum CodecType type){
232
    if(type == CODEC_TYPE_VIDEO){
233
        enum CodecID codec_id= CODEC_ID_NONE;
234

    
235
#if CONFIG_IMAGE2_MUXER
236
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
237
            codec_id= av_guess_image2_codec(filename);
238
        }
239
#endif
240
        if(codec_id == CODEC_ID_NONE)
241
            codec_id= fmt->video_codec;
242
        return codec_id;
243
    }else if(type == CODEC_TYPE_AUDIO)
244
        return fmt->audio_codec;
245
    else
246
        return CODEC_ID_NONE;
247
}
248

    
249
AVInputFormat *av_find_input_format(const char *short_name)
250
{
251
    AVInputFormat *fmt;
252
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
253
        if (match_format(short_name, fmt->name))
254
            return fmt;
255
    }
256
    return NULL;
257
}
258

    
259
/* memory handling */
260

    
261
void av_destruct_packet(AVPacket *pkt)
262
{
263
    av_free(pkt->data);
264
    pkt->data = NULL; pkt->size = 0;
265
}
266

    
267
void av_init_packet(AVPacket *pkt)
268
{
269
    pkt->pts   = AV_NOPTS_VALUE;
270
    pkt->dts   = AV_NOPTS_VALUE;
271
    pkt->pos   = -1;
272
    pkt->duration = 0;
273
    pkt->convergence_duration = 0;
274
    pkt->flags = 0;
275
    pkt->stream_index = 0;
276
    pkt->destruct= av_destruct_packet_nofree;
277
}
278

    
279
int av_new_packet(AVPacket *pkt, int size)
280
{
281
    uint8_t *data;
282
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
283
        return AVERROR(ENOMEM);
284
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
285
    if (!data)
286
        return AVERROR(ENOMEM);
287
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
288

    
289
    av_init_packet(pkt);
290
    pkt->data = data;
291
    pkt->size = size;
292
    pkt->destruct = av_destruct_packet;
293
    return 0;
294
}
295

    
296
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
297
{
298
    int ret= av_new_packet(pkt, size);
299

    
300
    if(ret<0)
301
        return ret;
302

    
303
    pkt->pos= url_ftell(s);
304

    
305
    ret= get_buffer(s, pkt->data, size);
306
    if(ret<=0)
307
        av_free_packet(pkt);
308
    else
309
        pkt->size= ret;
310

    
311
    return ret;
312
}
313

    
314
int av_dup_packet(AVPacket *pkt)
315
{
316
    if (((pkt->destruct == av_destruct_packet_nofree) || (pkt->destruct == NULL)) && pkt->data) {
317
        uint8_t *data;
318
        /* We duplicate the packet and don't forget to add the padding again. */
319
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
320
            return AVERROR(ENOMEM);
321
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
322
        if (!data) {
323
            return AVERROR(ENOMEM);
324
        }
325
        memcpy(data, pkt->data, pkt->size);
326
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
327
        pkt->data = data;
328
        pkt->destruct = av_destruct_packet;
329
    }
330
    return 0;
331
}
332

    
333
int av_filename_number_test(const char *filename)
334
{
335
    char buf[1024];
336
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
337
}
338

    
339
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
340
{
341
    AVInputFormat *fmt1, *fmt;
342
    int score;
343

    
344
    fmt = NULL;
345
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
346
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
347
            continue;
348
        score = 0;
349
        if (fmt1->read_probe) {
350
            score = fmt1->read_probe(pd);
351
        } else if (fmt1->extensions) {
352
            if (match_ext(pd->filename, fmt1->extensions)) {
353
                score = 50;
354
            }
355
        }
356
        if (score > *score_max) {
357
            *score_max = score;
358
            fmt = fmt1;
359
        }else if (score == *score_max)
360
            fmt = NULL;
361
    }
362
    return fmt;
363
}
364

    
365
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
366
    int score=0;
367
    return av_probe_input_format2(pd, is_opened, &score);
368
}
369

    
370
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
371
{
372
    AVInputFormat *fmt;
373
    fmt = av_probe_input_format2(pd, 1, &score);
374

    
375
    if (fmt) {
376
        if (!strcmp(fmt->name, "mp3")) {
377
            st->codec->codec_id = CODEC_ID_MP3;
378
            st->codec->codec_type = CODEC_TYPE_AUDIO;
379
        } else if (!strcmp(fmt->name, "ac3")) {
380
            st->codec->codec_id = CODEC_ID_AC3;
381
            st->codec->codec_type = CODEC_TYPE_AUDIO;
382
        } else if (!strcmp(fmt->name, "mpegvideo")) {
383
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
384
            st->codec->codec_type = CODEC_TYPE_VIDEO;
385
        } else if (!strcmp(fmt->name, "m4v")) {
386
            st->codec->codec_id = CODEC_ID_MPEG4;
387
            st->codec->codec_type = CODEC_TYPE_VIDEO;
388
        } else if (!strcmp(fmt->name, "h264")) {
389
            st->codec->codec_id = CODEC_ID_H264;
390
            st->codec->codec_type = CODEC_TYPE_VIDEO;
391
        }
392
    }
393
    return !!fmt;
394
}
395

    
396
/************************************************************/
397
/* input media file */
398

    
399
/**
400
 * Open a media file from an IO stream. 'fmt' must be specified.
401
 */
402
int av_open_input_stream(AVFormatContext **ic_ptr,
403
                         ByteIOContext *pb, const char *filename,
404
                         AVInputFormat *fmt, AVFormatParameters *ap)
405
{
406
    int err;
407
    AVFormatContext *ic;
408
    AVFormatParameters default_ap;
409

    
410
    if(!ap){
411
        ap=&default_ap;
412
        memset(ap, 0, sizeof(default_ap));
413
    }
414

    
415
    if(!ap->prealloced_context)
416
        ic = avformat_alloc_context();
417
    else
418
        ic = *ic_ptr;
419
    if (!ic) {
420
        err = AVERROR(ENOMEM);
421
        goto fail;
422
    }
423
    ic->iformat = fmt;
424
    ic->pb = pb;
425
    ic->duration = AV_NOPTS_VALUE;
426
    ic->start_time = AV_NOPTS_VALUE;
427
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
428

    
429
    /* allocate private data */
430
    if (fmt->priv_data_size > 0) {
431
        ic->priv_data = av_mallocz(fmt->priv_data_size);
432
        if (!ic->priv_data) {
433
            err = AVERROR(ENOMEM);
434
            goto fail;
435
        }
436
    } else {
437
        ic->priv_data = NULL;
438
    }
439

    
440
    if (ic->iformat->read_header) {
441
        err = ic->iformat->read_header(ic, ap);
442
        if (err < 0)
443
            goto fail;
444
    }
445

    
446
    if (pb && !ic->data_offset)
447
        ic->data_offset = url_ftell(ic->pb);
448

    
449
#if LIBAVFORMAT_VERSION_MAJOR < 53
450
    ff_metadata_demux_compat(ic);
451
#endif
452

    
453
    *ic_ptr = ic;
454
    return 0;
455
 fail:
456
    if (ic) {
457
        int i;
458
        av_freep(&ic->priv_data);
459
        for(i=0;i<ic->nb_streams;i++) {
460
            AVStream *st = ic->streams[i];
461
            if (st) {
462
                av_free(st->priv_data);
463
                av_free(st->codec->extradata);
464
            }
465
            av_free(st);
466
        }
467
    }
468
    av_free(ic);
469
    *ic_ptr = NULL;
470
    return err;
471
}
472

    
473
/** size of probe buffer, for guessing file type from file contents */
474
#define PROBE_BUF_MIN 2048
475
#define PROBE_BUF_MAX (1<<20)
476

    
477
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
478
                       AVInputFormat *fmt,
479
                       int buf_size,
480
                       AVFormatParameters *ap)
481
{
482
    int err, probe_size;
483
    AVProbeData probe_data, *pd = &probe_data;
484
    ByteIOContext *pb = NULL;
485

    
486
    pd->filename = "";
487
    if (filename)
488
        pd->filename = filename;
489
    pd->buf = NULL;
490
    pd->buf_size = 0;
491

    
492
    if (!fmt) {
493
        /* guess format if no file can be opened */
494
        fmt = av_probe_input_format(pd, 0);
495
    }
496

    
497
    /* Do not open file if the format does not need it. XXX: specific
498
       hack needed to handle RTSP/TCP */
499
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
500
        /* if no file needed do not try to open one */
501
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
502
            goto fail;
503
        }
504
        if (buf_size > 0) {
505
            url_setbufsize(pb, buf_size);
506
        }
507

    
508
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
509
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
510
            /* read probe data */
511
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
512
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
513
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
514
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
515
                url_fclose(pb);
516
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
517
                    pb = NULL;
518
                    err = AVERROR(EIO);
519
                    goto fail;
520
                }
521
            }
522
            /* guess file format */
523
            fmt = av_probe_input_format2(pd, 1, &score);
524
        }
525
        av_freep(&pd->buf);
526
    }
527

    
528
    /* if still no format found, error */
529
    if (!fmt) {
530
        err = AVERROR_NOFMT;
531
        goto fail;
532
    }
533

    
534
    /* check filename in case an image number is expected */
535
    if (fmt->flags & AVFMT_NEEDNUMBER) {
536
        if (!av_filename_number_test(filename)) {
537
            err = AVERROR_NUMEXPECTED;
538
            goto fail;
539
        }
540
    }
541
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
542
    if (err)
543
        goto fail;
544
    return 0;
545
 fail:
546
    av_freep(&pd->buf);
547
    if (pb)
548
        url_fclose(pb);
549
    *ic_ptr = NULL;
550
    return err;
551

    
552
}
553

    
554
/*******************************************************/
555

    
556
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
557
                               AVPacketList **plast_pktl){
558
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
559
    if (!pktl)
560
        return NULL;
561

    
562
    if (*packet_buffer)
563
        (*plast_pktl)->next = pktl;
564
    else
565
        *packet_buffer = pktl;
566

    
567
    /* add the packet in the buffered packet list */
568
    *plast_pktl = pktl;
569
    pktl->pkt= *pkt;
570
    return &pktl->pkt;
571
}
572

    
573
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
574
{
575
    int ret;
576
    AVStream *st;
577

    
578
    for(;;){
579
        AVPacketList *pktl = s->raw_packet_buffer;
580

    
581
        if (pktl) {
582
            *pkt = pktl->pkt;
583
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
584
                s->raw_packet_buffer = pktl->next;
585
                av_free(pktl);
586
                return 0;
587
            }
588
        }
589

    
590
        av_init_packet(pkt);
591
        ret= s->iformat->read_packet(s, pkt);
592
        if (ret < 0)
593
            return ret;
594
        st= s->streams[pkt->stream_index];
595

    
596
        switch(st->codec->codec_type){
597
        case CODEC_TYPE_VIDEO:
598
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
599
            break;
600
        case CODEC_TYPE_AUDIO:
601
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
602
            break;
603
        case CODEC_TYPE_SUBTITLE:
604
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
605
            break;
606
        }
607

    
608
        if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
609
            return ret;
610

    
611
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
612

    
613
        if(st->codec->codec_id == CODEC_ID_PROBE){
614
            AVProbeData *pd = &st->probe_data;
615

    
616
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
617
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
618
            pd->buf_size += pkt->size;
619
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
620

    
621
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
622
                set_codec_from_probe_data(st, pd, 1);
623
                if(st->codec->codec_id != CODEC_ID_PROBE){
624
                    pd->buf_size=0;
625
                    av_freep(&pd->buf);
626
                }
627
            }
628
        }
629
    }
630
}
631

    
632
/**********************************************************/
633

    
634
/**
635
 * Get the number of samples of an audio frame. Return -1 on error.
636
 */
637
static int get_audio_frame_size(AVCodecContext *enc, int size)
638
{
639
    int frame_size;
640

    
641
    if(enc->codec_id == CODEC_ID_VORBIS)
642
        return -1;
643

    
644
    if (enc->frame_size <= 1) {
645
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
646

    
647
        if (bits_per_sample) {
648
            if (enc->channels == 0)
649
                return -1;
650
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
651
        } else {
652
            /* used for example by ADPCM codecs */
653
            if (enc->bit_rate == 0)
654
                return -1;
655
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
656
        }
657
    } else {
658
        frame_size = enc->frame_size;
659
    }
660
    return frame_size;
661
}
662

    
663

    
664
/**
665
 * Return the frame duration in seconds. Return 0 if not available.
666
 */
667
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
668
                                   AVCodecParserContext *pc, AVPacket *pkt)
669
{
670
    int frame_size;
671

    
672
    *pnum = 0;
673
    *pden = 0;
674
    switch(st->codec->codec_type) {
675
    case CODEC_TYPE_VIDEO:
676
        if(st->time_base.num*1000LL > st->time_base.den){
677
            *pnum = st->time_base.num;
678
            *pden = st->time_base.den;
679
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
680
            *pnum = st->codec->time_base.num;
681
            *pden = st->codec->time_base.den;
682
            if (pc && pc->repeat_pict) {
683
                // NOTE: repeat_pict can be also -1 for half-frame durations,
684
                // e.g., in H.264 interlaced field picture stream
685
                *pden *= 2;
686
                *pnum = (*pnum) * (2 + pc->repeat_pict);
687
            }
688
        }
689
        break;
690
    case CODEC_TYPE_AUDIO:
691
        frame_size = get_audio_frame_size(st->codec, pkt->size);
692
        if (frame_size < 0)
693
            break;
694
        *pnum = frame_size;
695
        *pden = st->codec->sample_rate;
696
        break;
697
    default:
698
        break;
699
    }
700
}
701

    
702
static int is_intra_only(AVCodecContext *enc){
703
    if(enc->codec_type == CODEC_TYPE_AUDIO){
704
        return 1;
705
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
706
        switch(enc->codec_id){
707
        case CODEC_ID_MJPEG:
708
        case CODEC_ID_MJPEGB:
709
        case CODEC_ID_LJPEG:
710
        case CODEC_ID_RAWVIDEO:
711
        case CODEC_ID_DVVIDEO:
712
        case CODEC_ID_HUFFYUV:
713
        case CODEC_ID_FFVHUFF:
714
        case CODEC_ID_ASV1:
715
        case CODEC_ID_ASV2:
716
        case CODEC_ID_VCR1:
717
        case CODEC_ID_DNXHD:
718
        case CODEC_ID_JPEG2000:
719
            return 1;
720
        default: break;
721
        }
722
    }
723
    return 0;
724
}
725

    
726
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
727
                                      int64_t dts, int64_t pts)
728
{
729
    AVStream *st= s->streams[stream_index];
730
    AVPacketList *pktl= s->packet_buffer;
731

    
732
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
733
        return;
734

    
735
    st->first_dts= dts - st->cur_dts;
736
    st->cur_dts= dts;
737

    
738
    for(; pktl; pktl= pktl->next){
739
        if(pktl->pkt.stream_index != stream_index)
740
            continue;
741
        //FIXME think more about this check
742
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
743
            pktl->pkt.pts += st->first_dts;
744

    
745
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
746
            pktl->pkt.dts += st->first_dts;
747

    
748
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
749
            st->start_time= pktl->pkt.pts;
750
    }
751
    if (st->start_time == AV_NOPTS_VALUE)
752
        st->start_time = pts;
753
}
754

    
755
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
756
{
757
    AVPacketList *pktl= s->packet_buffer;
758
    int64_t cur_dts= 0;
759

    
760
    if(st->first_dts != AV_NOPTS_VALUE){
761
        cur_dts= st->first_dts;
762
        for(; pktl; pktl= pktl->next){
763
            if(pktl->pkt.stream_index == pkt->stream_index){
764
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
765
                    break;
766
                cur_dts -= pkt->duration;
767
            }
768
        }
769
        pktl= s->packet_buffer;
770
        st->first_dts = cur_dts;
771
    }else if(st->cur_dts)
772
        return;
773

    
774
    for(; pktl; pktl= pktl->next){
775
        if(pktl->pkt.stream_index != pkt->stream_index)
776
            continue;
777
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
778
           && !pktl->pkt.duration){
779
            pktl->pkt.dts= cur_dts;
780
            if(!st->codec->has_b_frames)
781
                pktl->pkt.pts= cur_dts;
782
            cur_dts += pkt->duration;
783
            pktl->pkt.duration= pkt->duration;
784
        }else
785
            break;
786
    }
787
    if(st->first_dts == AV_NOPTS_VALUE)
788
        st->cur_dts= cur_dts;
789
}
790

    
791
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
792
                               AVCodecParserContext *pc, AVPacket *pkt)
793
{
794
    int num, den, presentation_delayed, delay, i;
795
    int64_t offset;
796

    
797
    /* do we have a video B-frame ? */
798
    delay= st->codec->has_b_frames;
799
    presentation_delayed = 0;
800
    /* XXX: need has_b_frame, but cannot get it if the codec is
801
        not initialized */
802
    if (delay &&
803
        pc && pc->pict_type != FF_B_TYPE)
804
        presentation_delayed = 1;
805

    
806
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
807
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
808
        pkt->dts -= 1LL<<st->pts_wrap_bits;
809
    }
810

    
811
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
812
    // we take the conservative approach and discard both
813
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
814
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
815
        av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
816
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
817
    }
818

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

    
824
            if(pkt->duration != 0 && s->packet_buffer)
825
                update_initial_durations(s, st, pkt);
826
        }
827
    }
828

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

    
840
    /* This may be redundant, but it should not hurt. */
841
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
842
        presentation_delayed = 1;
843

    
844
//    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);
845
    /* interpolate PTS and DTS if they are not present */
846
    if(delay==0 || (delay==1 && pc)){
847
        if (presentation_delayed) {
848
            /* DTS = decompression timestamp */
849
            /* PTS = presentation timestamp */
850
            if (pkt->dts == AV_NOPTS_VALUE)
851
                pkt->dts = st->last_IP_pts;
852
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
853
            if (pkt->dts == AV_NOPTS_VALUE)
854
                pkt->dts = st->cur_dts;
855

    
856
            /* this is tricky: the dts must be incremented by the duration
857
            of the frame we are displaying, i.e. the last I- or P-frame */
858
            if (st->last_IP_duration == 0)
859
                st->last_IP_duration = pkt->duration;
860
            if(pkt->dts != AV_NOPTS_VALUE)
861
                st->cur_dts = pkt->dts + st->last_IP_duration;
862
            st->last_IP_duration  = pkt->duration;
863
            st->last_IP_pts= pkt->pts;
864
            /* cannot compute PTS if not present (we can compute it only
865
            by knowing the future */
866
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
867
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
868
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
869
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
870
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
871
                    pkt->pts += pkt->duration;
872
    //                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);
873
                }
874
            }
875

    
876
            /* presentation is not delayed : PTS and DTS are the same */
877
            if(pkt->pts == AV_NOPTS_VALUE)
878
                pkt->pts = pkt->dts;
879
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
880
            if(pkt->pts == AV_NOPTS_VALUE)
881
                pkt->pts = st->cur_dts;
882
            pkt->dts = pkt->pts;
883
            if(pkt->pts != AV_NOPTS_VALUE)
884
                st->cur_dts = pkt->pts + pkt->duration;
885
        }
886
    }
887

    
888
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
889
        st->pts_buffer[0]= pkt->pts;
890
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
891
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
892
        if(pkt->dts == AV_NOPTS_VALUE)
893
            pkt->dts= st->pts_buffer[0];
894
        if(delay>1){
895
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
896
        }
897
        if(pkt->dts > st->cur_dts)
898
            st->cur_dts = pkt->dts;
899
    }
900

    
901
//    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);
902

    
903
    /* update flags */
904
    if(is_intra_only(st->codec))
905
        pkt->flags |= PKT_FLAG_KEY;
906
    else if (pc) {
907
        pkt->flags = 0;
908
        /* keyframe computation */
909
        if (pc->key_frame == 1)
910
            pkt->flags |= PKT_FLAG_KEY;
911
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
912
            pkt->flags |= PKT_FLAG_KEY;
913
    }
914
    if (pc)
915
        pkt->convergence_duration = pc->convergence_duration;
916
}
917

    
918
void av_destruct_packet_nofree(AVPacket *pkt)
919
{
920
    pkt->data = NULL; pkt->size = 0;
921
}
922

    
923
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
924
{
925
    AVStream *st;
926
    int len, ret, i;
927

    
928
    av_init_packet(pkt);
929

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

    
951
                /* return packet if any */
952
                if (pkt->size) {
953
                    pkt->pos = st->cur_pkt.pos;              // Isn't quite accurate but close.
954
                got_packet:
955
                    pkt->duration = 0;
956
                    pkt->stream_index = st->index;
957
                    pkt->pts = st->parser->pts;
958
                    pkt->dts = st->parser->dts;
959
                    pkt->destruct = av_destruct_packet_nofree;
960
                    compute_pkt_fields(s, st, st->parser, pkt);
961

    
962
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
963
                        ff_reduce_index(s, st->index);
964
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
965
                                           0, 0, AVINDEX_KEYFRAME);
966
                    }
967

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

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

    
1012
            if(s->debug & FF_FDEBUG_TS)
1013
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
1014
                    st->cur_pkt.stream_index,
1015
                    st->cur_pkt.pts,
1016
                    st->cur_pkt.dts,
1017
                    st->cur_pkt.size,
1018
                    st->cur_pkt.flags);
1019

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

    
1046
    return 0;
1047
}
1048

    
1049
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1050
{
1051
    AVPacketList *pktl;
1052
    int eof=0;
1053
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1054

    
1055
    for(;;){
1056
        pktl = s->packet_buffer;
1057
        if (pktl) {
1058
            AVPacket *next_pkt= &pktl->pkt;
1059

    
1060
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1061
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1062
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1063
                       && next_pkt->dts < pktl->pkt.dts
1064
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1065
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1066
                        next_pkt->pts= pktl->pkt.dts;
1067
                    }
1068
                    pktl= pktl->next;
1069
                }
1070
                pktl = s->packet_buffer;
1071
            }
1072

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

    
1093
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1094
                                           &s->packet_buffer_end)) < 0)
1095
                return AVERROR(ENOMEM);
1096
        }else{
1097
            assert(!s->packet_buffer);
1098
            return av_read_frame_internal(s, pkt);
1099
        }
1100
    }
1101
}
1102

    
1103
/* XXX: suppress the packet queue */
1104
static void flush_packet_queue(AVFormatContext *s)
1105
{
1106
    AVPacketList *pktl;
1107

    
1108
    for(;;) {
1109
        pktl = s->packet_buffer;
1110
        if (!pktl)
1111
            break;
1112
        s->packet_buffer = pktl->next;
1113
        av_free_packet(&pktl->pkt);
1114
        av_free(pktl);
1115
    }
1116
}
1117

    
1118
/*******************************************************/
1119
/* seek support */
1120

    
1121
int av_find_default_stream_index(AVFormatContext *s)
1122
{
1123
    int first_audio_index = -1;
1124
    int i;
1125
    AVStream *st;
1126

    
1127
    if (s->nb_streams <= 0)
1128
        return -1;
1129
    for(i = 0; i < s->nb_streams; i++) {
1130
        st = s->streams[i];
1131
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1132
            return i;
1133
        }
1134
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1135
            first_audio_index = i;
1136
    }
1137
    return first_audio_index >= 0 ? first_audio_index : 0;
1138
}
1139

    
1140
/**
1141
 * Flush the frame reader.
1142
 */
1143
static void av_read_frame_flush(AVFormatContext *s)
1144
{
1145
    AVStream *st;
1146
    int i;
1147

    
1148
    flush_packet_queue(s);
1149

    
1150
    s->cur_st = NULL;
1151

    
1152
    /* for each stream, reset read state */
1153
    for(i = 0; i < s->nb_streams; i++) {
1154
        st = s->streams[i];
1155

    
1156
        if (st->parser) {
1157
            av_parser_close(st->parser);
1158
            st->parser = NULL;
1159
            av_free_packet(&st->cur_pkt);
1160
        }
1161
        st->last_IP_pts = AV_NOPTS_VALUE;
1162
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1163
        /* fail safe */
1164
        st->cur_ptr = NULL;
1165
        st->cur_len = 0;
1166
    }
1167
}
1168

    
1169
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1170
    int i;
1171

    
1172
    for(i = 0; i < s->nb_streams; i++) {
1173
        AVStream *st = s->streams[i];
1174

    
1175
        st->cur_dts = av_rescale(timestamp,
1176
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1177
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1178
    }
1179
}
1180

    
1181
void ff_reduce_index(AVFormatContext *s, int stream_index)
1182
{
1183
    AVStream *st= s->streams[stream_index];
1184
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1185

    
1186
    if((unsigned)st->nb_index_entries >= max_entries){
1187
        int i;
1188
        for(i=0; 2*i<st->nb_index_entries; i++)
1189
            st->index_entries[i]= st->index_entries[2*i];
1190
        st->nb_index_entries= i;
1191
    }
1192
}
1193

    
1194
int av_add_index_entry(AVStream *st,
1195
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1196
{
1197
    AVIndexEntry *entries, *ie;
1198
    int index;
1199

    
1200
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1201
        return -1;
1202

    
1203
    entries = av_fast_realloc(st->index_entries,
1204
                              &st->index_entries_allocated_size,
1205
                              (st->nb_index_entries + 1) *
1206
                              sizeof(AVIndexEntry));
1207
    if(!entries)
1208
        return -1;
1209

    
1210
    st->index_entries= entries;
1211

    
1212
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1213

    
1214
    if(index<0){
1215
        index= st->nb_index_entries++;
1216
        ie= &entries[index];
1217
        assert(index==0 || ie[-1].timestamp < timestamp);
1218
    }else{
1219
        ie= &entries[index];
1220
        if(ie->timestamp != timestamp){
1221
            if(ie->timestamp <= timestamp)
1222
                return -1;
1223
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1224
            st->nb_index_entries++;
1225
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1226
            distance= ie->min_distance;
1227
    }
1228

    
1229
    ie->pos = pos;
1230
    ie->timestamp = timestamp;
1231
    ie->min_distance= distance;
1232
    ie->size= size;
1233
    ie->flags = flags;
1234

    
1235
    return index;
1236
}
1237

    
1238
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1239
                              int flags)
1240
{
1241
    AVIndexEntry *entries= st->index_entries;
1242
    int nb_entries= st->nb_index_entries;
1243
    int a, b, m;
1244
    int64_t timestamp;
1245

    
1246
    a = - 1;
1247
    b = nb_entries;
1248

    
1249
    while (b - a > 1) {
1250
        m = (a + b) >> 1;
1251
        timestamp = entries[m].timestamp;
1252
        if(timestamp >= wanted_timestamp)
1253
            b = m;
1254
        if(timestamp <= wanted_timestamp)
1255
            a = m;
1256
    }
1257
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1258

    
1259
    if(!(flags & AVSEEK_FLAG_ANY)){
1260
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1261
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1262
        }
1263
    }
1264

    
1265
    if(m == nb_entries)
1266
        return -1;
1267
    return  m;
1268
}
1269

    
1270
#define DEBUG_SEEK
1271

    
1272
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1273
    AVInputFormat *avif= s->iformat;
1274
    int64_t pos_min, pos_max, pos, pos_limit;
1275
    int64_t ts_min, ts_max, ts;
1276
    int index;
1277
    AVStream *st;
1278

    
1279
    if (stream_index < 0)
1280
        return -1;
1281

    
1282
#ifdef DEBUG_SEEK
1283
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1284
#endif
1285

    
1286
    ts_max=
1287
    ts_min= AV_NOPTS_VALUE;
1288
    pos_limit= -1; //gcc falsely says it may be uninitialized
1289

    
1290
    st= s->streams[stream_index];
1291
    if(st->index_entries){
1292
        AVIndexEntry *e;
1293

    
1294
        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()
1295
        index= FFMAX(index, 0);
1296
        e= &st->index_entries[index];
1297

    
1298
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1299
            pos_min= e->pos;
1300
            ts_min= e->timestamp;
1301
#ifdef DEBUG_SEEK
1302
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1303
               pos_min,ts_min);
1304
#endif
1305
        }else{
1306
            assert(index==0);
1307
        }
1308

    
1309
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1310
        assert(index < st->nb_index_entries);
1311
        if(index >= 0){
1312
            e= &st->index_entries[index];
1313
            assert(e->timestamp >= target_ts);
1314
            pos_max= e->pos;
1315
            ts_max= e->timestamp;
1316
            pos_limit= pos_max - e->min_distance;
1317
#ifdef DEBUG_SEEK
1318
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1319
               pos_max,pos_limit, ts_max);
1320
#endif
1321
        }
1322
    }
1323

    
1324
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1325
    if(pos<0)
1326
        return -1;
1327

    
1328
    /* do the seek */
1329
    url_fseek(s->pb, pos, SEEK_SET);
1330

    
1331
    av_update_cur_dts(s, st, ts);
1332

    
1333
    return 0;
1334
}
1335

    
1336
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 )){
1337
    int64_t pos, ts;
1338
    int64_t start_pos, filesize;
1339
    int no_change;
1340

    
1341
#ifdef DEBUG_SEEK
1342
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1343
#endif
1344

    
1345
    if(ts_min == AV_NOPTS_VALUE){
1346
        pos_min = s->data_offset;
1347
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1348
        if (ts_min == AV_NOPTS_VALUE)
1349
            return -1;
1350
    }
1351

    
1352
    if(ts_max == AV_NOPTS_VALUE){
1353
        int step= 1024;
1354
        filesize = url_fsize(s->pb);
1355
        pos_max = filesize - 1;
1356
        do{
1357
            pos_max -= step;
1358
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1359
            step += step;
1360
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1361
        if (ts_max == AV_NOPTS_VALUE)
1362
            return -1;
1363

    
1364
        for(;;){
1365
            int64_t tmp_pos= pos_max + 1;
1366
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1367
            if(tmp_ts == AV_NOPTS_VALUE)
1368
                break;
1369
            ts_max= tmp_ts;
1370
            pos_max= tmp_pos;
1371
            if(tmp_pos >= filesize)
1372
                break;
1373
        }
1374
        pos_limit= pos_max;
1375
    }
1376

    
1377
    if(ts_min > ts_max){
1378
        return -1;
1379
    }else if(ts_min == ts_max){
1380
        pos_limit= pos_min;
1381
    }
1382

    
1383
    no_change=0;
1384
    while (pos_min < pos_limit) {
1385
#ifdef DEBUG_SEEK
1386
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1387
               pos_min, pos_max,
1388
               ts_min, ts_max);
1389
#endif
1390
        assert(pos_limit <= pos_max);
1391

    
1392
        if(no_change==0){
1393
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1394
            // interpolate position (better than dichotomy)
1395
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1396
                + pos_min - approximate_keyframe_distance;
1397
        }else if(no_change==1){
1398
            // bisection, if interpolation failed to change min or max pos last time
1399
            pos = (pos_min + pos_limit)>>1;
1400
        }else{
1401
            /* linear search if bisection failed, can only happen if there
1402
               are very few or no keyframes between min/max */
1403
            pos=pos_min;
1404
        }
1405
        if(pos <= pos_min)
1406
            pos= pos_min + 1;
1407
        else if(pos > pos_limit)
1408
            pos= pos_limit;
1409
        start_pos= pos;
1410

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

    
1435
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1436
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1437
#ifdef DEBUG_SEEK
1438
    pos_min = pos;
1439
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1440
    pos_min++;
1441
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1442
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1443
           pos, ts_min, target_ts, ts_max);
1444
#endif
1445
    *ts_ret= ts;
1446
    return pos;
1447
}
1448

    
1449
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1450
    int64_t pos_min, pos_max;
1451
#if 0
1452
    AVStream *st;
1453

1454
    if (stream_index < 0)
1455
        return -1;
1456

1457
    st= s->streams[stream_index];
1458
#endif
1459

    
1460
    pos_min = s->data_offset;
1461
    pos_max = url_fsize(s->pb) - 1;
1462

    
1463
    if     (pos < pos_min) pos= pos_min;
1464
    else if(pos > pos_max) pos= pos_max;
1465

    
1466
    url_fseek(s->pb, pos, SEEK_SET);
1467

    
1468
#if 0
1469
    av_update_cur_dts(s, st, ts);
1470
#endif
1471
    return 0;
1472
}
1473

    
1474
static int av_seek_frame_generic(AVFormatContext *s,
1475
                                 int stream_index, int64_t timestamp, int flags)
1476
{
1477
    int index, ret;
1478
    AVStream *st;
1479
    AVIndexEntry *ie;
1480

    
1481
    st = s->streams[stream_index];
1482

    
1483
    index = av_index_search_timestamp(st, timestamp, flags);
1484

    
1485
    if(index < 0 || index==st->nb_index_entries-1){
1486
        int i;
1487
        AVPacket pkt;
1488

    
1489
        if(st->nb_index_entries){
1490
            assert(st->index_entries);
1491
            ie= &st->index_entries[st->nb_index_entries-1];
1492
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1493
                return ret;
1494
            av_update_cur_dts(s, st, ie->timestamp);
1495
        }else{
1496
            if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1497
                return ret;
1498
        }
1499
        for(i=0;; i++) {
1500
            int ret;
1501
            do{
1502
                ret = av_read_frame(s, &pkt);
1503
            }while(ret == AVERROR(EAGAIN));
1504
            if(ret<0)
1505
                break;
1506
            av_free_packet(&pkt);
1507
            if(stream_index == pkt.stream_index){
1508
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1509
                    break;
1510
            }
1511
        }
1512
        index = av_index_search_timestamp(st, timestamp, flags);
1513
    }
1514
    if (index < 0)
1515
        return -1;
1516

    
1517
    av_read_frame_flush(s);
1518
    if (s->iformat->read_seek){
1519
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1520
            return 0;
1521
    }
1522
    ie = &st->index_entries[index];
1523
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1524
        return ret;
1525
    av_update_cur_dts(s, st, ie->timestamp);
1526

    
1527
    return 0;
1528
}
1529

    
1530
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1531
{
1532
    int ret;
1533
    AVStream *st;
1534

    
1535
    av_read_frame_flush(s);
1536

    
1537
    if(flags & AVSEEK_FLAG_BYTE)
1538
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1539

    
1540
    if(stream_index < 0){
1541
        stream_index= av_find_default_stream_index(s);
1542
        if(stream_index < 0)
1543
            return -1;
1544

    
1545
        st= s->streams[stream_index];
1546
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1547
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1548
    }
1549

    
1550
    /* first, we try the format specific seek */
1551
    if (s->iformat->read_seek)
1552
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1553
    else
1554
        ret = -1;
1555
    if (ret >= 0) {
1556
        return 0;
1557
    }
1558

    
1559
    if(s->iformat->read_timestamp)
1560
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1561
    else
1562
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1563
}
1564

    
1565
/*******************************************************/
1566

    
1567
/**
1568
 * Returns TRUE if the stream has accurate duration in any stream.
1569
 *
1570
 * @return TRUE if the stream has accurate duration for at least one component.
1571
 */
1572
static int av_has_duration(AVFormatContext *ic)
1573
{
1574
    int i;
1575
    AVStream *st;
1576

    
1577
    for(i = 0;i < ic->nb_streams; i++) {
1578
        st = ic->streams[i];
1579
        if (st->duration != AV_NOPTS_VALUE)
1580
            return 1;
1581
    }
1582
    return 0;
1583
}
1584

    
1585
/**
1586
 * Estimate the stream timings from the one of each components.
1587
 *
1588
 * Also computes the global bitrate if possible.
1589
 */
1590
static void av_update_stream_timings(AVFormatContext *ic)
1591
{
1592
    int64_t start_time, start_time1, end_time, end_time1;
1593
    int64_t duration, duration1;
1594
    int i;
1595
    AVStream *st;
1596

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

    
1636
static void fill_all_stream_timings(AVFormatContext *ic)
1637
{
1638
    int i;
1639
    AVStream *st;
1640

    
1641
    av_update_stream_timings(ic);
1642
    for(i = 0;i < ic->nb_streams; i++) {
1643
        st = ic->streams[i];
1644
        if (st->start_time == AV_NOPTS_VALUE) {
1645
            if(ic->start_time != AV_NOPTS_VALUE)
1646
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1647
            if(ic->duration != AV_NOPTS_VALUE)
1648
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1649
        }
1650
    }
1651
}
1652

    
1653
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1654
{
1655
    int64_t filesize, duration;
1656
    int bit_rate, i;
1657
    AVStream *st;
1658

    
1659
    /* if bit_rate is already set, we believe it */
1660
    if (ic->bit_rate == 0) {
1661
        bit_rate = 0;
1662
        for(i=0;i<ic->nb_streams;i++) {
1663
            st = ic->streams[i];
1664
            bit_rate += st->codec->bit_rate;
1665
        }
1666
        ic->bit_rate = bit_rate;
1667
    }
1668

    
1669
    /* if duration is already set, we believe it */
1670
    if (ic->duration == AV_NOPTS_VALUE &&
1671
        ic->bit_rate != 0 &&
1672
        ic->file_size != 0)  {
1673
        filesize = ic->file_size;
1674
        if (filesize > 0) {
1675
            for(i = 0; i < ic->nb_streams; i++) {
1676
                st = ic->streams[i];
1677
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1678
                if (st->duration == AV_NOPTS_VALUE)
1679
                    st->duration = duration;
1680
            }
1681
        }
1682
    }
1683
}
1684

    
1685
#define DURATION_MAX_READ_SIZE 250000
1686

    
1687
/* only usable for MPEG-PS streams */
1688
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1689
{
1690
    AVPacket pkt1, *pkt = &pkt1;
1691
    AVStream *st;
1692
    int read_size, i, ret;
1693
    int64_t end_time;
1694
    int64_t filesize, offset, duration;
1695

    
1696
    ic->cur_st = NULL;
1697

    
1698
    /* flush packet queue */
1699
    flush_packet_queue(ic);
1700

    
1701
    for(i=0;i<ic->nb_streams;i++) {
1702
        st = ic->streams[i];
1703
        if (st->parser) {
1704
            av_parser_close(st->parser);
1705
            st->parser= NULL;
1706
            av_free_packet(&st->cur_pkt);
1707
        }
1708
    }
1709

    
1710
    /* we read the first packets to get the first PTS (not fully
1711
       accurate, but it is enough now) */
1712
    url_fseek(ic->pb, 0, SEEK_SET);
1713
    read_size = 0;
1714
    for(;;) {
1715
        if (read_size >= DURATION_MAX_READ_SIZE)
1716
            break;
1717
        /* if all info is available, we can stop */
1718
        for(i = 0;i < ic->nb_streams; i++) {
1719
            st = ic->streams[i];
1720
            if (st->start_time == AV_NOPTS_VALUE)
1721
                break;
1722
        }
1723
        if (i == ic->nb_streams)
1724
            break;
1725

    
1726
        do{
1727
            ret = av_read_packet(ic, pkt);
1728
        }while(ret == AVERROR(EAGAIN));
1729
        if (ret != 0)
1730
            break;
1731
        read_size += pkt->size;
1732
        st = ic->streams[pkt->stream_index];
1733
        if (pkt->pts != AV_NOPTS_VALUE) {
1734
            if (st->start_time == AV_NOPTS_VALUE)
1735
                st->start_time = pkt->pts;
1736
        }
1737
        av_free_packet(pkt);
1738
    }
1739

    
1740
    /* estimate the end time (duration) */
1741
    /* XXX: may need to support wrapping */
1742
    filesize = ic->file_size;
1743
    offset = filesize - DURATION_MAX_READ_SIZE;
1744
    if (offset < 0)
1745
        offset = 0;
1746

    
1747
    url_fseek(ic->pb, offset, SEEK_SET);
1748
    read_size = 0;
1749
    for(;;) {
1750
        if (read_size >= DURATION_MAX_READ_SIZE)
1751
            break;
1752

    
1753
        do{
1754
            ret = av_read_packet(ic, pkt);
1755
        }while(ret == AVERROR(EAGAIN));
1756
        if (ret != 0)
1757
            break;
1758
        read_size += pkt->size;
1759
        st = ic->streams[pkt->stream_index];
1760
        if (pkt->pts != AV_NOPTS_VALUE &&
1761
            st->start_time != AV_NOPTS_VALUE) {
1762
            end_time = pkt->pts;
1763
            duration = end_time - st->start_time;
1764
            if (duration > 0) {
1765
                if (st->duration == AV_NOPTS_VALUE ||
1766
                    st->duration < duration)
1767
                    st->duration = duration;
1768
            }
1769
        }
1770
        av_free_packet(pkt);
1771
    }
1772

    
1773
    fill_all_stream_timings(ic);
1774

    
1775
    url_fseek(ic->pb, old_offset, SEEK_SET);
1776
    for(i=0; i<ic->nb_streams; i++){
1777
        st= ic->streams[i];
1778
        st->cur_dts= st->first_dts;
1779
        st->last_IP_pts = AV_NOPTS_VALUE;
1780
    }
1781
}
1782

    
1783
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1784
{
1785
    int64_t file_size;
1786

    
1787
    /* get the file size, if possible */
1788
    if (ic->iformat->flags & AVFMT_NOFILE) {
1789
        file_size = 0;
1790
    } else {
1791
        file_size = url_fsize(ic->pb);
1792
        if (file_size < 0)
1793
            file_size = 0;
1794
    }
1795
    ic->file_size = file_size;
1796

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

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

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

    
1851
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1852
{
1853
    int16_t *samples;
1854
    AVCodec *codec;
1855
    int got_picture, data_size, ret=0;
1856
    AVFrame picture;
1857

    
1858
  if(!st->codec->codec){
1859
    codec = avcodec_find_decoder(st->codec->codec_id);
1860
    if (!codec)
1861
        return -1;
1862
    ret = avcodec_open(st->codec, codec);
1863
    if (ret < 0)
1864
        return ret;
1865
  }
1866

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

    
1890
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1891
{
1892
    while (tags->id != CODEC_ID_NONE) {
1893
        if (tags->id == id)
1894
            return tags->tag;
1895
        tags++;
1896
    }
1897
    return 0;
1898
}
1899

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

    
1917
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1918
{
1919
    int i;
1920
    for(i=0; tags && tags[i]; i++){
1921
        int tag= codec_get_tag(tags[i], id);
1922
        if(tag) return tag;
1923
    }
1924
    return 0;
1925
}
1926

    
1927
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1928
{
1929
    int i;
1930
    for(i=0; tags && tags[i]; i++){
1931
        enum CodecID id= codec_get_id(tags[i], tag);
1932
        if(id!=CODEC_ID_NONE) return id;
1933
    }
1934
    return CODEC_ID_NONE;
1935
}
1936

    
1937
static void compute_chapters_end(AVFormatContext *s)
1938
{
1939
    unsigned int i;
1940

    
1941
    for (i=0; i+1<s->nb_chapters; i++)
1942
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1943
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1944
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1945
            s->chapters[i]->end = s->chapters[i+1]->start;
1946
        }
1947

    
1948
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1949
        assert(s->start_time != AV_NOPTS_VALUE);
1950
        assert(s->duration > 0);
1951
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1952
                                           AV_TIME_BASE_Q,
1953
                                           s->chapters[i]->time_base);
1954
    }
1955
}
1956

    
1957
/* absolute maximum size we read until we abort */
1958
#define MAX_READ_SIZE        5000000
1959

    
1960
#define MAX_STD_TIMEBASES (60*12+5)
1961
static int get_std_framerate(int i){
1962
    if(i<60*12) return i*1001;
1963
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1964
}
1965

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

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

    
1996
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1997
    if (!duration_error) return AVERROR(ENOMEM);
1998

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

    
2016
    for(i=0;i<MAX_STREAMS;i++){
2017
        last_dts[i]= AV_NOPTS_VALUE;
2018
    }
2019

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

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

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

    
2080
        read_size += pkt->size;
2081

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

    
2088
        {
2089
            int index= pkt->stream_index;
2090
            int64_t last= last_dts[index];
2091
            int64_t duration= pkt->dts - last;
2092

    
2093
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2094
                double dur= duration * av_q2d(st->time_base);
2095

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

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

    
2142
        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) {
2143
            break;
2144
        }
2145
        count++;
2146
    }
2147

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

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

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

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

    
2194
    av_estimate_timings(ic, old_offset);
2195

    
2196
    compute_chapters_end(ic);
2197

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

    
2223
    av_free(duration_error);
2224

    
2225
    return ret;
2226
}
2227

    
2228
/*******************************************************/
2229

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

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

    
2248
void av_close_input_stream(AVFormatContext *s)
2249
{
2250
    int i;
2251
    AVStream *st;
2252

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

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

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

    
2303
    if (s->nb_streams >= MAX_STREAMS)
2304
        return NULL;
2305

    
2306
    st = av_mallocz(sizeof(AVStream));
2307
    if (!st)
2308
        return NULL;
2309

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

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

    
2332
    st->sample_aspect_ratio = (AVRational){0,1};
2333

    
2334
    s->streams[s->nb_streams++] = st;
2335
    return st;
2336
}
2337

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

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

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

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

    
2360
    return program;
2361
}
2362

    
2363
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2364
{
2365
    AVChapter *chapter = NULL;
2366
    int i;
2367

    
2368
    for(i=0; i<s->nb_chapters; i++)
2369
        if(s->chapters[i]->id == id)
2370
            chapter = s->chapters[i];
2371

    
2372
    if(!chapter){
2373
        chapter= av_mallocz(sizeof(AVChapter));
2374
        if(!chapter)
2375
            return NULL;
2376
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2377
    }
2378
    av_free(chapter->title);
2379
    chapter->title = av_strdup(title);
2380
    chapter->id    = id;
2381
    chapter->time_base= time_base;
2382
    chapter->start = start;
2383
    chapter->end   = end;
2384

    
2385
    return chapter;
2386
}
2387

    
2388
/************************************************************/
2389
/* output media file */
2390

    
2391
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2392
{
2393
    int ret;
2394

    
2395
    if (s->oformat->priv_data_size > 0) {
2396
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2397
        if (!s->priv_data)
2398
            return AVERROR(ENOMEM);
2399
    } else
2400
        s->priv_data = NULL;
2401

    
2402
    if (s->oformat->set_parameters) {
2403
        ret = s->oformat->set_parameters(s, ap);
2404
        if (ret < 0)
2405
            return ret;
2406
    }
2407
    return 0;
2408
}
2409

    
2410
int av_write_header(AVFormatContext *s)
2411
{
2412
    int ret, i;
2413
    AVStream *st;
2414

    
2415
    // some sanity checks
2416
    for(i=0;i<s->nb_streams;i++) {
2417
        st = s->streams[i];
2418

    
2419
        switch (st->codec->codec_type) {
2420
        case CODEC_TYPE_AUDIO:
2421
            if(st->codec->sample_rate<=0){
2422
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2423
                return -1;
2424
            }
2425
            if(!st->codec->block_align)
2426
                st->codec->block_align = st->codec->channels *
2427
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2428
            break;
2429
        case CODEC_TYPE_VIDEO:
2430
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2431
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2432
                return -1;
2433
            }
2434
            if(st->codec->width<=0 || st->codec->height<=0){
2435
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2436
                return -1;
2437
            }
2438
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2439
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2440
                return -1;
2441
            }
2442
            break;
2443
        }
2444

    
2445
        if(s->oformat->codec_tag){
2446
            if(st->codec->codec_tag){
2447
                //FIXME
2448
                //check that tag + id is in the table
2449
                //if neither is in the table -> OK
2450
                //if tag is in the table with another id -> FAIL
2451
                //if id is in the table with another tag -> FAIL unless strict < ?
2452
            }else
2453
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2454
        }
2455

    
2456
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2457
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2458
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2459
    }
2460

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

    
2467
#if LIBAVFORMAT_VERSION_MAJOR < 53
2468
    ff_metadata_mux_compat(s);
2469
#endif
2470

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

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

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

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

    
2506
//    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);
2507

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

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

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

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

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

    
2537
        pkt->dts= st->pts_buffer[0];
2538
    }
2539

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

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

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

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

    
2574
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2575
{
2576
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2577

    
2578
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2579
        return ret;
2580

    
2581
    ret= s->oformat->write_packet(s, pkt);
2582
    if(!ret)
2583
        ret= url_ferror(s->pb);
2584
    return ret;
2585
}
2586

    
2587
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2588
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2589
{
2590
    AVPacketList **next_point, *this_pktl;
2591

    
2592
    this_pktl = av_mallocz(sizeof(AVPacketList));
2593
    this_pktl->pkt= *pkt;
2594
    if(pkt->destruct == av_destruct_packet)
2595
        pkt->destruct= NULL; // not shared -> must keep original from being freed
2596
    else
2597
        av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2598

    
2599
    next_point = &s->packet_buffer;
2600
    while(*next_point){
2601
        if(compare(s, &(*next_point)->pkt, pkt))
2602
            break;
2603
        next_point= &(*next_point)->next;
2604
    }
2605
    this_pktl->next= *next_point;
2606
    *next_point= this_pktl;
2607
}
2608

    
2609
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2610
{
2611
    AVStream *st = s->streams[ pkt ->stream_index];
2612
    AVStream *st2= s->streams[ next->stream_index];
2613
    int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2614
    int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2615

    
2616
    if (pkt->dts == AV_NOPTS_VALUE)
2617
        return 0;
2618

    
2619
    return next->dts * left > pkt->dts * right; //FIXME this can overflow
2620
}
2621

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

    
2627
    if(pkt){
2628
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2629
    }
2630

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

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

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

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

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

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

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

    
2681
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2682
        return -1;
2683

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

    
2690
        ret= s->oformat->write_packet(s, &opkt);
2691

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

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

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

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

    
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 = av_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->sample_aspect_ratio.num && // default
2776
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2777
        AVRational display_aspect_ratio;
2778
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2779
                  st->codec->width*st->sample_aspect_ratio.num,
2780
                  st->codec->height*st->sample_aspect_ratio.den,
2781
                  1024*1024);
2782
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2783
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2784
                 display_aspect_ratio.num, display_aspect_ratio.den);
2785
    }
2786
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2787
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2788
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2789
        if(st->time_base.den && st->time_base.num)
2790
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));
2791
        if(st->codec->time_base.den && st->codec->time_base.num)
2792
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2793
    }
2794
    av_log(NULL, AV_LOG_INFO, "\n");
2795
}
2796

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

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

    
2853
#if LIBAVFORMAT_VERSION_MAJOR < 53
2854
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2855
{
2856
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2857
}
2858

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

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

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

    
2895
#undef time
2896
    time_t now = time(0);
2897

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

    
2905
    memset(&dt, 0, sizeof(dt));
2906

    
2907
    p = datestr;
2908
    q = NULL;
2909
    if (!duration) {
2910
        if (!strncasecmp(datestr, "now", len))
2911
            return (int64_t) now * 1000000;
2912

    
2913
        /* parse the year-month-day part */
2914
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2915
            q = small_strptime(p, date_fmt[i], &dt);
2916
            if (q) {
2917
                break;
2918
            }
2919
        }
2920

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

    
2934
        if (*p == 'T' || *p == 't' || *p == ' ')
2935
            p++;
2936

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

    
2963
    /* Now we have all the fields that we can get */
2964
    if (!q) {
2965
        return INT64_MIN;
2966
    }
2967

    
2968
    if (duration) {
2969
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2970
    } else {
2971
        dt.tm_isdst = -1;       /* unknown */
2972
        if (is_utc) {
2973
            t = mktimegm(&dt);
2974
        } else {
2975
            t = mktime(&dt);
2976
        }
2977
    }
2978

    
2979
    t *= 1000000;
2980

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

    
2995
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2996
{
2997
    const char *p;
2998
    char tag[128], *q;
2999

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

    
3034
int av_get_frame_filename(char *buf, int buf_size,
3035
                          const char *path, int number)
3036
{
3037
    const char *p;
3038
    char *q, buf1[20], c;
3039
    int nd, len, percentd_found;
3040

    
3041
    q = buf;
3042
    p = path;
3043
    percentd_found = 0;
3044
    for(;;) {
3045
        c = *p++;
3046
        if (c == '\0')
3047
            break;
3048
        if (c == '%') {
3049
            do {
3050
                nd = 0;
3051
                while (isdigit(*p)) {
3052
                    nd = nd * 10 + *p++ - '0';
3053
                }
3054
                c = *p++;
3055
            } while (isdigit(c));
3056

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

    
3089
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3090
{
3091
    int len, i, j, c;
3092
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3093

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

    
3117
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3118
{
3119
    hex_dump_internal(NULL, f, 0, buf, size);
3120
}
3121

    
3122
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3123
{
3124
    hex_dump_internal(avcl, NULL, level, buf, size);
3125
}
3126

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

    
3153
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3154
{
3155
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3156
}
3157

    
3158
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3159
{
3160
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3161
}
3162

    
3163
void url_split(char *proto, int proto_size,
3164
               char *authorization, int authorization_size,
3165
               char *hostname, int hostname_size,
3166
               int *port_ptr,
3167
               char *path, int path_size,
3168
               const char *url)
3169
{
3170
    const char *p, *ls, *at, *col, *brk;
3171

    
3172
    if (port_ptr)               *port_ptr = -1;
3173
    if (proto_size > 0)         proto[0] = 0;
3174
    if (authorization_size > 0) authorization[0] = 0;
3175
    if (hostname_size > 0)      hostname[0] = 0;
3176
    if (path_size > 0)          path[0] = 0;
3177

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

    
3190
    /* separate path from hostname */
3191
    ls = strchr(p, '/');
3192
    if(!ls)
3193
        ls = strchr(p, '?');
3194
    if(ls)
3195
        av_strlcpy(path, ls, path_size);
3196
    else
3197
        ls = &p[strlen(p)]; // XXX
3198

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

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

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

    
3232
    for(i = 0; i < s; i++) {
3233
        buff[i * 2]     = hex_table[src[i] >> 4];
3234
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3235
    }
3236

    
3237
    return buff;
3238
}
3239

    
3240
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3241
                     int pts_num, int pts_den)
3242
{
3243
    unsigned int gcd= av_gcd(pts_num, pts_den);
3244
    s->pts_wrap_bits = pts_wrap_bits;
3245
    s->time_base.num = pts_num/gcd;
3246
    s->time_base.den = pts_den/gcd;
3247

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