Statistics
| Branch: | Revision:

ffmpeg / libavformat / utils.c @ 6612d8cf

History | View | Annotate | Download (119 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/internal.h"
24
#include "libavutil/opt.h"
25
#include "metadata.h"
26
#include "id3v2.h"
27
#include "libavutil/avstring.h"
28
#include "riff.h"
29
#include "audiointerleave.h"
30
#include <sys/time.h>
31
#include <time.h>
32
#include <strings.h>
33
#include <stdarg.h>
34
#if CONFIG_NETWORK
35
#include "network.h"
36
#endif
37

    
38
#undef NDEBUG
39
#include <assert.h>
40

    
41
/**
42
 * @file
43
 * various utility functions for use within FFmpeg
44
 */
45

    
46
unsigned avformat_version(void)
47
{
48
    return LIBAVFORMAT_VERSION_INT;
49
}
50

    
51
const char *avformat_configuration(void)
52
{
53
    return FFMPEG_CONFIGURATION;
54
}
55

    
56
const char *avformat_license(void)
57
{
58
#define LICENSE_PREFIX "libavformat license: "
59
    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
60
}
61

    
62
/* fraction handling */
63

    
64
/**
65
 * f = val + (num / den) + 0.5.
66
 *
67
 * 'num' is normalized so that it is such as 0 <= num < den.
68
 *
69
 * @param f fractional number
70
 * @param val integer value
71
 * @param num must be >= 0
72
 * @param den must be >= 1
73
 */
74
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
75
{
76
    num += (den >> 1);
77
    if (num >= den) {
78
        val += num / den;
79
        num = num % den;
80
    }
81
    f->val = val;
82
    f->num = num;
83
    f->den = den;
84
}
85

    
86
/**
87
 * Fractional addition to f: f = f + (incr / f->den).
88
 *
89
 * @param f fractional number
90
 * @param incr increment, can be positive or negative
91
 */
92
static void av_frac_add(AVFrac *f, int64_t incr)
93
{
94
    int64_t num, den;
95

    
96
    num = f->num + incr;
97
    den = f->den;
98
    if (num < 0) {
99
        f->val += num / den;
100
        num = num % den;
101
        if (num < 0) {
102
            num += den;
103
            f->val--;
104
        }
105
    } else if (num >= den) {
106
        f->val += num / den;
107
        num = num % den;
108
    }
109
    f->num = num;
110
}
111

    
112
/** head of registered input format linked list */
113
AVInputFormat *first_iformat = NULL;
114
/** head of registered output format linked list */
115
AVOutputFormat *first_oformat = NULL;
116

    
117
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
118
{
119
    if(f) return f->next;
120
    else  return first_iformat;
121
}
122

    
123
AVOutputFormat *av_oformat_next(AVOutputFormat *f)
124
{
125
    if(f) return f->next;
126
    else  return first_oformat;
127
}
128

    
129
void av_register_input_format(AVInputFormat *format)
130
{
131
    AVInputFormat **p;
132
    p = &first_iformat;
133
    while (*p != NULL) p = &(*p)->next;
134
    *p = format;
135
    format->next = NULL;
136
}
137

    
138
void av_register_output_format(AVOutputFormat *format)
139
{
140
    AVOutputFormat **p;
141
    p = &first_oformat;
142
    while (*p != NULL) p = &(*p)->next;
143
    *p = format;
144
    format->next = NULL;
145
}
146

    
147
int av_match_ext(const char *filename, const char *extensions)
148
{
149
    const char *ext, *p;
150
    char ext1[32], *q;
151

    
152
    if(!filename)
153
        return 0;
154

    
155
    ext = strrchr(filename, '.');
156
    if (ext) {
157
        ext++;
158
        p = extensions;
159
        for(;;) {
160
            q = ext1;
161
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
162
                *q++ = *p++;
163
            *q = '\0';
164
            if (!strcasecmp(ext1, ext))
165
                return 1;
166
            if (*p == '\0')
167
                break;
168
            p++;
169
        }
170
    }
171
    return 0;
172
}
173

    
174
static int match_format(const char *name, const char *names)
175
{
176
    const char *p;
177
    int len, namelen;
178

    
179
    if (!name || !names)
180
        return 0;
181

    
182
    namelen = strlen(name);
183
    while ((p = strchr(names, ','))) {
184
        len = FFMAX(p - names, namelen);
185
        if (!strncasecmp(name, names, len))
186
            return 1;
187
        names = p+1;
188
    }
189
    return !strcasecmp(name, names);
190
}
191

    
192
#if LIBAVFORMAT_VERSION_MAJOR < 53
193
AVOutputFormat *guess_format(const char *short_name, const char *filename,
194
                             const char *mime_type)
195
{
196
    return av_guess_format(short_name, filename, mime_type);
197
}
198
#endif
199

    
200
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
201
                                const char *mime_type)
202
{
203
    AVOutputFormat *fmt, *fmt_found;
204
    int score_max, score;
205

    
206
    /* specific test for image sequences */
207
#if CONFIG_IMAGE2_MUXER
208
    if (!short_name && filename &&
209
        av_filename_number_test(filename) &&
210
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
211
        return av_guess_format("image2", NULL, NULL);
212
    }
213
#endif
214
    /* Find the proper file type. */
215
    fmt_found = NULL;
216
    score_max = 0;
217
    fmt = first_oformat;
218
    while (fmt != NULL) {
219
        score = 0;
220
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
221
            score += 100;
222
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
223
            score += 10;
224
        if (filename && fmt->extensions &&
225
            av_match_ext(filename, fmt->extensions)) {
226
            score += 5;
227
        }
228
        if (score > score_max) {
229
            score_max = score;
230
            fmt_found = fmt;
231
        }
232
        fmt = fmt->next;
233
    }
234
    return fmt_found;
235
}
236

    
237
#if LIBAVFORMAT_VERSION_MAJOR < 53
238
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
239
                             const char *mime_type)
240
{
241
    AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
242

    
243
    if (fmt) {
244
        AVOutputFormat *stream_fmt;
245
        char stream_format_name[64];
246

    
247
        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
248
        stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
249

    
250
        if (stream_fmt)
251
            fmt = stream_fmt;
252
    }
253

    
254
    return fmt;
255
}
256
#endif
257

    
258
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
259
                            const char *filename, const char *mime_type, enum AVMediaType type){
260
    if(type == AVMEDIA_TYPE_VIDEO){
261
        enum CodecID codec_id= CODEC_ID_NONE;
262

    
263
#if CONFIG_IMAGE2_MUXER
264
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
265
            codec_id= av_guess_image2_codec(filename);
266
        }
267
#endif
268
        if(codec_id == CODEC_ID_NONE)
269
            codec_id= fmt->video_codec;
270
        return codec_id;
271
    }else if(type == AVMEDIA_TYPE_AUDIO)
272
        return fmt->audio_codec;
273
    else
274
        return CODEC_ID_NONE;
275
}
276

    
277
AVInputFormat *av_find_input_format(const char *short_name)
278
{
279
    AVInputFormat *fmt;
280
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
281
        if (match_format(short_name, fmt->name))
282
            return fmt;
283
    }
284
    return NULL;
285
}
286

    
287
#if LIBAVFORMAT_VERSION_MAJOR < 53 && CONFIG_SHARED && HAVE_SYMVER
288
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
289
{
290
    av_destruct_packet_nofree(pkt);
291
}
292

    
293
FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
294
{
295
    av_destruct_packet(pkt);
296
}
297

    
298
FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
299
{
300
    return av_new_packet(pkt, size);
301
}
302

    
303
FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
304
{
305
    return av_dup_packet(pkt);
306
}
307

    
308
FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
309
{
310
    av_free_packet(pkt);
311
}
312

    
313
FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
314
{
315
    av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
316
    av_init_packet(pkt);
317
}
318
#endif
319

    
320
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
321
{
322
    int ret= av_new_packet(pkt, size);
323

    
324
    if(ret<0)
325
        return ret;
326

    
327
    pkt->pos= url_ftell(s);
328

    
329
    ret= get_buffer(s, pkt->data, size);
330
    if(ret<=0)
331
        av_free_packet(pkt);
332
    else
333
        av_shrink_packet(pkt, ret);
334

    
335
    return ret;
336
}
337

    
338

    
339
int av_filename_number_test(const char *filename)
340
{
341
    char buf[1024];
342
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
343
}
344

    
345
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
346
{
347
    AVProbeData lpd = *pd;
348
    AVInputFormat *fmt1, *fmt;
349
    int score;
350

    
351
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
352
        int id3len = ff_id3v2_tag_len(lpd.buf);
353
        if (lpd.buf_size > id3len + 16) {
354
            lpd.buf += id3len;
355
            lpd.buf_size -= id3len;
356
        }
357
    }
358

    
359
    fmt = NULL;
360
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
361
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
362
            continue;
363
        score = 0;
364
        if (fmt1->read_probe) {
365
            score = fmt1->read_probe(&lpd);
366
        } else if (fmt1->extensions) {
367
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
368
                score = 50;
369
            }
370
        }
371
        if (score > *score_max) {
372
            *score_max = score;
373
            fmt = fmt1;
374
        }else if (score == *score_max)
375
            fmt = NULL;
376
    }
377
    return fmt;
378
}
379

    
380
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
381
    int score=0;
382
    return av_probe_input_format2(pd, is_opened, &score);
383
}
384

    
385
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
386
{
387
    static const struct {
388
        const char *name; enum CodecID id; enum AVMediaType type;
389
    } fmt_id_type[] = {
390
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
391
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
392
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
393
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
394
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
395
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
396
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
397
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
398
        { 0 }
399
    };
400
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
401

    
402
    if (fmt) {
403
        int i;
404
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
405
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
406
        for (i = 0; fmt_id_type[i].name; i++) {
407
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
408
                st->codec->codec_id   = fmt_id_type[i].id;
409
                st->codec->codec_type = fmt_id_type[i].type;
410
                break;
411
            }
412
        }
413
    }
414
    return !!fmt;
415
}
416

    
417
/************************************************************/
418
/* input media file */
419

    
420
/**
421
 * Open a media file from an IO stream. 'fmt' must be specified.
422
 */
423
int av_open_input_stream(AVFormatContext **ic_ptr,
424
                         ByteIOContext *pb, const char *filename,
425
                         AVInputFormat *fmt, AVFormatParameters *ap)
426
{
427
    int err;
428
    AVFormatContext *ic;
429
    AVFormatParameters default_ap;
430

    
431
    if(!ap){
432
        ap=&default_ap;
433
        memset(ap, 0, sizeof(default_ap));
434
    }
435

    
436
    if(!ap->prealloced_context)
437
        ic = avformat_alloc_context();
438
    else
439
        ic = *ic_ptr;
440
    if (!ic) {
441
        err = AVERROR(ENOMEM);
442
        goto fail;
443
    }
444
    ic->iformat = fmt;
445
    ic->pb = pb;
446
    ic->duration = AV_NOPTS_VALUE;
447
    ic->start_time = AV_NOPTS_VALUE;
448
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
449

    
450
    /* allocate private data */
451
    if (fmt->priv_data_size > 0) {
452
        ic->priv_data = av_mallocz(fmt->priv_data_size);
453
        if (!ic->priv_data) {
454
            err = AVERROR(ENOMEM);
455
            goto fail;
456
        }
457
    } else {
458
        ic->priv_data = NULL;
459
    }
460

    
461
    // e.g. AVFMT_NOFILE formats will not have a ByteIOContext
462
    if (ic->pb)
463
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
464

    
465
    if (ic->iformat->read_header) {
466
        err = ic->iformat->read_header(ic, ap);
467
        if (err < 0)
468
            goto fail;
469
    }
470

    
471
    if (pb && !ic->data_offset)
472
        ic->data_offset = url_ftell(ic->pb);
473

    
474
#if FF_API_OLD_METADATA
475
    ff_metadata_demux_compat(ic);
476
#endif
477

    
478
    ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
479

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

    
501
/** size of probe buffer, for guessing file type from file contents */
502
#define PROBE_BUF_MIN 2048
503
#define PROBE_BUF_MAX (1<<20)
504

    
505
int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
506
                          const char *filename, void *logctx,
507
                          unsigned int offset, unsigned int max_probe_size)
508
{
509
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
510
    unsigned char *buf = NULL;
511
    int ret = 0, probe_size;
512

    
513
    if (!max_probe_size) {
514
        max_probe_size = PROBE_BUF_MAX;
515
    } else if (max_probe_size > PROBE_BUF_MAX) {
516
        max_probe_size = PROBE_BUF_MAX;
517
    } else if (max_probe_size < PROBE_BUF_MIN) {
518
        return AVERROR(EINVAL);
519
    }
520

    
521
    if (offset >= max_probe_size) {
522
        return AVERROR(EINVAL);
523
    }
524

    
525
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
526
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
527
        int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
528
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
529

    
530
        if (probe_size < offset) {
531
            continue;
532
        }
533

    
534
        /* read probe data */
535
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
536
        if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
537
            /* fail if error was not end of file, otherwise, lower score */
538
            if (ret != AVERROR_EOF) {
539
                av_free(buf);
540
                return ret;
541
            }
542
            score = 0;
543
            ret = 0;            /* error was end of file, nothing read */
544
        }
545
        pd.buf_size += ret;
546
        pd.buf = &buf[offset];
547

    
548
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
549

    
550
        /* guess file format */
551
        *fmt = av_probe_input_format2(&pd, 1, &score);
552
        if(*fmt){
553
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
554
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
555
            }else
556
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
557
        }
558
    }
559

    
560
    if (!*fmt) {
561
        av_free(buf);
562
        return AVERROR_INVALIDDATA;
563
    }
564

    
565
    /* rewind. reuse probe buffer to avoid seeking */
566
    if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
567
        av_free(buf);
568

    
569
    return ret;
570
}
571

    
572
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
573
                       AVInputFormat *fmt,
574
                       int buf_size,
575
                       AVFormatParameters *ap)
