Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 818062f2

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

    
262
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
263
{
264
    int ret= av_new_packet(pkt, size);
265

    
266
    if(ret<0)
267
        return ret;
268

    
269
    pkt->pos= url_ftell(s);
270

    
271
    ret= get_buffer(s, pkt->data, size);
272
    if(ret<=0)
273
        av_free_packet(pkt);
274
    else
275
        av_shrink_packet(pkt, ret);
276

    
277
    return ret;
278
}
279

    
280

    
281
int av_filename_number_test(const char *filename)
282
{
283
    char buf[1024];
284
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
285
}
286

    
287
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
288
{
289
    AVInputFormat *fmt1, *fmt;
290
    int score;
291

    
292
    fmt = NULL;
293
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
294
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
295
            continue;
296
        score = 0;
297
        if (fmt1->read_probe) {
298
            score = fmt1->read_probe(pd);
299
        } else if (fmt1->extensions) {
300
            if (match_ext(pd->filename, fmt1->extensions)) {
301
                score = 50;
302
            }
303
        }
304
        if (score > *score_max) {
305
            *score_max = score;
306
            fmt = fmt1;
307
        }else if (score == *score_max)
308
            fmt = NULL;
309
    }
310
    return fmt;
311
}
312

    
313
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
314
    int score=0;
315
    return av_probe_input_format2(pd, is_opened, &score);
316
}
317

    
318
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
319
{
320
    AVInputFormat *fmt;
321
    fmt = av_probe_input_format2(pd, 1, &score);
322

    
323
    if (fmt) {
324
        if (!strcmp(fmt->name, "mp3")) {
325
            st->codec->codec_id = CODEC_ID_MP3;
326
            st->codec->codec_type = CODEC_TYPE_AUDIO;
327
        } else if (!strcmp(fmt->name, "ac3")) {
328
            st->codec->codec_id = CODEC_ID_AC3;
329
            st->codec->codec_type = CODEC_TYPE_AUDIO;
330
        } else if (!strcmp(fmt->name, "mpegvideo")) {
331
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
332
            st->codec->codec_type = CODEC_TYPE_VIDEO;
333
        } else if (!strcmp(fmt->name, "m4v")) {
334
            st->codec->codec_id = CODEC_ID_MPEG4;
335
            st->codec->codec_type = CODEC_TYPE_VIDEO;
336
        } else if (!strcmp(fmt->name, "h264")) {
337
            st->codec->codec_id = CODEC_ID_H264;
338
            st->codec->codec_type = CODEC_TYPE_VIDEO;
339
        } else if (!strcmp(fmt->name, "dts")) {
340
            st->codec->codec_id = CODEC_ID_DTS;
341
            st->codec->codec_type = CODEC_TYPE_AUDIO;
342
        }
343
    }
344
    return !!fmt;
345
}
346

    
347
/************************************************************/
348
/* input media file */
349

    
350
/**
351
 * Open a media file from an IO stream. 'fmt' must be specified.
352
 */
353
int av_open_input_stream(AVFormatContext **ic_ptr,
354
                         ByteIOContext *pb, const char *filename,
355
                         AVInputFormat *fmt, AVFormatParameters *ap)
356
{
357
    int err;
358
    AVFormatContext *ic;
359
    AVFormatParameters default_ap;
360

    
361
    if(!ap){
362
        ap=&default_ap;
363
        memset(ap, 0, sizeof(default_ap));
364
    }
365

    
366
    if(!ap->prealloced_context)
367
        ic = avformat_alloc_context();
368
    else
369
        ic = *ic_ptr;
370
    if (!ic) {
371
        err = AVERROR(ENOMEM);
372
        goto fail;
373
    }
374
    ic->iformat = fmt;
375
    ic->pb = pb;
376
    ic->duration = AV_NOPTS_VALUE;
377
    ic->start_time = AV_NOPTS_VALUE;
378
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
379

    
380
    /* allocate private data */
381
    if (fmt->priv_data_size > 0) {
382
        ic->priv_data = av_mallocz(fmt->priv_data_size);
383
        if (!ic->priv_data) {
384
            err = AVERROR(ENOMEM);
385
            goto fail;
386
        }
387
    } else {
388
        ic->priv_data = NULL;
389
    }
390

    
391
    if (ic->iformat->read_header) {
392
        err = ic->iformat->read_header(ic, ap);
393
        if (err < 0)
394
            goto fail;
395
    }
396

    
397
    if (pb && !ic->data_offset)
398
        ic->data_offset = url_ftell(ic->pb);
399

    
400
#if LIBAVFORMAT_VERSION_MAJOR < 53
401
    ff_metadata_demux_compat(ic);
402
#endif
403

    
404
    *ic_ptr = ic;
405
    return 0;
406
 fail:
407
    if (ic) {
408
        int i;
409
        av_freep(&ic->priv_data);
410
        for(i=0;i<ic->nb_streams;i++) {
411
            AVStream *st = ic->streams[i];
412
            if (st) {
413
                av_free(st->priv_data);
414
                av_free(st->codec->extradata);
415
            }
416
            av_free(st);
417
        }
418
    }
419
    av_free(ic);
420
    *ic_ptr = NULL;
421
    return err;
422
}
423

    
424
/** size of probe buffer, for guessing file type from file contents */
425
#define PROBE_BUF_MIN 2048
426
#define PROBE_BUF_MAX (1<<20)
427

    
428
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
429
                       AVInputFormat *fmt,
430
                       int buf_size,
431
                       AVFormatParameters *ap)
432
{
433
    int err, probe_size;
434
    AVProbeData probe_data, *pd = &probe_data;
435
    ByteIOContext *pb = NULL;
436

    
437
    pd->filename = "";
438
    if (filename)
439
        pd->filename = filename;
440
    pd->buf = NULL;
441
    pd->buf_size = 0;
442

    
443
    if (!fmt) {
444
        /* guess format if no file can be opened */
445
        fmt = av_probe_input_format(pd, 0);
446
    }
447

    
448
    /* Do not open file if the format does not need it. XXX: specific
449
       hack needed to handle RTSP/TCP */
450
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
451
        /* if no file needed do not try to open one */
452
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
453
            goto fail;
454
        }
455
        if (buf_size > 0) {
456
            url_setbufsize(pb, buf_size);
457
        }
458

    
459
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
460
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
461
            /* read probe data */
462
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
463
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
464
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
465
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
466
                url_fclose(pb);
467
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
468
                    pb = NULL;
469
                    err = AVERROR(EIO);
470
                    goto fail;
471
                }
472
            }
473
            /* guess file format */
474
            fmt = av_probe_input_format2(pd, 1, &score);
475
        }
476
        av_freep(&pd->buf);
477
    }
478

    
479
    /* if still no format found, error */
480
    if (!fmt) {
481
        err = AVERROR_NOFMT;
482
        goto fail;
483
    }
484

    
485
    /* check filename in case an image number is expected */
486
    if (fmt->flags & AVFMT_NEEDNUMBER) {
487
        if (!av_filename_number_test(filename)) {
488
            err = AVERROR_NUMEXPECTED;
489
            goto fail;
490
        }
491
    }
492
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
493
    if (err)
494
        goto fail;
495
    return 0;
496
 fail:
497
    av_freep(&pd->buf);
498
    if (pb)
499
        url_fclose(pb);
500
    *ic_ptr = NULL;
501
    return err;
502

    
503
}
504

    
505
/*******************************************************/
506

    
507
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
508
                               AVPacketList **plast_pktl){
509
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
510
    if (!pktl)
511
        return NULL;
512

    
513
    if (*packet_buffer)
514
        (*plast_pktl)->next = pktl;
515
    else
516
        *packet_buffer = pktl;
517

    
518
    /* add the packet in the buffered packet list */
519
    *plast_pktl = pktl;
520
    pktl->pkt= *pkt;
521
    return &pktl->pkt;
522
}
523

    
524
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
525
{
526
    int ret, i;
527
    AVStream *st;
528

    
529
    for(;;){
530
        AVPacketList *pktl = s->raw_packet_buffer;
531

    
532
        if (pktl) {
533
            *pkt = pktl->pkt;
534
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
535
               !s->streams[pkt->stream_index]->probe_packets){
536
                s->raw_packet_buffer = pktl->next;
537
                av_free(pktl);
538
                return 0;
539
            }
540
        }
541

    
542
        av_init_packet(pkt);
543
        ret= s->iformat->read_packet(s, pkt);
544
        if (ret < 0) {
545
            if (!pktl || ret == AVERROR(EAGAIN))
546
                return ret;
547
            for (i = 0; i < s->nb_streams; i++)
548
                s->streams[i]->probe_packets = 0;
549
            continue;
550
        }
551
        st= s->streams[pkt->stream_index];
552

    
553
        switch(st->codec->codec_type){
554
        case CODEC_TYPE_VIDEO:
555
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
556
            break;
557
        case CODEC_TYPE_AUDIO:
558
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
559
            break;
560
        case CODEC_TYPE_SUBTITLE:
561
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
562
            break;
563
        }
564

    
565
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
566
                     !st->probe_packets))
567
            return ret;
568

    
569
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
570

    
571
        if(st->codec->codec_id == CODEC_ID_PROBE){
572
            AVProbeData *pd = &st->probe_data;
573

    
574
            --st->probe_packets;
575

    
576
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
577
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
578
            pd->buf_size += pkt->size;
579
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
580

    
581
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
582
                set_codec_from_probe_data(st, pd, 1);
583
                if(st->codec->codec_id != CODEC_ID_PROBE){
584
                    pd->buf_size=0;
585
                    av_freep(&pd->buf);
586
                }
587
            }
588
        }
589
    }
590
}
591

    
592
/**********************************************************/
593

    
594
/**
595
 * Get the number of samples of an audio frame. Return -1 on error.
596
 */
597
static int get_audio_frame_size(AVCodecContext *enc, int size)
598
{
599
    int frame_size;
600

    
601
    if(enc->codec_id == CODEC_ID_VORBIS)
602
        return -1;
603

    
604
    if (enc->frame_size <= 1) {
605
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
606

    
607
        if (bits_per_sample) {
608
            if (enc->channels == 0)
609
                return -1;
610
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
611
        } else {
612
            /* used for example by ADPCM codecs */
613
            if (enc->bit_rate == 0)
614
                return -1;
615
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
616
        }
617
    } else {
618
        frame_size = enc->frame_size;
619
    }
620
    return frame_size;
621
}
622

    
623

    
624
/**
625
 * Return the frame duration in seconds. Return 0 if not available.
626
 */
