Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 708ec8fb

History | View | Annotate | Download (96.8 KB)

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

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

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

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

    
44
/* fraction handling */
45

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

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

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

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

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

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

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

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

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

    
134
    if(!filename)
135
        return 0;
136

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

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

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

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

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

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

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

    
209
    return fmt;
210
}
211

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

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

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

    
241
/* memory handling */
242

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

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

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

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

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

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

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

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

    
293
    return ret;
294
}
295

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

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

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

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

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

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

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

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

    
381
/**
382
 * Open a media file from an IO stream. 'fmt' must be specified.
383
 */
384
int av_open_input_stream(AVFormatContext **ic_ptr,
385
                         ByteIOContext *pb, const char *filename,
386
                         AVInputFormat *fmt, AVFormatParameters *ap)
387
{
388
    int err;
389
    AVFormatContext *ic;
390
    AVFormatParameters default_ap;
391

    
392
    if(!ap){
393
        ap=&default_ap;
394
        memset(ap, 0, sizeof(default_ap));
395
    }
396

    
397
    if(!ap->prealloced_context)
398
        ic = av_alloc_format_context();
399
    else
400
        ic = *ic_ptr;
401
    if (!ic) {
402
        err = AVERROR(ENOMEM);
403
        goto fail;
404
    }
405
    ic->iformat = fmt;
406
    ic->pb = pb;
407
    ic->duration = AV_NOPTS_VALUE;
408
    ic->start_time = AV_NOPTS_VALUE;
409
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
410

    
411
    /* allocate private data */
412
    if (fmt->priv_data_size > 0) {
413
        ic->priv_data = av_mallocz(fmt->priv_data_size);
414
        if (!ic->priv_data) {
415
            err = AVERROR(ENOMEM);
416
            goto fail;
417
        }
418
    } else {
419
        ic->priv_data = NULL;
420
    }
421

    
422
    if (ic->iformat->read_header) {
423
        err = ic->iformat->read_header(ic, ap);
424
        if (err < 0)
425
            goto fail;
426
    }
427

    
428
    if (pb && !ic->data_offset)
429
        ic->data_offset = url_ftell(ic->pb);
430

    
431
#if LIBAVFORMAT_VERSION_MAJOR < 53
432
    ff_metadata_demux_compat(ic);
433
#endif
434

    
435
    *ic_ptr = ic;
436
    return 0;
437
 fail:
438
    if (ic) {
439
        int i;
440
        av_freep(&ic->priv_data);
441
        for(i=0;i<ic->nb_streams;i++) {
442
            AVStream *st = ic->streams[i];
443
            if (st) {
444
                av_free(st->priv_data);
445
                av_free(st->codec->extradata);
446
            }
447
            av_free(st);
448
        }
449
    }
450
    av_free(ic);
451
    *ic_ptr = NULL;
452
    return err;
453
}
454

    
455
/** size of probe buffer, for guessing file type from file contents */
456
#define PROBE_BUF_MIN 2048
457
#define PROBE_BUF_MAX (1<<20)
458

    
459
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
460
                       AVInputFormat *fmt,
461
                       int buf_size,
462
                       AVFormatParameters *ap)
463
{
464
    int err, probe_size;
465
    AVProbeData probe_data, *pd = &probe_data;
466
    ByteIOContext *pb = NULL;
467

    
468
    pd->filename = "";
469
    if (filename)
470
        pd->filename = filename;
471
    pd->buf = NULL;
472
    pd->buf_size = 0;
473

    
474
    if (!fmt) {
475
        /* guess format if no file can be opened */
476
        fmt = av_probe_input_format(pd, 0);
477
    }
478

    
479
    /* Do not open file if the format does not need it. XXX: specific
480
       hack needed to handle RTSP/TCP */
481
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
482
        /* if no file needed do not try to open one */
483
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
484
            goto fail;
485
        }
486
        if (buf_size > 0) {
487
            url_setbufsize(pb, buf_size);
488
        }
489

    
490
        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
491
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
492
            /* read probe data */
493
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
494
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
495
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
496
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
497
                url_fclose(pb);
498
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
499
                    pb = NULL;
500
                    err = AVERROR(EIO);
501
                    goto fail;
502
                }
503
            }
504
            /* guess file format */
505
            fmt = av_probe_input_format2(pd, 1, &score);
506
        }
507
        av_freep(&pd->buf);
508
    }
509

    
510
    /* if still no format found, error */
511
    if (!fmt) {
512
        err = AVERROR_NOFMT;
513
        goto fail;
514
    }
515

    
516
    /* check filename in case an image number is expected */
517
    if (fmt->flags & AVFMT_NEEDNUMBER) {
518
        if (!av_filename_number_test(filename)) {
519
            err = AVERROR_NUMEXPECTED;
520
            goto fail;
521
        }
522
    }
523
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
524
    if (err)
525
        goto fail;
526
    return 0;
527
 fail:
528
    av_freep(&pd->buf);
529
    if (pb)
530
        url_fclose(pb);
531
    *ic_ptr = NULL;
532
    return err;
533

    
534
}
535

    
536
/*******************************************************/
537

    
538
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
539
                               AVPacketList **plast_pktl){
540
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
541
    if (!pktl)
542
        return NULL;
543

    
544
    if (*packet_buffer)
545
        (*plast_pktl)->next = pktl;
546
    else
547
        *packet_buffer = pktl;
548

    
549
    /* add the packet in the buffered packet list */
550
    *plast_pktl = pktl;
551
    pktl->pkt= *pkt;
552
    return &pktl->pkt;
553
}
554

    
555
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
556
{
557
    int ret;
558
    AVStream *st;
559

    
560
    for(;;){
561
        AVPacketList *pktl = s->raw_packet_buffer;
562

    
563
        if (pktl) {
564
            *pkt = pktl->pkt;
565
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
566
                s->raw_packet_buffer = pktl->next;
567
                av_free(pktl);
568
                return 0;
569
            }
570
        }
571

    
572
        av_init_packet(pkt);
573
        ret= s->iformat->read_packet(s, pkt);
574
        if (ret < 0)
575
            return ret;
576
        st= s->streams[pkt->stream_index];
577

    
578
        switch(st->codec->codec_type){
579
        case CODEC_TYPE_VIDEO:
580
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
581
            break;
582
        case CODEC_TYPE_AUDIO:
583
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
584
            break;
585
        case CODEC_TYPE_SUBTITLE:
586
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
587
            break;
588
        }
589

    
590
        if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
591
            return ret;
592

    
593
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
594

    
595
        if(st->codec->codec_id == CODEC_ID_PROBE){
596
            AVProbeData *pd = &st->probe_data;
597

    
598
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
599
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
600
            pd->buf_size += pkt->size;
601
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
602

    
603
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
604
                set_codec_from_probe_data(st, pd, 1);
605
                if(st->codec->codec_id != CODEC_ID_PROBE){
606
                    pd->buf_size=0;
607
                    av_freep(&pd->buf);
608
                }
609
            }
610
        }
611
    }
612
}
613

    
614
/**********************************************************/
615

    
616
/**
617
 * Get the number of samples of an audio frame. Return -1 on error.
618
 */
619
static int get_audio_frame_size(AVCodecContext *enc, int size)
620
{
621
    int frame_size;
622

    
623
    if(enc->codec_id == CODEC_ID_VORBIS)
624
        return -1;
625

    
626
    if (enc->frame_size <= 1) {
627
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
628

    
629
        if (bits_per_sample) {
630
            if (enc->channels == 0)
631
                return -1;
632
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
633
        } else {
634
            /* used for example by ADPCM codecs */
635
            if (enc->bit_rate == 0)
636
                return -1;
637
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
638
        }
639
    } else {
640
        frame_size = enc->frame_size;
641
    }
642
    return frame_size;
643
}
644

    
645

    
646
/**
647
 * Return the frame duration in seconds. Return 0 if not available.
648
 */
649
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
650
                                   AVCodecParserContext *pc, AVPacket *pkt)
651
{
652
    int frame_size;
653

    
654
    *pnum = 0;
655
    *pden = 0;
656
    switch(st->codec->codec_type) {
657
    case CODEC_TYPE_VIDEO:
658
        if(st->time_base.num*1000LL > st->time_base.den){
659
            *pnum = st->time_base.num;
660
            *pden = st->time_base.den;
661
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
662
            *pnum = st->codec->time_base.num;
663
            *pden = st->codec->time_base.den;
664
            if (pc && pc->repeat_pict) {
665
                *pden *= 2;
666
                *pnum = (*pnum) * (2 + pc->repeat_pict);
667
            }
668
        }
669
        break;
670
    case CODEC_TYPE_AUDIO:
671
        frame_size = get_audio_frame_size(st->codec, pkt->size);
672
        if (frame_size < 0)
673
            break;
674
        *pnum = frame_size;
675
        *pden = st->codec->sample_rate;
676
        break;
677
    default:
678
        break;
679
    }
680
}
681

    
682
static int is_intra_only(AVCodecContext *enc){
683
    if(enc->codec_type == CODEC_TYPE_AUDIO){
684
        return 1;
685
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
686
        switch(enc->codec_id){
687
        case CODEC_ID_MJPEG:
688
        case CODEC_ID_MJPEGB:
689
        case CODEC_ID_LJPEG:
690
        case CODEC_ID_RAWVIDEO:
691
        case CODEC_ID_DVVIDEO:
692
        case CODEC_ID_HUFFYUV:
693
        case CODEC_ID_FFVHUFF:
694
        case CODEC_ID_ASV1:
695
        case CODEC_ID_ASV2:
696
        case CODEC_ID_VCR1:
697
        case CODEC_ID_DNXHD:
698
            return 1;
699
        default: break;
700
        }
701
    }
702
    return 0;
703
}
704

    
705
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
706
                                      int64_t dts, int64_t pts)