576
{
577
    int err;
578
    AVProbeData probe_data, *pd = &probe_data;
579
    ByteIOContext *pb = NULL;
580
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
581

    
582
    pd->filename = "";
583
    if (filename)
584
        pd->filename = filename;
585
    pd->buf = NULL;
586
    pd->buf_size = 0;
587

    
588
    if (!fmt) {
589
        /* guess format if no file can be opened */
590
        fmt = av_probe_input_format(pd, 0);
591
    }
592

    
593
    /* Do not open file if the format does not need it. XXX: specific
594
       hack needed to handle RTSP/TCP */
595
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
596
        /* if no file needed do not try to open one */
597
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
598
            goto fail;
599
        }
600
        if (buf_size > 0) {
601
            url_setbufsize(pb, buf_size);
602
        }
603
        if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
604
            goto fail;
605
        }
606
    }
607

    
608
    /* if still no format found, error */
609
    if (!fmt) {
610
        err = AVERROR_INVALIDDATA;
611
        goto fail;
612
    }
613

    
614
    /* check filename in case an image number is expected */
615
    if (fmt->flags & AVFMT_NEEDNUMBER) {
616
        if (!av_filename_number_test(filename)) {
617
            err = AVERROR_NUMEXPECTED;
618
            goto fail;
619
        }
620
    }
621
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
622
    if (err)
623
        goto fail;
624
    return 0;
625
 fail:
626
    av_freep(&pd->buf);
627
    if (pb)
628
        url_fclose(pb);
629
    if (ap && ap->prealloced_context)
630
        av_free(*ic_ptr);
631
    *ic_ptr = NULL;
632
    return err;
633

    
634
}
635

    
636
/*******************************************************/
637

    
638
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
639
                               AVPacketList **plast_pktl){
640
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
641
    if (!pktl)
642
        return NULL;
643

    
644
    if (*packet_buffer)
645
        (*plast_pktl)->next = pktl;
646
    else
647
        *packet_buffer = pktl;
648

    
649
    /* add the packet in the buffered packet list */
650
    *plast_pktl = pktl;
651
    pktl->pkt= *pkt;
652
    return &pktl->pkt;
653
}
654

    
655
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
656
{
657
    int ret, i;
658
    AVStream *st;
659

    
660
    for(;;){
661
        AVPacketList *pktl = s->raw_packet_buffer;
662

    
663
        if (pktl) {
664
            *pkt = pktl->pkt;
665
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
666
               !s->streams[pkt->stream_index]->probe_packets ||
667
               s->raw_packet_buffer_remaining_size < pkt->size){
668
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
669
                av_freep(&pd->buf);
670
                pd->buf_size = 0;
671
                s->raw_packet_buffer = pktl->next;
672
                s->raw_packet_buffer_remaining_size += pkt->size;
673
                av_free(pktl);
674
                return 0;
675
            }
676
        }
677

    
678
        av_init_packet(pkt);
679
        ret= s->iformat->read_packet(s, pkt);
680
        if (ret < 0) {
681
            if (!pktl || ret == AVERROR(EAGAIN))
682
                return ret;
683
            for (i = 0; i < s->nb_streams; i++)
684
                s->streams[i]->probe_packets = 0;
685
            continue;
686
        }
687
        st= s->streams[pkt->stream_index];
688

    
689
        switch(st->codec->codec_type){
690
        case AVMEDIA_TYPE_VIDEO:
691
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
692
            break;
693
        case AVMEDIA_TYPE_AUDIO:
694
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
695
            break;
696
        case AVMEDIA_TYPE_SUBTITLE:
697
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
698
            break;
699
        }
700

    
701
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
702
                     !st->probe_packets))
703
            return ret;
704

    
705
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
706
        s->raw_packet_buffer_remaining_size -= pkt->size;
707

    
708
        if(st->codec->codec_id == CODEC_ID_PROBE){
709
            AVProbeData *pd = &st->probe_data;
710
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
711
            --st->probe_packets;
712

    
713
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
714
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
715
            pd->buf_size += pkt->size;
716
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
717

    
718
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
719
                //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
720
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
721
                if(st->codec->codec_id != CODEC_ID_PROBE){
722
                    pd->buf_size=0;
723
                    av_freep(&pd->buf);
724
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
725
                }
726
            }
727
        }
728
    }
729
}
730

    
731
/**********************************************************/
732

    
733
/**
734
 * Get the number of samples of an audio frame. Return -1 on error.
735
 */
736
static int get_audio_frame_size(AVCodecContext *enc, int size)
737
{
738
    int frame_size;
739

    
740
    if(enc->codec_id == CODEC_ID_VORBIS)
741
        return -1;
742

    
743
    if (enc->frame_size <= 1) {
744
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
745

    
746
        if (bits_per_sample) {
747
            if (enc->channels == 0)
748
                return -1;
749
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
750
        } else {
751
            /* used for example by ADPCM codecs */
752
            if (enc->bit_rate == 0)
753
                return -1;
754
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
755
        }
756
    } else {
757
        frame_size = enc->frame_size;
758
    }
759
    return frame_size;
760
}
761

    
762

    
763
/**
764
 * Return the frame duration in seconds. Return 0 if not available.
765
 */
766
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
767
                                   AVCodecParserContext *pc, AVPacket *pkt)
768
{
769
    int frame_size;
770

    
771
    *pnum = 0;
772
    *pden = 0;
773
    switch(st->codec->codec_type) {
774
    case AVMEDIA_TYPE_VIDEO:
775
        if(st->time_base.num*1000LL > st->time_base.den){
776
            *pnum = st->time_base.num;
777
            *pden = st->time_base.den;
778
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
779
            *pnum = st->codec->time_base.num;
780
            *pden = st->codec->time_base.den;
781
            if (pc && pc->repeat_pict) {
782
                *pnum = (*pnum) * (1 + pc->repeat_pict);
783
            }
784
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
785
            //Thus if we have no parser in such case leave duration undefined.
786
            if(st->codec->ticks_per_frame>1 && !pc){
787
                *pnum = *pden = 0;
788
            }
789
        }
790
        break;
791
    case AVMEDIA_TYPE_AUDIO:
792
        frame_size = get_audio_frame_size(st->codec, pkt->size);
793
        if (frame_size < 0)
794
            break;
795
        *pnum = frame_size;
796
        *pden = st->codec->sample_rate;
797
        break;
798
    default:
799
        break;
800
    }
801
}
802

    
803
static int is_intra_only(AVCodecContext *enc){
804
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
805
        return 1;
806
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
807
        switch(enc->codec_id){
808
        case CODEC_ID_MJPEG:
809
        case CODEC_ID_MJPEGB:
810
        case CODEC_ID_LJPEG:
811
        case CODEC_ID_RAWVIDEO:
812
        case CODEC_ID_DVVIDEO:
813
        case CODEC_ID_HUFFYUV:
814
        case CODEC_ID_FFVHUFF:
815
        case CODEC_ID_ASV1:
816
        case CODEC_ID_ASV2:
817
        case CODEC_ID_VCR1:
818
        case CODEC_ID_DNXHD:
819
        case CODEC_ID_JPEG2000:
820
            return 1;
821
        default: break;
822
        }
823
    }
824
    return 0;
825
}
826

    
827
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
828
                                      int64_t dts, int64_t pts)
829
{
830
    AVStream *st= s->streams[stream_index];
831
    AVPacketList *pktl= s->packet_buffer;
832

    
833
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
834
        return;
835

    
836
    st->first_dts= dts - st->cur_dts;
837
    st->cur_dts= dts;
838

    
839
    for(; pktl; pktl= pktl->next){
840
        if(pktl->pkt.stream_index != stream_index)
841
            continue;
842
        //FIXME think more about this check
843
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
844
            pktl->pkt.pts += st->first_dts;
845

    
846
        if(pktl->pkt.dts != AV_NOPTS_VALUE)
847
            pktl->pkt.dts += st->first_dts;
848

    
849
        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
850
            st->start_time= pktl->pkt.pts;
851
    }
852
    if (st->start_time == AV_NOPTS_VALUE)
853
        st->start_time = pts;
854
}
855

    
856
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
857
{
858
    AVPacketList *pktl= s->packet_buffer;
859
    int64_t cur_dts= 0;
860

    
861
    if(st->first_dts != AV_NOPTS_VALUE){
862
        cur_dts= st->first_dts;
863
        for(; pktl; pktl= pktl->next){
864
            if(pktl->pkt.stream_index == pkt->stream_index){
865
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
866
                    break;
867
                cur_dts -= pkt->duration;
868
            }
869
        }
870
        pktl= s->packet_buffer;
871
        st->first_dts = cur_dts;
872
    }else if(st->cur_dts)
873
        return;
874

    
875
    for(; pktl; pktl= pktl->next){
876
        if(pktl->pkt.stream_index != pkt->stream_index)
877
            continue;
878
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
879
           && !pktl->pkt.duration){
880
            pktl->pkt.dts= cur_dts;
881
            if(!st->codec->has_b_frames)
882
                pktl->pkt.pts= cur_dts;
883
            cur_dts += pkt->duration;
884
            pktl->pkt.duration= pkt->duration;
885
        }else
886
            break;
887
    }
888
    if(st->first_dts == AV_NOPTS_VALUE)
889
        st->cur_dts= cur_dts;
890
}
891

    
892
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
893
                               AVCodecParserContext *pc, AVPacket *pkt)
894
{
895
    int num, den, presentation_delayed, delay, i;
896
    int64_t offset;
897

    
898
    if (s->flags & AVFMT_FLAG_NOFILLIN)
899
        return;
900

    
901
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
902
        pkt->dts= AV_NOPTS_VALUE;
903

    
904
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
905
        //FIXME Set low_delay = 0 when has_b_frames = 1
906
        st->codec->has_b_frames = 1;
907

    
908
    /* do we have a video B-frame ? */
909
    delay= st->codec->has_b_frames;
910
    presentation_delayed = 0;
911
    /* XXX: need has_b_frame, but cannot get it if the codec is
912
        not initialized */
913
    if (delay &&
914
        pc && pc->pict_type != FF_B_TYPE)
915
        presentation_delayed = 1;
916

    
917
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
918
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
919
        pkt->dts -= 1LL<<st->pts_wrap_bits;
920
    }
921

    
922
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
923
    // we take the conservative approach and discard both
924
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
925
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
926
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
927
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
928
    }
929

    
930
    if (pkt->duration == 0) {
931
        compute_frame_duration(&num, &den, st, pc, pkt);
932
        if (den && num) {
933
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
934

    
935
            if(pkt->duration != 0 && s->packet_buffer)
936
                update_initial_durations(s, st, pkt);
937
        }
938
    }
939

    
940
    /* correct timestamps with byte offset if demuxers only have timestamps
941
       on packet boundaries */
942
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
943
        /* this will estimate bitrate based on this frame's duration and size */
944
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
945
        if(pkt->pts != AV_NOPTS_VALUE)
946
            pkt->pts += offset;
947
        if(pkt->dts != AV_NOPTS_VALUE)
948
            pkt->dts += offset;
949
    }
950

    
951
    if (pc && pc->dts_sync_point >= 0) {
952
        // we have synchronization info from the parser
953
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
954
        if (den > 0) {
955
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
956
            if (pkt->dts != AV_NOPTS_VALUE) {
957
                // got DTS from the stream, update reference timestamp
958
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
959
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
960
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
961
                // compute DTS based on reference timestamp
962
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
963
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
964
            }
965
            if (pc->dts_sync_point > 0)
966
                st->reference_dts = pkt->dts; // new reference
967
        }
968
    }
969

    
970
    /* This may be redundant, but it should not hurt. */
971
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
972
        presentation_delayed = 1;
973

    
974
//    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);
975
    /* interpolate PTS and DTS if they are not present */
976
    //We skip H264 currently because delay and has_b_frames are not reliably set
977
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
978
        if (presentation_delayed) {
979
            /* DTS = decompression timestamp */
980
            /* PTS = presentation timestamp */
981
            if (pkt->dts == AV_NOPTS_VALUE)
982
                pkt->dts = st->last_IP_pts;
983
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
984
            if (pkt->dts == AV_NOPTS_VALUE)
985
                pkt->dts = st->cur_dts;
986

    
987
            /* this is tricky: the dts must be incremented by the duration
988
            of the frame we are displaying, i.e. the last I- or P-frame */
989
            if (st->last_IP_duration == 0)
990
                st->last_IP_duration = pkt->duration;
991
            if(pkt->dts != AV_NOPTS_VALUE)
992
                st->cur_dts = pkt->dts + st->last_IP_duration;
993
            st->last_IP_duration  = pkt->duration;
994
            st->last_IP_pts= pkt->pts;
995
            /* cannot compute PTS if not present (we can compute it only
996
            by knowing the future */
997
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
998
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
999
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1000
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1001
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1002
                    pkt->pts += pkt->duration;
1003
    //                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);
1004
                }
1005
            }
1006

    
1007
            /* presentation is not delayed : PTS and DTS are the same */
1008
            if(pkt->pts == AV_NOPTS_VALUE)
1009
                pkt->pts = pkt->dts;
1010
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1011
            if(pkt->pts == AV_NOPTS_VALUE)
1012
                pkt->pts = st->cur_dts;
1013
            pkt->dts = pkt->pts;
1014
            if(pkt->pts != AV_NOPTS_VALUE)
1015
                st->cur_dts = pkt->pts + pkt->duration;
1016
        }
1017
    }
1018

    
1019
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1020
        st->pts_buffer[0]= pkt->pts;
1021
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1022
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1023
        if(pkt->dts == AV_NOPTS_VALUE)
1024
            pkt->dts= st->pts_buffer[0];
1025
        if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1026
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1027
        }
1028
        if(pkt->dts > st->cur_dts)
1029
            st->cur_dts = pkt->dts;
1030
    }
1031

    
1032
//    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);
1033

    
1034
    /* update flags */
1035
    if(is_intra_only(st->codec))
1036
        pkt->flags |= AV_PKT_FLAG_KEY;
1037
    else if (pc) {
1038
        pkt->flags = 0;
1039
        /* keyframe computation */
1040
        if (pc->key_frame == 1)
1041
            pkt->flags |= AV_PKT_FLAG_KEY;
1042
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1043
            pkt->flags |= AV_PKT_FLAG_KEY;
1044
    }