627
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
628
                                   AVCodecParserContext *pc, AVPacket *pkt)
629
{
630
    int frame_size;
631

    
632
    *pnum = 0;
633
    *pden = 0;
634
    switch(st->codec->codec_type) {
635
    case CODEC_TYPE_VIDEO:
636
        if(st->time_base.num*1000LL > st->time_base.den){
637
            *pnum = st->time_base.num;
638
            *pden = st->time_base.den;
639
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
640
            *pnum = st->codec->time_base.num;
641
            *pden = st->codec->time_base.den;
642
            if (pc && pc->repeat_pict) {
643
                *pnum = (*pnum) * (1 + pc->repeat_pict);
644
            }
645
        }
646
        break;
647
    case CODEC_TYPE_AUDIO:
648
        frame_size = get_audio_frame_size(st->codec, pkt->size);
649
        if (frame_size < 0)
650
            break;
651
        *pnum = frame_size;
652
        *pden = st->codec->sample_rate;
653
        break;
654
    default:
655
        break;
656
    }
657
}
658

    
659
static int is_intra_only(AVCodecContext *enc){
660
    if(enc->codec_type == CODEC_TYPE_AUDIO){
661
        return 1;
662
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
663
        switch(enc->codec_id){
664
        case CODEC_ID_MJPEG:
665
        case CODEC_ID_MJPEGB:
666
        case CODEC_ID_LJPEG:
667
        case CODEC_ID_RAWVIDEO:
668
        case CODEC_ID_DVVIDEO:
669
        case CODEC_ID_HUFFYUV:
670
        case CODEC_ID_FFVHUFF:
671
        case CODEC_ID_ASV1:
672
        case CODEC_ID_ASV2:
673
        case CODEC_ID_VCR1:
674
        case CODEC_ID_DNXHD:
675
        case CODEC_ID_JPEG2000:
676
            return 1;
677
        default: break;
678
        }
679
    }
680
    return 0;
681
}
682

    
683
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
684
                                      int64_t dts, int64_t pts)
685
{
686
    AVStream *st= s->streams[stream_index];
687
    AVPacketList *pktl= s->packet_buffer;
688

    
689
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
690
        return;
691

    
692
    st->first_dts= dts - st->cur_dts;
693
    st->cur_dts= dts;
694

    
695
    for(; pktl; pktl= pktl->next){
696
        if(pktl->pkt.stream_index != stream_index)
697
            continue;
698
        //FIXME think more about this check
699
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
700
            pktl->pkt.pts += st->first_dts;
701

    
702
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
703
            pktl->pkt.dts += st->first_dts;
704

    
705
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
706
            st->start_time= pktl->pkt.pts;
707
    }
708
    if (st->start_time == AV_NOPTS_VALUE)
709
        st->start_time = pts;
710
}
711

    
712
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
713
{
714
    AVPacketList *pktl= s->packet_buffer;
715
    int64_t cur_dts= 0;
716

    
717
    if(st->first_dts != AV_NOPTS_VALUE){
718
        cur_dts= st->first_dts;
719
        for(; pktl; pktl= pktl->next){
720
            if(pktl->pkt.stream_index == pkt->stream_index){
721
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
722
                    break;
723
                cur_dts -= pkt->duration;
724
            }
725
        }
726
        pktl= s->packet_buffer;
727
        st->first_dts = cur_dts;
728
    }else if(st->cur_dts)
729
        return;
730

    
731
    for(; pktl; pktl= pktl->next){
732
        if(pktl->pkt.stream_index != pkt->stream_index)
733
            continue;
734
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
735
           && !pktl->pkt.duration){
736
            pktl->pkt.dts= cur_dts;
737
            if(!st->codec->has_b_frames)
738
                pktl->pkt.pts= cur_dts;
739
            cur_dts += pkt->duration;
740
            pktl->pkt.duration= pkt->duration;
741
        }else
742
            break;
743
    }
744
    if(st->first_dts == AV_NOPTS_VALUE)
745
        st->cur_dts= cur_dts;
746
}
747

    
748
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
749
                               AVCodecParserContext *pc, AVPacket *pkt)
750
{
751
    int num, den, presentation_delayed, delay, i;
752
    int64_t offset;
753

    
754
    if (pc && pc->pict_type == FF_B_TYPE)
755
        st->codec->has_b_frames = 1;
756

    
757
    /* do we have a video B-frame ? */
758
    delay= st->codec->has_b_frames;
759
    presentation_delayed = 0;
760
    /* XXX: need has_b_frame, but cannot get it if the codec is
761
        not initialized */
762
    if (delay &&
763
        pc && pc->pict_type != FF_B_TYPE)
764
        presentation_delayed = 1;
765

    
766
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
767
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
768
        pkt->dts -= 1LL<<st->pts_wrap_bits;
769
    }
770

    
771
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
772
    // we take the conservative approach and discard both
773
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
774
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
775
        av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
776
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
777
    }
778

    
779
    if (pkt->duration == 0) {
780
        compute_frame_duration(&num, &den, st, pc, pkt);
781
        if (den && num) {
782
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
783

    
784
            if(pkt->duration != 0 && s->packet_buffer)
785
                update_initial_durations(s, st, pkt);
786
        }
787
    }
788

    
789
    /* correct timestamps with byte offset if demuxers only have timestamps
790
       on packet boundaries */
791
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
792
        /* this will estimate bitrate based on this frame's duration and size */
793
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
794
        if(pkt->pts != AV_NOPTS_VALUE)
795
            pkt->pts += offset;
796
        if(pkt->dts != AV_NOPTS_VALUE)
797
            pkt->dts += offset;
798
    }
799

    
800
    if (pc && pc->dts_sync_point >= 0) {
801
        // we have synchronization info from the parser
802
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
803
        if (den > 0) {
804
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
805
            if (pkt->dts != AV_NOPTS_VALUE) {
806
                // got DTS from the stream, update reference timestamp
807
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
808
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
809
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
810
                // compute DTS based on reference timestamp
811
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
812
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
813
            }
814
            if (pc->dts_sync_point > 0)
815
                st->reference_dts = pkt->dts; // new reference
816
        }
817
    }
818

    
819
    /* This may be redundant, but it should not hurt. */
820
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
821
        presentation_delayed = 1;
822

    
823
//    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);
824
    /* interpolate PTS and DTS if they are not present */
825
    //We skip H264 currently because delay and has_b_frames are not reliably set
826
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
827
        if (presentation_delayed) {
828
            /* DTS = decompression timestamp */
829
            /* PTS = presentation timestamp */
830
            if (pkt->dts == AV_NOPTS_VALUE)
831
                pkt->dts = st->last_IP_pts;
832
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
833
            if (pkt->dts == AV_NOPTS_VALUE)
834
                pkt->dts = st->cur_dts;
835

    
836
            /* this is tricky: the dts must be incremented by the duration
837
            of the frame we are displaying, i.e. the last I- or P-frame */
838
            if (st->last_IP_duration == 0)
839
                st->last_IP_duration = pkt->duration;
840
            if(pkt->dts != AV_NOPTS_VALUE)
841
                st->cur_dts = pkt->dts + st->last_IP_duration;
842
            st->last_IP_duration  = pkt->duration;
843
            st->last_IP_pts= pkt->pts;
844
            /* cannot compute PTS if not present (we can compute it only
845
            by knowing the future */
846
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
847
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
848
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
849
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
850
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
851
                    pkt->pts += pkt->duration;
852
    //                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);
853
                }
854
            }
855

    
856
            /* presentation is not delayed : PTS and DTS are the same */
857
            if(pkt->pts == AV_NOPTS_VALUE)
858
                pkt->pts = pkt->dts;
859
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
860
            if(pkt->pts == AV_NOPTS_VALUE)
861
                pkt->pts = st->cur_dts;
862
            pkt->dts = pkt->pts;
863
            if(pkt->pts != AV_NOPTS_VALUE)
864
                st->cur_dts = pkt->pts + pkt->duration;
865
        }
866
    }
867

    
868
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
869
        st->pts_buffer[0]= pkt->pts;
870
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
871
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
872
        if(pkt->dts == AV_NOPTS_VALUE)
873
            pkt->dts= st->pts_buffer[0];
874
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
875
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
876
        }
877
        if(pkt->dts > st->cur_dts)
878
            st->cur_dts = pkt->dts;
879
    }
880

    
881
//    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);
882

    
883
    /* update flags */
884
    if(is_intra_only(st->codec))
885
        pkt->flags |= PKT_FLAG_KEY;
886
    else if (pc) {
887
        pkt->flags = 0;
888
        /* keyframe computation */
889
        if (pc->key_frame == 1)
890
            pkt->flags |= PKT_FLAG_KEY;
891
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
892
            pkt->flags |= PKT_FLAG_KEY;
893
    }
894
    if (pc)
895
        pkt->convergence_duration = pc->convergence_duration;
896
}
897

    
898

    
899
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
900
{
901
    AVStream *st;
902
    int len, ret, i;
903

    
904
    av_init_packet(pkt);
905

    
906
    for(;;) {
907
        /* select current input stream component */
908
        st = s->cur_st;
909
        if (st) {
910
            if (!st->need_parsing || !st->parser) {
911
                /* no parsing needed: we just output the packet as is */
912
                /* raw data support */
913
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
914
                compute_pkt_fields(s, st, NULL, pkt);
915
                s->cur_st = NULL;
916
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
917
                    (pkt->flags & PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
918
                    ff_reduce_index(s, st->index);
919
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
920
                }
921
                break;
922
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
923
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
924
                                       st->cur_ptr, st->cur_len,
925
                                       st->cur_pkt.pts, st->cur_pkt.dts,
926
                                       st->cur_pkt.pos);
927
                st->cur_pkt.pts = AV_NOPTS_VALUE;
928
                st->cur_pkt.dts = AV_NOPTS_VALUE;
929
                /* increment read pointer */
930
                st->cur_ptr += len;
931
                st->cur_len -= len;
932

    
933
                /* return packet if any */
934
                if (pkt->size) {
935
                got_packet:
936
                    pkt->duration = 0;
937
                    pkt->stream_index = st->index;
938
                    pkt->pts = st->parser->pts;
939
                    pkt->dts = st->parser->dts;
940
                    pkt->pos = st->parser->pos;
941
                    pkt->destruct = NULL;
942
                    compute_pkt_fields(s, st, st->parser, pkt);
943

    
944
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
945
                        ff_reduce_index(s, st->index);
946
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
947
                                           0, 0, AVINDEX_KEYFRAME);
948
                    }
949

    
950
                    break;
951
                }
952
            } else {
953
                /* free packet */
954
                av_free_packet(&st->cur_pkt);
955
                s->cur_st = NULL;
956
            }