707
{
708
    AVStream *st= s->streams[stream_index];
709
    AVPacketList *pktl= s->packet_buffer;
710

    
711
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
712
        return;
713

    
714
    st->first_dts= dts - st->cur_dts;
715
    st->cur_dts= dts;
716

    
717
    for(; pktl; pktl= pktl->next){
718
        if(pktl->pkt.stream_index != stream_index)
719
            continue;
720
        //FIXME think more about this check
721
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
722
            pktl->pkt.pts += st->first_dts;
723

    
724
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
725
            pktl->pkt.dts += st->first_dts;
726

    
727
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
728
            st->start_time= pktl->pkt.pts;
729
    }
730
    if (st->start_time == AV_NOPTS_VALUE)
731
        st->start_time = pts;
732
}
733

    
734
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
735
{
736
    AVPacketList *pktl= s->packet_buffer;
737
    int64_t cur_dts= 0;
738

    
739
    if(st->first_dts != AV_NOPTS_VALUE){
740
        cur_dts= st->first_dts;
741
        for(; pktl; pktl= pktl->next){
742
            if(pktl->pkt.stream_index == pkt->stream_index){
743
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
744
                    break;
745
                cur_dts -= pkt->duration;
746
            }
747
        }
748
        pktl= s->packet_buffer;
749
        st->first_dts = cur_dts;
750
    }else if(st->cur_dts)
751
        return;
752

    
753
    for(; pktl; pktl= pktl->next){
754
        if(pktl->pkt.stream_index != pkt->stream_index)
755
            continue;
756
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
757
           && !pktl->pkt.duration){
758
            pktl->pkt.dts= cur_dts;
759
            if(!st->codec->has_b_frames)
760
                pktl->pkt.pts= cur_dts;
761
            cur_dts += pkt->duration;
762
            pktl->pkt.duration= pkt->duration;
763
        }else
764
            break;
765
    }
766
    if(st->first_dts == AV_NOPTS_VALUE)
767
        st->cur_dts= cur_dts;
768
}
769

    
770
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
771
                               AVCodecParserContext *pc, AVPacket *pkt)
772
{
773
    int num, den, presentation_delayed, delay, i;
774
    int64_t offset;
775

    
776
    /* do we have a video B-frame ? */
777
    delay= st->codec->has_b_frames;
778
    presentation_delayed = 0;
779
    /* XXX: need has_b_frame, but cannot get it if the codec is
780
        not initialized */
781
    if (delay &&
782
        pc && pc->pict_type != FF_B_TYPE)
783
        presentation_delayed = 1;
784

    
785
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
786
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
787
        pkt->dts -= 1LL<<st->pts_wrap_bits;
788
    }
789

    
790
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
791
    // we take the conservative approach and discard both
792
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
793
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
794
        av_log(s, AV_LOG_ERROR, "invalid dts/pts combination\n");
795
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
796
    }
797

    
798
    if (pkt->duration == 0) {
799
        compute_frame_duration(&num, &den, st, pc, pkt);
800
        if (den && num) {
801
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
802

    
803
            if(pkt->duration != 0 && s->packet_buffer)
804
                update_initial_durations(s, st, pkt);
805
        }
806
    }
807

    
808
    /* correct timestamps with byte offset if demuxers only have timestamps
809
       on packet boundaries */
810
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
811
        /* this will estimate bitrate based on this frame's duration and size */
812
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
813
        if(pkt->pts != AV_NOPTS_VALUE)
814
            pkt->pts += offset;
815
        if(pkt->dts != AV_NOPTS_VALUE)
816
            pkt->dts += offset;
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
    if(delay==0 || (delay==1 && pc)){
826
        if (presentation_delayed) {
827
            /* DTS = decompression timestamp */
828
            /* PTS = presentation timestamp */
829
            if (pkt->dts == AV_NOPTS_VALUE)
830
                pkt->dts = st->last_IP_pts;
831
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
832
            if (pkt->dts == AV_NOPTS_VALUE)
833
                pkt->dts = st->cur_dts;
834

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

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

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

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

    
882
    /* update flags */
883
    if(is_intra_only(st->codec))
884
        pkt->flags |= PKT_FLAG_KEY;
885
    else if (pc) {
886
        pkt->flags = 0;
887
        /* keyframe computation */
888
            if (pc->pict_type == FF_I_TYPE)
889
                pkt->flags |= PKT_FLAG_KEY;
890
    }
891
}
892

    
893
void av_destruct_packet_nofree(AVPacket *pkt)
894
{
895
    pkt->data = NULL; pkt->size = 0;
896
}
897

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

    
903
    av_init_packet(pkt);
904

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

    
926
                /* return packet if any */
927
                if (pkt->size) {
928
                got_packet:
929
                    pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
930
                    pkt->duration = 0;
931
                    pkt->stream_index = st->index;
932
                    pkt->pts = st->parser->pts;
933
                    pkt->dts = st->parser->dts;
934
                    pkt->destruct = av_destruct_packet_nofree;
935
                    compute_pkt_fields(s, st, st->parser, pkt);
936

    
937
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
938
                        ff_reduce_index(s, st->index);
939
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
940
                                           0, 0, AVINDEX_KEYFRAME);
941
                    }
942

    
943
                    break;
944
                }
945
            } else {
946
                /* free packet */
947
                av_free_packet(&s->cur_pkt);
948
                s->cur_st = NULL;
949
            }
950
        } else {
951
            /* read next packet */
952
            ret = av_read_packet(s, &s->cur_pkt);
953
            if (ret < 0) {
954
                if (ret == AVERROR(EAGAIN))
955
                    return ret;
956
                /* return the last frames, if any */
957
                for(i = 0; i < s->nb_streams; i++) {
958
                    st = s->streams[i];
959
                    if (st->parser && st->need_parsing) {
960
                        av_parser_parse(st->parser, st->codec,
961
                                        &pkt->data, &pkt->size,
962
                                        NULL, 0,
963
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
964
                        if (pkt->size)
965
                            goto got_packet;
966
                    }
967
                }
968
                /* no more packets: really terminate parsing */
969
                return ret;
970
            }
971

    
972
            if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
973
               s->cur_pkt.dts != AV_NOPTS_VALUE &&
974
               s->cur_pkt.pts < s->cur_pkt.dts){
975
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
976
                    s->cur_pkt.stream_index,
977
                    s->cur_pkt.pts,
978
                    s->cur_pkt.dts,
979
                    s->cur_pkt.size);
980
//                av_free_packet(&s->cur_pkt);
981
//                return -1;
982
            }
983

    
984
            st = s->streams[s->cur_pkt.stream_index];
985
            if(s->debug & FF_FDEBUG_TS)
986
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
987
                    s->cur_pkt.stream_index,
988
                    s->cur_pkt.pts,
989
                    s->cur_pkt.dts,
990
                    s->cur_pkt.size,
991
                    s->cur_pkt.flags);
992

    
993
            s->cur_st = st;
994
            s->cur_ptr = s->cur_pkt.data;
995
            s->cur_len = s->cur_pkt.size;
996
            if (st->need_parsing && !st->parser) {
997
                st->parser = av_parser_init(st->codec->codec_id);
998
                if (!st->parser) {
999
                    /* no parser available: just output the raw packets */
1000
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1001
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1002
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1003
                }
1004
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1005
                    st->parser->next_frame_offset=
1006
                    st->parser->cur_offset= s->cur_pkt.pos;
1007
                }
1008
            }
1009
        }
1010
    }
1011
    if(s->debug & FF_FDEBUG_TS)
1012
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
1013
            pkt->stream_index,
1014
            pkt->pts,
1015
            pkt->dts,
1016
            pkt->size,
1017
            pkt->flags);
1018

    
1019
    return 0;
1020
}
1021

    
1022
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1023
{
1024
    AVPacketList *pktl;
1025
    int eof=0;
1026
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1027

    
1028
    for(;;){
1029
        pktl = s->packet_buffer;
1030
        if (pktl) {
1031
            AVPacket *next_pkt= &pktl->pkt;
1032

    
1033
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1034
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1035
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1036
                       && next_pkt->dts < pktl->pkt.dts
1037
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1038
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1039
                        next_pkt->pts= pktl->pkt.dts;
1040
                    }
1041
                    pktl= pktl->next;
1042
                }
1043
                pktl = s->packet_buffer;
1044
            }
1045

    
1046
            if(   next_pkt->pts != AV_NOPTS_VALUE
1047
               || next_pkt->dts == AV_NOPTS_VALUE
1048
               || !genpts || eof){
1049
                /* read packet from packet buffer, if there is data */
1050
                *pkt = *next_pkt;
1051
                s->packet_buffer = pktl->next;
1052
                av_free(pktl);
1053
                return 0;
1054
            }
1055
        }
1056
        if(genpts){
1057
            int ret= av_read_frame_internal(s, pkt);
1058
            if(ret<0){
1059
                if(pktl && ret != AVERROR(EAGAIN)){
1060
                    eof=1;
1061
                    continue;
1062
                }else
1063
                    return ret;
1064
            }
1065

    
1066
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1067
                                           &s->packet_buffer_end)) < 0)
1068
                return AVERROR(ENOMEM);
1069
        }else{
1070
            assert(!s->packet_buffer);
1071
            return av_read_frame_internal(s, pkt);
1072
        }
1073
    }
1074
}
1075

    
1076
/* XXX: suppress the packet queue */
1077
static void flush_packet_queue(AVFormatContext *s)
1078
{
1079
    AVPacketList *pktl;
1080

    
1081
    for(;;) {
1082
        pktl = s->packet_buffer;
1083
        if (!pktl)
1084
            break;
1085
        s->packet_buffer = pktl->next;
1086
        av_free_packet(&pktl->pkt);
1087
        av_free(pktl);
1088
    }
1089
}
1090

    
1091
/*******************************************************/
1092
/* seek support */
1093

    
1094
int av_find_default_stream_index(AVFormatContext *s)
1095
{
1096
    int first_audio_index = -1;
1097
    int i;
1098
    AVStream *st;
1099

    
1100
    if (s->nb_streams <= 0)
1101
        return -1;
1102
    for(i = 0; i < s->nb_streams; i++) {
1103
        st = s->streams[i];
1104
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1105
            return i;
1106
        }
1107
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1108
            first_audio_index = i;
1109
    }
1110
    return first_audio_index >= 0 ? first_audio_index : 0;
1111
}
1112

    
1113
/**
1114
 * Flush the frame reader.
1115
 */
1116
static void av_read_frame_flush(AVFormatContext *s)
1117
{
1118
    AVStream *st;
1119
    int i;
1120

    
1121
    flush_packet_queue(s);
1122

    
1123
    /* free previous packet */
1124
    if (s->cur_st) {
1125
        if (s->cur_st->parser)
1126
            av_free_packet(&s->cur_pkt);
1127
        s->cur_st = NULL;
1128
    }
1129
    /* fail safe */
1130
    s->cur_ptr = NULL;
1131
    s->cur_len = 0;
1132

    
1133
    /* for each stream, reset read state */
1134
    for(i = 0; i < s->nb_streams; i++) {
1135
        st = s->streams[i];
1136

    
1137
        if (st->parser) {
1138
            av_parser_close(st->parser);
1139
            st->parser = NULL;
1140
        }
1141
        st->last_IP_pts = AV_NOPTS_VALUE;
1142
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1143
    }
1144
}
1145

    
1146
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1147
    int i;