1045
    if (pc)
1046
        pkt->convergence_duration = pc->convergence_duration;
1047
}
1048

    
1049

    
1050
static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1051
{
1052
    AVStream *st;
1053
    int len, ret, i;
1054

    
1055
    av_init_packet(pkt);
1056

    
1057
    for(;;) {
1058
        /* select current input stream component */
1059
        st = s->cur_st;
1060
        if (st) {
1061
            if (!st->need_parsing || !st->parser) {
1062
                /* no parsing needed: we just output the packet as is */
1063
                /* raw data support */
1064
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1065
                compute_pkt_fields(s, st, NULL, pkt);
1066
                s->cur_st = NULL;
1067
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1068
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1069
                    ff_reduce_index(s, st->index);
1070
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1071
                }
1072
                break;
1073
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1074
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1075
                                       st->cur_ptr, st->cur_len,
1076
                                       st->cur_pkt.pts, st->cur_pkt.dts,
1077
                                       st->cur_pkt.pos);
1078
                st->cur_pkt.pts = AV_NOPTS_VALUE;
1079
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1080
                /* increment read pointer */
1081
                st->cur_ptr += len;
1082
                st->cur_len -= len;
1083

    
1084
                /* return packet if any */
1085
                if (pkt->size) {
1086
                got_packet:
1087
                    pkt->duration = 0;
1088
                    pkt->stream_index = st->index;
1089
                    pkt->pts = st->parser->pts;
1090
                    pkt->dts = st->parser->dts;
1091
                    pkt->pos = st->parser->pos;
1092
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1093
                        s->cur_st = NULL;
1094
                        pkt->destruct= st->cur_pkt.destruct;
1095
                        st->cur_pkt.destruct= NULL;
1096
                        st->cur_pkt.data    = NULL;
1097
                        assert(st->cur_len == 0);
1098
                    }else{
1099
                    pkt->destruct = NULL;
1100
                    }
1101
                    compute_pkt_fields(s, st, st->parser, pkt);
1102

    
1103
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1104
                        ff_reduce_index(s, st->index);
1105
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1106
                                           0, 0, AVINDEX_KEYFRAME);
1107
                    }
1108

    
1109
                    break;
1110
                }
1111
            } else {
1112
                /* free packet */
1113
                av_free_packet(&st->cur_pkt);
1114
                s->cur_st = NULL;
1115
            }
1116
        } else {
1117
            AVPacket cur_pkt;
1118
            /* read next packet */
1119
            ret = av_read_packet(s, &cur_pkt);
1120
            if (ret < 0) {
1121
                if (ret == AVERROR(EAGAIN))
1122
                    return ret;
1123
                /* return the last frames, if any */
1124
                for(i = 0; i < s->nb_streams; i++) {
1125
                    st = s->streams[i];
1126
                    if (st->parser && st->need_parsing) {
1127
                        av_parser_parse2(st->parser, st->codec,
1128
                                        &pkt->data, &pkt->size,
1129
                                        NULL, 0,
1130
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1131
                                        AV_NOPTS_VALUE);
1132
                        if (pkt->size)
1133
                            goto got_packet;
1134
                    }
1135
                }
1136
                /* no more packets: really terminate parsing */
1137
                return ret;
1138
            }
1139
            st = s->streams[cur_pkt.stream_index];
1140
            st->cur_pkt= cur_pkt;
1141

    
1142
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1143
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
1144
               st->cur_pkt.pts < st->cur_pkt.dts){
1145
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1146
                    st->cur_pkt.stream_index,
1147
                    st->cur_pkt.pts,
1148
                    st->cur_pkt.dts,
1149
                    st->cur_pkt.size);
1150
//                av_free_packet(&st->cur_pkt);
1151
//                return -1;
1152
            }
1153

    
1154
            if(s->debug & FF_FDEBUG_TS)
1155
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1156
                    st->cur_pkt.stream_index,
1157
                    st->cur_pkt.pts,
1158
                    st->cur_pkt.dts,
1159
                    st->cur_pkt.size,
1160
                    st->cur_pkt.duration,
1161
                    st->cur_pkt.flags);
1162

    
1163
            s->cur_st = st;
1164
            st->cur_ptr = st->cur_pkt.data;
1165
            st->cur_len = st->cur_pkt.size;
1166
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1167
                st->parser = av_parser_init(st->codec->codec_id);
1168
                if (!st->parser) {
1169
                    /* no parser available: just output the raw packets */
1170
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1171
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1172
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1173
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1174
                    st->parser->flags |= PARSER_FLAG_ONCE;
1175
                }
1176
            }
1177
        }
1178
    }
1179
    if(s->debug & FF_FDEBUG_TS)
1180
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1181
            pkt->stream_index,
1182
            pkt->pts,
1183
            pkt->dts,
1184
            pkt->size,
1185
            pkt->duration,
1186
            pkt->flags);
1187

    
1188
    return 0;
1189
}
1190

    
1191
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1192
{
1193
    AVPacketList *pktl;
1194
    int eof=0;
1195
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1196

    
1197
    for(;;){
1198
        pktl = s->packet_buffer;
1199
        if (pktl) {
1200
            AVPacket *next_pkt= &pktl->pkt;
1201

    
1202
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1203
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1204
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1205
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1206
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1207
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1208
                        next_pkt->pts= pktl->pkt.dts;
1209
                    }
1210
                    pktl= pktl->next;
1211
                }
1212
                pktl = s->packet_buffer;
1213
            }
1214

    
1215
            if(   next_pkt->pts != AV_NOPTS_VALUE
1216
               || next_pkt->dts == AV_NOPTS_VALUE
1217
               || !genpts || eof){
1218
                /* read packet from packet buffer, if there is data */
1219
                *pkt = *next_pkt;
1220
                s->packet_buffer = pktl->next;
1221
                av_free(pktl);
1222
                return 0;
1223
            }
1224
        }
1225
        if(genpts){
1226
            int ret= av_read_frame_internal(s, pkt);
1227
            if(ret<0){
1228
                if(pktl && ret != AVERROR(EAGAIN)){
1229
                    eof=1;
1230
                    continue;
1231
                }else
1232
                    return ret;
1233
            }
1234

    
1235
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1236
                                           &s->packet_buffer_end)) < 0)
1237
                return AVERROR(ENOMEM);
1238
        }else{
1239
            assert(!s->packet_buffer);
1240
            return av_read_frame_internal(s, pkt);
1241
        }
1242
    }
1243
}
1244

    
1245
/* XXX: suppress the packet queue */
1246
static void flush_packet_queue(AVFormatContext *s)
1247
{
1248
    AVPacketList *pktl;
1249

    
1250
    for(;;) {
1251
        pktl = s->packet_buffer;
1252
        if (!pktl)
1253
            break;
1254
        s->packet_buffer = pktl->next;
1255
        av_free_packet(&pktl->pkt);
1256
        av_free(pktl);
1257
    }
1258
    while(s->raw_packet_buffer){
1259
        pktl = s->raw_packet_buffer;
1260
        s->raw_packet_buffer = pktl->next;
1261
        av_free_packet(&pktl->pkt);
1262
        av_free(pktl);
1263
    }
1264
    s->packet_buffer_end=
1265
    s->raw_packet_buffer_end= NULL;
1266
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1267
}
1268

    
1269
/*******************************************************/
1270
/* seek support */
1271

    
1272
int av_find_default_stream_index(AVFormatContext *s)
1273
{
1274
    int first_audio_index = -1;
1275
    int i;
1276
    AVStream *st;
1277

    
1278
    if (s->nb_streams <= 0)
1279
        return -1;
1280
    for(i = 0; i < s->nb_streams; i++) {
1281
        st = s->streams[i];
1282
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1283
            return i;
1284
        }
1285
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1286
            first_audio_index = i;
1287
    }
1288
    return first_audio_index >= 0 ? first_audio_index : 0;
1289
}
1290

    
1291
/**
1292
 * Flush the frame reader.
1293
 */
1294
void ff_read_frame_flush(AVFormatContext *s)
1295
{
1296
    AVStream *st;
1297
    int i, j;
1298

    
1299
    flush_packet_queue(s);
1300

    
1301
    s->cur_st = NULL;
1302

    
1303
    /* for each stream, reset read state */
1304
    for(i = 0; i < s->nb_streams; i++) {
1305
        st = s->streams[i];
1306

    
1307
        if (st->parser) {
1308
            av_parser_close(st->parser);
1309
            st->parser = NULL;
1310
            av_free_packet(&st->cur_pkt);
1311
        }
1312
        st->last_IP_pts = AV_NOPTS_VALUE;
1313
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1314
        st->reference_dts = AV_NOPTS_VALUE;
1315
        /* fail safe */
1316
        st->cur_ptr = NULL;
1317
        st->cur_len = 0;
1318

    
1319
        st->probe_packets = MAX_PROBE_PACKETS;
1320

    
1321
        for(j=0; j<MAX_REORDER_DELAY+1; j++)
1322
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1323
    }
1324
}
1325

    
1326
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1327
    int i;
1328

    
1329
    for(i = 0; i < s->nb_streams; i++) {
1330
        AVStream *st = s->streams[i];
1331

    
1332
        st->cur_dts = av_rescale(timestamp,
1333
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
1334
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1335
    }
1336
}
1337

    
1338
void ff_reduce_index(AVFormatContext *s, int stream_index)
1339
{
1340
    AVStream *st= s->streams[stream_index];
1341
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1342

    
1343
    if((unsigned)st->nb_index_entries >= max_entries){
1344
        int i;
1345
        for(i=0; 2*i<st->nb_index_entries; i++)
1346
            st->index_entries[i]= st->index_entries[2*i];
1347
        st->nb_index_entries= i;
1348
    }
1349
}
1350

    
1351
int av_add_index_entry(AVStream *st,
1352
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1353
{
1354
    AVIndexEntry *entries, *ie;
1355
    int index;
1356

    
1357
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1358
        return -1;
1359

    
1360
    entries = av_fast_realloc(st->index_entries,
1361
                              &st->index_entries_allocated_size,
1362
                              (st->nb_index_entries + 1) *
1363
                              sizeof(AVIndexEntry));
1364
    if(!entries)
1365
        return -1;
1366

    
1367
    st->index_entries= entries;
1368

    
1369
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1370

    
1371
    if(index<0){
1372
        index= st->nb_index_entries++;
1373
        ie= &entries[index];
1374
        assert(index==0 || ie[-1].timestamp < timestamp);
1375
    }else{
1376
        ie= &entries[index];
1377
        if(ie->timestamp != timestamp){
1378
            if(ie->timestamp <= timestamp)
1379
                return -1;
1380
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1381
            st->nb_index_entries++;
1382
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1383
            distance= ie->min_distance;
1384
    }
1385

    
1386
    ie->pos = pos;
1387
    ie->timestamp = timestamp;
1388
    ie->min_distance= distance;
1389
    ie->size= size;
1390
    ie->flags = flags;
1391

    
1392
    return index;
1393
}
1394

    
1395
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1396
                              int flags)
1397
{
1398
    AVIndexEntry *entries= st->index_entries;
1399
    int nb_entries= st->nb_index_entries;
1400
    int a, b, m;
1401
    int64_t timestamp;
1402

    
1403
    a = - 1;
1404
    b = nb_entries;
1405

    
1406
    //optimize appending index entries at the end
1407
    if(b && entries[b-1].timestamp < wanted_timestamp)
1408
        a= b-1;
1409

    
1410
    while (b - a > 1) {
1411
        m = (a + b) >> 1;
1412
        timestamp = entries[m].timestamp;
1413
        if(timestamp >= wanted_timestamp)
1414
            b = m;
1415
        if(timestamp <= wanted_timestamp)
1416
            a = m;
1417
    }
1418
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1419

    
1420
    if(!(flags & AVSEEK_FLAG_ANY)){
1421
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1422
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1423
        }
1424
    }
1425

    
1426
    if(m == nb_entries)
1427
        return -1;
1428
    return  m;
1429
}
1430

    
1431
#define DEBUG_SEEK
1432

    
1433
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1434
    AVInputFormat *avif= s->iformat;
1435
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1436
    int64_t ts_min, ts_max, ts;
1437
    int index;
1438
    int64_t ret;
1439
    AVStream *st;
1440

    
1441
    if (stream_index < 0)
1442
        return -1;
1443

    
1444
#ifdef DEBUG_SEEK
1445
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1446
#endif
1447

    
1448
    ts_max=
1449
    ts_min= AV_NOPTS_VALUE;
1450
    pos_limit= -1; //gcc falsely says it may be uninitialized
1451

    
1452
    st= s->streams[stream_index];
1453
    if(st->index_entries){
1454
        AVIndexEntry *e;
1455

    
1456
        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()
1457
        index= FFMAX(index, 0);
1458
        e= &st->index_entries[index];
1459

    
1460
        if(e->timestamp <= target_ts || e->pos == e->min_distance){
1461
            pos_min= e->pos;
1462
            ts_min= e->timestamp;
1463
#ifdef DEBUG_SEEK
1464
            av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1465
                   pos_min,ts_min);
1466
#endif
1467
        }else{
1468
            assert(index==0);
1469
        }
1470

    
1471
        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1472
        assert(index < st->nb_index_entries);
1473
        if(index >= 0){
1474
            e= &st->index_entries[index];
1475
            assert(e->timestamp >= target_ts);
1476
            pos_max= e->pos;
1477
            ts_max= e->timestamp;
1478
            pos_limit= pos_max - e->min_distance;
1479
#ifdef DEBUG_SEEK
1480
            av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1481
                   pos_max,pos_limit, ts_max);
1482
#endif
1483
        }
1484
    }
1485

    
1486
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1487
    if(pos<0)
1488
        return -1;
1489

    
1490
    /* do the seek */
1491
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1492
        return ret;
1493

    
1494
    av_update_cur_dts(s, st, ts);
1495

    
1496
    return 0;