957
        } else {
958
            AVPacket cur_pkt;
959
            /* read next packet */
960
            ret = av_read_packet(s, &cur_pkt);
961
            if (ret < 0) {
962
                if (ret == AVERROR(EAGAIN))
963
                    return ret;
964
                /* return the last frames, if any */
965
                for(i = 0; i < s->nb_streams; i++) {
966
                    st = s->streams[i];
967
                    if (st->parser && st->need_parsing) {
968
                        av_parser_parse2(st->parser, st->codec,
969
                                        &pkt->data, &pkt->size,
970
                                        NULL, 0,
971
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
972
                                        AV_NOPTS_VALUE);
973
                        if (pkt->size)
974
                            goto got_packet;
975
                    }
976
                }
977
                /* no more packets: really terminate parsing */
978
                return ret;
979
            }
980
            st = s->streams[cur_pkt.stream_index];
981
            st->cur_pkt= cur_pkt;
982

    
983
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
984
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
985
               st->cur_pkt.pts < st->cur_pkt.dts){
986
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
987
                    st->cur_pkt.stream_index,
988
                    st->cur_pkt.pts,
989
                    st->cur_pkt.dts,
990
                    st->cur_pkt.size);
991
//                av_free_packet(&st->cur_pkt);
992
//                return -1;
993
            }
994

    
995
            if(s->debug & FF_FDEBUG_TS)
996
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
997
                    st->cur_pkt.stream_index,
998
                    st->cur_pkt.pts,
999
                    st->cur_pkt.dts,
1000
                    st->cur_pkt.size,
1001
                    st->cur_pkt.flags);
1002

    
1003
            s->cur_st = st;
1004
            st->cur_ptr = st->cur_pkt.data;
1005
            st->cur_len = st->cur_pkt.size;
1006
            if (st->need_parsing && !st->parser) {
1007
                st->parser = av_parser_init(st->codec->codec_id);
1008
                if (!st->parser) {
1009
                    /* no parser available: just output the raw packets */
1010
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1011
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1012
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1013
                }
1014
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1015
                    st->parser->next_frame_offset=
1016
                    st->parser->cur_offset= st->cur_pkt.pos;
1017
                }
1018
            }
1019
        }
1020
    }
1021
    if(s->debug & FF_FDEBUG_TS)
1022
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1023
            pkt->stream_index,
1024
            pkt->pts,
1025
            pkt->dts,
1026
            pkt->size,
1027
            pkt->flags);
1028

    
1029
    return 0;
1030
}
1031

    
1032
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1033
{
1034
    AVPacketList *pktl;
1035
    int eof=0;
1036
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1037

    
1038
    for(;;){
1039
        pktl = s->packet_buffer;
1040
        if (pktl) {
1041
            AVPacket *next_pkt= &pktl->pkt;
1042

    
1043
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1044
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1045
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1046
                       && next_pkt->dts < pktl->pkt.dts
1047
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1048
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1049
                        next_pkt->pts= pktl->pkt.dts;
1050
                    }
1051
                    pktl= pktl->next;
1052
                }
1053
                pktl = s->packet_buffer;
1054
            }
1055

    
1056
            if(   next_pkt->pts != AV_NOPTS_VALUE
1057
               || next_pkt->dts == AV_NOPTS_VALUE
1058
               || !genpts || eof){
1059
                /* read packet from packet buffer, if there is data */
1060
                *pkt = *next_pkt;
1061
                s->packet_buffer = pktl->next;
1062
                av_free(pktl);
1063
                return 0;
1064
            }
1065
        }
1066
        if(genpts){
1067
            int ret= av_read_frame_internal(s, pkt);
1068
            if(ret<0){
1069
                if(pktl && ret != AVERROR(EAGAIN)){
1070
                    eof=1;
1071
                    continue;
1072
                }else
1073
                    return ret;
1074
            }
1075

    
1076
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1077
                                           &s->packet_buffer_end)) < 0)
1078
                return AVERROR(ENOMEM);
1079
        }else{
1080
            assert(!s->packet_buffer);
1081
            return av_read_frame_internal(s, pkt);
1082
        }
1083
    }
1084
}
1085

    
1086
/* XXX: suppress the packet queue */
1087
static void flush_packet_queue(AVFormatContext *s)
1088
{
1089
    AVPacketList *pktl;
1090

    
1091
    for(;;) {
1092
        pktl = s->packet_buffer;
1093
        if (!pktl)
1094
            break;
1095
        s->packet_buffer = pktl->next;
1096
        av_free_packet(&pktl->pkt);
1097
        av_free(pktl);
1098
    }
1099
    while(s->raw_packet_buffer){
1100
        pktl = s->raw_packet_buffer;
1101
        s->raw_packet_buffer = pktl->next;
1102
        av_free_packet(&pktl->pkt);
1103
        av_free(pktl);
1104
    }
1105
}
1106

    
1107
/*******************************************************/
1108
/* seek support */
1109

    
1110
int av_find_default_stream_index(AVFormatContext *s)
1111
{
1112
    int first_audio_index = -1;
1113
    int i;
1114
    AVStream *st;
1115

    
1116
    if (s->nb_streams <= 0)
1117
        return -1;
1118
    for(i = 0; i < s->nb_streams; i++) {
1119
        st = s->streams[i];
1120
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1121
            return i;
1122
        }
1123
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1124
            first_audio_index = i;
1125
    }
1126
    return first_audio_index >= 0 ? first_audio_index : 0;
1127
}
1128

    
1129
/**
1130
 * Flush the frame reader.
1131
 */
1132
static void av_read_frame_flush(AVFormatContext *s)
1133
{
1134
    AVStream *st;
1135
    int i;
1136

    
1137
    flush_packet_queue(s);
1138

    
1139
    s->cur_st = NULL;
1140

    
1141
    /* for each stream, reset read state */
1142
    for(i = 0; i < s->nb_streams; i++) {
1143
        st = s->streams[i];
1144

    
1145
        if (st->parser) {
1146
            av_parser_close(st->parser);
1147
            st->parser = NULL;
1148
            av_free_packet(&st->cur_pkt);
1149
        }
1150
        st->last_IP_pts = AV_NOPTS_VALUE;
1151
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1152
        st->reference_dts = AV_NOPTS_VALUE;
1153
        /* fail safe */
1154
        st->cur_ptr = NULL;
1155
        st->cur_len = 0;
1156

    
1157
        st->probe_packets = MAX_PROBE_PACKETS;
1158
    }
1159
}
1160

    
1161
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1162
    int i;
1163

    
1164
    for(i = 0; i < s->nb_streams; i++) {
1165
        AVStream *st = s->streams[i];
1166

    
1167
        st->cur_dts = av_rescale(timestamp,
1168
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1169
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1170
    }
1171
}
1172

    
1173
void ff_reduce_index(AVFormatContext *s, int stream_index)
1174
{
1175
    AVStream *st= s->streams[stream_index];
1176
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1177

    
1178
    if((unsigned)st->nb_index_entries >= max_entries){
1179
        int i;
1180
        for(i=0; 2*i<st->nb_index_entries; i++)
1181
            st->index_entries[i]= st->index_entries[2*i];
1182
        st->nb_index_entries= i;
1183
    }
1184
}
1185

    
1186
int av_add_index_entry(AVStream *st,
1187
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1188
{
1189
    AVIndexEntry *entries, *ie;
1190
    int index;
1191

    
1192
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1193
        return -1;
1194

    
1195
    entries = av_fast_realloc(st->index_entries,
1196
                              &st->index_entries_allocated_size,
1197
                              (st->nb_index_entries + 1) *
1198
                              sizeof(AVIndexEntry));
1199
    if(!entries)
1200
        return -1;
1201

    
1202
    st->index_entries= entries;
1203

    
1204
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1205

    
1206
    if(index<0){
1207
        index= st->nb_index_entries++;
1208
        ie= &entries[index];
1209
        assert(index==0 || ie[-1].timestamp < timestamp);
1210
    }else{
1211
        ie= &entries[index];
1212
        if(ie->timestamp != timestamp){
1213
            if(ie->timestamp <= timestamp)
1214
                return -1;
1215
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1216
            st->nb_index_entries++;
1217
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1218
            distance= ie->min_distance;
1219
    }
1220

    
1221
    ie->pos = pos;
1222
    ie->timestamp = timestamp;
1223
    ie->min_distance= distance;
1224
    ie->size= size;
1225
    ie->flags = flags;
1226

    
1227
    return index;
1228
}
1229

    
1230
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1231
                              int flags)
1232
{
1233
    AVIndexEntry *entries= st->index_entries;
1234
    int nb_entries= st->nb_index_entries;
1235
    int a, b, m;
1236
    int64_t timestamp;
1237

    
1238
    a = - 1;
1239
    b = nb_entries;
1240

    
1241
    while (b - a > 1) {
1242
        m = (a + b) >> 1;
1243
        timestamp = entries[m].timestamp;
1244
        if(timestamp >= wanted_timestamp)
1245
            b = m;
1246
        if(timestamp <= wanted_timestamp)
1247
            a = m;
1248
    }
1249
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1250

    
1251
    if(!(flags & AVSEEK_FLAG_ANY)){
1252
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1253
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1254
        }
1255
    }
1256

    
1257
    if(m == nb_entries)
1258
        return -1;
1259
    return  m;
1260
}
1261

    
1262
#define DEBUG_SEEK
1263

    
1264
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1265
    AVInputFormat *avif= s->iformat;
1266
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1267
    int64_t ts_min, ts_max, ts;
1268
    int index;
1269
    AVStream *st;
1270

    
1271
    if (stream_index < 0)
1272
        return -1;
1273

    
1274
#ifdef DEBUG_SEEK
1275
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1276
#endif
1277

    
1278
    ts_max=
1279
    ts_min= AV_NOPTS_VALUE;
1280
    pos_limit= -1; //gcc falsely says it may be uninitialized
1281

    
1282
    st= s->streams[stream_index];