1148

    
1149
    for(i = 0; i < s->nb_streams; i++) {
1150
        AVStream *st = s->streams[i];
1151

    
1152
        st->cur_dts = av_rescale(timestamp,
1153
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1154
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1155
    }
1156
}
1157

    
1158
void ff_reduce_index(AVFormatContext *s, int stream_index)
1159
{
1160
    AVStream *st= s->streams[stream_index];
1161
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1162

    
1163
    if((unsigned)st->nb_index_entries >= max_entries){
1164
        int i;
1165
        for(i=0; 2*i<st->nb_index_entries; i++)
1166
            st->index_entries[i]= st->index_entries[2*i];
1167
        st->nb_index_entries= i;
1168
    }
1169
}
1170

    
1171
int av_add_index_entry(AVStream *st,
1172
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1173
{
1174
    AVIndexEntry *entries, *ie;
1175
    int index;
1176

    
1177
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1178
        return -1;
1179

    
1180
    entries = av_fast_realloc(st->index_entries,
1181
                              &st->index_entries_allocated_size,
1182
                              (st->nb_index_entries + 1) *
1183
                              sizeof(AVIndexEntry));
1184
    if(!entries)
1185
        return -1;
1186

    
1187
    st->index_entries= entries;
1188

    
1189
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1190

    
1191
    if(index<0){
1192
        index= st->nb_index_entries++;
1193
        ie= &entries[index];
1194
        assert(index==0 || ie[-1].timestamp < timestamp);
1195
    }else{
1196
        ie= &entries[index];
1197
        if(ie->timestamp != timestamp){
1198
            if(ie->timestamp <= timestamp)
1199
                return -1;
1200
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1201
            st->nb_index_entries++;
1202
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1203
            distance= ie->min_distance;
1204
    }
1205

    
1206
    ie->pos = pos;
1207
    ie->timestamp = timestamp;
1208
    ie->min_distance= distance;
1209
    ie->size= size;
1210
    ie->flags = flags;
1211

    
1212
    return index;
1213
}
1214

    
1215
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1216
                              int flags)
1217
{
1218
    AVIndexEntry *entries= st->index_entries;
1219
    int nb_entries= st->nb_index_entries;
1220
    int a, b, m;
1221
    int64_t timestamp;
1222

    
1223
    a = - 1;
1224
    b = nb_entries;
1225

    
1226
    while (b - a > 1) {
1227
        m = (a + b) >> 1;
1228
        timestamp = entries[m].timestamp;
1229
        if(timestamp >= wanted_timestamp)
1230
            b = m;
1231
        if(timestamp <= wanted_timestamp)
1232
            a = m;
1233
    }
1234
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1235

    
1236
    if(!(flags & AVSEEK_FLAG_ANY)){
1237
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1238
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1239
        }
1240
    }
1241

    
1242
    if(m == nb_entries)
1243
        return -1;
1244
    return  m;
1245
}
1246

    
1247
#define DEBUG_SEEK
1248

    
1249
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1250
    AVInputFormat *avif= s->iformat;
1251
    int64_t pos_min, pos_max, pos, pos_limit;
1252
    int64_t ts_min, ts_max, ts;
1253
    int index;
1254
    AVStream *st;
1255

    
1256
    if (stream_index < 0)
1257
        return -1;
1258

    
1259
#ifdef DEBUG_SEEK
1260
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1261
#endif
1262

    
1263
    ts_max=
1264
    ts_min= AV_NOPTS_VALUE;
1265
    pos_limit= -1; //gcc falsely says it may be uninitialized
1266

    
1267
    st= s->streams[stream_index];
1268
    if(st->index_entries){
1269
        AVIndexEntry *e;
1270

    
1271
        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()
1272
        index= FFMAX(index, 0);
1273
        e= &st->index_entries[index];
1274

    
1275
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1276
            pos_min= e->pos;
1277
            ts_min= e->timestamp;
1278
#ifdef DEBUG_SEEK
1279
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1280
               pos_min,ts_min);
1281
#endif
1282
        }else{
1283
            assert(index==0);
1284
        }
1285

    
1286
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1287
        assert(index < st->nb_index_entries);
1288
        if(index >= 0){
1289
            e= &st->index_entries[index];
1290
            assert(e->timestamp >= target_ts);
1291
            pos_max= e->pos;
1292
            ts_max= e->timestamp;
1293
            pos_limit= pos_max - e->min_distance;
1294
#ifdef DEBUG_SEEK
1295
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1296
               pos_max,pos_limit, ts_max);
1297
#endif
1298
        }
1299
    }
1300

    
1301
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1302
    if(pos<0)
1303
        return -1;
1304

    
1305
    /* do the seek */
1306
    url_fseek(s->pb, pos, SEEK_SET);
1307

    
1308
    av_update_cur_dts(s, st, ts);
1309

    
1310
    return 0;
1311
}
1312

    
1313
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 )){
1314
    int64_t pos, ts;
1315
    int64_t start_pos, filesize;
1316
    int no_change;
1317

    
1318
#ifdef DEBUG_SEEK
1319
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1320
#endif
1321

    
1322
    if(ts_min == AV_NOPTS_VALUE){
1323
        pos_min = s->data_offset;
1324
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1325
        if (ts_min == AV_NOPTS_VALUE)
1326
            return -1;
1327
    }
1328

    
1329
    if(ts_max == AV_NOPTS_VALUE){
1330
        int step= 1024;
1331
        filesize = url_fsize(s->pb);
1332
        pos_max = filesize - 1;
1333
        do{
1334
            pos_max -= step;
1335
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1336
            step += step;
1337
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1338
        if (ts_max == AV_NOPTS_VALUE)
1339
            return -1;
1340

    
1341
        for(;;){
1342
            int64_t tmp_pos= pos_max + 1;
1343
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1344
            if(tmp_ts == AV_NOPTS_VALUE)
1345
                break;
1346
            ts_max= tmp_ts;
1347
            pos_max= tmp_pos;
1348
            if(tmp_pos >= filesize)
1349
                break;
1350
        }
1351
        pos_limit= pos_max;
1352
    }
1353

    
1354
    if(ts_min > ts_max){
1355
        return -1;
1356
    }else if(ts_min == ts_max){
1357
        pos_limit= pos_min;
1358
    }
1359

    
1360
    no_change=0;
1361
    while (pos_min < pos_limit) {
1362
#ifdef DEBUG_SEEK
1363
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1364
               pos_min, pos_max,
1365
               ts_min, ts_max);
1366
#endif
1367
        assert(pos_limit <= pos_max);
1368

    
1369
        if(no_change==0){
1370
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1371
            // interpolate position (better than dichotomy)
1372
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1373
                + pos_min - approximate_keyframe_distance;
1374
        }else if(no_change==1){
1375
            // bisection, if interpolation failed to change min or max pos last time
1376
            pos = (pos_min + pos_limit)>>1;
1377
        }else{
1378
            /* linear search if bisection failed, can only happen if there
1379
               are very few or no keyframes between min/max */
1380
            pos=pos_min;
1381
        }
1382
        if(pos <= pos_min)
1383
            pos= pos_min + 1;
1384
        else if(pos > pos_limit)
1385
            pos= pos_limit;
1386
        start_pos= pos;
1387

    
1388
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1389
        if(pos == pos_max)
1390
            no_change++;
1391
        else
1392
            no_change=0;
1393
#ifdef DEBUG_SEEK
1394
av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1395
#endif
1396
        if(ts == AV_NOPTS_VALUE){
1397
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1398
            return -1;
1399
        }
1400
        assert(ts != AV_NOPTS_VALUE);
1401
        if (target_ts <= ts) {
1402
            pos_limit = start_pos - 1;
1403
            pos_max = pos;
1404
            ts_max = ts;
1405
        }
1406
        if (target_ts >= ts) {
1407
            pos_min = pos;
1408
            ts_min = ts;
1409
        }
1410
    }
1411

    
1412
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1413
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1414
#ifdef DEBUG_SEEK
1415
    pos_min = pos;
1416
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1417
    pos_min++;
1418
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1419
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1420
           pos, ts_min, target_ts, ts_max);
1421
#endif
1422
    *ts_ret= ts;
1423
    return pos;
1424
}
1425

    
1426
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1427
    int64_t pos_min, pos_max;
1428
#if 0
1429
    AVStream *st;
1430

1431
    if (stream_index < 0)
1432
        return -1;
1433

1434
    st= s->streams[stream_index];
1435
#endif
1436

    
1437
    pos_min = s->data_offset;
1438
    pos_max = url_fsize(s->pb) - 1;
1439

    
1440
    if     (pos < pos_min) pos= pos_min;
1441
    else if(pos > pos_max) pos= pos_max;
1442

    
1443
    url_fseek(s->pb, pos, SEEK_SET);
1444

    
1445
#if 0
1446
    av_update_cur_dts(s, st, ts);
1447
#endif
1448
    return 0;
1449
}
1450

    
1451
static int av_seek_frame_generic(AVFormatContext *s,
1452
                                 int stream_index, int64_t timestamp, int flags)
1453
{
1454
    int index, ret;
1455
    AVStream *st;
1456
    AVIndexEntry *ie;
1457

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

    
1460
    index = av_index_search_timestamp(st, timestamp, flags);
1461

    
1462
    if(index < 0 || index==st->nb_index_entries-1){
1463
        int i;
1464
        AVPacket pkt;
1465

    
1466
        if(st->nb_index_entries){
1467
            assert(st->index_entries);
1468
            ie= &st->index_entries[st->nb_index_entries-1];
1469
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1470
                return ret;
1471
            av_update_cur_dts(s, st, ie->timestamp);
1472
        }else{
1473
            if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1474
                return ret;
1475
        }
1476
        for(i=0;; i++) {
1477
            int ret = av_read_frame(s, &pkt);
1478
            if(ret<0)
1479
                break;
1480
            av_free_packet(&pkt);
1481
            if(stream_index == pkt.stream_index){
1482
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1483
                    break;
1484
            }
1485
        }
1486
        index = av_index_search_timestamp(st, timestamp, flags);
1487
    }
1488
    if (index < 0)
1489
        return -1;
1490

    
1491
    av_read_frame_flush(s);
1492
    if (s->iformat->read_seek){
1493
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1494
            return 0;
1495
    }
1496
    ie = &st->index_entries[index];
1497
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1498
        return ret;
1499
    av_update_cur_dts(s, st, ie->timestamp);
1500

    
1501
    return 0;
1502
}
1503

    
1504
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1505
{
1506
    int ret;
1507
    AVStream *st;
1508

    
1509
    av_read_frame_flush(s);
1510

    
1511
    if(flags & AVSEEK_FLAG_BYTE)
1512
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1513

    
1514
    if(stream_index < 0){
1515
        stream_index= av_find_default_stream_index(s);
1516
        if(stream_index < 0)
1517
            return -1;
1518

    
1519
        st= s->streams[stream_index];
1520
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1521
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1522
    }
1523

    
1524
    /* first, we try the format specific seek */
1525
    if (s->iformat->read_seek)
1526
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1527
    else
1528
        ret = -1;
1529
    if (ret >= 0) {
1530
        return 0;
1531
    }
1532

    
1533
    if(s->iformat->read_timestamp)
1534
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1535
    else
1536
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1537
}
1538

    
1539
/*******************************************************/
1540

    
1541
/**
1542
 * Returns TRUE if the stream has accurate duration in any stream.
1543
 *
1544
 * @return TRUE if the stream has accurate duration for at least one component.
1545
 */