1497
}
1498

    
1499
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 )){
1500
    int64_t pos, ts;
1501
    int64_t start_pos, filesize;
1502
    int no_change;
1503

    
1504
#ifdef DEBUG_SEEK
1505
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1506
#endif
1507

    
1508
    if(ts_min == AV_NOPTS_VALUE){
1509
        pos_min = s->data_offset;
1510
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1511
        if (ts_min == AV_NOPTS_VALUE)
1512
            return -1;
1513
    }
1514

    
1515
    if(ts_max == AV_NOPTS_VALUE){
1516
        int step= 1024;
1517
        filesize = url_fsize(s->pb);
1518
        pos_max = filesize - 1;
1519
        do{
1520
            pos_max -= step;
1521
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1522
            step += step;
1523
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1524
        if (ts_max == AV_NOPTS_VALUE)
1525
            return -1;
1526

    
1527
        for(;;){
1528
            int64_t tmp_pos= pos_max + 1;
1529
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1530
            if(tmp_ts == AV_NOPTS_VALUE)
1531
                break;
1532
            ts_max= tmp_ts;
1533
            pos_max= tmp_pos;
1534
            if(tmp_pos >= filesize)
1535
                break;
1536
        }
1537
        pos_limit= pos_max;
1538
    }
1539

    
1540
    if(ts_min > ts_max){
1541
        return -1;
1542
    }else if(ts_min == ts_max){
1543
        pos_limit= pos_min;
1544
    }
1545

    
1546
    no_change=0;
1547
    while (pos_min < pos_limit) {
1548
#ifdef DEBUG_SEEK
1549
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1550
               pos_min, pos_max,
1551
               ts_min, ts_max);
1552
#endif
1553
        assert(pos_limit <= pos_max);
1554

    
1555
        if(no_change==0){
1556
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
1557
            // interpolate position (better than dichotomy)
1558
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1559
                + pos_min - approximate_keyframe_distance;
1560
        }else if(no_change==1){
1561
            // bisection, if interpolation failed to change min or max pos last time
1562
            pos = (pos_min + pos_limit)>>1;
1563
        }else{
1564
            /* linear search if bisection failed, can only happen if there
1565
               are very few or no keyframes between min/max */
1566
            pos=pos_min;
1567
        }
1568
        if(pos <= pos_min)
1569
            pos= pos_min + 1;
1570
        else if(pos > pos_limit)
1571
            pos= pos_limit;
1572
        start_pos= pos;
1573

    
1574
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1575
        if(pos == pos_max)
1576
            no_change++;
1577
        else
1578
            no_change=0;
1579
#ifdef DEBUG_SEEK
1580
        av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1581
               pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1582
               start_pos, no_change);
1583
#endif
1584
        if(ts == AV_NOPTS_VALUE){
1585
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1586
            return -1;
1587
        }
1588
        assert(ts != AV_NOPTS_VALUE);
1589
        if (target_ts <= ts) {
1590
            pos_limit = start_pos - 1;
1591
            pos_max = pos;
1592
            ts_max = ts;
1593
        }
1594
        if (target_ts >= ts) {
1595
            pos_min = pos;
1596
            ts_min = ts;
1597
        }
1598
    }
1599

    
1600
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1601
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1602
#ifdef DEBUG_SEEK
1603
    pos_min = pos;
1604
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1605
    pos_min++;
1606
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1607
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1608
           pos, ts_min, target_ts, ts_max);
1609
#endif
1610
    *ts_ret= ts;
1611
    return pos;
1612
}
1613

    
1614
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1615
    int64_t pos_min, pos_max;
1616
#if 0
1617
    AVStream *st;
1618

1619
    if (stream_index < 0)
1620
        return -1;
1621

1622
    st= s->streams[stream_index];
1623
#endif
1624

    
1625
    pos_min = s->data_offset;
1626
    pos_max = url_fsize(s->pb) - 1;
1627

    
1628
    if     (pos < pos_min) pos= pos_min;
1629
    else if(pos > pos_max) pos= pos_max;
1630

    
1631
    url_fseek(s->pb, pos, SEEK_SET);
1632

    
1633
#if 0
1634
    av_update_cur_dts(s, st, ts);
1635
#endif
1636
    return 0;
1637
}
1638

    
1639
static int av_seek_frame_generic(AVFormatContext *s,
1640
                                 int stream_index, int64_t timestamp, int flags)
1641
{
1642
    int index;
1643
    int64_t ret;
1644
    AVStream *st;
1645
    AVIndexEntry *ie;
1646

    
1647
    st = s->streams[stream_index];
1648

    
1649
    index = av_index_search_timestamp(st, timestamp, flags);
1650

    
1651
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1652
        return -1;
1653

    
1654
    if(index < 0 || index==st->nb_index_entries-1){
1655
        int i;
1656
        AVPacket pkt;
1657

    
1658
        if(st->nb_index_entries){
1659
            assert(st->index_entries);
1660
            ie= &st->index_entries[st->nb_index_entries-1];
1661
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1662
                return ret;
1663
            av_update_cur_dts(s, st, ie->timestamp);
1664
        }else{
1665
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1666
                return ret;
1667
        }
1668
        for(i=0;; i++) {
1669
            int ret;
1670
            do{
1671
                ret = av_read_frame(s, &pkt);
1672
            }while(ret == AVERROR(EAGAIN));
1673
            if(ret<0)
1674
                break;
1675
            av_free_packet(&pkt);
1676
            if(stream_index == pkt.stream_index){
1677
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1678
                    break;
1679
            }
1680
        }
1681
        index = av_index_search_timestamp(st, timestamp, flags);
1682
    }
1683
    if (index < 0)
1684
        return -1;
1685

    
1686
    ff_read_frame_flush(s);
1687
    if (s->iformat->read_seek){
1688
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1689
            return 0;
1690
    }
1691
    ie = &st->index_entries[index];
1692
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1693
        return ret;
1694
    av_update_cur_dts(s, st, ie->timestamp);
1695

    
1696
    return 0;
1697
}
1698

    
1699
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1700
{
1701
    int ret;
1702
    AVStream *st;
1703

    
1704
    ff_read_frame_flush(s);
1705

    
1706
    if(flags & AVSEEK_FLAG_BYTE)
1707
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1708

    
1709
    if(stream_index < 0){
1710
        stream_index= av_find_default_stream_index(s);
1711
        if(stream_index < 0)
1712
            return -1;
1713

    
1714
        st= s->streams[stream_index];
1715
       /* timestamp for default must be expressed in AV_TIME_BASE units */
1716
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1717
    }
1718

    
1719
    /* first, we try the format specific seek */
1720
    if (s->iformat->read_seek)
1721
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1722
    else
1723
        ret = -1;
1724
    if (ret >= 0) {
1725
        return 0;
1726
    }
1727

    
1728
    if(s->iformat->read_timestamp)
1729
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1730
    else
1731
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1732
}
1733

    
1734
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1735
{
1736
    if(min_ts > ts || max_ts < ts)
1737
        return -1;
1738

    
1739
    ff_read_frame_flush(s);
1740

    
1741
    if (s->iformat->read_seek2)
1742
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1743

    
1744
    if(s->iformat->read_timestamp){
1745
        //try to seek via read_timestamp()
1746
    }
1747

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

    
1753
    // try some generic seek like av_seek_frame_generic() but with new ts semantics
1754
}
1755

    
1756
/*******************************************************/
1757

    
1758
/**
1759
 * Return TRUE if the stream has accurate duration in any stream.
1760
 *
1761
 * @return TRUE if the stream has accurate duration for at least one component.
1762
 */
1763
static int av_has_duration(AVFormatContext *ic)
1764
{
1765
    int i;
1766
    AVStream *st;
1767

    
1768
    for(i = 0;i < ic->nb_streams; i++) {
1769
        st = ic->streams[i];
1770
        if (st->duration != AV_NOPTS_VALUE)
1771
            return 1;
1772
    }
1773
    return 0;
1774
}
1775

    
1776
/**
1777
 * Estimate the stream timings from the one of each components.
1778
 *
1779
 * Also computes the global bitrate if possible.
1780
 */
1781
static void av_update_stream_timings(AVFormatContext *ic)
1782
{
1783
    int64_t start_time, start_time1, end_time, end_time1;
1784
    int64_t duration, duration1;
1785
    int i;
1786
    AVStream *st;
1787

    
1788
    start_time = INT64_MAX;
1789
    end_time = INT64_MIN;
1790
    duration = INT64_MIN;
1791
    for(i = 0;i < ic->nb_streams; i++) {
1792
        st = ic->streams[i];
1793
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1794
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1795
            if (start_time1 < start_time)
1796
                start_time = start_time1;
1797
            if (st->duration != AV_NOPTS_VALUE) {
1798
                end_time1 = start_time1
1799
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1800
                if (end_time1 > end_time)
1801
                    end_time = end_time1;
1802
            }
1803
        }
1804
        if (st->duration != AV_NOPTS_VALUE) {
1805
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1806
            if (duration1 > duration)
1807
                duration = duration1;
1808
        }
1809
    }
1810
    if (start_time != INT64_MAX) {
1811
        ic->start_time = start_time;
1812
        if (end_time != INT64_MIN) {
1813
            if (end_time - start_time > duration)
1814
                duration = end_time - start_time;
1815
        }
1816
    }
1817
    if (duration != INT64_MIN) {
1818
        ic->duration = duration;
1819
        if (ic->file_size > 0) {
1820
            /* compute the bitrate */
1821
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1822
                (double)ic->duration;
1823
        }
1824
    }
1825
}
1826

    
1827
static void fill_all_stream_timings(AVFormatContext *ic)
1828
{
1829
    int i;
1830
    AVStream *st;
1831

    
1832
    av_update_stream_timings(ic);
1833
    for(i = 0;i < ic->nb_streams; i++) {
1834
        st = ic->streams[i];
1835
        if (st->start_time == AV_NOPTS_VALUE) {
1836
            if(ic->start_time != AV_NOPTS_VALUE)
1837
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1838
            if(ic->duration != AV_NOPTS_VALUE)
1839
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1840
        }
1841
    }
1842
}
1843

    
1844
static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1845
{
1846
    int64_t filesize, duration;
1847
    int bit_rate, i;
1848
    AVStream *st;
1849

    
1850
    /* if bit_rate is already set, we believe it */
1851
    if (ic->bit_rate == 0) {
1852
        bit_rate = 0;
1853
        for(i=0;i<ic->nb_streams;i++) {
1854
            st = ic->streams[i];
1855
            bit_rate += st->codec->bit_rate;
1856
        }
1857
        ic->bit_rate = bit_rate;
1858
    }
1859

    
1860
    /* if duration is already set, we believe it */
1861
    if (ic->duration == AV_NOPTS_VALUE &&
1862
        ic->bit_rate != 0 &&
1863
        ic->file_size != 0)  {
1864
        filesize = ic->file_size;
1865
        if (filesize > 0) {
1866
            for(i = 0; i < ic->nb_streams; i++) {
1867
                st = ic->streams[i];
1868
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1869
                if (st->duration == AV_NOPTS_VALUE)
1870
                    st->duration = duration;
1871
            }
1872
        }
1873
    }
1874
}
1875

    
1876
#define DURATION_MAX_READ_SIZE 250000
1877
#define DURATION_MAX_RETRY 3
1878

    
1879
/* only usable for MPEG-PS streams */
1880
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1881
{
1882
    AVPacket pkt1, *pkt = &pkt1;
1883
    AVStream *st;
1884
    int read_size, i, ret;
1885
    int64_t end_time, start_time[MAX_STREAMS];
1886
    int64_t filesize, offset, duration;
1887
    int retry=0;
1888

    
1889
    ic->cur_st = NULL;
1890

    
1891
    /* flush packet queue */
1892
    flush_packet_queue(ic);
1893

    
1894
    for(i=0;i<ic->nb_streams;i++) {
1895
        st = ic->streams[i];
1896
        if(st->start_time != AV_NOPTS_VALUE){
1897
            start_time[i]= st->start_time;
1898
        }else if(st->first_dts != AV_NOPTS_VALUE){
1899
            start_time[i]= st->first_dts;
1900
        }else
1901
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1902

    
1903
        if (st->parser) {
1904
            av_parser_close(st->parser);
1905
            st->parser= NULL;
1906
            av_free_packet(&st->cur_pkt);
1907
        }
1908
    }
1909

    
1910
    /* estimate the end time (duration) */
1911
    /* XXX: may need to support wrapping */
1912
    filesize = ic->file_size;
1913
    end_time = AV_NOPTS_VALUE;
1914
    do{
1915
    offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1916
    if (offset < 0)
1917
        offset = 0;
1918

    
1919
    url_fseek(ic->pb, offset, SEEK_SET);
1920
    read_size = 0;
1921
    for(;;) {
1922
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1923
            break;
1924

    
1925
        do{
1926
            ret = av_read_packet(ic, pkt);
1927
        }while(ret == AVERROR(EAGAIN));
1928
        if (ret != 0)
1929
            break;
1930
        read_size += pkt->size;
1931
        st = ic->streams[pkt->stream_index];
1932
        if (pkt->pts != AV_NOPTS_VALUE &&
1933
            start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1934
            end_time = pkt->pts;
1935
            duration = end_time - start_time[pkt->stream_index];
1936
            if (duration < 0)
1937
                duration += 1LL<<st->pts_wrap_bits;
1938
            if (duration > 0) {
1939
                if (st->duration == AV_NOPTS_VALUE ||
1940
                    st->duration < duration)
1941
                    st->duration = duration;
1942
            }
1943
        }
1944
        av_free_packet(pkt);
1945
    }
1946
    }while(   end_time==AV_NOPTS_VALUE
1947
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
1948
           && ++retry <= DURATION_MAX_RETRY);
1949

    
1950
    fill_all_stream_timings(ic);
1951

    
1952
    url_fseek(ic->pb, old_offset, SEEK_SET);
1953
    for(i=0; i<ic->nb_streams; i++){
1954
        st= ic->streams[i];
1955
        st->cur_dts= st->first_dts;
1956
        st->last_IP_pts = AV_NOPTS_VALUE;
1957
    }
1958
}
1959

    
1960
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1961
{
1962
    int64_t file_size;
1963

    
1964
    /* get the file size, if possible */
1965
    if (ic->iformat->flags & AVFMT_NOFILE) {
1966
        file_size = 0;
1967
    } else {
1968
        file_size = url_fsize(ic->pb);
1969
        if (file_size < 0)
1970
            file_size = 0;
1971
    }
1972
    ic->file_size = file_size;
1973

    
1974
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1975
         !strcmp(ic->iformat->name, "mpegts")) &&