1283
    if(st->index_entries){
1284
        AVIndexEntry *e;
1285

    
1286
        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()
1287
        index= FFMAX(index, 0);
1288
        e= &st->index_entries[index];
1289

    
1290
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1291
            pos_min= e->pos;
1292
            ts_min= e->timestamp;
1293
#ifdef DEBUG_SEEK
1294
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1295
                   pos_min,ts_min);
1296
#endif
1297
        }else{
1298
            assert(index==0);
1299
        }
1300

    
1301
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1302
        assert(index < st->nb_index_entries);
1303
        if(index >= 0){
1304
            e= &st->index_entries[index];
1305
            assert(e->timestamp >= target_ts);
1306
            pos_max= e->pos;
1307
            ts_max= e->timestamp;
1308
            pos_limit= pos_max - e->min_distance;
1309
#ifdef DEBUG_SEEK
1310
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1311
                   pos_max,pos_limit, ts_max);
1312
#endif
1313
        }
1314
    }
1315

    
1316
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1317
    if(pos<0)
1318
        return -1;
1319

    
1320
    /* do the seek */
1321
    url_fseek(s->pb, pos, SEEK_SET);
1322

    
1323
    av_update_cur_dts(s, st, ts);
1324

    
1325
    return 0;
1326
}
1327

    
1328
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 )){
1329
    int64_t pos, ts;
1330
    int64_t start_pos, filesize;
1331
    int no_change;
1332

    
1333
#ifdef DEBUG_SEEK
1334
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1335
#endif
1336

    
1337
    if(ts_min == AV_NOPTS_VALUE){
1338
        pos_min = s->data_offset;
1339
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1340
        if (ts_min == AV_NOPTS_VALUE)
1341
            return -1;
1342
    }
1343

    
1344
    if(ts_max == AV_NOPTS_VALUE){
1345
        int step= 1024;
1346
        filesize = url_fsize(s->pb);
1347
        pos_max = filesize - 1;
1348
        do{
1349
            pos_max -= step;
1350
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1351
            step += step;
1352
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1353
        if (ts_max == AV_NOPTS_VALUE)
1354
            return -1;
1355

    
1356
        for(;;){
1357
            int64_t tmp_pos= pos_max + 1;
1358
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1359
            if(tmp_ts == AV_NOPTS_VALUE)
1360
                break;
1361
            ts_max= tmp_ts;
1362
            pos_max= tmp_pos;
1363
            if(tmp_pos >= filesize)
1364
                break;
1365
        }
1366
        pos_limit= pos_max;
1367
    }
1368

    
1369
    if(ts_min > ts_max){
1370
        return -1;
1371
    }else if(ts_min == ts_max){
1372
        pos_limit= pos_min;
1373
    }
1374

    
1375
    no_change=0;
1376
    while (pos_min < pos_limit) {
1377
#ifdef DEBUG_SEEK
1378
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1379
               pos_min, pos_max,
1380
               ts_min, ts_max);
1381
#endif
1382
        assert(pos_limit <= pos_max);
1383

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

    
1403
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1404
        if(pos == pos_max)
1405
            no_change++;
1406
        else
1407
            no_change=0;
1408
#ifdef DEBUG_SEEK
1409
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1410
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1411
               start_pos, no_change);
1412
#endif
1413
        if(ts == AV_NOPTS_VALUE){
1414
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1415
            return -1;
1416
        }
1417
        assert(ts != AV_NOPTS_VALUE);
1418
        if (target_ts <= ts) {
1419
            pos_limit = start_pos - 1;
1420
            pos_max = pos;
1421
            ts_max = ts;
1422
        }
1423
        if (target_ts >= ts) {
1424
            pos_min = pos;
1425
            ts_min = ts;
1426
        }
1427
    }
1428

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

    
1443
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1444
    int64_t pos_min, pos_max;
1445
#if 0
1446
    AVStream *st;
1447

1448
    if (stream_index < 0)
1449
        return -1;
1450

1451
    st= s->streams[stream_index];
1452
#endif
1453

    
1454
    pos_min = s->data_offset;
1455
    pos_max = url_fsize(s->pb) - 1;
1456

    
1457
    if     (pos < pos_min) pos= pos_min;
1458
    else if(pos > pos_max) pos= pos_max;
1459

    
1460
    url_fseek(s->pb, pos, SEEK_SET);
1461

    
1462
#if 0
1463
    av_update_cur_dts(s, st, ts);
1464
#endif
1465
    return 0;
1466
}
1467

    
1468
static int av_seek_frame_generic(AVFormatContext *s,
1469
                                 int stream_index, int64_t timestamp, int flags)
1470
{
1471
    int index, ret;
1472
    AVStream *st;
1473
    AVIndexEntry *ie;
1474

    
1475
    st = s->streams[stream_index];
1476

    
1477
    index = av_index_search_timestamp(st, timestamp, flags);
1478

    
1479
    if(index < 0 || index==st->nb_index_entries-1){
1480
        int i;
1481
        AVPacket pkt;
1482

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

    
1511
    av_read_frame_flush(s);
1512
    if (s->iformat->read_seek){
1513
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1514
            return 0;
1515
    }
1516
    ie = &st->index_entries[index];
1517
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1518
        return ret;
1519
    av_update_cur_dts(s, st, ie->timestamp);
1520

    
1521
    return 0;
1522
}
1523

    
1524
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1525
{
1526
    int ret;
1527
    AVStream *st;
1528

    
1529
    av_read_frame_flush(s);
1530

    
1531
    if(flags & AVSEEK_FLAG_BYTE)
1532
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1533

    
1534
    if(stream_index < 0){
1535
        stream_index= av_find_default_stream_index(s);
1536
        if(stream_index < 0)
1537
            return -1;
1538

    
1539
        st= s->streams[stream_index];
1540
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1541
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1542
    }
1543

    
1544
    /* first, we try the format specific seek */
1545
    if (s->iformat->read_seek)
1546
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1547
    else
1548
        ret = -1;
1549
    if (ret >= 0) {
1550
        return 0;
1551
    }
1552

    
1553
    if(s->iformat->read_timestamp)
1554
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1555
    else
1556
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1557
}
1558

    
1559
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1560
{
1561
    if(min_ts > ts || max_ts < ts)
1562
        return -1;
1563

    
1564
    av_read_frame_flush(s);
1565

    
1566
    if (s->iformat->read_seek2)
1567
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1568

    
1569
    if(s->iformat->read_timestamp){
1570
        //try to seek via read_timestamp()
1571
    }
1572

    
1573
    //Fallback to old API if new is not implemented but old is
1574
    //Note the old has somewat different sematics
1575
    if(s->iformat->read_seek || 1)
1576
        return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1577

    
1578
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1579
}
1580

    
1581
/*******************************************************/
1582

    
1583
/**
1584
 * Returns TRUE if the stream has accurate duration in any stream.
1585
 *
1586
 * @return TRUE if the stream has accurate duration for at least one component.
1587
 */
1588
static int av_has_duration(AVFormatContext *ic)
1589
{
1590
    int i;
1591
    AVStream *st;
1592

    
1593
    for(i = 0;i < ic->nb_streams; i++) {
1594
        st = ic->streams[i];
1595
        if (st->duration != AV_NOPTS_VALUE)
1596
            return 1;
1597
    }
1598
    return 0;
1599
}
1600

    
1601
/**
1602
 * Estimate the stream timings from the one of each components.
1603
 *
1604
 * Also computes the global bitrate if possible.
1605
 */
1606
static void av_update_stream_timings(AVFormatContext *ic)
1607
{
1608
    int64_t start_time, start_time1, end_time, end_time1;
1609
    int64_t duration, duration1;
1610
    int i;
1611
    AVStream *st;
1612

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

    
1652
static void fill_all_stream_timings(AVFormatContext *ic)
1653
{
1654
    int i;
1655
    AVStream *st;
1656

    
1657
    av_update_stream_timings(ic);
1658
    for(i = 0;i < ic->nb_streams; i++) {
1659
        st = ic->streams[i];
1660
        if (st->start_time == AV_NOPTS_VALUE) {
1661
            if(ic->start_time != AV_NOPTS_VALUE)
1662
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1663
            if(ic->duration != AV_NOPTS_VALUE)
1664
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1665
        }
1666
    }
1667
}
1668

    
1669
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1670
{
1671
    int64_t filesize, duration;
1672
    int bit_rate, i;
1673
    AVStream *st;
1674

    
1675
    /* if bit_rate is already set, we believe it */
1676
    if (ic->bit_rate == 0) {
1677
        bit_rate = 0;
1678
        for(i=0;i<ic->nb_streams;i++) {
1679
            st = ic->streams[i];
1680
            bit_rate += st->codec->bit_rate;
1681
        }
1682
        ic->bit_rate = bit_rate;
1683
    }
1684

    
1685
    /* if duration is already set, we believe it */
1686
    if (ic->duration == AV_NOPTS_VALUE &&
1687
        ic->bit_rate != 0 &&
1688
        ic->file_size != 0)  {
1689
        filesize = ic->file_size;
1690
        if (filesize > 0) {
1691
            for(i = 0; i < ic->nb_streams; i++) {
1692
                st = ic->streams[i];
1693
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1694
                if (st->duration == AV_NOPTS_VALUE)
1695
                    st->duration = duration;
1696
            }
1697
        }
1698
    }
1699
}
1700

    
1701
#define DURATION_MAX_READ_SIZE 250000
1702

    
1703
/* only usable for MPEG-PS streams */
1704
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1705
{
1706
    AVPacket pkt1, *pkt = &pkt1;
1707
    AVStream *st;
1708
    int read_size, i, ret;
1709
    int64_t end_time;
1710
    int64_t filesize, offset, duration;
1711

    
1712
    ic->cur_st = NULL;
1713

    
1714
    /* flush packet queue */
1715
    flush_packet_queue(ic);
1716

    
1717
    for(i=0;i<ic->nb_streams;i++) {
1718
        st = ic->streams[i];
1719
        if (st->parser) {
1720
            av_parser_close(st->parser);
1721
            st->parser= NULL;
1722
            av_free_packet(&st->cur_pkt);
1723
        }
1724
    }
1725

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

    
1742
        do{
1743
            ret = av_read_packet(ic, pkt);
1744
        }while(ret == AVERROR(EAGAIN));
1745
        if (ret != 0)
1746
            break;
1747
        read_size += pkt->size;
1748
        st = ic->streams[pkt->stream_index];
1749
        if (pkt->pts != AV_NOPTS_VALUE) {
1750
            if (st->start_time == AV_NOPTS_VALUE)
1751
                st->start_time = pkt->pts;
1752
        }
1753
        av_free_packet(pkt);
1754
    }
1755

    
1756
    /* estimate the end time (duration) */
1757
    /* XXX: may need to support wrapping */
1758
    filesize = ic->file_size;
1759
    offset = filesize - DURATION_MAX_READ_SIZE;
1760
    if (offset < 0)
1761
        offset = 0;
1762

    
1763
    url_fseek(ic->pb, offset, SEEK_SET);
1764
    read_size = 0;
1765
    for(;;) {
1766
        if (read_size >= DURATION_MAX_READ_SIZE)
1767
            break;
1768

    
1769
        do{
1770
            ret = av_read_packet(ic, pkt);
1771
        }while(ret == AVERROR(EAGAIN));
1772
        if (ret != 0)
1773
            break;
1774
        read_size += pkt->size;
1775
        st = ic->streams[pkt->stream_index];
1776
        if (pkt->pts != AV_NOPTS_VALUE &&
1777
            st->start_time != AV_NOPTS_VALUE) {
1778
            end_time = pkt->pts;
1779
            duration = end_time - st->start_time;
1780
            if (duration > 0) {
1781
                if (st->duration == AV_NOPTS_VALUE ||
1782
                    st->duration < duration)
1783
                    st->duration = duration;
1784
            }
1785
        }
1786
        av_free_packet(pkt);
1787
    }
1788

    
1789
    fill_all_stream_timings(ic);
1790

    
1791
    url_fseek(ic->pb, old_offset, SEEK_SET);
1792
    for(i=0; i<ic->nb_streams; i++){
1793
        st= ic->streams[i];
1794
        st->cur_dts= st->first_dts;
1795
        st->last_IP_pts = AV_NOPTS_VALUE;
1796
    }
1797
}
1798

    
1799
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1800
{
1801
    int64_t file_size;
1802

    
1803
    /* get the file size, if possible */
1804
    if (ic->iformat->flags & AVFMT_NOFILE) {
1805
        file_size = 0;
1806
    } else {
1807
        file_size = url_fsize(ic->pb);
1808
        if (file_size < 0)
1809
            file_size = 0;
1810
    }
1811
    ic->file_size = file_size;
1812

    
1813
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1814
         !strcmp(ic->iformat->name, "mpegts")) &&
1815
        file_size && !url_is_streamed(ic->pb)) {
1816
        /* get accurate estimate from the PTSes */
1817
        av_estimate_timings_from_pts(ic, old_offset);
1818
    } else if (av_has_duration(ic)) {
1819
        /* at least one component has timings - we use them for all
1820
           the components */
1821
        fill_all_stream_timings(ic);
1822
    } else {
1823
        /* less precise: use bitrate info */
1824
        av_estimate_timings_from_bit_rate(ic);
1825
    }