1546
static int av_has_duration(AVFormatContext *ic)
1547
{
1548
    int i;
1549
    AVStream *st;
1550

    
1551
    for(i = 0;i < ic->nb_streams; i++) {
1552
        st = ic->streams[i];
1553
        if (st->duration != AV_NOPTS_VALUE)
1554
            return 1;
1555
    }
1556
    return 0;
1557
}
1558

    
1559
/**
1560
 * Estimate the stream timings from the one of each components.
1561
 *
1562
 * Also computes the global bitrate if possible.
1563
 */
1564
static void av_update_stream_timings(AVFormatContext *ic)
1565
{
1566
    int64_t start_time, start_time1, end_time, end_time1;
1567
    int64_t duration, duration1;
1568
    int i;
1569
    AVStream *st;
1570

    
1571
    start_time = INT64_MAX;
1572
    end_time = INT64_MIN;
1573
    duration = INT64_MIN;
1574
    for(i = 0;i < ic->nb_streams; i++) {
1575
        st = ic->streams[i];
1576
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1577
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1578
            if (start_time1 < start_time)
1579
                start_time = start_time1;
1580
            if (st->duration != AV_NOPTS_VALUE) {
1581
                end_time1 = start_time1
1582
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1583
                if (end_time1 > end_time)
1584
                    end_time = end_time1;
1585
            }
1586
        }
1587
        if (st->duration != AV_NOPTS_VALUE) {
1588
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1589
            if (duration1 > duration)
1590
                duration = duration1;
1591
        }
1592
    }
1593
    if (start_time != INT64_MAX) {
1594
        ic->start_time = start_time;
1595
        if (end_time != INT64_MIN) {
1596
            if (end_time - start_time > duration)
1597
                duration = end_time - start_time;
1598
        }
1599
    }
1600
    if (duration != INT64_MIN) {
1601
        ic->duration = duration;
1602
        if (ic->file_size > 0) {
1603
            /* compute the bitrate */
1604
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1605
                (double)ic->duration;
1606
        }
1607
    }
1608
}
1609

    
1610
static void fill_all_stream_timings(AVFormatContext *ic)
1611
{
1612
    int i;
1613
    AVStream *st;
1614

    
1615
    av_update_stream_timings(ic);
1616
    for(i = 0;i < ic->nb_streams; i++) {
1617
        st = ic->streams[i];
1618
        if (st->start_time == AV_NOPTS_VALUE) {
1619
            if(ic->start_time != AV_NOPTS_VALUE)
1620
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1621
            if(ic->duration != AV_NOPTS_VALUE)
1622
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1623
        }
1624
    }
1625
}
1626

    
1627
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1628
{
1629
    int64_t filesize, duration;
1630
    int bit_rate, i;
1631
    AVStream *st;
1632

    
1633
    /* if bit_rate is already set, we believe it */
1634
    if (ic->bit_rate == 0) {
1635
        bit_rate = 0;
1636
        for(i=0;i<ic->nb_streams;i++) {
1637
            st = ic->streams[i];
1638
            bit_rate += st->codec->bit_rate;
1639
        }
1640
        ic->bit_rate = bit_rate;
1641
    }
1642

    
1643
    /* if duration is already set, we believe it */
1644
    if (ic->duration == AV_NOPTS_VALUE &&
1645
        ic->bit_rate != 0 &&
1646
        ic->file_size != 0)  {
1647
        filesize = ic->file_size;
1648
        if (filesize > 0) {
1649
            for(i = 0; i < ic->nb_streams; i++) {
1650
                st = ic->streams[i];
1651
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1652
                if (st->duration == AV_NOPTS_VALUE)
1653
                    st->duration = duration;
1654
            }
1655
        }
1656
    }
1657
}
1658

    
1659
#define DURATION_MAX_READ_SIZE 250000
1660

    
1661
/* only usable for MPEG-PS streams */
1662
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1663
{
1664
    AVPacket pkt1, *pkt = &pkt1;
1665
    AVStream *st;
1666
    int read_size, i, ret;
1667
    int64_t end_time;
1668
    int64_t filesize, offset, duration;
1669

    
1670
    /* free previous packet */
1671
    if (ic->cur_st && ic->cur_st->parser)
1672
        av_free_packet(&ic->cur_pkt);
1673
    ic->cur_st = NULL;
1674

    
1675
    /* flush packet queue */
1676
    flush_packet_queue(ic);
1677

    
1678
    for(i=0;i<ic->nb_streams;i++) {
1679
        st = ic->streams[i];
1680
        if (st->parser) {
1681
            av_parser_close(st->parser);
1682
            st->parser= NULL;
1683
        }
1684
    }
1685

    
1686
    /* we read the first packets to get the first PTS (not fully
1687
       accurate, but it is enough now) */
1688
    url_fseek(ic->pb, 0, SEEK_SET);
1689
    read_size = 0;
1690
    for(;;) {
1691
        if (read_size >= DURATION_MAX_READ_SIZE)
1692
            break;
1693
        /* if all info is available, we can stop */
1694
        for(i = 0;i < ic->nb_streams; i++) {
1695
            st = ic->streams[i];
1696
            if (st->start_time == AV_NOPTS_VALUE)
1697
                break;
1698
        }
1699
        if (i == ic->nb_streams)
1700
            break;
1701

    
1702
        ret = av_read_packet(ic, pkt);
1703
        if (ret != 0)
1704
            break;
1705
        read_size += pkt->size;
1706
        st = ic->streams[pkt->stream_index];
1707
        if (pkt->pts != AV_NOPTS_VALUE) {
1708
            if (st->start_time == AV_NOPTS_VALUE)
1709
                st->start_time = pkt->pts;
1710
        }
1711
        av_free_packet(pkt);
1712
    }
1713

    
1714
    /* estimate the end time (duration) */
1715
    /* XXX: may need to support wrapping */
1716
    filesize = ic->file_size;
1717
    offset = filesize - DURATION_MAX_READ_SIZE;
1718
    if (offset < 0)
1719
        offset = 0;
1720

    
1721
    url_fseek(ic->pb, offset, SEEK_SET);
1722
    read_size = 0;
1723
    for(;;) {
1724
        if (read_size >= DURATION_MAX_READ_SIZE)
1725
            break;
1726

    
1727
        ret = av_read_packet(ic, pkt);
1728
        if (ret != 0)
1729
            break;
1730
        read_size += pkt->size;
1731
        st = ic->streams[pkt->stream_index];
1732
        if (pkt->pts != AV_NOPTS_VALUE &&
1733
            st->start_time != AV_NOPTS_VALUE) {
1734
            end_time = pkt->pts;
1735
            duration = end_time - st->start_time;
1736
            if (duration > 0) {
1737
                if (st->duration == AV_NOPTS_VALUE ||
1738
                    st->duration < duration)
1739
                    st->duration = duration;
1740
            }
1741
        }
1742
        av_free_packet(pkt);
1743
    }
1744

    
1745
    fill_all_stream_timings(ic);
1746

    
1747
    url_fseek(ic->pb, old_offset, SEEK_SET);
1748
    for(i=0; i<ic->nb_streams; i++){
1749
        st= ic->streams[i];
1750
        st->cur_dts= st->first_dts;
1751
        st->last_IP_pts = AV_NOPTS_VALUE;
1752
    }
1753
}
1754

    
1755
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1756
{
1757
    int64_t file_size;
1758

    
1759
    /* get the file size, if possible */
1760
    if (ic->iformat->flags & AVFMT_NOFILE) {
1761
        file_size = 0;
1762
    } else {
1763
        file_size = url_fsize(ic->pb);
1764
        if (file_size < 0)
1765
            file_size = 0;
1766
    }
1767
    ic->file_size = file_size;
1768

    
1769
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1770
         !strcmp(ic->iformat->name, "mpegts")) &&
1771
        file_size && !url_is_streamed(ic->pb)) {
1772
        /* get accurate estimate from the PTSes */
1773
        av_estimate_timings_from_pts(ic, old_offset);
1774
    } else if (av_has_duration(ic)) {
1775
        /* at least one component has timings - we use them for all
1776
           the components */
1777
        fill_all_stream_timings(ic);
1778
    } else {
1779
        /* less precise: use bitrate info */
1780
        av_estimate_timings_from_bit_rate(ic);
1781
    }
1782
    av_update_stream_timings(ic);
1783

    
1784
#if 0
1785
    {
1786
        int i;
1787
        AVStream *st;
1788
        for(i = 0;i < ic->nb_streams; i++) {
1789
            st = ic->streams[i];
1790
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1791
               i, (double)st->start_time / AV_TIME_BASE,
1792
               (double)st->duration / AV_TIME_BASE);
1793
        }
1794
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1795
               (double)ic->start_time / AV_TIME_BASE,
1796
               (double)ic->duration / AV_TIME_BASE,
1797
               ic->bit_rate / 1000);
1798
    }