1976
        file_size && !url_is_streamed(ic->pb)) {
1977
        /* get accurate estimate from the PTSes */
1978
        av_estimate_timings_from_pts(ic, old_offset);
1979
    } else if (av_has_duration(ic)) {
1980
        /* at least one component has timings - we use them for all
1981
           the components */
1982
        fill_all_stream_timings(ic);
1983
    } else {
1984
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1985
        /* less precise: use bitrate info */
1986
        av_estimate_timings_from_bit_rate(ic);
1987
    }
1988
    av_update_stream_timings(ic);
1989

    
1990
#if 0
1991
    {
1992
        int i;
1993
        AVStream *st;
1994
        for(i = 0;i < ic->nb_streams; i++) {
1995
            st = ic->streams[i];
1996
        printf("%d: start_time: %0.3f duration: %0.3f\n",
1997
               i, (double)st->start_time / AV_TIME_BASE,
1998
               (double)st->duration / AV_TIME_BASE);
1999
        }
2000
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2001
               (double)ic->start_time / AV_TIME_BASE,
2002
               (double)ic->duration / AV_TIME_BASE,
2003
               ic->bit_rate / 1000);
2004
    }
2005
#endif
2006
}
2007

    
2008
static int has_codec_parameters(AVCodecContext *enc)
2009
{
2010
    int val;
2011
    switch(enc->codec_type) {
2012
    case AVMEDIA_TYPE_AUDIO:
2013
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
2014
        if(!enc->frame_size &&
2015
           (enc->codec_id == CODEC_ID_VORBIS ||
2016
            enc->codec_id == CODEC_ID_AAC ||
2017
            enc->codec_id == CODEC_ID_MP1 ||
2018
            enc->codec_id == CODEC_ID_MP2 ||
2019
            enc->codec_id == CODEC_ID_MP3 ||
2020
            enc->codec_id == CODEC_ID_SPEEX))
2021
            return 0;
2022
        break;
2023
    case AVMEDIA_TYPE_VIDEO:
2024
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2025
        break;
2026
    default:
2027
        val = 1;
2028
        break;
2029
    }
2030
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2031
}
2032

    
2033
static int has_decode_delay_been_guessed(AVStream *st)
2034
{
2035
    return st->codec->codec_id != CODEC_ID_H264 ||
2036
        st->codec_info_nb_frames >= 4 + st->codec->has_b_frames;
2037
}
2038

    
2039
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2040
{
2041
    int16_t *samples;
2042
    AVCodec *codec;
2043
    int got_picture, data_size, ret=0;
2044
    AVFrame picture;
2045

    
2046
    if(!st->codec->codec){
2047
        codec = avcodec_find_decoder(st->codec->codec_id);
2048
        if (!codec)
2049
            return -1;
2050
        ret = avcodec_open(st->codec, codec);
2051
        if (ret < 0)
2052
            return ret;
2053
    }
2054

    
2055
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2056
        switch(st->codec->codec_type) {
2057
        case AVMEDIA_TYPE_VIDEO:
2058
            avcodec_get_frame_defaults(&picture);
2059
            ret = avcodec_decode_video2(st->codec, &picture,
2060
                                        &got_picture, avpkt);
2061
            break;
2062
        case AVMEDIA_TYPE_AUDIO:
2063
            data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2064
            samples = av_malloc(data_size);
2065
            if (!samples)
2066
                goto fail;
2067
            ret = avcodec_decode_audio3(st->codec, samples,
2068
                                        &data_size, avpkt);
2069
            av_free(samples);
2070
            break;
2071
        default:
2072
            break;
2073
        }
2074
    }
2075
 fail:
2076
    return ret;
2077
}
2078

    
2079
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2080
{
2081
    while (tags->id != CODEC_ID_NONE) {
2082
        if (tags->id == id)
2083
            return tags->tag;
2084
        tags++;
2085
    }
2086
    return 0;
2087
}
2088

    
2089
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2090
{
2091
    int i;
2092
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2093
        if(tag == tags[i].tag)
2094
            return tags[i].id;
2095
    }
2096
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2097
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2098
            return tags[i].id;
2099
    }
2100
    return CODEC_ID_NONE;
2101
}
2102

    
2103
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2104
{
2105
    int i;
2106
    for(i=0; tags && tags[i]; i++){
2107
        int tag= ff_codec_get_tag(tags[i], id);
2108
        if(tag) return tag;
2109
    }
2110
    return 0;
2111
}
2112

    
2113
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2114
{
2115
    int i;
2116
    for(i=0; tags && tags[i]; i++){
2117
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2118
        if(id!=CODEC_ID_NONE) return id;
2119
    }
2120
    return CODEC_ID_NONE;
2121
}
2122

    
2123
static void compute_chapters_end(AVFormatContext *s)
2124
{
2125
    unsigned int i;
2126

    
2127
    for (i=0; i+1<s->nb_chapters; i++)
2128
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2129
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2130
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2131
            s->chapters[i]->end = s->chapters[i+1]->start;
2132
        }
2133

    
2134
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2135
        assert(s->start_time != AV_NOPTS_VALUE);
2136
        assert(s->duration > 0);
2137
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2138
                                           AV_TIME_BASE_Q,
2139
                                           s->chapters[i]->time_base);
2140
    }
2141
}
2142

    
2143
#define MAX_STD_TIMEBASES (60*12+5)
2144
static int get_std_framerate(int i){
2145
    if(i<60*12) return i*1001;
2146
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2147
}
2148

    
2149
/*
2150
 * Is the time base unreliable.
2151
 * This is a heuristic to balance between quick acceptance of the values in
2152
 * the headers vs. some extra checks.
2153
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2154
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2155
 * And there are "variable" fps files this needs to detect as well.
2156
 */
2157
static int tb_unreliable(AVCodecContext *c){
2158
    if(   c->time_base.den >= 101L*c->time_base.num
2159
       || c->time_base.den <    5L*c->time_base.num
2160
/*       || c->codec_tag == AV_RL32("DIVX")
2161
       || c->codec_tag == AV_RL32("XVID")*/
2162
       || c->codec_id == CODEC_ID_MPEG2VIDEO
2163
       || c->codec_id == CODEC_ID_H264
2164
       )
2165
        return 1;
2166
    return 0;
2167
}
2168

    
2169
int av_find_stream_info(AVFormatContext *ic)
2170
{
2171
    int i, count, ret, read_size, j;
2172
    AVStream *st;
2173
    AVPacket pkt1, *pkt;
2174
    int64_t old_offset = url_ftell(ic->pb);
2175
    struct {
2176
        int64_t last_dts;
2177
        int64_t duration_gcd;
2178
        int duration_count;
2179
        double duration_error[MAX_STD_TIMEBASES];
2180
        int64_t codec_info_duration;
2181
    } info[MAX_STREAMS] = {{0}};
2182

    
2183
    for(i=0;i<ic->nb_streams;i++) {
2184
        AVCodec *codec;
2185
        st = ic->streams[i];
2186
        if (st->codec->codec_id == CODEC_ID_AAC) {
2187
            st->codec->sample_rate = 0;
2188
            st->codec->frame_size = 0;
2189
            st->codec->channels = 0;
2190
        }
2191
        if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2192
/*            if(!st->time_base.num)
2193
                st->time_base= */
2194
            if(!st->codec->time_base.num)
2195
                st->codec->time_base= st->time_base;
2196
        }
2197
        //only for the split stuff
2198
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2199
            st->parser = av_parser_init(st->codec->codec_id);
2200
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2201
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2202
            }
2203
        }
2204
        assert(!st->codec->codec);
2205
        codec = avcodec_find_decoder(st->codec->codec_id);
2206

    
2207
        /* Force decoding of at least one frame of codec data
2208
         * this makes sure the codec initializes the channel configuration
2209
         * and does not trust the values from the container.
2210
         */
2211
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2212
            st->codec->channels = 0;
2213

    
2214
        //try to just open decoders, in case this is enough to get parameters
2215
        if(!has_codec_parameters(st->codec)){
2216
            if (codec)
2217
                avcodec_open(st->codec, codec);
2218
        }
2219
    }
2220

    
2221
    for(i=0;i<MAX_STREAMS;i++){
2222
        info[i].last_dts= AV_NOPTS_VALUE;
2223
    }
2224

    
2225
    count = 0;
2226
    read_size = 0;
2227
    for(;;) {
2228
        if(url_interrupt_cb()){
2229
            ret= AVERROR(EINTR);
2230
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2231
            break;
2232
        }
2233

    
2234
        /* check if one codec still needs to be handled */
2235
        for(i=0;i<ic->nb_streams;i++) {
2236
            st = ic->streams[i];
2237
            if (!has_codec_parameters(st->codec))
2238
                break;
2239
            /* variable fps and no guess at the real fps */
2240
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2241
               && info[i].duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2242
                break;
2243
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2244
                break;
2245
            if(st->first_dts == AV_NOPTS_VALUE)
2246
                break;
2247
        }
2248
        if (i == ic->nb_streams) {
2249
            /* NOTE: if the format has no header, then we need to read
2250
               some packets to get most of the streams, so we cannot
2251
               stop here */
2252
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2253
                /* if we found the info for all the codecs, we can stop */
2254
                ret = count;
2255
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2256
                break;
2257
            }
2258
        }
2259
        /* we did not get all the codec info, but we read too much data */
2260
        if (read_size >= ic->probesize) {
2261
            ret = count;
2262
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2263
            break;
2264
        }
2265

    
2266
        /* NOTE: a new stream can be added there if no header in file
2267
           (AVFMTCTX_NOHEADER) */
2268
        ret = av_read_frame_internal(ic, &pkt1);
2269
        if(ret == AVERROR(EAGAIN))
2270
            continue;
2271
        if (ret < 0) {
2272
            /* EOF or error */
2273
            ret = -1; /* we could not have all the codec parameters before EOF */
2274
            for(i=0;i<ic->nb_streams;i++) {
2275
                st = ic->streams[i];
2276
                if (!has_codec_parameters(st->codec)){
2277
                    char buf[256];
2278
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2279
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2280
                } else {
2281
                    ret = 0;
2282
                }
2283
            }
2284
            break;
2285
        }
2286

    
2287
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2288
        if(av_dup_packet(pkt) < 0) {
2289
            return AVERROR(ENOMEM);
2290
        }
2291

    
2292
        read_size += pkt->size;
2293

    
2294
        st = ic->streams[pkt->stream_index];
2295
        if(st->codec_info_nb_frames>1) {
2296
            if (st->time_base.den > 0 && av_rescale_q(info[st->index].codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
2297
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2298
                break;
2299
            }
2300
            info[st->index].codec_info_duration += pkt->duration;
2301
        }
2302
        {
2303
            int index= pkt->stream_index;
2304
            int64_t last= info[index].last_dts;
2305
            int64_t duration= pkt->dts - last;
2306

    
2307
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2308
                double dur= duration * av_q2d(st->time_base);
2309

    
2310
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2311
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2312
                if(info[index].duration_count < 2)
2313
                    memset(info[index].duration_error, 0, sizeof(info[index].duration_error));
2314
                for(i=1; i<MAX_STD_TIMEBASES; i++){
2315
                    int framerate= get_std_framerate(i);
2316
                    int ticks= lrintf(dur*framerate/(1001*12));
2317
                    double error= dur - ticks*1001*12/(double)framerate;
2318
                    info[index].duration_error[i] += error*error;
2319
                }
2320
                info[index].duration_count++;
2321
                // ignore the first 4 values, they might have some random jitter
2322
                if (info[index].duration_count > 3)
2323
                    info[index].duration_gcd = av_gcd(info[index].duration_gcd, duration);
2324
            }
2325
            if(last == AV_NOPTS_VALUE || info[index].duration_count <= 1)
2326
                info[pkt->stream_index].last_dts = pkt->dts;
2327
        }
2328
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2329
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2330
            if(i){
2331
                st->codec->extradata_size= i;
2332
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2333
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2334
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2335
            }
2336
        }
2337

    
2338
        /* if still no information, we try to open the codec and to
2339
           decompress the frame. We try to avoid that in most cases as
2340
           it takes longer and uses more memory. For MPEG-4, we need to
2341
           decompress for QuickTime. */
2342
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2343
            try_decode_frame(st, pkt);
2344

    
2345
        st->codec_info_nb_frames++;
2346
        count++;
2347
    }
2348

    
2349
    // close codecs which were opened in try_decode_frame()
2350
    for(i=0;i<ic->nb_streams;i++) {
2351
        st = ic->streams[i];
2352
        if(st->codec->codec)
2353
            avcodec_close(st->codec);
2354
    }
2355
    for(i=0;i<ic->nb_streams;i++) {
2356
        st = ic->streams[i];
2357
        if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && info[i].codec_info_duration)
2358
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2359
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2360
                      info[i].codec_info_duration*(int64_t)st->time_base.num, 60000);
2361
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2362
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2363
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2364

    
2365
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2366
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2367
            // ipmovie.c produces.
2368
            if (tb_unreliable(st->codec) && info[i].duration_count > 15 && info[i].duration_gcd > 1 && !st->r_frame_rate.num)
2369
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * info[i].duration_gcd, INT_MAX);
2370
            if(info[i].duration_count && !st->r_frame_rate.num
2371
               && tb_unreliable(st->codec) /*&&
2372
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2373
               st->time_base.num*duration_sum[i]/info[i].duration_count*101LL > st->time_base.den*/){
2374
                int num = 0;
2375
                double best_error= 2*av_q2d(st->time_base);
2376
                best_error= best_error*best_error*info[i].duration_count*1000*12*30;
2377

    
2378
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2379
                    double error= info[i].duration_error[j] * get_std_framerate(j);
2380
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2381
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2382
                    if(error < best_error){
2383
                        best_error= error;
2384
                        num = get_std_framerate(j);
2385
                    }
2386
                }