1826
    av_update_stream_timings(ic);
1827

    
1828
#if 0
1829
    {
1830
        int i;
1831
        AVStream *st;
1832
        for(i = 0;i < ic->nb_streams; i++) {
1833
            st = ic->streams[i];
1834
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1835
               i, (double)st->start_time / AV_TIME_BASE,
1836
               (double)st->duration / AV_TIME_BASE);
1837
        }
1838
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1839
               (double)ic->start_time / AV_TIME_BASE,
1840
               (double)ic->duration / AV_TIME_BASE,
1841
               ic->bit_rate / 1000);
1842
    }
1843
#endif
1844
}
1845

    
1846
static int has_codec_parameters(AVCodecContext *enc)
1847
{
1848
    int val;
1849
    switch(enc->codec_type) {
1850
    case CODEC_TYPE_AUDIO:
1851
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1852
        if(!enc->frame_size &&
1853
           (enc->codec_id == CODEC_ID_VORBIS ||
1854
            enc->codec_id == CODEC_ID_AAC))
1855
            return 0;
1856
        break;
1857
    case CODEC_TYPE_VIDEO:
1858
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1859
        break;
1860
    default:
1861
        val = 1;
1862
        break;
1863
    }
1864
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1865
}
1866

    
1867
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1868
{
1869
    int16_t *samples;
1870
    AVCodec *codec;
1871
    int got_picture, data_size, ret=0;
1872
    AVFrame picture;
1873

    
1874
    if(!st->codec->codec){
1875
        codec = avcodec_find_decoder(st->codec->codec_id);
1876
        if (!codec)
1877
            return -1;
1878
        ret = avcodec_open(st->codec, codec);
1879
        if (ret < 0)
1880
            return ret;
1881
    }
1882

    
1883
    if(!has_codec_parameters(st->codec)){
1884
        switch(st->codec->codec_type) {
1885
        case CODEC_TYPE_VIDEO:
1886
            avcodec_get_frame_defaults(&picture);
1887
            ret = avcodec_decode_video2(st->codec, &picture,
1888
                                        &got_picture, avpkt);
1889
            break;
1890
        case CODEC_TYPE_AUDIO:
1891
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1892
            samples = av_malloc(data_size);
1893
            if (!samples)
1894
                goto fail;
1895
            ret = avcodec_decode_audio3(st->codec, samples,
1896
                                        &data_size, avpkt);
1897
            av_free(samples);
1898
            break;
1899
        default:
1900
            break;
1901
        }
1902
    }
1903
 fail:
1904
    return ret;
1905
}
1906

    
1907
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1908
{
1909
    while (tags->id != CODEC_ID_NONE) {
1910
        if (tags->id == id)
1911
            return tags->tag;
1912
        tags++;
1913
    }
1914
    return 0;
1915
}
1916

    
1917
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1918
{
1919
    int i;
1920
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1921
        if(tag == tags[i].tag)
1922
            return tags[i].id;
1923
    }
1924
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1925
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1926
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1927
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1928
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1929
            return tags[i].id;
1930
    }
1931
    return CODEC_ID_NONE;
1932
}
1933

    
1934
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1935
{
1936
    int i;
1937
    for(i=0; tags && tags[i]; i++){
1938
        int tag= codec_get_tag(tags[i], id);
1939
        if(tag) return tag;
1940
    }
1941
    return 0;
1942
}
1943

    
1944
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1945
{
1946
    int i;
1947
    for(i=0; tags && tags[i]; i++){
1948
        enum CodecID id= codec_get_id(tags[i], tag);
1949
        if(id!=CODEC_ID_NONE) return id;
1950
    }
1951
    return CODEC_ID_NONE;
1952
}
1953

    
1954
static void compute_chapters_end(AVFormatContext *s)
1955
{
1956
    unsigned int i;
1957

    
1958
    for (i=0; i+1<s->nb_chapters; i++)
1959
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1960
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1961
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1962
            s->chapters[i]->end = s->chapters[i+1]->start;
1963
        }
1964

    
1965
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1966
        assert(s->start_time != AV_NOPTS_VALUE);
1967
        assert(s->duration > 0);
1968
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1969
                                           AV_TIME_BASE_Q,
1970
                                           s->chapters[i]->time_base);
1971
    }
1972
}
1973

    
1974
/* absolute maximum size we read until we abort */
1975
#define MAX_READ_SIZE        5000000
1976

    
1977
#define MAX_STD_TIMEBASES (60*12+5)
1978
static int get_std_framerate(int i){
1979
    if(i<60*12) return i*1001;
1980
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1981
}
1982

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

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

    
2016
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2017
    if (!duration_error) return AVERROR(ENOMEM);
2018

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

    
2036
    for(i=0;i<MAX_STREAMS;i++){
2037
        last_dts[i]= AV_NOPTS_VALUE;
2038
    }
2039

    
2040
    count = 0;
2041
    read_size = 0;
2042
    for(;;) {
2043
        if(url_interrupt_cb()){
2044
            ret= AVERROR(EINTR);
2045
            break;
2046
        }
2047

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

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

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

    
2105
        read_size += pkt->size;
2106

    
2107
        st = ic->streams[pkt->stream_index];
2108
        if(codec_info_nb_frames[st->index]>1) {
2109
            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)
2110
                break;
2111
            codec_info_duration[st->index] += pkt->duration;
2112
        }
2113
        if (pkt->duration != 0)
2114
            codec_info_nb_frames[st->index]++;
2115

    
2116
        {
2117
            int index= pkt->stream_index;
2118
            int64_t last= last_dts[index];
2119
            int64_t duration= pkt->dts - last;
2120

    
2121
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2122
                double dur= duration * av_q2d(st->time_base);
2123

    
2124
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2125
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2126
                if(duration_count[index] < 2)
2127
                    memset(duration_error[index], 0, sizeof(*duration_error));
2128
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2129
                    int framerate= get_std_framerate(i);
2130
                    int ticks= lrintf(dur*framerate/(1001*12));
2131
                    double error= dur - ticks*1001*12/(double)framerate;
2132
                    duration_error[index][i] += error*error;
2133
                }
2134
                duration_count[index]++;
2135
                // ignore the first 4 values, they might have some random jitter
2136
                if (duration_count[index] > 3)
2137
                    duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2138
            }
2139
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2140
                last_dts[pkt->stream_index]= pkt->dts;
2141
        }
2142
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2143
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2144
            if(i){
2145
                st->codec->extradata_size= i;
2146
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2147
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2148
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2149
            }
2150
        }
2151

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

    
2173
        count++;
2174
    }
2175

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

    
2188
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2189
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2190
            // ipmovie.c produces.
2191
            if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
2192
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
2193
            if(duration_count[i]
2194
               && tb_unreliable(st->codec) /*&&
2195
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2196
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2197
                int num = 0;
2198
                double best_error= 2*av_q2d(st->time_base);
2199
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2200

    
2201
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2202
                    double error= duration_error[i][j] * get_std_framerate(j);
2203
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2204
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2205
                    if(error < best_error){
2206
                        best_error= error;
2207
                        num = get_std_framerate(j);
2208
                    }
2209
                }
2210
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2211
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2212
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2213
            }
2214

    
2215
            if (!st->r_frame_rate.num){
2216
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2217
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2218
                    st->r_frame_rate.num = st->codec->time_base.den;
2219
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2220
                }else{
2221
                    st->r_frame_rate.num = st->time_base.den;
2222
                    st->r_frame_rate.den = st->time_base.num;
2223
                }
2224
            }
2225
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2226
            if(!st->codec->bits_per_coded_sample)
2227
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2228
        }
2229
    }
2230

    
2231
    av_estimate_timings(ic, old_offset);
2232

    
2233
    compute_chapters_end(ic);
2234

    
2235
#if 0
2236
    /* correct DTS for B-frame streams with no timestamps */
2237
    for(i=0;i<ic->nb_streams;i++) {
2238
        st = ic->streams[i];
2239
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2240
            if(b-frames){
2241
                ppktl = &ic->packet_buffer;
2242
                while(ppkt1){
2243
                    if(ppkt1->stream_index != i)
2244
                        continue;
2245
                    if(ppkt1->pkt->dts < 0)
2246
                        break;
2247
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2248
                        break;
2249
                    ppkt1->pkt->dts -= delta;
2250
                    ppkt1= ppkt1->next;
2251
                }
2252
                if(ppkt1)
2253
                    continue;
2254
                st->cur_dts -= delta;
2255
            }
2256
        }
2257
    }