1799
#endif
1800
}
1801

    
1802
static int has_codec_parameters(AVCodecContext *enc)
1803
{
1804
    int val;
1805
    switch(enc->codec_type) {
1806
    case CODEC_TYPE_AUDIO:
1807
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1808
        if(!enc->frame_size &&
1809
           (enc->codec_id == CODEC_ID_VORBIS ||
1810
            enc->codec_id == CODEC_ID_AAC))
1811
            return 0;
1812
        break;
1813
    case CODEC_TYPE_VIDEO:
1814
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1815
        break;
1816
    default:
1817
        val = 1;
1818
        break;
1819
    }
1820
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1821
}
1822

    
1823
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1824
{
1825
    int16_t *samples;
1826
    AVCodec *codec;
1827
    int got_picture, data_size, ret=0;
1828
    AVFrame picture;
1829

    
1830
  if(!st->codec->codec){
1831
    codec = avcodec_find_decoder(st->codec->codec_id);
1832
    if (!codec)
1833
        return -1;
1834
    ret = avcodec_open(st->codec, codec);
1835
    if (ret < 0)
1836
        return ret;
1837
  }
1838

    
1839
  if(!has_codec_parameters(st->codec)){
1840
    switch(st->codec->codec_type) {
1841
    case CODEC_TYPE_VIDEO:
1842
        ret = avcodec_decode_video(st->codec, &picture,
1843
                                   &got_picture, data, size);
1844
        break;
1845
    case CODEC_TYPE_AUDIO:
1846
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1847
        samples = av_malloc(data_size);
1848
        if (!samples)
1849
            goto fail;
1850
        ret = avcodec_decode_audio2(st->codec, samples,
1851
                                    &data_size, data, size);
1852
        av_free(samples);
1853
        break;
1854
    default:
1855
        break;
1856
    }
1857
  }
1858
 fail:
1859
    return ret;
1860
}
1861

    
1862
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1863
{
1864
    while (tags->id != CODEC_ID_NONE) {
1865
        if (tags->id == id)
1866
            return tags->tag;
1867
        tags++;
1868
    }
1869
    return 0;
1870
}
1871

    
1872
enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1873
{
1874
    int i;
1875
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1876
        if(tag == tags[i].tag)
1877
            return tags[i].id;
1878
    }
1879
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1880
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1881
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1882
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1883
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1884
            return tags[i].id;
1885
    }
1886
    return CODEC_ID_NONE;
1887
}
1888

    
1889
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1890
{
1891
    int i;
1892
    for(i=0; tags && tags[i]; i++){
1893
        int tag= codec_get_tag(tags[i], id);
1894
        if(tag) return tag;
1895
    }
1896
    return 0;
1897
}
1898

    
1899
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1900
{
1901
    int i;
1902
    for(i=0; tags && tags[i]; i++){
1903
        enum CodecID id= codec_get_id(tags[i], tag);
1904
        if(id!=CODEC_ID_NONE) return id;
1905
    }
1906
    return CODEC_ID_NONE;
1907
}
1908

    
1909
static void compute_chapters_end(AVFormatContext *s)
1910
{
1911
    unsigned int i;
1912

    
1913
    for (i=0; i+1<s->nb_chapters; i++)
1914
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1915
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1916
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1917
            s->chapters[i]->end = s->chapters[i+1]->start;
1918
        }
1919

    
1920
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1921
        assert(s->start_time != AV_NOPTS_VALUE);
1922
        assert(s->duration > 0);
1923
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1924
                                           AV_TIME_BASE_Q,
1925
                                           s->chapters[i]->time_base);
1926
    }
1927
}
1928

    
1929
/* absolute maximum size we read until we abort */
1930
#define MAX_READ_SIZE        5000000
1931

    
1932
#define MAX_STD_TIMEBASES (60*12+5)
1933
static int get_std_framerate(int i){
1934
    if(i<60*12) return i*1001;
1935
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1936
}
1937

    
1938
/*
1939
 * Is the time base unreliable.
1940
 * This is a heuristic to balance between quick acceptance of the values in
1941
 * the headers vs. some extra checks.
1942
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1943
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1944
 * And there are "variable" fps files this needs to detect as well.
1945
 */
1946
static int tb_unreliable(AVCodecContext *c){
1947
    if(   c->time_base.den >= 101L*c->time_base.num
1948
       || c->time_base.den <    5L*c->time_base.num
1949
/*       || c->codec_tag == ff_get_fourcc("DIVX")
1950
       || c->codec_tag == ff_get_fourcc("XVID")*/
1951
       || c->codec_id == CODEC_ID_MPEG2VIDEO)
1952
        return 1;
1953
    return 0;
1954
}
1955

    
1956
int av_find_stream_info(AVFormatContext *ic)
1957
{
1958
    int i, count, ret, read_size, j;
1959
    AVStream *st;
1960
    AVPacket pkt1, *pkt;
1961
    int64_t last_dts[MAX_STREAMS];
1962
    int duration_count[MAX_STREAMS]={0};
1963
    double (*duration_error)[MAX_STD_TIMEBASES];
1964
    int64_t old_offset = url_ftell(ic->pb);
1965
    int64_t codec_info_duration[MAX_STREAMS]={0};
1966
    int codec_info_nb_frames[MAX_STREAMS]={0};
1967

    
1968
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1969
    if (!duration_error) return AVERROR(ENOMEM);
1970

    
1971
    for(i=0;i<ic->nb_streams;i++) {
1972
        st = ic->streams[i];
1973
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1974
/*            if(!st->time_base.num)
1975
                st->time_base= */
1976
            if(!st->codec->time_base.num)
1977
                st->codec->time_base= st->time_base;
1978
        }
1979
        //only for the split stuff
1980
        if (!st->parser) {
1981
            st->parser = av_parser_init(st->codec->codec_id);
1982
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1983
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1984
            }
1985
        }
1986
    }
1987

    
1988
    for(i=0;i<MAX_STREAMS;i++){
1989
        last_dts[i]= AV_NOPTS_VALUE;
1990
    }
1991

    
1992
    count = 0;
1993
    read_size = 0;
1994
    for(;;) {
1995
        /* check if one codec still needs to be handled */
1996
        for(i=0;i<ic->nb_streams;i++) {
1997
            st = ic->streams[i];
1998
            if (!has_codec_parameters(st->codec))
1999
                break;
2000
            /* variable fps and no guess at the real fps */
2001
            if(   tb_unreliable(st->codec)
2002
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2003
                break;
2004
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2005
                break;
2006
            if(st->first_dts == AV_NOPTS_VALUE)
2007
                break;
2008
        }
2009
        if (i == ic->nb_streams) {
2010
            /* NOTE: if the format has no header, then we need to read
2011
               some packets to get most of the streams, so we cannot
2012
               stop here */
2013
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2014
                /* if we found the info for all the codecs, we can stop */
2015
                ret = count;
2016
                break;
2017
            }
2018
        }
2019
        /* we did not get all the codec info, but we read too much data */
2020
        if (read_size >= MAX_READ_SIZE) {
2021
            ret = count;
2022
            break;
2023
        }
2024

    
2025
        /* NOTE: a new stream can be added there if no header in file
2026
           (AVFMTCTX_NOHEADER) */
2027
        ret = av_read_frame_internal(ic, &pkt1);
2028
        if (ret < 0) {
2029
            /* EOF or error */
2030
            ret = -1; /* we could not have all the codec parameters before EOF */
2031
            for(i=0;i<ic->nb_streams;i++) {
2032
                st = ic->streams[i];
2033
                if (!has_codec_parameters(st->codec)){
2034
                    char buf[256];
2035
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2036
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2037
                } else {
2038
                    ret = 0;
2039
                }
2040
            }
2041
            break;
2042
        }
2043

    
2044
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2045
        if(av_dup_packet(pkt) < 0) {
2046
            av_free(duration_error);
2047
            return AVERROR(ENOMEM);
2048
        }
2049

    
2050
        read_size += pkt->size;
2051

    
2052
        st = ic->streams[pkt->stream_index];
2053
        if(codec_info_nb_frames[st->index]>1)
2054
            codec_info_duration[st->index] += pkt->duration;
2055
        if (pkt->duration != 0)
2056
            codec_info_nb_frames[st->index]++;
2057

    
2058
        {
2059
            int index= pkt->stream_index;
2060
            int64_t last= last_dts[index];
2061
            int64_t duration= pkt->dts - last;
2062

    
2063
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2064
                double dur= duration * av_q2d(st->time_base);
2065

    
2066
//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2067
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2068
                if(duration_count[index] < 2)
2069
                    memset(duration_error[index], 0, sizeof(*duration_error));
2070
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2071
                    int framerate= get_std_framerate(i);
2072
                    int ticks= lrintf(dur*framerate/(1001*12));
2073
                    double error= dur - ticks*1001*12/(double)framerate;
2074
                    duration_error[index][i] += error*error;
2075
                }
2076
                duration_count[index]++;
2077
            }
2078
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2079
                last_dts[pkt->stream_index]= pkt->dts;
2080
        }
2081
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2082
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2083
            if(i){
2084
                st->codec->extradata_size= i;
2085
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2086
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2087
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2088
            }
2089
        }
2090

    
2091
        /* if still no information, we try to open the codec and to
2092
           decompress the frame. We try to avoid that in most cases as
2093
           it takes longer and uses more memory. For MPEG-4, we need to
2094
           decompress for QuickTime. */
2095
        if (!has_codec_parameters(st->codec) /*&&
2096
            (st->codec->codec_id == CODEC_ID_FLV1 ||
2097
             st->codec->codec_id == CODEC_ID_H264 ||
2098
             st->codec->codec_id == CODEC_ID_H263 ||
2099
             st->codec->codec_id == CODEC_ID_H261 ||
2100
             st->codec->codec_id == CODEC_ID_VORBIS ||
2101
             st->codec->codec_id == CODEC_ID_MJPEG ||
2102
             st->codec->codec_id == CODEC_ID_PNG ||
2103
             st->codec->codec_id == CODEC_ID_PAM ||
2104
             st->codec->codec_id == CODEC_ID_PGM ||
2105
             st->codec->codec_id == CODEC_ID_PGMYUV ||
2106
             st->codec->codec_id == CODEC_ID_PBM ||
2107
             st->codec->codec_id == CODEC_ID_PPM ||
2108
             st->codec->codec_id == CODEC_ID_SHORTEN ||
2109
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2110
            try_decode_frame(st, pkt->data, pkt->size);
2111

    
2112
        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) {
2113
            break;
2114
        }
2115
        count++;
2116
    }
2117

    
2118
    // close codecs which were opened in try_decode_frame()
2119
    for(i=0;i<ic->nb_streams;i++) {
2120
        st = ic->streams[i];
2121
        if(st->codec->codec)
2122
            avcodec_close(st->codec);
2123
    }
2124
    for(i=0;i<ic->nb_streams;i++) {
2125
        st = ic->streams[i];
2126
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2127
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2128
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2129

    
2130
            if(duration_count[i]
2131
               && tb_unreliable(st->codec) /*&&
2132
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2133
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2134
                double best_error= 2*av_q2d(st->time_base);
2135
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
2136

    
2137
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2138
                    double error= duration_error[i][j] * get_std_framerate(j);
2139
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2140
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2141
                    if(error < best_error){
2142
                        best_error= error;
2143
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2144
                    }
2145
                }
2146
            }
2147

    
2148
            if (!st->r_frame_rate.num){
2149
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2150
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
2151
                    st->r_frame_rate.num = st->codec->time_base.den;
2152
                    st->r_frame_rate.den = st->codec->time_base.num;
2153
                }else{
2154
                    st->r_frame_rate.num = st->time_base.den;
2155
                    st->r_frame_rate.den = st->time_base.num;
2156
                }
2157
            }
2158
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2159
            if(!st->codec->bits_per_coded_sample)
2160
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2161
        }
2162
    }
2163

    
2164
    av_estimate_timings(ic, old_offset);
2165

    
2166
    compute_chapters_end(ic);
2167

    
2168
#if 0
2169
    /* correct DTS for B-frame streams with no timestamps */
2170
    for(i=0;i<ic->nb_streams;i++) {
2171
        st = ic->streams[i];
2172
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2173
            if(b-frames){
2174
                ppktl = &ic->packet_buffer;
2175
                while(ppkt1){
2176
                    if(ppkt1->stream_index != i)
2177
                        continue;
2178
                    if(ppkt1->pkt->dts < 0)
2179
                        break;
2180
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2181
                        break;
2182
                    ppkt1->pkt->dts -= delta;
2183
                    ppkt1= ppkt1->next;
2184
                }
2185
                if(ppkt1)
2186
                    continue;
2187
                st->cur_dts -= delta;
2188
            }
2189
        }
2190
    }