2387
                // do not increase frame rate by more than 1 % in order to match a standard rate.
2388
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2389
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2390
            }
2391

    
2392
            if (!st->r_frame_rate.num){
2393
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2394
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2395
                    st->r_frame_rate.num = st->codec->time_base.den;
2396
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2397
                }else{
2398
                    st->r_frame_rate.num = st->time_base.den;
2399
                    st->r_frame_rate.den = st->time_base.num;
2400
                }
2401
            }
2402
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2403
            if(!st->codec->bits_per_coded_sample)
2404
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2405
        }
2406
    }
2407

    
2408
    av_estimate_timings(ic, old_offset);
2409

    
2410
    compute_chapters_end(ic);
2411

    
2412
#if 0
2413
    /* correct DTS for B-frame streams with no timestamps */
2414
    for(i=0;i<ic->nb_streams;i++) {
2415
        st = ic->streams[i];
2416
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2417
            if(b-frames){
2418
                ppktl = &ic->packet_buffer;
2419
                while(ppkt1){
2420
                    if(ppkt1->stream_index != i)
2421
                        continue;
2422
                    if(ppkt1->pkt->dts < 0)
2423
                        break;
2424
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2425
                        break;
2426
                    ppkt1->pkt->dts -= delta;
2427
                    ppkt1= ppkt1->next;
2428
                }
2429
                if(ppkt1)
2430
                    continue;
2431
                st->cur_dts -= delta;
2432
            }
2433
        }
2434
    }
2435
#endif
2436

    
2437
    return ret;
2438
}
2439

    
2440
/*******************************************************/
2441

    
2442
int av_read_play(AVFormatContext *s)
2443
{
2444
    if (s->iformat->read_play)
2445
        return s->iformat->read_play(s);
2446
    if (s->pb)
2447
        return av_url_read_fpause(s->pb, 0);
2448
    return AVERROR(ENOSYS);
2449
}
2450

    
2451
int av_read_pause(AVFormatContext *s)
2452
{
2453
    if (s->iformat->read_pause)
2454
        return s->iformat->read_pause(s);
2455
    if (s->pb)
2456
        return av_url_read_fpause(s->pb, 1);
2457
    return AVERROR(ENOSYS);
2458
}
2459

    
2460
void av_close_input_stream(AVFormatContext *s)
2461
{
2462
    int i;
2463
    AVStream *st;
2464

    
2465
    if (s->iformat->read_close)
2466
        s->iformat->read_close(s);
2467
    for(i=0;i<s->nb_streams;i++) {
2468
        /* free all data in a stream component */
2469
        st = s->streams[i];
2470
        if (st->parser) {
2471
            av_parser_close(st->parser);
2472
            av_free_packet(&st->cur_pkt);
2473
        }
2474
        av_metadata_free(&st->metadata);
2475
        av_free(st->index_entries);
2476
        av_free(st->codec->extradata);
2477
        av_free(st->codec);
2478
#if FF_API_OLD_METADATA
2479
        av_free(st->filename);
2480
#endif
2481
        av_free(st->priv_data);
2482
        av_free(st);
2483
    }
2484
    for(i=s->nb_programs-1; i>=0; i--) {
2485
#if FF_API_OLD_METADATA
2486
        av_freep(&s->programs[i]->provider_name);
2487
        av_freep(&s->programs[i]->name);
2488
#endif
2489
        av_metadata_free(&s->programs[i]->metadata);
2490
        av_freep(&s->programs[i]->stream_index);
2491
        av_freep(&s->programs[i]);
2492
    }
2493
    av_freep(&s->programs);
2494
    flush_packet_queue(s);
2495
    av_freep(&s->priv_data);
2496
    while(s->nb_chapters--) {
2497
#if FF_API_OLD_METADATA
2498
        av_free(s->chapters[s->nb_chapters]->title);
2499
#endif
2500
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2501
        av_free(s->chapters[s->nb_chapters]);
2502
    }
2503
    av_freep(&s->chapters);
2504
    av_metadata_free(&s->metadata);
2505
    av_freep(&s->key);
2506
    av_free(s);
2507
}
2508

    
2509
void av_close_input_file(AVFormatContext *s)
2510
{
2511
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2512
    av_close_input_stream(s);
2513
    if (pb)
2514
        url_fclose(pb);
2515
}
2516

    
2517
AVStream *av_new_stream(AVFormatContext *s, int id)
2518
{
2519
    AVStream *st;
2520
    int i;
2521

    
2522
    if (s->nb_streams >= MAX_STREAMS){
2523
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
2524
        return NULL;
2525
    }
2526

    
2527
    st = av_mallocz(sizeof(AVStream));
2528
    if (!st)
2529
        return NULL;
2530

    
2531
    st->codec= avcodec_alloc_context();
2532
    if (s->iformat) {
2533
        /* no default bitrate if decoding */
2534
        st->codec->bit_rate = 0;
2535
    }
2536
    st->index = s->nb_streams;
2537
    st->id = id;
2538
    st->start_time = AV_NOPTS_VALUE;
2539
    st->duration = AV_NOPTS_VALUE;
2540
        /* we set the current DTS to 0 so that formats without any timestamps
2541
           but durations get some timestamps, formats with some unknown
2542
           timestamps have their first few packets buffered and the
2543
           timestamps corrected before they are returned to the user */
2544
    st->cur_dts = 0;
2545
    st->first_dts = AV_NOPTS_VALUE;
2546
    st->probe_packets = MAX_PROBE_PACKETS;
2547

    
2548
    /* default pts setting is MPEG-like */
2549
    av_set_pts_info(st, 33, 1, 90000);
2550
    st->last_IP_pts = AV_NOPTS_VALUE;
2551
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
2552
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2553
    st->reference_dts = AV_NOPTS_VALUE;
2554

    
2555
    st->sample_aspect_ratio = (AVRational){0,1};
2556

    
2557
    s->streams[s->nb_streams++] = st;
2558
    return st;
2559
}
2560

    
2561
AVProgram *av_new_program(AVFormatContext *ac, int id)
2562
{
2563
    AVProgram *program=NULL;
2564
    int i;
2565

    
2566
#ifdef DEBUG_SI
2567
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2568
#endif
2569

    
2570
    for(i=0; i<ac->nb_programs; i++)
2571
        if(ac->programs[i]->id == id)
2572
            program = ac->programs[i];
2573

    
2574
    if(!program){
2575
        program = av_mallocz(sizeof(AVProgram));
2576
        if (!program)
2577
            return NULL;
2578
        dynarray_add(&ac->programs, &ac->nb_programs, program);
2579
        program->discard = AVDISCARD_NONE;
2580
    }
2581
    program->id = id;
2582

    
2583
    return program;
2584
}
2585

    
2586
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2587
{
2588
    AVChapter *chapter = NULL;
2589
    int i;
2590

    
2591
    for(i=0; i<s->nb_chapters; i++)
2592
        if(s->chapters[i]->id == id)
2593
            chapter = s->chapters[i];
2594

    
2595
    if(!chapter){
2596
        chapter= av_mallocz(sizeof(AVChapter));
2597
        if(!chapter)
2598
            return NULL;
2599
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2600
    }
2601
#if FF_API_OLD_METADATA
2602
    av_free(chapter->title);
2603
#endif
2604
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2605
    chapter->id    = id;
2606
    chapter->time_base= time_base;
2607
    chapter->start = start;
2608
    chapter->end   = end;
2609

    
2610
    return chapter;
2611
}
2612

    
2613
/************************************************************/
2614
/* output media file */
2615

    
2616
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2617
{
2618
    int ret;
2619

    
2620
    if (s->oformat->priv_data_size > 0) {
2621
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2622
        if (!s->priv_data)
2623
            return AVERROR(ENOMEM);
2624
    } else
2625
        s->priv_data = NULL;
2626

    
2627
    if (s->oformat->set_parameters) {
2628
        ret = s->oformat->set_parameters(s, ap);
2629
        if (ret < 0)
2630
            return ret;
2631
    }
2632
    return 0;
2633
}
2634

    
2635
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2636
{
2637
    const AVCodecTag *avctag;
2638
    int n;
2639
    enum CodecID id = CODEC_ID_NONE;
2640
    unsigned int tag = 0;
2641

    
2642
    /**
2643
     * Check that tag + id is in the table
2644
     * If neither is in the table -> OK
2645
     * If tag is in the table with another id -> FAIL
2646
     * If id is in the table with another tag -> FAIL unless strict < normal
2647
     */
2648
    for (n = 0; s->oformat->codec_tag[n]; n++) {
2649
        avctag = s->oformat->codec_tag[n];
2650
        while (avctag->id != CODEC_ID_NONE) {
2651
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2652
                id = avctag->id;
2653
                if (id == st->codec->codec_id)
2654
                    return 1;
2655
            }
2656
            if (avctag->id == st->codec->codec_id)
2657
                tag = avctag->tag;
2658
            avctag++;
2659
        }
2660
    }
2661
    if (id != CODEC_ID_NONE)
2662
        return 0;
2663
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2664
        return 0;
2665
    return 1;
2666
}
2667

    
2668
int av_write_header(AVFormatContext *s)
2669
{
2670
    int ret, i;
2671
    AVStream *st;
2672

    
2673
    // some sanity checks
2674
    if (s->nb_streams == 0) {
2675
        av_log(s, AV_LOG_ERROR, "no streams\n");
2676
        return AVERROR(EINVAL);
2677
    }
2678

    
2679
    for(i=0;i<s->nb_streams;i++) {
2680
        st = s->streams[i];
2681

    
2682
        switch (st->codec->codec_type) {
2683
        case AVMEDIA_TYPE_AUDIO:
2684
            if(st->codec->sample_rate<=0){
2685
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2686
                return AVERROR(EINVAL);
2687
            }
2688
            if(!st->codec->block_align)
2689
                st->codec->block_align = st->codec->channels *
2690
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2691
            break;
2692
        case AVMEDIA_TYPE_VIDEO:
2693
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2694
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2695
                return AVERROR(EINVAL);
2696
            }
2697
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2698
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2699
                return AVERROR(EINVAL);
2700
            }
2701
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2702
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2703
                return AVERROR(EINVAL);
2704
            }
2705
            break;
2706
        }
2707

    
2708
        if(s->oformat->codec_tag){
2709
            if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2710
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2711
                st->codec->codec_tag= 0;
2712
            }
2713
            if(st->codec->codec_tag){
2714
                if (!validate_codec_tag(s, st)) {
2715
                    char tagbuf[32];
2716
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2717
                    av_log(s, AV_LOG_ERROR,
2718
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2719
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2720
                    return AVERROR_INVALIDDATA;
2721
                }
2722
            }else
2723
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2724
        }
2725

    
2726
        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2727
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2728
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2729
    }
2730

    
2731
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2732
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2733
        if (!s->priv_data)
2734
            return AVERROR(ENOMEM);
2735
    }
2736

    
2737
#if FF_API_OLD_METADATA
2738
    ff_metadata_mux_compat(s);
2739
#endif
2740

    
2741
    /* set muxer identification string */
2742
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2743
        AVMetadata *m;
2744
        AVMetadataTag *t;
2745

    
2746
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2747
            return AVERROR(ENOMEM);
2748
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2749
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2750
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2751
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2752
        av_metadata_free(&m);
2753
    }
2754

    
2755
    if(s->oformat->write_header){
2756
        ret = s->oformat->write_header(s);
2757
        if (ret < 0)
2758
            return ret;
2759
    }
2760

    
2761
    /* init PTS generation */
2762
    for(i=0;i<s->nb_streams;i++) {
2763
        int64_t den = AV_NOPTS_VALUE;
2764
        st = s->streams[i];
2765

    
2766
        switch (st->codec->codec_type) {
2767
        case AVMEDIA_TYPE_AUDIO:
2768
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2769
            break;
2770
        case AVMEDIA_TYPE_VIDEO:
2771
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2772
            break;
2773
        default:
2774
            break;
2775
        }
2776
        if (den != AV_NOPTS_VALUE) {
2777
            if (den <= 0)
2778
                return AVERROR_INVALIDDATA;
2779
            av_frac_init(&st->pts, 0, 0, den);
2780
        }
2781
    }
2782
    return 0;
2783
}
2784

    
2785
//FIXME merge with compute_pkt_fields
2786
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2787
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2788
    int num, den, frame_size, i;
2789

    
2790
//    av_log(s, 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);
2791

    
2792
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2793
        return -1;*/
2794

    
2795
    /* duration field */
2796
    if (pkt->duration == 0) {
2797
        compute_frame_duration(&num, &den, st, NULL, pkt);
2798
        if (den && num) {
2799
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2800
        }
2801
    }
2802

    
2803
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2804
        pkt->pts= pkt->dts;
2805

    
2806
    //XXX/FIXME this is a temporary hack until all encoders output pts
2807
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2808
        pkt->dts=
2809
//        pkt->pts= st->cur_dts;
2810
        pkt->pts= st->pts.val;
2811
    }
2812

    
2813
    //calculate dts from pts
2814
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2815
        st->pts_buffer[0]= pkt->pts;
2816
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2817
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2818
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2819
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2820

    
2821
        pkt->dts= st->pts_buffer[0];
2822
    }
2823

    
2824
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2825
        av_log(s, AV_LOG_ERROR,
2826
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2827
               st->index, st->cur_dts, pkt->dts);
2828
        return -1;
2829
    }
2830
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2831
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2832
        return -1;
2833
    }
2834

    
2835
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2836
    st->cur_dts= pkt->dts;
2837
    st->pts.val= pkt->dts;
2838

    
2839
    /* update pts */
2840
    switch (st->codec->codec_type) {
2841
    case AVMEDIA_TYPE_AUDIO:
2842
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2843

    
2844
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
2845
           likely equal to the encoder delay, but it would be better if we
2846
           had the real timestamps from the encoder */
2847
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2848
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2849
        }