2258
#endif
2259

    
2260
    av_free(duration_error);
2261

    
2262
    return ret;
2263
}
2264

    
2265
/*******************************************************/
2266

    
2267
int av_read_play(AVFormatContext *s)
2268
{
2269
    if (s->iformat->read_play)
2270
        return s->iformat->read_play(s);
2271
    if (s->pb)
2272
        return av_url_read_fpause(s->pb, 0);
2273
    return AVERROR(ENOSYS);
2274
}
2275

    
2276
int av_read_pause(AVFormatContext *s)
2277
{
2278
    if (s->iformat->read_pause)
2279
        return s->iformat->read_pause(s);
2280
    if (s->pb)
2281
        return av_url_read_fpause(s->pb, 1);
2282
    return AVERROR(ENOSYS);
2283
}
2284

    
2285
void av_close_input_stream(AVFormatContext *s)
2286
{
2287
    int i;
2288
    AVStream *st;
2289

    
2290
    if (s->iformat->read_close)
2291
        s->iformat->read_close(s);
2292
    for(i=0;i<s->nb_streams;i++) {
2293
        /* free all data in a stream component */
2294
        st = s->streams[i];
2295
        if (st->parser) {
2296
            av_parser_close(st->parser);
2297
            av_free_packet(&st->cur_pkt);
2298
        }
2299
        av_metadata_free(&st->metadata);
2300
        av_free(st->index_entries);
2301
        av_free(st->codec->extradata);
2302
        av_free(st->codec);
2303
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2304
        av_free(st->filename);
2305
#endif
2306
        av_free(st->priv_data);
2307
        av_free(st);
2308
    }
2309
    for(i=s->nb_programs-1; i>=0; i--) {
2310
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2311
        av_freep(&s->programs[i]->provider_name);
2312
        av_freep(&s->programs[i]->name);
2313
#endif
2314
        av_metadata_free(&s->programs[i]->metadata);
2315
        av_freep(&s->programs[i]->stream_index);
2316
        av_freep(&s->programs[i]);
2317
    }
2318
    av_freep(&s->programs);
2319
    flush_packet_queue(s);
2320
    av_freep(&s->priv_data);
2321
    while(s->nb_chapters--) {
2322
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2323
        av_free(s->chapters[s->nb_chapters]->title);
2324
#endif
2325
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2326
        av_free(s->chapters[s->nb_chapters]);
2327
    }
2328
    av_freep(&s->chapters);
2329
    av_metadata_free(&s->metadata);
2330
    av_free(s);
2331
}
2332

    
2333
void av_close_input_file(AVFormatContext *s)
2334
{
2335
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2336
    av_close_input_stream(s);
2337
    if (pb)
2338
        url_fclose(pb);
2339
}
2340

    
2341
AVStream *av_new_stream(AVFormatContext *s, int id)
2342
{
2343
    AVStream *st;
2344
    int i;
2345

    
2346
    if (s->nb_streams >= MAX_STREAMS)
2347
        return NULL;
2348

    
2349
    st = av_mallocz(sizeof(AVStream));
2350
    if (!st)
2351
        return NULL;
2352

    
2353
    st->codec= avcodec_alloc_context();
2354
    if (s->iformat) {
2355
        /* no default bitrate if decoding */
2356
        st->codec->bit_rate = 0;
2357
    }
2358
    st->index = s->nb_streams;
2359
    st->id = id;
2360
    st->start_time = AV_NOPTS_VALUE;
2361
    st->duration = AV_NOPTS_VALUE;
2362
        /* we set the current DTS to 0 so that formats without any timestamps
2363
           but durations get some timestamps, formats with some unknown
2364
           timestamps have their first few packets buffered and the
2365
           timestamps corrected before they are returned to the user */
2366
    st->cur_dts = 0;
2367
    st->first_dts = AV_NOPTS_VALUE;
2368
    st->probe_packets = MAX_PROBE_PACKETS;
2369

    
2370
    /* default pts setting is MPEG-like */
2371
    av_set_pts_info(st, 33, 1, 90000);
2372
    st->last_IP_pts = AV_NOPTS_VALUE;
2373
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2374
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2375
    st->reference_dts = AV_NOPTS_VALUE;
2376

    
2377
    st->sample_aspect_ratio = (AVRational){0,1};
2378

    
2379
    s->streams[s->nb_streams++] = st;
2380
    return st;
2381
}
2382

    
2383
AVProgram *av_new_program(AVFormatContext *ac, int id)
2384
{
2385
    AVProgram *program=NULL;
2386
    int i;
2387

    
2388
#ifdef DEBUG_SI
2389
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2390
#endif
2391

    
2392
    for(i=0; i<ac->nb_programs; i++)
2393
        if(ac->programs[i]->id == id)
2394
            program = ac->programs[i];
2395

    
2396
    if(!program){
2397
        program = av_mallocz(sizeof(AVProgram));
2398
        if (!program)
2399
            return NULL;
2400
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2401
        program->discard = AVDISCARD_NONE;
2402
    }
2403
    program->id = id;
2404

    
2405
    return program;
2406
}
2407

    
2408
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2409
{
2410
    AVChapter *chapter = NULL;
2411
    int i;
2412

    
2413
    for(i=0; i<s->nb_chapters; i++)
2414
        if(s->chapters[i]->id == id)
2415
            chapter = s->chapters[i];
2416

    
2417
    if(!chapter){
2418
        chapter= av_mallocz(sizeof(AVChapter));
2419
        if(!chapter)
2420
            return NULL;
2421
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2422
    }
2423
#if LIBAVFORMAT_VERSION_INT < (53<<16)
2424
    av_free(chapter->title);
2425
#endif
2426
    av_metadata_set(&chapter->metadata, "title", title);
2427
    chapter->id    = id;
2428
    chapter->time_base= time_base;
2429
    chapter->start = start;
2430
    chapter->end   = end;
2431

    
2432
    return chapter;
2433
}
2434

    
2435
/************************************************************/
2436
/* output media file */
2437

    
2438
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2439
{
2440
    int ret;
2441

    
2442
    if (s->oformat->priv_data_size > 0) {
2443
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2444
        if (!s->priv_data)
2445
            return AVERROR(ENOMEM);
2446
    } else
2447
        s->priv_data = NULL;
2448

    
2449
    if (s->oformat->set_parameters) {
2450
        ret = s->oformat->set_parameters(s, ap);
2451
        if (ret < 0)
2452
            return ret;
2453
    }
2454
    return 0;
2455
}
2456

    
2457
int av_write_header(AVFormatContext *s)
2458
{
2459
    int ret, i;
2460
    AVStream *st;
2461

    
2462
    // some sanity checks
2463
    for(i=0;i<s->nb_streams;i++) {
2464
        st = s->streams[i];
2465

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

    
2492
        if(s->oformat->codec_tag){
2493
            if(st->codec->codec_tag){
2494
                //FIXME
2495
                //check that tag + id is in the table
2496
                //if neither is in the table -> OK
2497
                //if tag is in the table with another id -> FAIL
2498
                //if id is in the table with another tag -> FAIL unless strict < ?
2499
            }else
2500
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2501
        }
2502

    
2503
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2504
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2505
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2506
    }
2507

    
2508
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2509
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2510
        if (!s->priv_data)
2511
            return AVERROR(ENOMEM);
2512
    }
2513

    
2514
#if LIBAVFORMAT_VERSION_MAJOR < 53
2515
    ff_metadata_mux_compat(s);
2516
#endif
2517

    
2518
    if(s->oformat->write_header){
2519
        ret = s->oformat->write_header(s);
2520
        if (ret < 0)
2521
            return ret;
2522
    }
2523

    
2524
    /* init PTS generation */
2525
    for(i=0;i<s->nb_streams;i++) {
2526
        int64_t den = AV_NOPTS_VALUE;
2527
        st = s->streams[i];
2528

    
2529
        switch (st->codec->codec_type) {
2530
        case CODEC_TYPE_AUDIO:
2531
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2532
            break;
2533
        case CODEC_TYPE_VIDEO:
2534
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2535
            break;
2536
        default:
2537
            break;
2538
        }
2539
        if (den != AV_NOPTS_VALUE) {
2540
            if (den <= 0)
2541
                return AVERROR_INVALIDDATA;
2542
            av_frac_init(&st->pts, 0, 0, den);
2543
        }
2544
    }
2545
    return 0;
2546
}
2547

    
2548
//FIXME merge with compute_pkt_fields
2549
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2550
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2551
    int num, den, frame_size, i;
2552

    
2553
//    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);
2554

    
2555
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2556
        return -1;*/
2557

    
2558
    /* duration field */
2559
    if (pkt->duration == 0) {
2560
        compute_frame_duration(&num, &den, st, NULL, pkt);
2561
        if (den && num) {
2562
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2563
        }
2564
    }
2565

    
2566
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2567
        pkt->pts= pkt->dts;
2568

    
2569
    //XXX/FIXME this is a temporary hack until all encoders output pts
2570
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2571
        pkt->dts=
2572
//        pkt->pts= st->cur_dts;
2573
        pkt->pts= st->pts.val;
2574
    }
2575

    
2576
    //calculate dts from pts
2577
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2578
        st->pts_buffer[0]= pkt->pts;
2579
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2580
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2581
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2582
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2583

    
2584
        pkt->dts= st->pts_buffer[0];
2585
    }
2586

    
2587
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2588
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2589
        return -1;
2590
    }
2591
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2592
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2593
        return -1;
2594
    }
2595

    
2596
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2597
    st->cur_dts= pkt->dts;
2598
    st->pts.val= pkt->dts;
2599

    
2600
    /* update pts */