2191
#endif
2192

    
2193
    av_free(duration_error);
2194

    
2195
    return ret;
2196
}
2197

    
2198
/*******************************************************/
2199

    
2200
int av_read_play(AVFormatContext *s)
2201
{
2202
    if (s->iformat->read_play)
2203
        return s->iformat->read_play(s);
2204
    if (s->pb)
2205
        return av_url_read_fpause(s->pb, 0);
2206
    return AVERROR(ENOSYS);
2207
}
2208

    
2209
int av_read_pause(AVFormatContext *s)
2210
{
2211
    if (s->iformat->read_pause)
2212
        return s->iformat->read_pause(s);
2213
    if (s->pb)
2214
        return av_url_read_fpause(s->pb, 1);
2215
    return AVERROR(ENOSYS);
2216
}
2217

    
2218
void av_close_input_stream(AVFormatContext *s)
2219
{
2220
    int i;
2221
    AVStream *st;
2222

    
2223
    /* free previous packet */
2224
    if (s->cur_st && s->cur_st->parser)
2225
        av_free_packet(&s->cur_pkt);
2226

    
2227
    if (s->iformat->read_close)
2228
        s->iformat->read_close(s);
2229
    for(i=0;i<s->nb_streams;i++) {
2230
        /* free all data in a stream component */
2231
        st = s->streams[i];
2232
        if (st->parser) {
2233
            av_parser_close(st->parser);
2234
        }
2235
        av_metadata_free(&st->metadata);
2236
        av_free(st->index_entries);
2237
        av_free(st->codec->extradata);
2238
        av_free(st->codec);
2239
        av_free(st->filename);
2240
        av_free(st->priv_data);
2241
        av_free(st);
2242
    }
2243
    for(i=s->nb_programs-1; i>=0; i--) {
2244
        av_freep(&s->programs[i]->provider_name);
2245
        av_freep(&s->programs[i]->name);
2246
        av_metadata_free(&s->programs[i]->metadata);
2247
        av_freep(&s->programs[i]->stream_index);
2248
        av_freep(&s->programs[i]);
2249
    }
2250
    av_freep(&s->programs);
2251
    flush_packet_queue(s);
2252
    av_freep(&s->priv_data);
2253
    while(s->nb_chapters--) {
2254
        av_free(s->chapters[s->nb_chapters]->title);
2255
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2256
        av_free(s->chapters[s->nb_chapters]);
2257
    }
2258
    av_freep(&s->chapters);
2259
    av_metadata_free(&s->metadata);
2260
    av_free(s);
2261
}
2262

    
2263
void av_close_input_file(AVFormatContext *s)
2264
{
2265
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2266
    av_close_input_stream(s);
2267
    if (pb)
2268
        url_fclose(pb);
2269
}
2270

    
2271
AVStream *av_new_stream(AVFormatContext *s, int id)
2272
{
2273
    AVStream *st;
2274
    int i;
2275

    
2276
    if (s->nb_streams >= MAX_STREAMS)
2277
        return NULL;
2278

    
2279
    st = av_mallocz(sizeof(AVStream));
2280
    if (!st)
2281
        return NULL;
2282

    
2283
    st->codec= avcodec_alloc_context();
2284
    if (s->iformat) {
2285
        /* no default bitrate if decoding */
2286
        st->codec->bit_rate = 0;
2287
    }
2288
    st->index = s->nb_streams;
2289
    st->id = id;
2290
    st->start_time = AV_NOPTS_VALUE;
2291
    st->duration = AV_NOPTS_VALUE;
2292
        /* we set the current DTS to 0 so that formats without any timestamps
2293
           but durations get some timestamps, formats with some unknown
2294
           timestamps have their first few packets buffered and the
2295
           timestamps corrected before they are returned to the user */
2296
    st->cur_dts = 0;
2297
    st->first_dts = AV_NOPTS_VALUE;
2298

    
2299
    /* default pts setting is MPEG-like */
2300
    av_set_pts_info(st, 33, 1, 90000);
2301
    st->last_IP_pts = AV_NOPTS_VALUE;
2302
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2303
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2304

    
2305
    st->sample_aspect_ratio = (AVRational){0,1};
2306

    
2307
    s->streams[s->nb_streams++] = st;
2308
    return st;
2309
}
2310

    
2311
AVProgram *av_new_program(AVFormatContext *ac, int id)
2312
{
2313
    AVProgram *program=NULL;
2314
    int i;
2315

    
2316
#ifdef DEBUG_SI
2317
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2318
#endif
2319

    
2320
    for(i=0; i<ac->nb_programs; i++)
2321
        if(ac->programs[i]->id == id)
2322
            program = ac->programs[i];
2323

    
2324
    if(!program){
2325
        program = av_mallocz(sizeof(AVProgram));
2326
        if (!program)
2327
            return NULL;
2328
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2329
        program->discard = AVDISCARD_NONE;
2330
    }
2331
    program->id = id;
2332

    
2333
    return program;
2334
}
2335

    
2336
void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2337
{
2338
    assert(!provider_name == !name);
2339
    if(name){
2340
        av_free(program->provider_name);
2341
        av_free(program->         name);
2342
        program->provider_name = av_strdup(provider_name);
2343
        program->         name = av_strdup(         name);
2344
    }
2345
}
2346

    
2347
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2348
{
2349
    AVChapter *chapter = NULL;
2350
    int i;
2351

    
2352
    for(i=0; i<s->nb_chapters; i++)
2353
        if(s->chapters[i]->id == id)
2354
            chapter = s->chapters[i];
2355

    
2356
    if(!chapter){
2357
        chapter= av_mallocz(sizeof(AVChapter));
2358
        if(!chapter)
2359
            return NULL;
2360
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2361
    }
2362
    av_free(chapter->title);
2363
    chapter->title = av_strdup(title);
2364
    chapter->id    = id;
2365
    chapter->time_base= time_base;
2366
    chapter->start = start;
2367
    chapter->end   = end;
2368

    
2369
    return chapter;
2370
}
2371

    
2372
/************************************************************/
2373
/* output media file */
2374

    
2375
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2376
{
2377
    int ret;
2378

    
2379
    if (s->oformat->priv_data_size > 0) {
2380
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2381
        if (!s->priv_data)
2382
            return AVERROR(ENOMEM);
2383
    } else
2384
        s->priv_data = NULL;
2385

    
2386
    if (s->oformat->set_parameters) {
2387
        ret = s->oformat->set_parameters(s, ap);
2388
        if (ret < 0)
2389
            return ret;
2390
    }
2391
    return 0;
2392
}
2393

    
2394
int av_write_header(AVFormatContext *s)
2395
{
2396
    int ret, i;
2397
    AVStream *st;
2398

    
2399
    // some sanity checks
2400
    for(i=0;i<s->nb_streams;i++) {
2401
        st = s->streams[i];
2402

    
2403
        switch (st->codec->codec_type) {
2404
        case CODEC_TYPE_AUDIO:
2405
            if(st->codec->sample_rate<=0){
2406
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2407
                return -1;
2408
            }
2409
            if(!st->codec->block_align)
2410
                st->codec->block_align = st->codec->channels *
2411
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2412
            break;
2413
        case CODEC_TYPE_VIDEO:
2414
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2415
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2416
                return -1;
2417
            }
2418
            if(st->codec->width<=0 || st->codec->height<=0){
2419
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2420
                return -1;
2421
            }
2422
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2423
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2424
                return -1;
2425
            }
2426
            break;
2427
        }
2428

    
2429
        if(s->oformat->codec_tag){
2430
            if(st->codec->codec_tag){
2431
                //FIXME
2432
                //check that tag + id is in the table
2433
                //if neither is in the table -> OK
2434
                //if tag is in the table with another id -> FAIL
2435
                //if id is in the table with another tag -> FAIL unless strict < ?
2436
            }else
2437
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2438
        }
2439
    }
2440

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

    
2447
#if LIBAVFORMAT_VERSION_MAJOR < 53
2448
    ff_metadata_mux_compat(s);
2449
#endif
2450

    
2451
    if(s->oformat->write_header){
2452
        ret = s->oformat->write_header(s);
2453
        if (ret < 0)
2454
            return ret;
2455
    }
2456

    
2457
    /* init PTS generation */
2458
    for(i=0;i<s->nb_streams;i++) {
2459
        int64_t den = AV_NOPTS_VALUE;
2460
        st = s->streams[i];
2461

    
2462
        switch (st->codec->codec_type) {
2463
        case CODEC_TYPE_AUDIO:
2464
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2465
            break;
2466
        case CODEC_TYPE_VIDEO:
2467
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2468
            break;
2469
        default:
2470
            break;
2471
        }
2472
        if (den != AV_NOPTS_VALUE) {
2473
            if (den <= 0)
2474
                return AVERROR_INVALIDDATA;
2475
            av_frac_init(&st->pts, 0, 0, den);
2476
        }
2477
    }
2478
    return 0;