2850
        break;
2851
    case AVMEDIA_TYPE_VIDEO:
2852
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2853
        break;
2854
    default:
2855
        break;
2856
    }
2857
    return 0;
2858
}
2859

    
2860
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2861
{
2862
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2863

    
2864
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2865
        return ret;
2866

    
2867
    ret= s->oformat->write_packet(s, pkt);
2868
    if(!ret)
2869
        ret= url_ferror(s->pb);
2870
    return ret;
2871
}
2872

    
2873
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2874
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2875
{
2876
    AVPacketList **next_point, *this_pktl;
2877

    
2878
    this_pktl = av_mallocz(sizeof(AVPacketList));
2879
    this_pktl->pkt= *pkt;
2880
    pkt->destruct= NULL;             // do not free original but only the copy
2881
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2882

    
2883
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2884
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2885
    }else
2886
        next_point = &s->packet_buffer;
2887

    
2888
    if(*next_point){
2889
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2890
            while(!compare(s, &(*next_point)->pkt, pkt)){
2891
                next_point= &(*next_point)->next;
2892
            }
2893
            goto next_non_null;
2894
        }else{
2895
            next_point = &(s->packet_buffer_end->next);
2896
        }
2897
    }
2898
    assert(!*next_point);
2899

    
2900
    s->packet_buffer_end= this_pktl;
2901
next_non_null:
2902

    
2903
    this_pktl->next= *next_point;
2904

    
2905
    s->streams[pkt->stream_index]->last_in_packet_buffer=
2906
    *next_point= this_pktl;
2907
}
2908

    
2909
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2910
{
2911
    AVStream *st = s->streams[ pkt ->stream_index];
2912
    AVStream *st2= s->streams[ next->stream_index];
2913
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2914
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2915
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2916
}
2917

    
2918
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2919
    AVPacketList *pktl;
2920
    int stream_count=0;
2921
    int i;
2922

    
2923
    if(pkt){
2924
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2925
    }
2926

    
2927
    for(i=0; i < s->nb_streams; i++)
2928
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
2929

    
2930
    if(stream_count && (s->nb_streams == stream_count || flush)){
2931
        pktl= s->packet_buffer;
2932
        *out= pktl->pkt;
2933

    
2934
        s->packet_buffer= pktl->next;
2935
        if(!s->packet_buffer)
2936
            s->packet_buffer_end= NULL;
2937

    
2938
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2939
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2940
        av_freep(&pktl);
2941
        return 1;
2942
    }else{
2943
        av_init_packet(out);
2944
        return 0;
2945
    }
2946
}
2947

    
2948
/**
2949
 * Interleave an AVPacket correctly so it can be muxed.
2950
 * @param out the interleaved packet will be output here
2951
 * @param in the input packet
2952
 * @param flush 1 if no further packets are available as input and all
2953
 *              remaining packets should be output
2954
 * @return 1 if a packet was output, 0 if no packet could be output,
2955
 *         < 0 if an error occurred
2956
 */
2957
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2958
    if(s->oformat->interleave_packet)
2959
        return s->oformat->interleave_packet(s, out, in, flush);
2960
    else
2961
        return av_interleave_packet_per_dts(s, out, in, flush);
2962
}
2963

    
2964
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2965
    AVStream *st= s->streams[ pkt->stream_index];
2966

    
2967
    //FIXME/XXX/HACK drop zero sized packets
2968
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2969
        return 0;
2970

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

    
2975
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2976
        return -1;
2977

    
2978
    for(;;){
2979
        AVPacket opkt;
2980
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
2981
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
2982
            return ret;
2983

    
2984
        ret= s->oformat->write_packet(s, &opkt);
2985

    
2986
        av_free_packet(&opkt);
2987
        pkt= NULL;
2988

    
2989
        if(ret<0)
2990
            return ret;
2991
        if(url_ferror(s->pb))
2992
            return url_ferror(s->pb);
2993
    }
2994
}
2995

    
2996
int av_write_trailer(AVFormatContext *s)
2997
{
2998
    int ret, i;
2999

    
3000
    for(;;){
3001
        AVPacket pkt;
3002
        ret= av_interleave_packet(s, &pkt, NULL, 1);
3003
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3004
            goto fail;
3005
        if(!ret)
3006
            break;
3007

    
3008
        ret= s->oformat->write_packet(s, &pkt);
3009

    
3010
        av_free_packet(&pkt);
3011

    
3012
        if(ret<0)
3013
            goto fail;
3014
        if(url_ferror(s->pb))
3015
            goto fail;
3016
    }
3017

    
3018
    if(s->oformat->write_trailer)
3019
        ret = s->oformat->write_trailer(s);
3020
fail:
3021
    if(ret == 0)
3022
       ret=url_ferror(s->pb);
3023
    for(i=0;i<s->nb_streams;i++) {
3024
        av_freep(&s->streams[i]->priv_data);
3025
        av_freep(&s->streams[i]->index_entries);
3026
    }
3027
    av_freep(&s->priv_data);
3028
    return ret;
3029
}
3030

    
3031
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3032
{
3033
    int i, j;
3034
    AVProgram *program=NULL;
3035
    void *tmp;
3036

    
3037
    if (idx >= ac->nb_streams) {
3038
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3039
        return;
3040
    }
3041

    
3042
    for(i=0; i<ac->nb_programs; i++){
3043
        if(ac->programs[i]->id != progid)
3044
            continue;
3045
        program = ac->programs[i];
3046
        for(j=0; j<program->nb_stream_indexes; j++)
3047
            if(program->stream_index[j] == idx)
3048
                return;
3049

    
3050
        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3051
        if(!tmp)
3052
            return;
3053
        program->stream_index = tmp;
3054
        program->stream_index[program->nb_stream_indexes++] = idx;
3055
        return;
3056
    }
3057
}
3058

    
3059
static void print_fps(double d, const char *postfix){
3060
    uint64_t v= lrintf(d*100);
3061
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3062
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3063
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3064
}
3065

    
3066
static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3067
{
3068
    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3069
        AVMetadataTag *tag=NULL;
3070

    
3071
        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3072
        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3073
            if(strcmp("language", tag->key))
3074
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3075
        }
3076
    }
3077
}
3078

    
3079
/* "user interface" functions */
3080
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3081
{
3082
    char buf[256];
3083
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3084
    AVStream *st = ic->streams[i];
3085
    int g = av_gcd(st->time_base.num, st->time_base.den);
3086
    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3087
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
3088
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3089
    /* the pid is an important information, so we display it */
3090
    /* XXX: add a generic system */
3091
    if (flags & AVFMT_SHOW_IDS)
3092
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3093
    if (lang)
3094
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3095
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3096
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3097
    if (st->sample_aspect_ratio.num && // default
3098
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3099
        AVRational display_aspect_ratio;
3100
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3101
                  st->codec->width*st->sample_aspect_ratio.num,
3102
                  st->codec->height*st->sample_aspect_ratio.den,
3103
                  1024*1024);
3104
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3105
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3106
                 display_aspect_ratio.num, display_aspect_ratio.den);
3107
    }
3108
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3109
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3110
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3111
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3112
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3113
        if(st->time_base.den && st->time_base.num)
3114
            print_fps(1/av_q2d(st->time_base), "tbn");
3115
        if(st->codec->time_base.den && st->codec->time_base.num)
3116
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3117
    }
3118
    av_log(NULL, AV_LOG_INFO, "\n");
3119
    dump_metadata(NULL, st->metadata, "    ");
3120
}
3121

    
3122
void dump_format(AVFormatContext *ic,
3123
                 int index,
3124
                 const char *url,
3125
                 int is_output)
3126
{
3127
    int i;
3128
    uint8_t *printed = av_mallocz(ic->nb_streams);
3129
    if (ic->nb_streams && !printed)
3130
        return;
3131

    
3132
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3133
            is_output ? "Output" : "Input",
3134
            index,
3135
            is_output ? ic->oformat->name : ic->iformat->name,
3136
            is_output ? "to" : "from", url);
3137
    dump_metadata(NULL, ic->metadata, "  ");
3138
    if (!is_output) {
3139
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3140
        if (ic->duration != AV_NOPTS_VALUE) {
3141
            int hours, mins, secs, us;
3142
            secs = ic->duration / AV_TIME_BASE;
3143
            us = ic->duration % AV_TIME_BASE;
3144
            mins = secs / 60;
3145
            secs %= 60;
3146
            hours = mins / 60;
3147
            mins %= 60;
3148
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3149
                   (100 * us) / AV_TIME_BASE);
3150
        } else {
3151
            av_log(NULL, AV_LOG_INFO, "N/A");
3152
        }
3153
        if (ic->start_time != AV_NOPTS_VALUE) {
3154
            int secs, us;
3155
            av_log(NULL, AV_LOG_INFO, ", start: ");
3156
            secs = ic->start_time / AV_TIME_BASE;
3157
            us = abs(ic->start_time % AV_TIME_BASE);
3158
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3159
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3160
        }
3161
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3162
        if (ic->bit_rate) {
3163
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3164
        } else {
3165
            av_log(NULL, AV_LOG_INFO, "N/A");
3166
        }
3167
        av_log(NULL, AV_LOG_INFO, "\n");
3168
    }
3169
    for (i = 0; i < ic->nb_chapters; i++) {
3170
        AVChapter *ch = ic->chapters[i];
3171
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3172
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3173
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3174

    
3175
        dump_metadata(NULL, ch->metadata, "    ");
3176
    }
3177
    if(ic->nb_programs) {
3178
        int j, k, total = 0;
3179
        for(j=0; j<ic->nb_programs; j++) {
3180
            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3181
                                                  "name", NULL, 0);
3182
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3183
                   name ? name->value : "");
3184
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3185
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3186
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3187
                printed[ic->programs[j]->stream_index[k]] = 1;
3188
            }
3189
            total += ic->programs[j]->nb_stream_indexes;
3190
        }
3191
        if (total < ic->nb_streams)
3192
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
3193
    }
3194
    for(i=0;i<ic->nb_streams;i++)
3195
        if (!printed[i])
3196
            dump_stream_format(ic, i, index, is_output);
3197

    
3198
    av_free(printed);
3199
}
3200

    
3201
#if LIBAVFORMAT_VERSION_MAJOR < 53
3202
#include "libavcore/parseutils.h"
3203

    
3204
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3205
{
3206
    return av_parse_video_size(width_ptr, height_ptr, str);
3207
}
3208

    
3209
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3210
{
3211
    AVRational frame_rate;
3212
    int ret = av_parse_video_rate(&frame_rate, arg);
3213
    *frame_rate_num= frame_rate.num;
3214
    *frame_rate_den= frame_rate.den;
3215
    return ret;
3216
}
3217
#endif
3218

    
3219
int64_t av_gettime(void)
3220
{
3221
    struct timeval tv;
3222
    gettimeofday(&tv,NULL);
3223
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3224
}
3225

    
3226
uint64_t ff_ntp_time(void)
3227
{
3228
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3229
}
3230

    
3231
int64_t parse_date(const char *datestr, int duration)
3232
{
3233
    const char *p;
3234
    int64_t t;
3235
    struct tm dt;
3236
    int i;
3237
    static const char * const date_fmt[] = {
3238
        "%Y-%m-%d",
3239
        "%Y%m%d",
3240
    };
3241
    static const char * const time_fmt[] = {
3242
        "%H:%M:%S",
3243
        "%H%M%S",
3244
    };
3245
    const char *q;
3246
    int is_utc, len;
3247
    char lastch;
3248
    int negative = 0;
3249

    
3250
#undef time
3251
    time_t now = time(0);
3252

    
3253
    len = strlen(datestr);
3254
    if (len > 0)
3255
        lastch = datestr[len - 1];
3256
    else
3257
        lastch = '\0';
3258
    is_utc = (lastch == 'z' || lastch == 'Z');
3259

    
3260
    memset(&dt, 0, sizeof(dt));
3261

    
3262
    p = datestr;
3263
    q = NULL;
3264
    if (!duration) {
3265
        if (!strncasecmp(datestr, "now", len))
3266
            return (int64_t) now * 1000000;
3267

    
3268
        /* parse the year-month-day part */
3269
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3270
            q = small_strptime(p, date_fmt[i], &dt);
3271
            if (q) {
3272
                break;
3273
            }
3274
        }
3275

    
3276
        /* if the year-month-day part is missing, then take the
3277
         * current year-month-day time */
3278
        if (!q) {
3279
            if (is_utc) {
3280
                dt = *gmtime(&now);
3281
            } else {
3282
                dt = *localtime(&now);
3283
            }
3284
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3285
        } else {
3286
            p = q;
3287
        }
3288

    
3289
        if (*p == 'T' || *p == 't' || *p == ' ')
3290
            p++;
3291

    
3292
        /* parse the hour-minute-second part */
3293
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3294
            q = small_strptime(p, time_fmt[i], &dt);
3295
            if (q) {
3296
                break;
3297
            }
3298
        }
3299
    } else {
3300
        /* parse datestr as a duration */
3301
        if (p[0] == '-') {
3302
            negative = 1;
3303
            ++p;
3304
        }
3305
        /* parse datestr as HH:MM:SS */
3306
        q = small_strptime(p, time_fmt[0], &dt);
3307
        if (!q) {
3308
            /* parse datestr as S+ */
3309
            dt.tm_sec = strtol(p, (char **)&q, 10);
3310
            if (q == p)
3311
                /* the parsing didn't succeed */
3312
                return INT64_MIN;
3313
            dt.tm_min = 0;
3314
            dt.tm_hour = 0;
3315
        }
3316
    }
3317

    
3318
    /* Now we have all the fields that we can get */
3319
    if (!q) {
3320
        return INT64_MIN;
3321
    }
3322

    
3323
    if (duration) {
3324
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3325
    } else {
3326
        dt.tm_isdst = -1;       /* unknown */
3327
        if (is_utc) {
3328
            t = mktimegm(&dt);
3329
        } else {
3330
            t = mktime(&dt);
3331
        }
3332
    }