2601
    switch (st->codec->codec_type) {
2602
    case CODEC_TYPE_AUDIO:
2603
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2604

    
2605
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2606
           likely equal to the encoder delay, but it would be better if we
2607
           had the real timestamps from the encoder */
2608
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2609
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2610
        }
2611
        break;
2612
    case CODEC_TYPE_VIDEO:
2613
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2614
        break;
2615
    default:
2616
        break;
2617
    }
2618
    return 0;
2619
}
2620

    
2621
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2622
{
2623
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2624

    
2625
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2626
        return ret;
2627

    
2628
    ret= s->oformat->write_packet(s, pkt);
2629
    if(!ret)
2630
        ret= url_ferror(s->pb);
2631
    return ret;
2632
}
2633

    
2634
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2635
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2636
{
2637
    AVPacketList **next_point, *this_pktl;
2638

    
2639
    this_pktl = av_mallocz(sizeof(AVPacketList));
2640
    this_pktl->pkt= *pkt;
2641
    pkt->destruct= NULL;             // do not free original but only the copy
2642
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2643

    
2644
    next_point = &s->packet_buffer;
2645
    while(*next_point){
2646
        if(compare(s, &(*next_point)->pkt, pkt))
2647
            break;
2648
        next_point= &(*next_point)->next;
2649
    }
2650
    this_pktl->next= *next_point;
2651
    *next_point= this_pktl;
2652
}
2653

    
2654
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2655
{
2656
    AVStream *st = s->streams[ pkt ->stream_index];
2657
    AVStream *st2= s->streams[ next->stream_index];
2658
    int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2659
    int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2660

    
2661
    if (pkt->dts == AV_NOPTS_VALUE)
2662
        return 0;
2663

    
2664
    return next->dts * left > pkt->dts * right; //FIXME this can overflow
2665
}
2666

    
2667
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2668
    AVPacketList *pktl;
2669
    int stream_count=0;
2670
    int streams[MAX_STREAMS];
2671

    
2672
    if(pkt){
2673
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2674
    }
2675

    
2676
    memset(streams, 0, sizeof(streams));
2677
    pktl= s->packet_buffer;
2678
    while(pktl){
2679
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2680
        if(streams[ pktl->pkt.stream_index ] == 0)
2681
            stream_count++;
2682
        streams[ pktl->pkt.stream_index ]++;
2683
        pktl= pktl->next;
2684
    }
2685

    
2686
    if(stream_count && (s->nb_streams == stream_count || flush)){
2687
        pktl= s->packet_buffer;
2688
        *out= pktl->pkt;
2689

    
2690
        s->packet_buffer= pktl->next;
2691
        av_freep(&pktl);
2692
        return 1;
2693
    }else{
2694
        av_init_packet(out);
2695
        return 0;
2696
    }
2697
}
2698

    
2699
/**
2700
 * Interleaves an AVPacket correctly so it can be muxed.
2701
 * @param out the interleaved packet will be output here
2702
 * @param in the input packet
2703
 * @param flush 1 if no further packets are available as input and all
2704
 *              remaining packets should be output
2705
 * @return 1 if a packet was output, 0 if no packet could be output,
2706
 *         < 0 if an error occurred
2707
 */
2708
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2709
    if(s->oformat->interleave_packet)
2710
        return s->oformat->interleave_packet(s, out, in, flush);
2711
    else
2712
        return av_interleave_packet_per_dts(s, out, in, flush);
2713
}
2714

    
2715
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2716
    AVStream *st= s->streams[ pkt->stream_index];
2717

    
2718
    //FIXME/XXX/HACK drop zero sized packets
2719
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2720
        return 0;
2721

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

    
2726
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2727
        return -1;
2728

    
2729
    for(;;){
2730
        AVPacket opkt;
2731
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2732
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2733
            return ret;
2734

    
2735
        ret= s->oformat->write_packet(s, &opkt);
2736

    
2737
        av_free_packet(&opkt);
2738
        pkt= NULL;
2739

    
2740
        if(ret<0)
2741
            return ret;
2742
        if(url_ferror(s->pb))
2743
            return url_ferror(s->pb);
2744
    }
2745
}
2746

    
2747
int av_write_trailer(AVFormatContext *s)
2748
{
2749
    int ret, i;
2750

    
2751
    for(;;){
2752
        AVPacket pkt;
2753
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2754
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2755
            goto fail;
2756
        if(!ret)
2757
            break;
2758

    
2759
        ret= s->oformat->write_packet(s, &pkt);
2760

    
2761
        av_free_packet(&pkt);
2762

    
2763
        if(ret<0)
2764
            goto fail;
2765
        if(url_ferror(s->pb))
2766
            goto fail;
2767
    }
2768

    
2769
    if(s->oformat->write_trailer)
2770
        ret = s->oformat->write_trailer(s);
2771
fail:
2772
    if(ret == 0)
2773
       ret=url_ferror(s->pb);
2774
    for(i=0;i<s->nb_streams;i++)
2775
        av_freep(&s->streams[i]->priv_data);
2776
    av_freep(&s->priv_data);
2777
    return ret;
2778
}
2779

    
2780
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2781
{
2782
    int i, j;
2783
    AVProgram *program=NULL;
2784
    void *tmp;
2785

    
2786
    for(i=0; i<ac->nb_programs; i++){
2787
        if(ac->programs[i]->id != progid)
2788
            continue;
2789
        program = ac->programs[i];
2790
        for(j=0; j<program->nb_stream_indexes; j++)
2791
            if(program->stream_index[j] == idx)
2792
                return;
2793

    
2794
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2795
        if(!tmp)
2796
            return;
2797
        program->stream_index = tmp;
2798
        program->stream_index[program->nb_stream_indexes++] = idx;
2799
        return;
2800
    }
2801
}
2802

    
2803
static void print_fps(double d, const char *postfix){
2804
    uint64_t v= lrintf(d*100);
2805
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2806
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2807
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2808
}
2809

    
2810
/* "user interface" functions */
2811
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2812
{
2813
    char buf[256];
2814
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2815
    AVStream *st = ic->streams[i];
2816
    int g = av_gcd(st->time_base.num, st->time_base.den);
2817
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2818
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2819
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2820
    /* the pid is an important information, so we display it */
2821
    /* XXX: add a generic system */
2822
    if (flags & AVFMT_SHOW_IDS)
2823
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2824
    if (lang)
2825
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2826
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2827
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2828
    if (st->sample_aspect_ratio.num && // default
2829
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2830
        AVRational display_aspect_ratio;
2831
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2832
                  st->codec->width*st->sample_aspect_ratio.num,
2833
                  st->codec->height*st->sample_aspect_ratio.den,
2834
                  1024*1024);
2835
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2836
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2837
                 display_aspect_ratio.num, display_aspect_ratio.den);
2838
    }
2839
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2840
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2841
            print_fps(av_q2d(st->r_frame_rate), "tbr");
2842
        if(st->time_base.den && st->time_base.num)
2843
            print_fps(1/av_q2d(st->time_base), "tbn");
2844
        if(st->codec->time_base.den && st->codec->time_base.num)
2845
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
2846
    }
2847
    av_log(NULL, AV_LOG_INFO, "\n");
2848
}
2849

    
2850
void dump_format(AVFormatContext *ic,
2851
                 int index,
2852
                 const char *url,
2853
                 int is_output)
2854
{
2855
    int i;
2856

    
2857
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2858
            is_output ? "Output" : "Input",
2859
            index,
2860
            is_output ? ic->oformat->name : ic->iformat->name,
2861
            is_output ? "to" : "from", url);
2862
    if (!is_output) {
2863
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2864
        if (ic->duration != AV_NOPTS_VALUE) {
2865
            int hours, mins, secs, us;
2866
            secs = ic->duration / AV_TIME_BASE;
2867
            us = ic->duration % AV_TIME_BASE;
2868
            mins = secs / 60;
2869
            secs %= 60;
2870
            hours = mins / 60;
2871
            mins %= 60;
2872
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2873
                   (100 * us) / AV_TIME_BASE);
2874
        } else {
2875
            av_log(NULL, AV_LOG_INFO, "N/A");
2876
        }
2877
        if (ic->start_time != AV_NOPTS_VALUE) {
2878
            int secs, us;
2879
            av_log(NULL, AV_LOG_INFO, ", start: ");
2880
            secs = ic->start_time / AV_TIME_BASE;
2881
            us = ic->start_time % AV_TIME_BASE;
2882
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2883
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2884
        }
2885
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2886
        if (ic->bit_rate) {
2887
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2888
        } else {
2889
            av_log(NULL, AV_LOG_INFO, "N/A");
2890
        }
2891
        av_log(NULL, AV_LOG_INFO, "\n");
2892
    }
2893
    if(ic->nb_programs) {
2894
        int j, k;
2895
        for(j=0; j<ic->nb_programs; j++) {
2896
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
2897
                                                  "name", NULL, 0);
2898
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2899
                   name ? name->value : "");
2900
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2901
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2902
         }
2903
    } else
2904
    for(i=0;i<ic->nb_streams;i++)
2905
        dump_stream_format(ic, i, index, is_output);
2906
}
2907

    
2908
#if LIBAVFORMAT_VERSION_MAJOR < 53
2909
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2910
{
2911
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2912
}
2913

    
2914
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2915
{
2916
    AVRational frame_rate;
2917
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2918
    *frame_rate_num= frame_rate.num;
2919
    *frame_rate_den= frame_rate.den;
2920
    return ret;
2921
}
2922
#endif
2923

    
2924
int64_t av_gettime(void)
2925
{
2926
    struct timeval tv;
2927
    gettimeofday(&tv,NULL);
2928
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2929
}
2930

    
2931
int64_t parse_date(const char *datestr, int duration)
2932
{
2933
    const char *p;
2934
    int64_t t;
2935
    struct tm dt;
2936
    int i;
2937
    static const char * const date_fmt[] = {
2938
        "%Y-%m-%d",
2939
        "%Y%m%d",
2940
    };
2941
    static const char * const time_fmt[] = {
2942
        "%H:%M:%S",
2943
        "%H%M%S",
2944
    };
2945
    const char *q;
2946
    int is_utc, len;
2947
    char lastch;
2948
    int negative = 0;
2949

    
2950
#undef time
2951
    time_t now = time(0);
2952

    
2953
    len = strlen(datestr);
2954
    if (len > 0)
2955
        lastch = datestr[len - 1];
2956
    else
2957
        lastch = '\0';
2958
    is_utc = (lastch == 'z' || lastch == 'Z');
2959

    
2960
    memset(&dt, 0, sizeof(dt));
2961

    
2962
    p = datestr;
2963
    q = NULL;
2964
    if (!duration) {
2965
        if (!strncasecmp(datestr, "now", len))
2966
            return (int64_t) now * 1000000;
2967

    
2968
        /* parse the year-month-day part */
2969
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2970
            q = small_strptime(p, date_fmt[i], &dt);
2971
            if (q) {
2972
                break;
2973
            }
2974
        }
2975

    
2976
        /* if the year-month-day part is missing, then take the
2977
         * current year-month-day time */
2978
        if (!q) {
2979
            if (is_utc) {
2980
                dt = *gmtime(&now);
2981
            } else {
2982
                dt = *localtime(&now);
2983
            }
2984
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2985
        } else {
2986
            p = q;
2987
        }
2988

    
2989
        if (*p == 'T' || *p == 't' || *p == ' ')
2990
            p++;
2991

    
2992
        /* parse the hour-minute-second part */
2993
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2994
            q = small_strptime(p, time_fmt[i], &dt);
2995
            if (q) {
2996
                break;
2997
            }
2998
        }