2479
}
2480

    
2481
//FIXME merge with compute_pkt_fields
2482
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2483
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2484
    int num, den, frame_size, i;
2485

    
2486
//    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);
2487

    
2488
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2489
        return -1;*/
2490

    
2491
    /* duration field */
2492
    if (pkt->duration == 0) {
2493
        compute_frame_duration(&num, &den, st, NULL, pkt);
2494
        if (den && num) {
2495
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2496
        }
2497
    }
2498

    
2499
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2500
        pkt->pts= pkt->dts;
2501

    
2502
    //XXX/FIXME this is a temporary hack until all encoders output pts
2503
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2504
        pkt->dts=
2505
//        pkt->pts= st->cur_dts;
2506
        pkt->pts= st->pts.val;
2507
    }
2508

    
2509
    //calculate dts from pts
2510
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2511
        st->pts_buffer[0]= pkt->pts;
2512
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2513
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2514
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2515
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2516

    
2517
        pkt->dts= st->pts_buffer[0];
2518
    }
2519

    
2520
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2521
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2522
        return -1;
2523
    }
2524
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2525
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2526
        return -1;
2527
    }
2528

    
2529
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2530
    st->cur_dts= pkt->dts;
2531
    st->pts.val= pkt->dts;
2532

    
2533
    /* update pts */
2534
    switch (st->codec->codec_type) {
2535
    case CODEC_TYPE_AUDIO:
2536
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2537

    
2538
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2539
           likely equal to the encoder delay, but it would be better if we
2540
           had the real timestamps from the encoder */
2541
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2542
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2543
        }
2544
        break;
2545
    case CODEC_TYPE_VIDEO:
2546
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2547
        break;
2548
    default:
2549
        break;
2550
    }
2551
    return 0;
2552
}
2553

    
2554
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2555
{
2556
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2557

    
2558
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2559
        return ret;
2560

    
2561
    ret= s->oformat->write_packet(s, pkt);
2562
    if(!ret)
2563
        ret= url_ferror(s->pb);
2564
    return ret;
2565
}
2566

    
2567
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2568
    AVPacketList *pktl, **next_point, *this_pktl;
2569
    int stream_count=0;
2570
    int streams[MAX_STREAMS];
2571

    
2572
    if(pkt){
2573
        AVStream *st= s->streams[ pkt->stream_index];
2574

    
2575
//        assert(pkt->destruct != av_destruct_packet); //FIXME
2576

    
2577
        this_pktl = av_mallocz(sizeof(AVPacketList));
2578
        this_pktl->pkt= *pkt;
2579
        if(pkt->destruct == av_destruct_packet)
2580
            pkt->destruct= NULL; // not shared -> must keep original from being freed
2581
        else
2582
            av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2583

    
2584
        next_point = &s->packet_buffer;
2585
        while(*next_point){
2586
            AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2587
            int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2588
            int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2589
            if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2590
                break;
2591
            next_point= &(*next_point)->next;
2592
        }
2593
        this_pktl->next= *next_point;
2594
        *next_point= this_pktl;
2595
    }
2596

    
2597
    memset(streams, 0, sizeof(streams));
2598
    pktl= s->packet_buffer;
2599
    while(pktl){
2600
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2601
        if(streams[ pktl->pkt.stream_index ] == 0)
2602
            stream_count++;
2603
        streams[ pktl->pkt.stream_index ]++;
2604
        pktl= pktl->next;
2605
    }
2606

    
2607
    if(stream_count && (s->nb_streams == stream_count || flush)){
2608
        pktl= s->packet_buffer;
2609
        *out= pktl->pkt;
2610

    
2611
        s->packet_buffer= pktl->next;
2612
        av_freep(&pktl);
2613
        return 1;
2614
    }else{
2615
        av_init_packet(out);
2616
        return 0;
2617
    }
2618
}
2619

    
2620
/**
2621
 * Interleaves an AVPacket correctly so it can be muxed.
2622
 * @param out the interleaved packet will be output here
2623
 * @param in the input packet
2624
 * @param flush 1 if no further packets are available as input and all
2625
 *              remaining packets should be output
2626
 * @return 1 if a packet was output, 0 if no packet could be output,
2627
 *         < 0 if an error occurred
2628
 */
2629
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2630
    if(s->oformat->interleave_packet)
2631
        return s->oformat->interleave_packet(s, out, in, flush);
2632
    else
2633
        return av_interleave_packet_per_dts(s, out, in, flush);
2634
}
2635

    
2636
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2637
    AVStream *st= s->streams[ pkt->stream_index];
2638

    
2639
    //FIXME/XXX/HACK drop zero sized packets
2640
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2641
        return 0;
2642

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

    
2647
    if(pkt->dts == AV_NOPTS_VALUE)
2648
        return -1;
2649

    
2650
    for(;;){
2651
        AVPacket opkt;
2652
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2653
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2654
            return ret;
2655

    
2656
        ret= s->oformat->write_packet(s, &opkt);
2657

    
2658
        av_free_packet(&opkt);
2659
        pkt= NULL;
2660

    
2661
        if(ret<0)
2662
            return ret;
2663
        if(url_ferror(s->pb))
2664
            return url_ferror(s->pb);
2665
    }
2666
}
2667

    
2668
int av_write_trailer(AVFormatContext *s)
2669
{
2670
    int ret, i;
2671

    
2672
    for(;;){
2673
        AVPacket pkt;
2674
        ret= av_interleave_packet(s, &pkt, NULL, 1);
2675
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2676
            goto fail;
2677
        if(!ret)
2678
            break;
2679

    
2680
        ret= s->oformat->write_packet(s, &pkt);
2681

    
2682
        av_free_packet(&pkt);
2683

    
2684
        if(ret<0)
2685
            goto fail;
2686
        if(url_ferror(s->pb))
2687
            goto fail;
2688
    }
2689

    
2690
    if(s->oformat->write_trailer)
2691
        ret = s->oformat->write_trailer(s);
2692
fail:
2693
    if(ret == 0)
2694
       ret=url_ferror(s->pb);
2695
    for(i=0;i<s->nb_streams;i++)
2696
        av_freep(&s->streams[i]->priv_data);
2697
    av_freep(&s->priv_data);
2698
    return ret;
2699
}
2700

    
2701
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2702
{
2703
    int i, j;
2704
    AVProgram *program=NULL;
2705
    void *tmp;
2706

    
2707
    for(i=0; i<ac->nb_programs; i++){
2708
        if(ac->programs[i]->id != progid)
2709
            continue;
2710
        program = ac->programs[i];
2711
        for(j=0; j<program->nb_stream_indexes; j++)
2712
            if(program->stream_index[j] == idx)
2713
                return;
2714

    
2715
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2716
        if(!tmp)
2717
            return;
2718
        program->stream_index = tmp;
2719
        program->stream_index[program->nb_stream_indexes++] = idx;
2720
        return;
2721
    }
2722
}
2723

    
2724
/* "user interface" functions */
2725
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2726
{
2727
    char buf[256];
2728
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2729
    AVStream *st = ic->streams[i];
2730
    int g = ff_gcd(st->time_base.num, st->time_base.den);
2731
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
2732
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2733
    /* the pid is an important information, so we display it */
2734
    /* XXX: add a generic system */
2735
    if (flags & AVFMT_SHOW_IDS)
2736
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2737
    if (strlen(st->language) > 0)
2738
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2739
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2740
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2741
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2742
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2743
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2744
/*      else if(st->time_base.den && st->time_base.num)
2745
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2746
        else
2747
            av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2748
    }
2749
    av_log(NULL, AV_LOG_INFO, "\n");
2750
}
2751

    
2752
void dump_format(AVFormatContext *ic,
2753
                 int index,
2754
                 const char *url,
2755
                 int is_output)
2756
{
2757
    int i;
2758

    
2759
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2760
            is_output ? "Output" : "Input",
2761
            index,
2762
            is_output ? ic->oformat->name : ic->iformat->name,
2763
            is_output ? "to" : "from", url);
2764
    if (!is_output) {
2765
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2766
        if (ic->duration != AV_NOPTS_VALUE) {
2767
            int hours, mins, secs, us;
2768
            secs = ic->duration / AV_TIME_BASE;
2769
            us = ic->duration % AV_TIME_BASE;
2770
            mins = secs / 60;
2771
            secs %= 60;
2772
            hours = mins / 60;
2773
            mins %= 60;
2774
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2775
                   (100 * us) / AV_TIME_BASE);
2776
        } else {
2777
            av_log(NULL, AV_LOG_INFO, "N/A");
2778
        }
2779
        if (ic->start_time != AV_NOPTS_VALUE) {
2780
            int secs, us;
2781
            av_log(NULL, AV_LOG_INFO, ", start: ");
2782
            secs = ic->start_time / AV_TIME_BASE;
2783
            us = ic->start_time % AV_TIME_BASE;
2784
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2785
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2786
        }
2787
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2788
        if (ic->bit_rate) {
2789
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2790
        } else {
2791
            av_log(NULL, AV_LOG_INFO, "N/A");
2792
        }
2793
        av_log(NULL, AV_LOG_INFO, "\n");
2794
    }
2795
    if(ic->nb_programs) {
2796
        int j, k;
2797
        for(j=0; j<ic->nb_programs; j++) {
2798
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2799
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2800
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2801
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2802
         }
2803
    } else
2804
    for(i=0;i<ic->nb_streams;i++)
2805
        dump_stream_format(ic, i, index, is_output);
2806
}
2807

    
2808
#if LIBAVFORMAT_VERSION_MAJOR < 53
2809
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2810
{
2811
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
2812
}
2813

    
2814
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2815
{
2816
    AVRational frame_rate;
2817
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
2818
    *frame_rate_num= frame_rate.num;
2819
    *frame_rate_den= frame_rate.den;
2820
    return ret;
2821
}
2822
#endif
2823

    
2824
int64_t av_gettime(void)
2825
{
2826
    struct timeval tv;
2827
    gettimeofday(&tv,NULL);
2828
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2829
}
2830

    
2831
int64_t parse_date(const char *datestr, int duration)
2832
{
2833
    const char *p;
2834
    int64_t t;
2835
    struct tm dt;
2836
    int i;
2837
    static const char * const date_fmt[] = {
2838
        "%Y-%m-%d",
2839
        "%Y%m%d",
2840
    };
2841
    static const char * const time_fmt[] = {
2842
        "%H:%M:%S",
2843
        "%H%M%S",
2844
    };
2845
    const char *q;
2846
    int is_utc, len;
2847
    char lastch;
2848
    int negative = 0;
2849

    
2850
#undef time
2851
    time_t now = time(0);
2852

    
2853
    len = strlen(datestr);
2854
    if (len > 0)
2855
        lastch = datestr[len - 1];
2856
    else
2857
        lastch = '\0';
2858
    is_utc = (lastch == 'z' || lastch == 'Z');
2859

    
2860
    memset(&dt, 0, sizeof(dt));
2861

    
2862
    p = datestr;
2863
    q = NULL;
2864
    if (!duration) {
2865
        /* parse the year-month-day part */
2866
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2867
            q = small_strptime(p, date_fmt[i], &dt);
2868
            if (q) {
2869
                break;
2870
            }
2871
        }