3333

    
3334
    t *= 1000000;
3335

    
3336
    /* parse the .m... part */
3337
    if (*q == '.') {
3338
        int val, n;
3339
        q++;
3340
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3341
            if (!isdigit(*q))
3342
                break;
3343
            val += n * (*q - '0');
3344
        }
3345
        t += val;
3346
    }
3347
    return negative ? -t : t;
3348
}
3349

    
3350
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3351
{
3352
    const char *p;
3353
    char tag[128], *q;
3354

    
3355
    p = info;
3356
    if (*p == '?')
3357
        p++;
3358
    for(;;) {
3359
        q = tag;
3360
        while (*p != '\0' && *p != '=' && *p != '&') {
3361
            if ((q - tag) < sizeof(tag) - 1)
3362
                *q++ = *p;
3363
            p++;
3364
        }
3365
        *q = '\0';
3366
        q = arg;
3367
        if (*p == '=') {
3368
            p++;
3369
            while (*p != '&' && *p != '\0') {
3370
                if ((q - arg) < arg_size - 1) {
3371
                    if (*p == '+')
3372
                        *q++ = ' ';
3373
                    else
3374
                        *q++ = *p;
3375
                }
3376
                p++;
3377
            }
3378
        }
3379
        *q = '\0';
3380
        if (!strcmp(tag, tag1))
3381
            return 1;
3382
        if (*p != '&')
3383
            break;
3384
        p++;
3385
    }
3386
    return 0;
3387
}
3388

    
3389
int av_get_frame_filename(char *buf, int buf_size,
3390
                          const char *path, int number)
3391
{
3392
    const char *p;
3393
    char *q, buf1[20], c;
3394
    int nd, len, percentd_found;
3395

    
3396
    q = buf;
3397
    p = path;
3398
    percentd_found = 0;
3399
    for(;;) {
3400
        c = *p++;
3401
        if (c == '\0')
3402
            break;
3403
        if (c == '%') {
3404
            do {
3405
                nd = 0;
3406
                while (isdigit(*p)) {
3407
                    nd = nd * 10 + *p++ - '0';
3408
                }
3409
                c = *p++;
3410
            } while (isdigit(c));
3411

    
3412
            switch(c) {
3413
            case '%':
3414
                goto addchar;
3415
            case 'd':
3416
                if (percentd_found)
3417
                    goto fail;
3418
                percentd_found = 1;
3419
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3420
                len = strlen(buf1);
3421
                if ((q - buf + len) > buf_size - 1)
3422
                    goto fail;
3423
                memcpy(q, buf1, len);
3424
                q += len;
3425
                break;
3426
            default:
3427
                goto fail;
3428
            }
3429
        } else {
3430
        addchar:
3431
            if ((q - buf) < buf_size - 1)
3432
                *q++ = c;
3433
        }
3434
    }
3435
    if (!percentd_found)
3436
        goto fail;
3437
    *q = '\0';
3438
    return 0;
3439
 fail:
3440
    *q = '\0';
3441
    return -1;
3442
}
3443

    
3444
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3445
{
3446
    int len, i, j, c;
3447
#undef fprintf
3448
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3449

    
3450
    for(i=0;i<size;i+=16) {
3451
        len = size - i;
3452
        if (len > 16)
3453
            len = 16;
3454
        PRINT("%08x ", i);
3455
        for(j=0;j<16;j++) {
3456
            if (j < len)
3457
                PRINT(" %02x", buf[i+j]);
3458
            else
3459
                PRINT("   ");
3460
        }
3461
        PRINT(" ");
3462
        for(j=0;j<len;j++) {
3463
            c = buf[i+j];
3464
            if (c < ' ' || c > '~')
3465
                c = '.';
3466
            PRINT("%c", c);
3467
        }
3468
        PRINT("\n");
3469
    }
3470
#undef PRINT
3471
}
3472

    
3473
void av_hex_dump(FILE *f, uint8_t *buf, int size)
3474
{
3475
    hex_dump_internal(NULL, f, 0, buf, size);
3476
}
3477

    
3478
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3479
{
3480
    hex_dump_internal(avcl, NULL, level, buf, size);
3481
}
3482

    
3483
 //FIXME needs to know the time_base
3484
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3485
{
3486
#undef fprintf
3487
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3488
    PRINT("stream #%d:\n", pkt->stream_index);
3489
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3490
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3491
    /* DTS is _always_ valid after av_read_frame() */
3492
    PRINT("  dts=");
3493
    if (pkt->dts == AV_NOPTS_VALUE)
3494
        PRINT("N/A");
3495
    else
3496
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3497
    /* PTS may not be known if B-frames are present. */
3498
    PRINT("  pts=");
3499
    if (pkt->pts == AV_NOPTS_VALUE)
3500
        PRINT("N/A");
3501
    else
3502
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3503
    PRINT("\n");
3504
    PRINT("  size=%d\n", pkt->size);
3505
#undef PRINT
3506
    if (dump_payload)
3507
        av_hex_dump(f, pkt->data, pkt->size);
3508
}
3509

    
3510
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3511
{
3512
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3513
}
3514

    
3515
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3516
{
3517
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3518
}
3519

    
3520
#if LIBAVFORMAT_VERSION_MAJOR < 53
3521
attribute_deprecated
3522
void ff_url_split(char *proto, int proto_size,
3523
                  char *authorization, int authorization_size,
3524
                  char *hostname, int hostname_size,
3525
                  int *port_ptr,
3526
                  char *path, int path_size,
3527
                  const char *url)
3528
{
3529
    av_url_split(proto, proto_size,
3530
                 authorization, authorization_size,
3531
                 hostname, hostname_size,
3532
                 port_ptr,
3533
                 path, path_size,
3534
                 url);
3535
}
3536
#endif
3537

    
3538
void av_url_split(char *proto, int proto_size,
3539
                  char *authorization, int authorization_size,
3540
                  char *hostname, int hostname_size,
3541
                  int *port_ptr,
3542
                  char *path, int path_size,
3543
                  const char *url)
3544
{
3545
    const char *p, *ls, *at, *col, *brk;
3546

    
3547
    if (port_ptr)               *port_ptr = -1;
3548
    if (proto_size > 0)         proto[0] = 0;
3549
    if (authorization_size > 0) authorization[0] = 0;
3550
    if (hostname_size > 0)      hostname[0] = 0;
3551
    if (path_size > 0)          path[0] = 0;
3552

    
3553
    /* parse protocol */
3554
    if ((p = strchr(url, ':'))) {
3555
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3556
        p++; /* skip ':' */
3557
        if (*p == '/') p++;
3558
        if (*p == '/') p++;
3559
    } else {
3560
        /* no protocol means plain filename */
3561
        av_strlcpy(path, url, path_size);
3562
        return;
3563
    }
3564

    
3565
    /* separate path from hostname */
3566
    ls = strchr(p, '/');
3567
    if(!ls)
3568
        ls = strchr(p, '?');
3569
    if(ls)
3570
        av_strlcpy(path, ls, path_size);
3571
    else
3572
        ls = &p[strlen(p)]; // XXX
3573

    
3574
    /* the rest is hostname, use that to parse auth/port */
3575
    if (ls != p) {
3576
        /* authorization (user[:pass]@hostname) */
3577
        if ((at = strchr(p, '@')) && at < ls) {
3578
            av_strlcpy(authorization, p,
3579
                       FFMIN(authorization_size, at + 1 - p));
3580
            p = at + 1; /* skip '@' */
3581
        }
3582

    
3583
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3584
            /* [host]:port */
3585
            av_strlcpy(hostname, p + 1,
3586
                       FFMIN(hostname_size, brk - p));
3587
            if (brk[1] == ':' && port_ptr)
3588
                *port_ptr = atoi(brk + 2);
3589
        } else if ((col = strchr(p, ':')) && col < ls) {
3590
            av_strlcpy(hostname, p,
3591
                       FFMIN(col + 1 - p, hostname_size));
3592
            if (port_ptr) *port_ptr = atoi(col + 1);
3593
        } else
3594
            av_strlcpy(hostname, p,
3595
                       FFMIN(ls + 1 - p, hostname_size));
3596
    }
3597
}
3598

    
3599
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3600
{
3601
    int i;
3602
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
3603
                                           '4', '5', '6', '7',
3604
                                           '8', '9', 'A', 'B',
3605
                                           'C', 'D', 'E', 'F' };
3606
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
3607
                                           '4', '5', '6', '7',
3608
                                           '8', '9', 'a', 'b',
3609
                                           'c', 'd', 'e', 'f' };
3610
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3611

    
3612
    for(i = 0; i < s; i++) {
3613
        buff[i * 2]     = hex_table[src[i] >> 4];
3614
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3615
    }
3616

    
3617
    return buff;
3618
}
3619

    
3620
int ff_hex_to_data(uint8_t *data, const char *p)
3621
{
3622
    int c, len, v;
3623

    
3624
    len = 0;
3625
    v = 1;
3626
    for (;;) {
3627
        p += strspn(p, SPACE_CHARS);
3628
        if (*p == '\0')
3629
            break;
3630
        c = toupper((unsigned char) *p++);
3631
        if (c >= '0' && c <= '9')
3632
            c = c - '0';
3633
        else if (c >= 'A' && c <= 'F')
3634
            c = c - 'A' + 10;
3635
        else
3636
            break;
3637
        v = (v << 4) | c;
3638
        if (v & 0x100) {
3639
            if (data)
3640
                data[len] = v;
3641
            len++;
3642
            v = 1;
3643
        }
3644
    }
3645
    return len;
3646
}
3647

    
3648
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3649
                     unsigned int pts_num, unsigned int pts_den)
3650
{
3651
    s->pts_wrap_bits = pts_wrap_bits;
3652

    
3653
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3654
        if(s->time_base.num != pts_num)
3655
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3656
    }else
3657
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3658

    
3659
    if(!s->time_base.num || !s->time_base.den)
3660
        s->time_base.num= s->time_base.den= 0;
3661
}
3662

    
3663
int ff_url_join(char *str, int size, const char *proto,
3664
                const char *authorization, const char *hostname,
3665
                int port, const char *fmt, ...)
3666
{
3667
#if CONFIG_NETWORK
3668
    struct addrinfo hints, *ai;
3669
#endif
3670

    
3671
    str[0] = '\0';
3672
    if (proto)
3673
        av_strlcatf(str, size, "%s://", proto);
3674
    if (authorization && authorization[0])
3675
        av_strlcatf(str, size, "%s@", authorization);
3676
#if CONFIG_NETWORK && defined(AF_INET6)
3677
    /* Determine if hostname is a numerical IPv6 address,
3678
     * properly escape it within [] in that case. */
3679
    memset(&hints, 0, sizeof(hints));
3680
    hints.ai_flags = AI_NUMERICHOST;
3681
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3682
        if (ai->ai_family == AF_INET6) {
3683
            av_strlcat(str, "[", size);
3684
            av_strlcat(str, hostname, size);
3685
            av_strlcat(str, "]", size);
3686
        } else {
3687
            av_strlcat(str, hostname, size);
3688
        }
3689
        freeaddrinfo(ai);
3690
    } else
3691
#endif
3692
        /* Not an IPv6 address, just output the plain string. */
3693
        av_strlcat(str, hostname, size);
3694

    
3695
    if (port >= 0)
3696
        av_strlcatf(str, size, ":%d", port);
3697
    if (fmt) {
3698
        va_list vl;
3699
        int len = strlen(str);
3700

    
3701
        va_start(vl, fmt);
3702
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3703
        va_end(vl);
3704
    }
3705
    return strlen(str);
3706
}
3707

    
3708
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3709
                     AVFormatContext *src)
3710
{
3711
    AVPacket local_pkt;
3712

    
3713
    local_pkt = *pkt;
3714
    local_pkt.stream_index = dst_stream;
3715
    if (pkt->pts != AV_NOPTS_VALUE)
3716
        local_pkt.pts = av_rescale_q(pkt->pts,
3717
                                     src->streams[pkt->stream_index]->time_base,
3718
                                     dst->streams[dst_stream]->time_base);
3719
    if (pkt->dts != AV_NOPTS_VALUE)
3720
        local_pkt.dts = av_rescale_q(pkt->dts,
3721
                                     src->streams[pkt->stream_index]->time_base,
3722
                                     dst->streams[dst_stream]->time_base);
3723
    return av_write_frame(dst, &local_pkt);
3724
}
3725

    
3726
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3727
                        void *context)
3728
{
3729
    const char *ptr = str;
3730

    
3731
    /* Parse key=value pairs. */
3732
    for (;;) {
3733
        const char *key;
3734
        char *dest = NULL, *dest_end;
3735
        int key_len, dest_len = 0;
3736

    
3737
        /* Skip whitespace and potential commas. */
3738
        while (*ptr && (isspace(*ptr) || *ptr == ','))
3739
            ptr++;
3740
        if (!*ptr)
3741
            break;
3742

    
3743
        key = ptr;
3744

    
3745
        if (!(ptr = strchr(key, '=')))
3746
            break;
3747
        ptr++;
3748
        key_len = ptr - key;
3749

    
3750
        callback_get_buf(context, key, key_len, &dest, &dest_len);
3751
        dest_end = dest + dest_len - 1;
3752

    
3753
        if (*ptr == '\"') {
3754
            ptr++;
3755
            while (*ptr && *ptr != '\"') {
3756
                if (*ptr == '\\') {
3757
                    if (!ptr[1])
3758
                        break;
3759
                    if (dest && dest < dest_end)
3760
                        *dest++ = ptr[1];
3761
                    ptr += 2;
3762
                } else {
3763
                    if (dest && dest < dest_end)
3764
                        *dest++ = *ptr;
3765
                    ptr++;
3766
                }
3767
            }
3768
            if (*ptr == '\"')
3769
                ptr++;
3770
        } else {
3771
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3772
                if (dest && dest < dest_end)
3773
                    *dest++ = *ptr;
3774
        }
3775
        if (dest)
3776
            *dest = 0;
3777
    }
3778
}
3779