2999
    } else {
3000
        /* parse datestr as a duration */
3001
        if (p[0] == '-') {
3002
            negative = 1;
3003
            ++p;
3004
        }
3005
        /* parse datestr as HH:MM:SS */
3006
        q = small_strptime(p, time_fmt[0], &dt);
3007
        if (!q) {
3008
            /* parse datestr as S+ */
3009
            dt.tm_sec = strtol(p, (char **)&q, 10);
3010
            if (q == p)
3011
                /* the parsing didn't succeed */
3012
                return INT64_MIN;
3013
            dt.tm_min = 0;
3014
            dt.tm_hour = 0;
3015
        }
3016
    }
3017

    
3018
    /* Now we have all the fields that we can get */
3019
    if (!q) {
3020
        return INT64_MIN;
3021
    }
3022

    
3023
    if (duration) {
3024
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3025
    } else {
3026
        dt.tm_isdst = -1;       /* unknown */
3027
        if (is_utc) {
3028
            t = mktimegm(&dt);
3029
        } else {
3030
            t = mktime(&dt);
3031
        }
3032
    }
3033

    
3034
    t *= 1000000;
3035

    
3036
    /* parse the .m... part */
3037
    if (*q == '.') {
3038
        int val, n;
3039
        q++;
3040
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3041
            if (!isdigit(*q))
3042
                break;
3043
            val += n * (*q - '0');
3044
        }
3045
        t += val;
3046
    }
3047
    return negative ? -t : t;
3048
}
3049

    
3050
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3051
{
3052
    const char *p;
3053
    char tag[128], *q;
3054

    
3055
    p = info;
3056
    if (*p == '?')
3057
        p++;
3058
    for(;;) {
3059
        q = tag;
3060
        while (*p != '\0' && *p != '=' && *p != '&') {
3061
            if ((q - tag) < sizeof(tag) - 1)
3062
                *q++ = *p;
3063
            p++;
3064
        }
3065
        *q = '\0';
3066
        q = arg;
3067
        if (*p == '=') {
3068
            p++;
3069
            while (*p != '&' && *p != '\0') {
3070
                if ((q - arg) < arg_size - 1) {
3071
                    if (*p == '+')
3072
                        *q++ = ' ';
3073
                    else
3074
                        *q++ = *p;
3075
                }
3076
                p++;
3077
            }
3078
            *q = '\0';
3079
        }
3080
        if (!strcmp(tag, tag1))
3081
            return 1;
3082
        if (*p != '&')
3083
            break;
3084
        p++;
3085
    }
3086
    return 0;
3087
}
3088

    
3089
int av_get_frame_filename(char *buf, int buf_size,
3090
                          const char *path, int number)
3091
{
3092
    const char *p;
3093
    char *q, buf1[20], c;
3094
    int nd, len, percentd_found;
3095

    
3096
    q = buf;
3097
    p = path;
3098
    percentd_found = 0;
3099
    for(;;) {
3100
        c = *p++;
3101
        if (c == '\0')
3102
            break;
3103
        if (c == '%') {
3104
            do {
3105
                nd = 0;
3106
                while (isdigit(*p)) {
3107
                    nd = nd * 10 + *p++ - '0';
3108
                }
3109
                c = *p++;
3110
            } while (isdigit(c));
3111

    
3112
            switch(c) {
3113
            case '%':
3114
                goto addchar;
3115
            case 'd':
3116
                if (percentd_found)
3117
                    goto fail;
3118
                percentd_found = 1;
3119
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3120
                len = strlen(buf1);
3121
                if ((q - buf + len) > buf_size - 1)
3122
                    goto fail;
3123
                memcpy(q, buf1, len);
3124
                q += len;
3125
                break;
3126
            default:
3127
                goto fail;
3128
            }
3129
        } else {
3130
        addchar:
3131
            if ((q - buf) < buf_size - 1)
3132
                *q++ = c;
3133
        }
3134
    }
3135
    if (!percentd_found)
3136
        goto fail;
3137
    *q = '\0';
3138
    return 0;
3139
 fail:
3140
    *q = '\0';
3141
    return -1;
3142
}
3143

    
3144
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3145
{
3146
    int len, i, j, c;
3147
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3148

    
3149
    for(i=0;i<size;i+=16) {
3150
        len = size - i;
3151
        if (len > 16)
3152
            len = 16;
3153
        PRINT("%08x ", i);
3154
        for(j=0;j<16;j++) {
3155
            if (j < len)
3156
                PRINT(" %02x", buf[i+j]);
3157
            else
3158
                PRINT("   ");
3159
        }
3160
        PRINT(" ");
3161
        for(j=0;j<len;j++) {
3162
            c = buf[i+j];
3163
            if (c < ' ' || c > '~')
3164
                c = '.';
3165
            PRINT("%c", c);
3166
        }
3167
        PRINT("\n");
3168
    }
3169
#undef PRINT
3170
}
3171

    
3172
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3173
{
3174
    hex_dump_internal(NULL, f, 0, buf, size);
3175
}
3176

    
3177
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3178
{
3179
    hex_dump_internal(avcl, NULL, level, buf, size);
3180
}
3181

    
3182
 //FIXME needs to know the time_base
3183
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3184
{
3185
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3186
    PRINT("stream #%d:\n", pkt->stream_index);
3187
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3188
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3189
    /* DTS is _always_ valid after av_read_frame() */
3190
    PRINT("  dts=");
3191
    if (pkt->dts == AV_NOPTS_VALUE)
3192
        PRINT("N/A");
3193
    else
3194
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3195
    /* PTS may not be known if B-frames are present. */
3196
    PRINT("  pts=");
3197
    if (pkt->pts == AV_NOPTS_VALUE)
3198
        PRINT("N/A");
3199
    else
3200
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3201
    PRINT("\n");
3202
    PRINT("  size=%d\n", pkt->size);
3203
#undef PRINT
3204
    if (dump_payload)
3205
        av_hex_dump(f, pkt->data, pkt->size);
3206
}
3207

    
3208
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3209
{
3210
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3211
}
3212

    
3213
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3214
{
3215
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3216
}
3217

    
3218
void url_split(char *proto, int proto_size,
3219
               char *authorization, int authorization_size,
3220
               char *hostname, int hostname_size,
3221
               int *port_ptr,
3222
               char *path, int path_size,
3223
               const char *url)
3224
{
3225
    const char *p, *ls, *at, *col, *brk;
3226

    
3227
    if (port_ptr)               *port_ptr = -1;
3228
    if (proto_size > 0)         proto[0] = 0;
3229
    if (authorization_size > 0) authorization[0] = 0;
3230
    if (hostname_size > 0)      hostname[0] = 0;
3231
    if (path_size > 0)          path[0] = 0;
3232

    
3233
    /* parse protocol */
3234
    if ((p = strchr(url, ':'))) {
3235
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3236
        p++; /* skip ':' */
3237
        if (*p == '/') p++;
3238
        if (*p == '/') p++;
3239
    } else {
3240
        /* no protocol means plain filename */
3241
        av_strlcpy(path, url, path_size);
3242
        return;
3243
    }
3244

    
3245
    /* separate path from hostname */
3246
    ls = strchr(p, '/');
3247
    if(!ls)
3248
        ls = strchr(p, '?');
3249
    if(ls)
3250
        av_strlcpy(path, ls, path_size);
3251
    else
3252
        ls = &p[strlen(p)]; // XXX
3253

    
3254
    /* the rest is hostname, use that to parse auth/port */
3255
    if (ls != p) {
3256
        /* authorization (user[:pass]@hostname) */
3257
        if ((at = strchr(p, '@')) && at < ls) {
3258
            av_strlcpy(authorization, p,
3259
                       FFMIN(authorization_size, at + 1 - p));
3260
            p = at + 1; /* skip '@' */
3261
        }
3262

    
3263
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3264
            /* [host]:port */
3265
            av_strlcpy(hostname, p + 1,
3266
                       FFMIN(hostname_size, brk - p));
3267
            if (brk[1] == ':' && port_ptr)
3268
                *port_ptr = atoi(brk + 2);
3269
        } else if ((col = strchr(p, ':')) && col < ls) {
3270
            av_strlcpy(hostname, p,
3271
                       FFMIN(col + 1 - p, hostname_size));
3272
            if (port_ptr) *port_ptr = atoi(col + 1);
3273
        } else
3274
            av_strlcpy(hostname, p,
3275
                       FFMIN(ls + 1 - p, hostname_size));
3276
    }
3277
}
3278

    
3279
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3280
{
3281
    int i;
3282
    static const char hex_table[16] = { '0', '1', '2', '3',
3283
                                        '4', '5', '6', '7',
3284
                                        '8', '9', 'A', 'B',
3285
                                        'C', 'D', 'E', 'F' };
3286

    
3287
    for(i = 0; i < s; i++) {
3288
        buff[i * 2]     = hex_table[src[i] >> 4];
3289
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3290
    }
3291

    
3292
    return buff;
3293
}
3294

    
3295
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3296
                     int pts_num, int pts_den)
3297
{
3298
    unsigned int gcd= av_gcd(pts_num, pts_den);
3299
    s->pts_wrap_bits = pts_wrap_bits;
3300
    s->time_base.num = pts_num/gcd;
3301
    s->time_base.den = pts_den/gcd;
3302

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