2872

    
2873
        /* if the year-month-day part is missing, then take the
2874
         * current year-month-day time */
2875
        if (!q) {
2876
            if (is_utc) {
2877
                dt = *gmtime(&now);
2878
            } else {
2879
                dt = *localtime(&now);
2880
            }
2881
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2882
        } else {
2883
            p = q;
2884
        }
2885

    
2886
        if (*p == 'T' || *p == 't' || *p == ' ')
2887
            p++;
2888

    
2889
        /* parse the hour-minute-second part */
2890
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2891
            q = small_strptime(p, time_fmt[i], &dt);
2892
            if (q) {
2893
                break;
2894
            }
2895
        }
2896
    } else {
2897
        /* parse datestr as a duration */
2898
        if (p[0] == '-') {
2899
            negative = 1;
2900
            ++p;
2901
        }
2902
        /* parse datestr as HH:MM:SS */
2903
        q = small_strptime(p, time_fmt[0], &dt);
2904
        if (!q) {
2905
            /* parse datestr as S+ */
2906
            dt.tm_sec = strtol(p, (char **)&q, 10);
2907
            if (q == p)
2908
                /* the parsing didn't succeed */
2909
                return INT64_MIN;
2910
            dt.tm_min = 0;
2911
            dt.tm_hour = 0;
2912
        }
2913
    }
2914

    
2915
    /* Now we have all the fields that we can get */
2916
    if (!q) {
2917
        return INT64_MIN;
2918
    }
2919

    
2920
    if (duration) {
2921
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2922
    } else {
2923
        dt.tm_isdst = -1;       /* unknown */
2924
        if (is_utc) {
2925
            t = mktimegm(&dt);
2926
        } else {
2927
            t = mktime(&dt);
2928
        }
2929
    }
2930

    
2931
    t *= 1000000;
2932

    
2933
    /* parse the .m... part */
2934
    if (*q == '.') {
2935
        int val, n;
2936
        q++;
2937
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2938
            if (!isdigit(*q))
2939
                break;
2940
            val += n * (*q - '0');
2941
        }
2942
        t += val;
2943
    }
2944
    return negative ? -t : t;
2945
}
2946

    
2947
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2948
{
2949
    const char *p;
2950
    char tag[128], *q;
2951

    
2952
    p = info;
2953
    if (*p == '?')
2954
        p++;
2955
    for(;;) {
2956
        q = tag;
2957
        while (*p != '\0' && *p != '=' && *p != '&') {
2958
            if ((q - tag) < sizeof(tag) - 1)
2959
                *q++ = *p;
2960
            p++;
2961
        }
2962
        *q = '\0';
2963
        q = arg;
2964
        if (*p == '=') {
2965
            p++;
2966
            while (*p != '&' && *p != '\0') {
2967
                if ((q - arg) < arg_size - 1) {
2968
                    if (*p == '+')
2969
                        *q++ = ' ';
2970
                    else
2971
                        *q++ = *p;
2972
                }
2973
                p++;
2974
            }
2975
            *q = '\0';
2976
        }
2977
        if (!strcmp(tag, tag1))
2978
            return 1;
2979
        if (*p != '&')
2980
            break;
2981
        p++;
2982
    }
2983
    return 0;
2984
}
2985

    
2986
int av_get_frame_filename(char *buf, int buf_size,
2987
                          const char *path, int number)
2988
{
2989
    const char *p;
2990
    char *q, buf1[20], c;
2991
    int nd, len, percentd_found;
2992

    
2993
    q = buf;
2994
    p = path;
2995
    percentd_found = 0;
2996
    for(;;) {
2997
        c = *p++;
2998
        if (c == '\0')
2999
            break;
3000
        if (c == '%') {
3001
            do {
3002
                nd = 0;
3003
                while (isdigit(*p)) {
3004
                    nd = nd * 10 + *p++ - '0';
3005
                }
3006
                c = *p++;
3007
            } while (isdigit(c));
3008

    
3009
            switch(c) {
3010
            case '%':
3011
                goto addchar;
3012
            case 'd':
3013
                if (percentd_found)
3014
                    goto fail;
3015
                percentd_found = 1;
3016
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3017
                len = strlen(buf1);
3018
                if ((q - buf + len) > buf_size - 1)
3019
                    goto fail;
3020
                memcpy(q, buf1, len);
3021
                q += len;
3022
                break;
3023
            default:
3024
                goto fail;
3025
            }
3026
        } else {
3027
        addchar:
3028
            if ((q - buf) < buf_size - 1)
3029
                *q++ = c;
3030
        }
3031
    }
3032
    if (!percentd_found)
3033
        goto fail;
3034
    *q = '\0';
3035
    return 0;
3036
 fail:
3037
    *q = '\0';
3038
    return -1;
3039
}
3040

    
3041
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3042
{
3043
    int len, i, j, c;
3044
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3045

    
3046
    for(i=0;i<size;i+=16) {
3047
        len = size - i;
3048
        if (len > 16)
3049
            len = 16;
3050
        PRINT("%08x ", i);
3051
        for(j=0;j<16;j++) {
3052
            if (j < len)
3053
                PRINT(" %02x", buf[i+j]);
3054
            else
3055
                PRINT("   ");
3056
        }
3057
        PRINT(" ");
3058
        for(j=0;j<len;j++) {
3059
            c = buf[i+j];
3060
            if (c < ' ' || c > '~')
3061
                c = '.';
3062
            PRINT("%c", c);
3063
        }
3064
        PRINT("\n");
3065
    }
3066
#undef PRINT
3067
}
3068

    
3069
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3070
{
3071
    hex_dump_internal(NULL, f, 0, buf, size);
3072
}
3073

    
3074
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3075
{
3076
    hex_dump_internal(avcl, NULL, level, buf, size);
3077
}
3078

    
3079
 //FIXME needs to know the time_base
3080
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3081
{
3082
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3083
    PRINT("stream #%d:\n", pkt->stream_index);
3084
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3085
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3086
    /* DTS is _always_ valid after av_read_frame() */
3087
    PRINT("  dts=");
3088
    if (pkt->dts == AV_NOPTS_VALUE)
3089
        PRINT("N/A");
3090
    else
3091
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3092
    /* PTS may not be known if B-frames are present. */
3093
    PRINT("  pts=");
3094
    if (pkt->pts == AV_NOPTS_VALUE)
3095
        PRINT("N/A");
3096
    else
3097
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3098
    PRINT("\n");
3099
    PRINT("  size=%d\n", pkt->size);
3100
#undef PRINT
3101
    if (dump_payload)
3102
        av_hex_dump(f, pkt->data, pkt->size);
3103
}
3104

    
3105
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3106
{
3107
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3108
}
3109

    
3110
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3111
{
3112
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3113
}
3114

    
3115
void url_split(char *proto, int proto_size,
3116
               char *authorization, int authorization_size,
3117
               char *hostname, int hostname_size,
3118
               int *port_ptr,
3119
               char *path, int path_size,
3120
               const char *url)
3121
{
3122
    const char *p, *ls, *at, *col, *brk;
3123

    
3124
    if (port_ptr)               *port_ptr = -1;
3125
    if (proto_size > 0)         proto[0] = 0;
3126
    if (authorization_size > 0) authorization[0] = 0;
3127
    if (hostname_size > 0)      hostname[0] = 0;
3128
    if (path_size > 0)          path[0] = 0;
3129

    
3130
    /* parse protocol */
3131
    if ((p = strchr(url, ':'))) {
3132
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3133
        p++; /* skip ':' */
3134
        if (*p == '/') p++;
3135
        if (*p == '/') p++;
3136
    } else {
3137
        /* no protocol means plain filename */
3138
        av_strlcpy(path, url, path_size);
3139
        return;
3140
    }
3141

    
3142
    /* separate path from hostname */
3143
    ls = strchr(p, '/');
3144
    if(!ls)
3145
        ls = strchr(p, '?');
3146
    if(ls)
3147
        av_strlcpy(path, ls, path_size);
3148
    else
3149
        ls = &p[strlen(p)]; // XXX
3150

    
3151
    /* the rest is hostname, use that to parse auth/port */
3152
    if (ls != p) {
3153
        /* authorization (user[:pass]@hostname) */
3154
        if ((at = strchr(p, '@')) && at < ls) {
3155
            av_strlcpy(authorization, p,
3156
                       FFMIN(authorization_size, at + 1 - p));
3157
            p = at + 1; /* skip '@' */
3158
        }
3159

    
3160
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3161
            /* [host]:port */
3162
            av_strlcpy(hostname, p + 1,
3163
                       FFMIN(hostname_size, brk - p));
3164
            if (brk[1] == ':' && port_ptr)
3165
                *port_ptr = atoi(brk + 2);
3166
        } else if ((col = strchr(p, ':')) && col < ls) {
3167
            av_strlcpy(hostname, p,
3168
                       FFMIN(col + 1 - p, hostname_size));
3169
            if (port_ptr) *port_ptr = atoi(col + 1);
3170
        } else
3171
            av_strlcpy(hostname, p,
3172
                       FFMIN(ls + 1 - p, hostname_size));
3173
    }
3174
}
3175

    
3176
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3177
{
3178
    int i;
3179
    static const char hex_table[16] = { '0', '1', '2', '3',
3180
                                        '4', '5', '6', '7',
3181
                                        '8', '9', 'A', 'B',
3182
                                        'C', 'D', 'E', 'F' };
3183

    
3184
    for(i = 0; i < s; i++) {
3185
        buff[i * 2]     = hex_table[src[i] >> 4];
3186
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3187
    }
3188

    
3189
    return buff;
3190
}
3191

    
3192
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3193
                     int pts_num, int pts_den)
3194
{
3195
    unsigned int gcd= ff_gcd(pts_num, pts_den);
3196
    s->pts_wrap_bits = pts_wrap_bits;
3197
    s->time_base.num = pts_num/gcd;
3198
    s->time_base.den = pts_den/gcd;
3199

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