← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libav/trusty

« back to all changes in this revision

Viewing changes to libavformat/utils.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-04-19 15:04:55 UTC
  • mfrom: (1.2.1 upstream)
  • mto: (1.3.4 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20110419150455-c1nac6gjm3t2aa4n
Tags: 4:0.7~b1-1
* New upstream version
* bump SONAME and SHLIBS
* configure flags --disable-stripping was removed upstream
* the MAINTAINERS file was removed upstream
* remove patch disable-configuration-warning.patch
* drop avfilter confflags, it is enable by default in 0.7
* libfaad wrapper has been removed upstream
* also update the *contents* of the lintian overrides

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavformat/utils.c
1
1
/*
2
 
 * various utility functions for use within FFmpeg
 
2
 * various utility functions for use within Libav
3
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
4
 *
5
 
 * This file is part of FFmpeg.
 
5
 * This file is part of Libav.
6
6
 *
7
 
 * FFmpeg is free software; you can redistribute it and/or
 
7
 * Libav is free software; you can redistribute it and/or
8
8
 * modify it under the terms of the GNU Lesser General Public
9
9
 * License as published by the Free Software Foundation; either
10
10
 * version 2.1 of the License, or (at your option) any later version.
11
11
 *
12
 
 * FFmpeg is distributed in the hope that it will be useful,
 
12
 * Libav is distributed in the hope that it will be useful,
13
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
15
 * Lesser General Public License for more details.
16
16
 *
17
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
 
18
 * License along with Libav; if not, write to the Free Software
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
20
 */
 
21
 
 
22
/* #define DEBUG */
 
23
 
21
24
#include "avformat.h"
 
25
#include "avio_internal.h"
22
26
#include "internal.h"
23
 
#include "libavcodec/opt.h"
 
27
#include "libavcodec/internal.h"
 
28
#include "libavutil/opt.h"
24
29
#include "metadata.h"
 
30
#include "id3v2.h"
25
31
#include "libavutil/avstring.h"
26
32
#include "riff.h"
27
33
#include "audiointerleave.h"
 
34
#include "url.h"
28
35
#include <sys/time.h>
29
36
#include <time.h>
30
37
#include <strings.h>
38
45
 
39
46
/**
40
47
 * @file
41
 
 * various utility functions for use within FFmpeg
 
48
 * various utility functions for use within Libav
42
49
 */
43
50
 
44
51
unsigned avformat_version(void)
48
55
 
49
56
const char *avformat_configuration(void)
50
57
{
51
 
    return FFMPEG_CONFIGURATION;
 
58
    return LIBAV_CONFIGURATION;
52
59
}
53
60
 
54
61
const char *avformat_license(void)
55
62
{
56
63
#define LICENSE_PREFIX "libavformat license: "
57
 
    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 
64
    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
58
65
}
59
66
 
60
67
/* fraction handling */
108
115
}
109
116
 
110
117
/** head of registered input format linked list */
 
118
#if !FF_API_FIRST_FORMAT
 
119
static
 
120
#endif
111
121
AVInputFormat *first_iformat = NULL;
112
122
/** head of registered output format linked list */
 
123
#if !FF_API_FIRST_FORMAT
 
124
static
 
125
#endif
113
126
AVOutputFormat *first_oformat = NULL;
114
127
 
115
128
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
187
200
    return !strcasecmp(name, names);
188
201
}
189
202
 
190
 
#if LIBAVFORMAT_VERSION_MAJOR < 53
 
203
#if FF_API_GUESS_FORMAT
191
204
AVOutputFormat *guess_format(const char *short_name, const char *filename,
192
205
                             const char *mime_type)
193
206
{
198
211
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
199
212
                                const char *mime_type)
200
213
{
201
 
    AVOutputFormat *fmt, *fmt_found;
 
214
    AVOutputFormat *fmt = NULL, *fmt_found;
202
215
    int score_max, score;
203
216
 
204
217
    /* specific test for image sequences */
205
218
#if CONFIG_IMAGE2_MUXER
206
219
    if (!short_name && filename &&
207
220
        av_filename_number_test(filename) &&
208
 
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
 
221
        ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
209
222
        return av_guess_format("image2", NULL, NULL);
210
223
    }
211
224
#endif
212
225
    /* Find the proper file type. */
213
226
    fmt_found = NULL;
214
227
    score_max = 0;
215
 
    fmt = first_oformat;
216
 
    while (fmt != NULL) {
 
228
    while ((fmt = av_oformat_next(fmt))) {
217
229
        score = 0;
218
230
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
219
231
            score += 100;
227
239
            score_max = score;
228
240
            fmt_found = fmt;
229
241
        }
230
 
        fmt = fmt->next;
231
242
    }
232
243
    return fmt_found;
233
244
}
234
245
 
235
 
#if LIBAVFORMAT_VERSION_MAJOR < 53
 
246
#if FF_API_GUESS_FORMAT
236
247
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
237
248
                             const char *mime_type)
238
249
{
260
271
 
261
272
#if CONFIG_IMAGE2_MUXER
262
273
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
263
 
            codec_id= av_guess_image2_codec(filename);
 
274
            codec_id= ff_guess_image2_codec(filename);
264
275
        }
265
276
#endif
266
277
        if(codec_id == CODEC_ID_NONE)
268
279
        return codec_id;
269
280
    }else if(type == AVMEDIA_TYPE_AUDIO)
270
281
        return fmt->audio_codec;
 
282
    else if (type == AVMEDIA_TYPE_SUBTITLE)
 
283
        return fmt->subtitle_codec;
271
284
    else
272
285
        return CODEC_ID_NONE;
273
286
}
274
287
 
275
288
AVInputFormat *av_find_input_format(const char *short_name)
276
289
{
277
 
    AVInputFormat *fmt;
278
 
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
 
290
    AVInputFormat *fmt = NULL;
 
291
    while ((fmt = av_iformat_next(fmt))) {
279
292
        if (match_format(short_name, fmt->name))
280
293
            return fmt;
281
294
    }
282
295
    return NULL;
283
296
}
284
297
 
285
 
#if LIBAVFORMAT_VERSION_MAJOR < 53 && CONFIG_SHARED && HAVE_SYMVER
 
298
#if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
286
299
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
287
300
{
288
301
    av_destruct_packet_nofree(pkt);
315
328
}
316
329
#endif
317
330
 
318
 
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
 
331
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
319
332
{
320
333
    int ret= av_new_packet(pkt, size);
321
334
 
322
335
    if(ret<0)
323
336
        return ret;
324
337
 
325
 
    pkt->pos= url_ftell(s);
 
338
    pkt->pos= avio_tell(s);
326
339
 
327
 
    ret= get_buffer(s, pkt->data, size);
 
340
    ret= avio_read(s, pkt->data, size);
328
341
    if(ret<=0)
329
342
        av_free_packet(pkt);
330
343
    else
333
346
    return ret;
334
347
}
335
348
 
 
349
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
 
350
{
 
351
    int ret;
 
352
    int old_size;
 
353
    if (!pkt->size)
 
354
        return av_get_packet(s, pkt, size);
 
355
    old_size = pkt->size;
 
356
    ret = av_grow_packet(pkt, size);
 
357
    if (ret < 0)
 
358
        return ret;
 
359
    ret = avio_read(s, pkt->data + old_size, size);
 
360
    av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
 
361
    return ret;
 
362
}
 
363
 
336
364
 
337
365
int av_filename_number_test(const char *filename)
338
366
{
342
370
 
343
371
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
344
372
{
345
 
    AVInputFormat *fmt1, *fmt;
346
 
    int score;
 
373
    AVProbeData lpd = *pd;
 
374
    AVInputFormat *fmt1 = NULL, *fmt;
 
375
    int score, id3 = 0;
 
376
 
 
377
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
 
378
        int id3len = ff_id3v2_tag_len(lpd.buf);
 
379
        if (lpd.buf_size > id3len + 16) {
 
380
            lpd.buf += id3len;
 
381
            lpd.buf_size -= id3len;
 
382
        }
 
383
        id3 = 1;
 
384
    }
347
385
 
348
386
    fmt = NULL;
349
 
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
 
387
    while ((fmt1 = av_iformat_next(fmt1))) {
350
388
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
351
389
            continue;
352
390
        score = 0;
353
391
        if (fmt1->read_probe) {
354
 
            score = fmt1->read_probe(pd);
 
392
            score = fmt1->read_probe(&lpd);
355
393
        } else if (fmt1->extensions) {
356
 
            if (av_match_ext(pd->filename, fmt1->extensions)) {
 
394
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
357
395
                score = 50;
358
396
            }
359
397
        }
363
401
        }else if (score == *score_max)
364
402
            fmt = NULL;
365
403
    }
 
404
 
 
405
    /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
 
406
    if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4) {
 
407
        while ((fmt = av_iformat_next(fmt)))
 
408
            if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
 
409
                *score_max = AVPROBE_SCORE_MAX/4;
 
410
                break;
 
411
            }
 
412
    }
 
413
 
366
414
    return fmt;
367
415
}
368
416
 
373
421
 
374
422
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
375
423
{
376
 
    AVInputFormat *fmt;
377
 
    fmt = av_probe_input_format2(pd, 1, &score);
 
424
    static const struct {
 
425
        const char *name; enum CodecID id; enum AVMediaType type;
 
426
    } fmt_id_type[] = {
 
427
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
 
428
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
 
429
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
 
430
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
 
431
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
 
432
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
 
433
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
 
434
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
 
435
        { 0 }
 
436
    };
 
437
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
378
438
 
379
439
    if (fmt) {
 
440
        int i;
380
441
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
381
442
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
382
 
        if (!strcmp(fmt->name, "mp3")) {
383
 
            st->codec->codec_id = CODEC_ID_MP3;
384
 
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
385
 
        } else if (!strcmp(fmt->name, "ac3")) {
386
 
            st->codec->codec_id = CODEC_ID_AC3;
387
 
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
388
 
        } else if (!strcmp(fmt->name, "eac3")) {
389
 
            st->codec->codec_id = CODEC_ID_EAC3;
390
 
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
391
 
        } else if (!strcmp(fmt->name, "mpegvideo")) {
392
 
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
393
 
            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
394
 
        } else if (!strcmp(fmt->name, "m4v")) {
395
 
            st->codec->codec_id = CODEC_ID_MPEG4;
396
 
            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
397
 
        } else if (!strcmp(fmt->name, "h264")) {
398
 
            st->codec->codec_id = CODEC_ID_H264;
399
 
            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
400
 
        } else if (!strcmp(fmt->name, "dts")) {
401
 
            st->codec->codec_id = CODEC_ID_DTS;
402
 
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
403
 
        } else if (!strcmp(fmt->name, "aac")) {
404
 
            st->codec->codec_id = CODEC_ID_AAC;
405
 
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
 
443
        for (i = 0; fmt_id_type[i].name; i++) {
 
444
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
 
445
                st->codec->codec_id   = fmt_id_type[i].id;
 
446
                st->codec->codec_type = fmt_id_type[i].type;
 
447
                break;
 
448
            }
406
449
        }
407
450
    }
408
451
    return !!fmt;
415
458
 * Open a media file from an IO stream. 'fmt' must be specified.
416
459
 */
417
460
int av_open_input_stream(AVFormatContext **ic_ptr,
418
 
                         ByteIOContext *pb, const char *filename,
 
461
                         AVIOContext *pb, const char *filename,
419
462
                         AVInputFormat *fmt, AVFormatParameters *ap)
420
463
{
421
464
    int err;
452
495
        ic->priv_data = NULL;
453
496
    }
454
497
 
 
498
    // e.g. AVFMT_NOFILE formats will not have a AVIOContext
 
499
    if (ic->pb)
 
500
        ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
 
501
 
455
502
    if (ic->iformat->read_header) {
456
503
        err = ic->iformat->read_header(ic, ap);
457
504
        if (err < 0)
459
506
    }
460
507
 
461
508
    if (pb && !ic->data_offset)
462
 
        ic->data_offset = url_ftell(ic->pb);
 
509
        ic->data_offset = avio_tell(ic->pb);
463
510
 
464
 
#if LIBAVFORMAT_VERSION_MAJOR < 53
 
511
#if FF_API_OLD_METADATA
465
512
    ff_metadata_demux_compat(ic);
466
513
#endif
467
514
 
478
525
            if (st) {
479
526
                av_free(st->priv_data);
480
527
                av_free(st->codec->extradata);
 
528
                av_free(st->codec);
 
529
                av_free(st->info);
481
530
            }
482
531
            av_free(st);
483
532
        }
491
540
#define PROBE_BUF_MIN 2048
492
541
#define PROBE_BUF_MAX (1<<20)
493
542
 
494
 
int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
 
543
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
495
544
                          const char *filename, void *logctx,
496
545
                          unsigned int offset, unsigned int max_probe_size)
497
546
{
522
571
 
523
572
        /* read probe data */
524
573
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
525
 
        if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
 
574
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
526
575
            /* fail if error was not end of file, otherwise, lower score */
527
576
            if (ret != AVERROR_EOF) {
528
577
                av_free(buf);
552
601
    }
553
602
 
554
603
    /* rewind. reuse probe buffer to avoid seeking */
555
 
    if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
 
604
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
556
605
        av_free(buf);
557
606
 
558
607
    return ret;
565
614
{
566
615
    int err;
567
616
    AVProbeData probe_data, *pd = &probe_data;
568
 
    ByteIOContext *pb = NULL;
 
617
    AVIOContext *pb = NULL;
569
618
    void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
570
619
 
571
620
    pd->filename = "";
583
632
       hack needed to handle RTSP/TCP */
584
633
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
585
634
        /* if no file needed do not try to open one */
586
 
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
 
635
        if ((err=avio_open(&pb, filename, AVIO_RDONLY)) < 0) {
587
636
            goto fail;
588
637
        }
589
638
        if (buf_size > 0) {
590
 
            url_setbufsize(pb, buf_size);
 
639
            ffio_set_buf_size(pb, buf_size);
591
640
        }
592
 
        if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
 
641
        if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
593
642
            goto fail;
594
643
        }
595
644
    }
614
663
 fail:
615
664
    av_freep(&pd->buf);
616
665
    if (pb)
617
 
        url_fclose(pb);
 
666
        avio_close(pb);
618
667
    if (ap && ap->prealloced_context)
619
668
        av_free(*ic_ptr);
620
669
    *ic_ptr = NULL;
779
828
        break;
780
829
    case AVMEDIA_TYPE_AUDIO:
781
830
        frame_size = get_audio_frame_size(st->codec, pkt->size);
782
 
        if (frame_size < 0)
 
831
        if (frame_size <= 0 || st->codec->sample_rate <= 0)
783
832
            break;
784
833
        *pnum = frame_size;
785
834
        *pden = st->codec->sample_rate;
897
946
    /* do we have a video B-frame ? */
898
947
    delay= st->codec->has_b_frames;
899
948
    presentation_delayed = 0;
 
949
 
 
950
    // ignore delay caused by frame threading so that the mpeg2-without-dts
 
951
    // warning will not trigger
 
952
    if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
 
953
        delay -= st->codec->thread_count-1;
 
954
 
900
955
    /* XXX: need has_b_frame, but cannot get it if the codec is
901
956
        not initialized */
902
957
    if (delay &&
912
967
    // we take the conservative approach and discard both
913
968
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
914
969
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
915
 
        av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
 
970
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
916
971
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
917
972
    }
918
973
 
1078
1133
                    pkt->pts = st->parser->pts;
1079
1134
                    pkt->dts = st->parser->dts;
1080
1135
                    pkt->pos = st->parser->pos;
 
1136
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
 
1137
                        s->cur_st = NULL;
 
1138
                        pkt->destruct= st->cur_pkt.destruct;
 
1139
                        st->cur_pkt.destruct= NULL;
 
1140
                        st->cur_pkt.data    = NULL;
 
1141
                        assert(st->cur_len == 0);
 
1142
                    }else{
1081
1143
                    pkt->destruct = NULL;
 
1144
                    }
1082
1145
                    compute_pkt_fields(s, st, st->parser, pkt);
1083
1146
 
1084
1147
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1151
1214
                    st->need_parsing = AVSTREAM_PARSE_NONE;
1152
1215
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1153
1216
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1154
 
                }
1155
 
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1156
 
                    st->parser->next_frame_offset=
1157
 
                    st->parser->cur_offset= st->cur_pkt.pos;
 
1217
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
 
1218
                    st->parser->flags |= PARSER_FLAG_ONCE;
1158
1219
                }
1159
1220
            }
1160
1221
        }
1183
1244
            AVPacket *next_pkt= &pktl->pkt;
1184
1245
 
1185
1246
            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
 
1247
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1186
1248
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1187
1249
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1188
 
                       && next_pkt->dts < pktl->pkt.dts
1189
 
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
1190
 
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
 
1250
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
 
1251
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1191
1252
                        next_pkt->pts= pktl->pkt.dts;
1192
1253
                    }
1193
1254
                    pktl= pktl->next;
1331
1392
    }
1332
1393
}
1333
1394
 
1334
 
int av_add_index_entry(AVStream *st,
1335
 
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
 
1395
int ff_add_index_entry(AVIndexEntry **index_entries,
 
1396
                       int *nb_index_entries,
 
1397
                       unsigned int *index_entries_allocated_size,
 
1398
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1336
1399
{
1337
1400
    AVIndexEntry *entries, *ie;
1338
1401
    int index;
1339
1402
 
1340
 
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
 
1403
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1341
1404
        return -1;
1342
1405
 
1343
 
    entries = av_fast_realloc(st->index_entries,
1344
 
                              &st->index_entries_allocated_size,
1345
 
                              (st->nb_index_entries + 1) *
 
1406
    entries = av_fast_realloc(*index_entries,
 
1407
                              index_entries_allocated_size,
 
1408
                              (*nb_index_entries + 1) *
1346
1409
                              sizeof(AVIndexEntry));
1347
1410
    if(!entries)
1348
1411
        return -1;
1349
1412
 
1350
 
    st->index_entries= entries;
 
1413
    *index_entries= entries;
1351
1414
 
1352
 
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
 
1415
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1353
1416
 
1354
1417
    if(index<0){
1355
 
        index= st->nb_index_entries++;
 
1418
        index= (*nb_index_entries)++;
1356
1419
        ie= &entries[index];
1357
1420
        assert(index==0 || ie[-1].timestamp < timestamp);
1358
1421
    }else{
1360
1423
        if(ie->timestamp != timestamp){
1361
1424
            if(ie->timestamp <= timestamp)
1362
1425
                return -1;
1363
 
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1364
 
            st->nb_index_entries++;
 
1426
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
 
1427
            (*nb_index_entries)++;
1365
1428
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1366
1429
            distance= ie->min_distance;
1367
1430
    }
1375
1438
    return index;
1376
1439
}
1377
1440
 
1378
 
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1379
 
                              int flags)
1380
 
{
1381
 
    AVIndexEntry *entries= st->index_entries;
1382
 
    int nb_entries= st->nb_index_entries;
 
1441
int av_add_index_entry(AVStream *st,
 
1442
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
 
1443
{
 
1444
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
 
1445
                              &st->index_entries_allocated_size, pos,
 
1446
                              timestamp, size, distance, flags);
 
1447
}
 
1448
 
 
1449
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
 
1450
                              int64_t wanted_timestamp, int flags)
 
1451
{
1383
1452
    int a, b, m;
1384
1453
    int64_t timestamp;
1385
1454
 
1411
1480
    return  m;
1412
1481
}
1413
1482
 
 
1483
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
 
1484
                              int flags)
 
1485
{
 
1486
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
 
1487
                                     wanted_timestamp, flags);
 
1488
}
 
1489
 
1414
1490
#define DEBUG_SEEK
1415
1491
 
1416
1492
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1471
1547
        return -1;
1472
1548
 
1473
1549
    /* do the seek */
1474
 
    if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
 
1550
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1475
1551
        return ret;
1476
1552
 
1477
1553
    av_update_cur_dts(s, st, ts);
1497
1573
 
1498
1574
    if(ts_max == AV_NOPTS_VALUE){
1499
1575
        int step= 1024;
1500
 
        filesize = url_fsize(s->pb);
 
1576
        filesize = avio_size(s->pb);
1501
1577
        pos_max = filesize - 1;
1502
1578
        do{
1503
1579
            pos_max -= step;
1606
1682
#endif
1607
1683
 
1608
1684
    pos_min = s->data_offset;
1609
 
    pos_max = url_fsize(s->pb) - 1;
 
1685
    pos_max = avio_size(s->pb) - 1;
1610
1686
 
1611
1687
    if     (pos < pos_min) pos= pos_min;
1612
1688
    else if(pos > pos_max) pos= pos_max;
1613
1689
 
1614
 
    url_fseek(s->pb, pos, SEEK_SET);
 
1690
    avio_seek(s->pb, pos, SEEK_SET);
1615
1691
 
1616
1692
#if 0
1617
1693
    av_update_cur_dts(s, st, ts);
1641
1717
        if(st->nb_index_entries){
1642
1718
            assert(st->index_entries);
1643
1719
            ie= &st->index_entries[st->nb_index_entries-1];
1644
 
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
 
1720
            if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1645
1721
                return ret;
1646
1722
            av_update_cur_dts(s, st, ie->timestamp);
1647
1723
        }else{
1648
 
            if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
 
1724
            if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1649
1725
                return ret;
1650
1726
        }
1651
1727
        for(i=0;; i++) {
1672
1748
            return 0;
1673
1749
    }
1674
1750
    ie = &st->index_entries[index];
1675
 
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
 
1751
    if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1676
1752
        return ret;
1677
1753
    av_update_cur_dts(s, st, ie->timestamp);
1678
1754
 
1739
1815
/*******************************************************/
1740
1816
 
1741
1817
/**
1742
 
 * Returns TRUE if the stream has accurate duration in any stream.
 
1818
 * Return TRUE if the stream has accurate duration in any stream.
1743
1819
 *
1744
1820
 * @return TRUE if the stream has accurate duration for at least one component.
1745
1821
 */
1831
1907
    AVStream *st;
1832
1908
 
1833
1909
    /* if bit_rate is already set, we believe it */
1834
 
    if (ic->bit_rate == 0) {
 
1910
    if (ic->bit_rate <= 0) {
1835
1911
        bit_rate = 0;
1836
1912
        for(i=0;i<ic->nb_streams;i++) {
1837
1913
            st = ic->streams[i];
 
1914
            if (st->codec->bit_rate > 0)
1838
1915
            bit_rate += st->codec->bit_rate;
1839
1916
        }
1840
1917
        ic->bit_rate = bit_rate;
1865
1942
    AVPacket pkt1, *pkt = &pkt1;
1866
1943
    AVStream *st;
1867
1944
    int read_size, i, ret;
1868
 
    int64_t end_time, start_time[MAX_STREAMS];
 
1945
    int64_t end_time;
1869
1946
    int64_t filesize, offset, duration;
1870
1947
    int retry=0;
1871
1948
 
1874
1951
    /* flush packet queue */
1875
1952
    flush_packet_queue(ic);
1876
1953
 
1877
 
    for(i=0;i<ic->nb_streams;i++) {
 
1954
    for (i=0; i<ic->nb_streams; i++) {
1878
1955
        st = ic->streams[i];
1879
 
        if(st->start_time != AV_NOPTS_VALUE){
1880
 
            start_time[i]= st->start_time;
1881
 
        }else if(st->first_dts != AV_NOPTS_VALUE){
1882
 
            start_time[i]= st->first_dts;
1883
 
        }else
 
1956
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1884
1957
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1885
1958
 
1886
1959
        if (st->parser) {
1899
1972
    if (offset < 0)
1900
1973
        offset = 0;
1901
1974
 
1902
 
    url_fseek(ic->pb, offset, SEEK_SET);
 
1975
    avio_seek(ic->pb, offset, SEEK_SET);
1903
1976
    read_size = 0;
1904
1977
    for(;;) {
1905
1978
        if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1913
1986
        read_size += pkt->size;
1914
1987
        st = ic->streams[pkt->stream_index];
1915
1988
        if (pkt->pts != AV_NOPTS_VALUE &&
1916
 
            start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1917
 
            end_time = pkt->pts;
1918
 
            duration = end_time - start_time[pkt->stream_index];
 
1989
            (st->start_time != AV_NOPTS_VALUE ||
 
1990
             st->first_dts  != AV_NOPTS_VALUE)) {
 
1991
            duration = end_time = pkt->pts;
 
1992
            if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
 
1993
            else                                   duration -= st->first_dts;
1919
1994
            if (duration < 0)
1920
1995
                duration += 1LL<<st->pts_wrap_bits;
1921
1996
            if (duration > 0) {
1932
2007
 
1933
2008
    fill_all_stream_timings(ic);
1934
2009
 
1935
 
    url_fseek(ic->pb, old_offset, SEEK_SET);
1936
 
    for(i=0; i<ic->nb_streams; i++){
 
2010
    avio_seek(ic->pb, old_offset, SEEK_SET);
 
2011
    for (i=0; i<ic->nb_streams; i++) {
1937
2012
        st= ic->streams[i];
1938
2013
        st->cur_dts= st->first_dts;
1939
2014
        st->last_IP_pts = AV_NOPTS_VALUE;
1948
2023
    if (ic->iformat->flags & AVFMT_NOFILE) {
1949
2024
        file_size = 0;
1950
2025
    } else {
1951
 
        file_size = url_fsize(ic->pb);
 
2026
        file_size = avio_size(ic->pb);
1952
2027
        if (file_size < 0)
1953
2028
            file_size = 0;
1954
2029
    }
1956
2031
 
1957
2032
    if ((!strcmp(ic->iformat->name, "mpeg") ||
1958
2033
         !strcmp(ic->iformat->name, "mpegts")) &&
1959
 
        file_size && !url_is_streamed(ic->pb)) {
 
2034
        file_size && ic->pb->seekable) {
1960
2035
        /* get accurate estimate from the PTSes */
1961
2036
        av_estimate_timings_from_pts(ic, old_offset);
1962
2037
    } else if (av_has_duration(ic)) {
1993
2068
    int val;
1994
2069
    switch(enc->codec_type) {
1995
2070
    case AVMEDIA_TYPE_AUDIO:
1996
 
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
 
2071
        val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
1997
2072
        if(!enc->frame_size &&
1998
2073
           (enc->codec_id == CODEC_ID_VORBIS ||
1999
2074
            enc->codec_id == CODEC_ID_AAC ||
2013
2088
    return enc->codec_id != CODEC_ID_NONE && val != 0;
2014
2089
}
2015
2090
 
 
2091
static int has_decode_delay_been_guessed(AVStream *st)
 
2092
{
 
2093
    return st->codec->codec_id != CODEC_ID_H264 ||
 
2094
        st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
 
2095
}
 
2096
 
2016
2097
static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2017
2098
{
2018
2099
    int16_t *samples;
2029
2110
            return ret;
2030
2111
    }
2031
2112
 
2032
 
    if(!has_codec_parameters(st->codec)){
 
2113
    if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2033
2114
        switch(st->codec->codec_type) {
2034
2115
        case AVMEDIA_TYPE_VIDEO:
2035
2116
            avcodec_get_frame_defaults(&picture);
2053
2134
    return ret;
2054
2135
}
2055
2136
 
2056
 
unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
 
2137
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2057
2138
{
2058
2139
    while (tags->id != CODEC_ID_NONE) {
2059
2140
        if (tags->id == id)
2071
2152
            return tags[i].id;
2072
2153
    }
2073
2154
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2074
 
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
2075
 
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
2076
 
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
2077
 
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
 
2155
        if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2078
2156
            return tags[i].id;
2079
2157
    }
2080
2158
    return CODEC_ID_NONE;
2102
2180
 
2103
2181
static void compute_chapters_end(AVFormatContext *s)
2104
2182
{
2105
 
    unsigned int i;
 
2183
    unsigned int i, j;
 
2184
    int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2106
2185
 
2107
 
    for (i=0; i+1<s->nb_chapters; i++)
 
2186
    for (i = 0; i < s->nb_chapters; i++)
2108
2187
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2109
 
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2110
 
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2111
 
            s->chapters[i]->end = s->chapters[i+1]->start;
 
2188
            AVChapter *ch = s->chapters[i];
 
2189
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
 
2190
                                     : INT64_MAX;
 
2191
 
 
2192
            for (j = 0; j < s->nb_chapters; j++) {
 
2193
                AVChapter *ch1 = s->chapters[j];
 
2194
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
 
2195
                if (j != i && next_start > ch->start && next_start < end)
 
2196
                    end = next_start;
 
2197
            }
 
2198
            ch->end = (end == INT64_MAX) ? ch->start : end;
2112
2199
        }
2113
 
 
2114
 
    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2115
 
        assert(s->start_time != AV_NOPTS_VALUE);
2116
 
        assert(s->duration > 0);
2117
 
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2118
 
                                           AV_TIME_BASE_Q,
2119
 
                                           s->chapters[i]->time_base);
2120
 
    }
2121
2200
}
2122
2201
 
2123
 
#define MAX_STD_TIMEBASES (60*12+5)
2124
2202
static int get_std_framerate(int i){
2125
2203
    if(i<60*12) return i*1001;
2126
2204
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2151
2229
    int i, count, ret, read_size, j;
2152
2230
    AVStream *st;
2153
2231
    AVPacket pkt1, *pkt;
2154
 
    int64_t last_dts[MAX_STREAMS];
2155
 
    int64_t duration_gcd[MAX_STREAMS]={0};
2156
 
    int duration_count[MAX_STREAMS]={0};
2157
 
    double (*duration_error)[MAX_STD_TIMEBASES];
2158
 
    int64_t old_offset = url_ftell(ic->pb);
2159
 
    int64_t codec_info_duration[MAX_STREAMS]={0};
2160
 
 
2161
 
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2162
 
    if (!duration_error) return AVERROR(ENOMEM);
 
2232
    int64_t old_offset = avio_tell(ic->pb);
2163
2233
 
2164
2234
    for(i=0;i<ic->nb_streams;i++) {
 
2235
        AVCodec *codec;
2165
2236
        st = ic->streams[i];
2166
2237
        if (st->codec->codec_id == CODEC_ID_AAC) {
2167
2238
            st->codec->sample_rate = 0;
2168
2239
            st->codec->frame_size = 0;
2169
2240
            st->codec->channels = 0;
2170
2241
        }
2171
 
        if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
 
2242
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
 
2243
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2172
2244
/*            if(!st->time_base.num)
2173
2245
                st->time_base= */
2174
2246
            if(!st->codec->time_base.num)
2182
2254
            }
2183
2255
        }
2184
2256
        assert(!st->codec->codec);
 
2257
        codec = avcodec_find_decoder(st->codec->codec_id);
 
2258
 
 
2259
        /* Force decoding of at least one frame of codec data
 
2260
         * this makes sure the codec initializes the channel configuration
 
2261
         * and does not trust the values from the container.
 
2262
         */
 
2263
        if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
 
2264
            st->codec->channels = 0;
 
2265
 
 
2266
        /* Ensure that subtitle_header is properly set. */
 
2267
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
 
2268
            && codec && !st->codec->codec)
 
2269
            avcodec_open(st->codec, codec);
 
2270
 
2185
2271
        //try to just open decoders, in case this is enough to get parameters
2186
2272
        if(!has_codec_parameters(st->codec)){
2187
 
            AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
2188
 
            if (codec)
 
2273
            if (codec && !st->codec->codec)
2189
2274
                avcodec_open(st->codec, codec);
2190
2275
        }
2191
2276
    }
2192
2277
 
2193
 
    for(i=0;i<MAX_STREAMS;i++){
2194
 
        last_dts[i]= AV_NOPTS_VALUE;
 
2278
    for (i=0; i<ic->nb_streams; i++) {
 
2279
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2195
2280
    }
2196
2281
 
2197
2282
    count = 0;
2198
2283
    read_size = 0;
2199
2284
    for(;;) {
2200
2285
        if(url_interrupt_cb()){
2201
 
            ret= AVERROR(EINTR);
 
2286
            ret= AVERROR_EXIT;
2202
2287
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2203
2288
            break;
2204
2289
        }
2210
2295
                break;
2211
2296
            /* variable fps and no guess at the real fps */
2212
2297
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2213
 
               && duration_count[i]<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
 
2298
               && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2214
2299
                break;
2215
2300
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2216
2301
                break;
2238
2323
        /* NOTE: a new stream can be added there if no header in file
2239
2324
           (AVFMTCTX_NOHEADER) */
2240
2325
        ret = av_read_frame_internal(ic, &pkt1);
2241
 
        if(ret == AVERROR(EAGAIN))
2242
 
            continue;
2243
 
        if (ret < 0) {
 
2326
        if (ret < 0 && ret != AVERROR(EAGAIN)) {
2244
2327
            /* EOF or error */
2245
2328
            ret = -1; /* we could not have all the codec parameters before EOF */
2246
2329
            for(i=0;i<ic->nb_streams;i++) {
2256
2339
            break;
2257
2340
        }
2258
2341
 
 
2342
        if (ret == AVERROR(EAGAIN))
 
2343
            continue;
 
2344
 
2259
2345
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2260
 
        if(av_dup_packet(pkt) < 0) {
2261
 
            av_free(duration_error);
2262
 
            return AVERROR(ENOMEM);
2263
 
        }
 
2346
        if ((ret = av_dup_packet(pkt)) < 0)
 
2347
            goto find_stream_info_err;
2264
2348
 
2265
2349
        read_size += pkt->size;
2266
2350
 
2267
2351
        st = ic->streams[pkt->stream_index];
2268
 
        if(st->codec_info_nb_frames>1) {
2269
 
            if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
 
2352
        if (st->codec_info_nb_frames>1) {
 
2353
            if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2270
2354
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2271
2355
                break;
2272
2356
            }
2273
 
            codec_info_duration[st->index] += pkt->duration;
 
2357
            st->info->codec_info_duration += pkt->duration;
2274
2358
        }
2275
 
            st->codec_info_nb_frames++;
2276
 
 
2277
2359
        {
2278
 
            int index= pkt->stream_index;
2279
 
            int64_t last= last_dts[index];
 
2360
            int64_t last = st->info->last_dts;
2280
2361
            int64_t duration= pkt->dts - last;
2281
2362
 
2282
2363
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2284
2365
 
2285
2366
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2286
2367
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2287
 
                if(duration_count[index] < 2)
2288
 
                    memset(duration_error[index], 0, sizeof(*duration_error));
2289
 
                for(i=1; i<MAX_STD_TIMEBASES; i++){
 
2368
                if (st->info->duration_count < 2)
 
2369
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
 
2370
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2290
2371
                    int framerate= get_std_framerate(i);
2291
2372
                    int ticks= lrintf(dur*framerate/(1001*12));
2292
2373
                    double error= dur - ticks*1001*12/(double)framerate;
2293
 
                    duration_error[index][i] += error*error;
 
2374
                    st->info->duration_error[i] += error*error;
2294
2375
                }
2295
 
                duration_count[index]++;
 
2376
                st->info->duration_count++;
2296
2377
                // ignore the first 4 values, they might have some random jitter
2297
 
                if (duration_count[index] > 3)
2298
 
                    duration_gcd[index] = av_gcd(duration_gcd[index], duration);
 
2378
                if (st->info->duration_count > 3)
 
2379
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2299
2380
            }
2300
 
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2301
 
                last_dts[pkt->stream_index]= pkt->dts;
 
2381
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
 
2382
                st->info->last_dts = pkt->dts;
2302
2383
        }
2303
2384
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
2304
2385
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2314
2395
           decompress the frame. We try to avoid that in most cases as
2315
2396
           it takes longer and uses more memory. For MPEG-4, we need to
2316
2397
           decompress for QuickTime. */
2317
 
        if (!has_codec_parameters(st->codec))
 
2398
        if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2318
2399
            try_decode_frame(st, pkt);
2319
2400
 
 
2401
        st->codec_info_nb_frames++;
2320
2402
        count++;
2321
2403
    }
2322
2404
 
2328
2410
    }
2329
2411
    for(i=0;i<ic->nb_streams;i++) {
2330
2412
        st = ic->streams[i];
2331
 
        if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
 
2413
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2332
2414
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2333
2415
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2334
 
                      codec_info_duration[i]    *(int64_t)st->time_base.num, 60000);
 
2416
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2335
2417
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2336
2418
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2337
2419
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2339
2421
            // the check for tb_unreliable() is not completely correct, since this is not about handling
2340
2422
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2341
2423
            // ipmovie.c produces.
2342
 
            if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
2343
 
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
2344
 
            if(duration_count[i] && !st->r_frame_rate.num
 
2424
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
 
2425
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
 
2426
            if (st->info->duration_count && !st->r_frame_rate.num
2345
2427
               && tb_unreliable(st->codec) /*&&
2346
2428
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2347
 
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
 
2429
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2348
2430
                int num = 0;
2349
2431
                double best_error= 2*av_q2d(st->time_base);
2350
 
                best_error= best_error*best_error*duration_count[i]*1000*12*30;
 
2432
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2351
2433
 
2352
 
                for(j=1; j<MAX_STD_TIMEBASES; j++){
2353
 
                    double error= duration_error[i][j] * get_std_framerate(j);
 
2434
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
 
2435
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2354
2436
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2355
2437
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2356
2438
                    if(error < best_error){
2376
2458
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2377
2459
            if(!st->codec->bits_per_coded_sample)
2378
2460
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
 
2461
            // set stream disposition based on audio service type
 
2462
            switch (st->codec->audio_service_type) {
 
2463
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
 
2464
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
 
2465
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
 
2466
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
 
2467
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
 
2468
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
 
2469
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
 
2470
                st->disposition = AV_DISPOSITION_COMMENT;          break;
 
2471
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
 
2472
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
 
2473
            }
2379
2474
        }
2380
2475
    }
2381
2476
 
2408
2503
    }
2409
2504
#endif
2410
2505
 
2411
 
    av_free(duration_error);
2412
 
 
 
2506
 find_stream_info_err:
 
2507
    for (i=0; i < ic->nb_streams; i++)
 
2508
        av_freep(&ic->streams[i]->info);
 
2509
    return ret;
 
2510
}
 
2511
 
 
2512
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
 
2513
{
 
2514
    int i, j;
 
2515
 
 
2516
    for (i = 0; i < ic->nb_programs; i++)
 
2517
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
 
2518
            if (ic->programs[i]->stream_index[j] == s)
 
2519
                return ic->programs[i];
 
2520
    return NULL;
 
2521
}
 
2522
 
 
2523
int av_find_best_stream(AVFormatContext *ic,
 
2524
                        enum AVMediaType type,
 
2525
                        int wanted_stream_nb,
 
2526
                        int related_stream,
 
2527
                        AVCodec **decoder_ret,
 
2528
                        int flags)
 
2529
{
 
2530
    int i, nb_streams = ic->nb_streams, stream_number = 0;
 
2531
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
 
2532
    unsigned *program = NULL;
 
2533
    AVCodec *decoder = NULL, *best_decoder = NULL;
 
2534
 
 
2535
    if (related_stream >= 0 && wanted_stream_nb < 0) {
 
2536
        AVProgram *p = find_program_from_stream(ic, related_stream);
 
2537
        if (p) {
 
2538
            program = p->stream_index;
 
2539
            nb_streams = p->nb_stream_indexes;
 
2540
        }
 
2541
    }
 
2542
    for (i = 0; i < nb_streams; i++) {
 
2543
        AVStream *st = ic->streams[program ? program[i] : i];
 
2544
        AVCodecContext *avctx = st->codec;
 
2545
        if (avctx->codec_type != type)
 
2546
            continue;
 
2547
        if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
 
2548
            continue;
 
2549
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
 
2550
            continue;
 
2551
        if (decoder_ret) {
 
2552
            decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
 
2553
            if (!decoder) {
 
2554
                if (ret < 0)
 
2555
                    ret = AVERROR_DECODER_NOT_FOUND;
 
2556
                continue;
 
2557
            }
 
2558
        }
 
2559
        if (best_count >= st->codec_info_nb_frames)
 
2560
            continue;
 
2561
        best_count = st->codec_info_nb_frames;
 
2562
        ret = program ? program[i] : i;
 
2563
        best_decoder = decoder;
 
2564
        if (program && i == nb_streams - 1 && ret < 0) {
 
2565
            program = NULL;
 
2566
            nb_streams = ic->nb_streams;
 
2567
            i = 0; /* no related stream found, try again with everything */
 
2568
        }
 
2569
    }
 
2570
    if (decoder_ret)
 
2571
        *decoder_ret = best_decoder;
2413
2572
    return ret;
2414
2573
}
2415
2574
 
2420
2579
    if (s->iformat->read_play)
2421
2580
        return s->iformat->read_play(s);
2422
2581
    if (s->pb)
2423
 
        return av_url_read_fpause(s->pb, 0);
 
2582
        return avio_pause(s->pb, 0);
2424
2583
    return AVERROR(ENOSYS);
2425
2584
}
2426
2585
 
2429
2588
    if (s->iformat->read_pause)
2430
2589
        return s->iformat->read_pause(s);
2431
2590
    if (s->pb)
2432
 
        return av_url_read_fpause(s->pb, 1);
 
2591
        return avio_pause(s->pb, 1);
2433
2592
    return AVERROR(ENOSYS);
2434
2593
}
2435
2594
 
2436
2595
void av_close_input_stream(AVFormatContext *s)
2437
2596
{
2438
 
    int i;
2439
 
    AVStream *st;
2440
 
 
 
2597
    flush_packet_queue(s);
2441
2598
    if (s->iformat->read_close)
2442
2599
        s->iformat->read_close(s);
 
2600
    avformat_free_context(s);
 
2601
}
 
2602
 
 
2603
void avformat_free_context(AVFormatContext *s)
 
2604
{
 
2605
    int i;
 
2606
    AVStream *st;
 
2607
 
2443
2608
    for(i=0;i<s->nb_streams;i++) {
2444
2609
        /* free all data in a stream component */
2445
2610
        st = s->streams[i];
2450
2615
        av_metadata_free(&st->metadata);
2451
2616
        av_free(st->index_entries);
2452
2617
        av_free(st->codec->extradata);
 
2618
        av_free(st->codec->subtitle_header);
2453
2619
        av_free(st->codec);
2454
 
#if LIBAVFORMAT_VERSION_INT < (53<<16)
 
2620
#if FF_API_OLD_METADATA
2455
2621
        av_free(st->filename);
2456
2622
#endif
2457
2623
        av_free(st->priv_data);
 
2624
        av_free(st->info);
2458
2625
        av_free(st);
2459
2626
    }
2460
2627
    for(i=s->nb_programs-1; i>=0; i--) {
2461
 
#if LIBAVFORMAT_VERSION_INT < (53<<16)
 
2628
#if FF_API_OLD_METADATA
2462
2629
        av_freep(&s->programs[i]->provider_name);
2463
2630
        av_freep(&s->programs[i]->name);
2464
2631
#endif
2467
2634
        av_freep(&s->programs[i]);
2468
2635
    }
2469
2636
    av_freep(&s->programs);
2470
 
    flush_packet_queue(s);
2471
2637
    av_freep(&s->priv_data);
2472
2638
    while(s->nb_chapters--) {
2473
 
#if LIBAVFORMAT_VERSION_INT < (53<<16)
 
2639
#if FF_API_OLD_METADATA
2474
2640
        av_free(s->chapters[s->nb_chapters]->title);
2475
2641
#endif
2476
2642
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2478
2644
    }
2479
2645
    av_freep(&s->chapters);
2480
2646
    av_metadata_free(&s->metadata);
 
2647
    av_freep(&s->key);
2481
2648
    av_free(s);
2482
2649
}
2483
2650
 
2484
2651
void av_close_input_file(AVFormatContext *s)
2485
2652
{
2486
 
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
 
2653
    AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2487
2654
    av_close_input_stream(s);
2488
2655
    if (pb)
2489
 
        url_fclose(pb);
 
2656
        avio_close(pb);
2490
2657
}
2491
2658
 
2492
2659
AVStream *av_new_stream(AVFormatContext *s, int id)
2494
2661
    AVStream *st;
2495
2662
    int i;
2496
2663
 
2497
 
    if (s->nb_streams >= MAX_STREAMS)
2498
 
        return NULL;
 
2664
#if FF_API_MAX_STREAMS
 
2665
    if (s->nb_streams >= MAX_STREAMS){
 
2666
        av_log(s, AV_LOG_ERROR, "Too many streams\n");
 
2667
        return NULL;
 
2668
    }
 
2669
#else
 
2670
    AVStream **streams;
 
2671
 
 
2672
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
 
2673
        return NULL;
 
2674
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
 
2675
    if (!streams)
 
2676
        return NULL;
 
2677
    s->streams = streams;
 
2678
#endif
2499
2679
 
2500
2680
    st = av_mallocz(sizeof(AVStream));
2501
2681
    if (!st)
2502
2682
        return NULL;
 
2683
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
 
2684
        av_free(st);
 
2685
        return NULL;
 
2686
    }
2503
2687
 
2504
2688
    st->codec= avcodec_alloc_context();
2505
2689
    if (s->iformat) {
2571
2755
            return NULL;
2572
2756
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2573
2757
    }
2574
 
#if LIBAVFORMAT_VERSION_INT < (53<<16)
 
2758
#if FF_API_OLD_METADATA
2575
2759
    av_free(chapter->title);
2576
2760
#endif
2577
2761
    av_metadata_set2(&chapter->metadata, "title", title, 0);
2594
2778
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2595
2779
        if (!s->priv_data)
2596
2780
            return AVERROR(ENOMEM);
 
2781
        if (s->oformat->priv_class) {
 
2782
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
 
2783
            av_opt_set_defaults(s->priv_data);
 
2784
        }
2597
2785
    } else
2598
2786
        s->priv_data = NULL;
2599
2787
 
2605
2793
    return 0;
2606
2794
}
2607
2795
 
 
2796
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
 
2797
{
 
2798
    const AVCodecTag *avctag;
 
2799
    int n;
 
2800
    enum CodecID id = CODEC_ID_NONE;
 
2801
    unsigned int tag = 0;
 
2802
 
 
2803
    /**
 
2804
     * Check that tag + id is in the table
 
2805
     * If neither is in the table -> OK
 
2806
     * If tag is in the table with another id -> FAIL
 
2807
     * If id is in the table with another tag -> FAIL unless strict < normal
 
2808
     */
 
2809
    for (n = 0; s->oformat->codec_tag[n]; n++) {
 
2810
        avctag = s->oformat->codec_tag[n];
 
2811
        while (avctag->id != CODEC_ID_NONE) {
 
2812
            if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
 
2813
                id = avctag->id;
 
2814
                if (id == st->codec->codec_id)
 
2815
                    return 1;
 
2816
            }
 
2817
            if (avctag->id == st->codec->codec_id)
 
2818
                tag = avctag->tag;
 
2819
            avctag++;
 
2820
        }
 
2821
    }
 
2822
    if (id != CODEC_ID_NONE)
 
2823
        return 0;
 
2824
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
 
2825
        return 0;
 
2826
    return 1;
 
2827
}
 
2828
 
2608
2829
int av_write_header(AVFormatContext *s)
2609
2830
{
2610
2831
    int ret, i;
2611
2832
    AVStream *st;
2612
2833
 
2613
2834
    // some sanity checks
2614
 
    if (s->nb_streams == 0) {
 
2835
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2615
2836
        av_log(s, AV_LOG_ERROR, "no streams\n");
2616
 
        return -1;
 
2837
        return AVERROR(EINVAL);
2617
2838
    }
2618
2839
 
2619
2840
    for(i=0;i<s->nb_streams;i++) {
2623
2844
        case AVMEDIA_TYPE_AUDIO:
2624
2845
            if(st->codec->sample_rate<=0){
2625
2846
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2626
 
                return -1;
 
2847
                return AVERROR(EINVAL);
2627
2848
            }
2628
2849
            if(!st->codec->block_align)
2629
2850
                st->codec->block_align = st->codec->channels *
2632
2853
        case AVMEDIA_TYPE_VIDEO:
2633
2854
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2634
2855
                av_log(s, AV_LOG_ERROR, "time base not set\n");
2635
 
                return -1;
 
2856
                return AVERROR(EINVAL);
2636
2857
            }
2637
2858
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2638
2859
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2639
 
                return -1;
 
2860
                return AVERROR(EINVAL);
2640
2861
            }
2641
2862
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2642
2863
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2643
 
                return -1;
 
2864
                return AVERROR(EINVAL);
2644
2865
            }
2645
2866
            break;
2646
2867
        }
2647
2868
 
2648
2869
        if(s->oformat->codec_tag){
 
2870
            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)){
 
2871
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
 
2872
                st->codec->codec_tag= 0;
 
2873
            }
2649
2874
            if(st->codec->codec_tag){
2650
 
                //FIXME
2651
 
                //check that tag + id is in the table
2652
 
                //if neither is in the table -> OK
2653
 
                //if tag is in the table with another id -> FAIL
2654
 
                //if id is in the table with another tag -> FAIL unless strict < ?
 
2875
                if (!validate_codec_tag(s, st)) {
 
2876
                    char tagbuf[32];
 
2877
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
 
2878
                    av_log(s, AV_LOG_ERROR,
 
2879
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
 
2880
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
 
2881
                    return AVERROR_INVALIDDATA;
 
2882
                }
2655
2883
            }else
2656
2884
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2657
2885
        }
2667
2895
            return AVERROR(ENOMEM);
2668
2896
    }
2669
2897
 
2670
 
#if LIBAVFORMAT_VERSION_MAJOR < 53
 
2898
#if FF_API_OLD_METADATA
2671
2899
    ff_metadata_mux_compat(s);
2672
2900
#endif
2673
2901
 
2674
2902
    /* set muxer identification string */
2675
 
    if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2676
 
        AVMetadata *m;
2677
 
        AVMetadataTag *t;
2678
 
 
2679
 
        if (!(m = av_mallocz(sizeof(AVMetadata))))
2680
 
            return AVERROR(ENOMEM);
2681
 
        av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2682
 
        metadata_conv(&m, s->oformat->metadata_conv, NULL);
2683
 
        if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2684
 
            av_metadata_set2(&s->metadata, t->key, t->value, 0);
2685
 
        av_metadata_free(&m);
 
2903
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
 
2904
        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2686
2905
    }
2687
2906
 
2688
2907
    if(s->oformat->write_header){
2720
2939
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2721
2940
    int num, den, frame_size, i;
2722
2941
 
2723
 
//    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);
 
2942
    av_dlog(s, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
 
2943
            pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2724
2944
 
2725
2945
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2726
2946
        return -1;*/
2756
2976
 
2757
2977
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2758
2978
        av_log(s, AV_LOG_ERROR,
2759
 
               "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
 
2979
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2760
2980
               st->index, st->cur_dts, pkt->dts);
2761
2981
        return -1;
2762
2982
    }
2763
2983
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2764
 
        av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
 
2984
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2765
2985
        return -1;
2766
2986
    }
2767
2987
 
2798
3018
        return ret;
2799
3019
 
2800
3020
    ret= s->oformat->write_packet(s, pkt);
2801
 
    if(!ret)
2802
 
        ret= url_ferror(s->pb);
2803
3021
    return ret;
2804
3022
}
2805
3023
 
2839
3057
    *next_point= this_pktl;
2840
3058
}
2841
3059
 
2842
 
int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
 
3060
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2843
3061
{
2844
3062
    AVStream *st = s->streams[ pkt ->stream_index];
2845
3063
    AVStream *st2= s->streams[ next->stream_index];
2846
3064
    int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2847
3065
    int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2848
 
    return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
 
3066
    int64_t dts1 = av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN);
 
3067
    if (dts1 == next->dts)
 
3068
        return pkt->stream_index < next->stream_index;
 
3069
    return dts1 < next->dts;
2849
3070
}
2850
3071
 
2851
3072
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2879
3100
}
2880
3101
 
2881
3102
/**
2882
 
 * Interleaves an AVPacket correctly so it can be muxed.
 
3103
 * Interleave an AVPacket correctly so it can be muxed.
2883
3104
 * @param out the interleaved packet will be output here
2884
3105
 * @param in the input packet
2885
3106
 * @param flush 1 if no further packets are available as input and all
2896
3117
 
2897
3118
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2898
3119
    AVStream *st= s->streams[ pkt->stream_index];
 
3120
    int ret;
2899
3121
 
2900
3122
    //FIXME/XXX/HACK drop zero sized packets
2901
3123
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2902
3124
        return 0;
2903
3125
 
2904
 
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2905
 
    if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2906
 
        return -1;
 
3126
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
 
3127
            pkt->size, pkt->dts, pkt->pts);
 
3128
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
 
3129
        return ret;
2907
3130
 
2908
3131
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2909
 
        return -1;
 
3132
        return AVERROR(EINVAL);
2910
3133
 
2911
3134
    for(;;){
2912
3135
        AVPacket opkt;
2921
3144
 
2922
3145
        if(ret<0)
2923
3146
            return ret;
2924
 
        if(url_ferror(s->pb))
2925
 
            return url_ferror(s->pb);
2926
3147
    }
2927
3148
}
2928
3149
 
2944
3165
 
2945
3166
        if(ret<0)
2946
3167
            goto fail;
2947
 
        if(url_ferror(s->pb))
2948
 
            goto fail;
2949
3168
    }
2950
3169
 
2951
3170
    if(s->oformat->write_trailer)
2952
3171
        ret = s->oformat->write_trailer(s);
2953
3172
fail:
2954
 
    if(ret == 0)
2955
 
       ret=url_ferror(s->pb);
2956
3173
    for(i=0;i<s->nb_streams;i++) {
2957
3174
        av_freep(&s->streams[i]->priv_data);
2958
3175
        av_freep(&s->streams[i]->index_entries);
3048
3265
        if(st->codec->time_base.den && st->codec->time_base.num)
3049
3266
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3050
3267
    }
 
3268
    if (st->disposition & AV_DISPOSITION_DEFAULT)
 
3269
        av_log(NULL, AV_LOG_INFO, " (default)");
 
3270
    if (st->disposition & AV_DISPOSITION_DUB)
 
3271
        av_log(NULL, AV_LOG_INFO, " (dub)");
 
3272
    if (st->disposition & AV_DISPOSITION_ORIGINAL)
 
3273
        av_log(NULL, AV_LOG_INFO, " (original)");
 
3274
    if (st->disposition & AV_DISPOSITION_COMMENT)
 
3275
        av_log(NULL, AV_LOG_INFO, " (comment)");
 
3276
    if (st->disposition & AV_DISPOSITION_LYRICS)
 
3277
        av_log(NULL, AV_LOG_INFO, " (lyrics)");
 
3278
    if (st->disposition & AV_DISPOSITION_KARAOKE)
 
3279
        av_log(NULL, AV_LOG_INFO, " (karaoke)");
 
3280
    if (st->disposition & AV_DISPOSITION_FORCED)
 
3281
        av_log(NULL, AV_LOG_INFO, " (forced)");
 
3282
    if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
 
3283
        av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
 
3284
    if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
 
3285
        av_log(NULL, AV_LOG_INFO, " (visual impaired)");
 
3286
    if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
 
3287
        av_log(NULL, AV_LOG_INFO, " (clean effects)");
3051
3288
    av_log(NULL, AV_LOG_INFO, "\n");
3052
3289
    dump_metadata(NULL, st->metadata, "    ");
3053
3290
}
3054
3291
 
 
3292
#if FF_API_DUMP_FORMAT
3055
3293
void dump_format(AVFormatContext *ic,
3056
3294
                 int index,
3057
3295
                 const char *url,
3058
3296
                 int is_output)
3059
3297
{
 
3298
    av_dump_format(ic, index, url, is_output);
 
3299
}
 
3300
#endif
 
3301
 
 
3302
void av_dump_format(AVFormatContext *ic,
 
3303
                    int index,
 
3304
                    const char *url,
 
3305
                    int is_output)
 
3306
{
3060
3307
    int i;
3061
3308
    uint8_t *printed = av_mallocz(ic->nb_streams);
3062
3309
    if (ic->nb_streams && !printed)
3087
3334
            int secs, us;
3088
3335
            av_log(NULL, AV_LOG_INFO, ", start: ");
3089
3336
            secs = ic->start_time / AV_TIME_BASE;
3090
 
            us = ic->start_time % AV_TIME_BASE;
 
3337
            us = abs(ic->start_time % AV_TIME_BASE);
3091
3338
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3092
3339
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3093
3340
        }
3131
3378
    av_free(printed);
3132
3379
}
3133
3380
 
3134
 
#if LIBAVFORMAT_VERSION_MAJOR < 53
 
3381
#if FF_API_PARSE_FRAME_PARAM
 
3382
#include "libavutil/parseutils.h"
 
3383
 
3135
3384
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3136
3385
{
3137
 
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
 
3386
    return av_parse_video_size(width_ptr, height_ptr, str);
3138
3387
}
3139
3388
 
3140
3389
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3141
3390
{
3142
3391
    AVRational frame_rate;
3143
 
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
 
3392
    int ret = av_parse_video_rate(&frame_rate, arg);
3144
3393
    *frame_rate_num= frame_rate.num;
3145
3394
    *frame_rate_den= frame_rate.den;
3146
3395
    return ret;
3159
3408
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3160
3409
}
3161
3410
 
3162
 
int64_t parse_date(const char *datestr, int duration)
 
3411
#if FF_API_PARSE_DATE
 
3412
#include "libavutil/parseutils.h"
 
3413
 
 
3414
int64_t parse_date(const char *timestr, int duration)
3163
3415
{
3164
 
    const char *p;
3165
 
    int64_t t;
3166
 
    struct tm dt;
3167
 
    int i;
3168
 
    static const char * const date_fmt[] = {
3169
 
        "%Y-%m-%d",
3170
 
        "%Y%m%d",
3171
 
    };
3172
 
    static const char * const time_fmt[] = {
3173
 
        "%H:%M:%S",
3174
 
        "%H%M%S",
3175
 
    };
3176
 
    const char *q;
3177
 
    int is_utc, len;
3178
 
    char lastch;
3179
 
    int negative = 0;
3180
 
 
3181
 
#undef time
3182
 
    time_t now = time(0);
3183
 
 
3184
 
    len = strlen(datestr);
3185
 
    if (len > 0)
3186
 
        lastch = datestr[len - 1];
3187
 
    else
3188
 
        lastch = '\0';
3189
 
    is_utc = (lastch == 'z' || lastch == 'Z');
3190
 
 
3191
 
    memset(&dt, 0, sizeof(dt));
3192
 
 
3193
 
    p = datestr;
3194
 
    q = NULL;
3195
 
    if (!duration) {
3196
 
        if (!strncasecmp(datestr, "now", len))
3197
 
            return (int64_t) now * 1000000;
3198
 
 
3199
 
        /* parse the year-month-day part */
3200
 
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3201
 
            q = small_strptime(p, date_fmt[i], &dt);
3202
 
            if (q) {
3203
 
                break;
3204
 
            }
3205
 
        }
3206
 
 
3207
 
        /* if the year-month-day part is missing, then take the
3208
 
         * current year-month-day time */
3209
 
        if (!q) {
3210
 
            if (is_utc) {
3211
 
                dt = *gmtime(&now);
3212
 
            } else {
3213
 
                dt = *localtime(&now);
3214
 
            }
3215
 
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3216
 
        } else {
3217
 
            p = q;
3218
 
        }
3219
 
 
3220
 
        if (*p == 'T' || *p == 't' || *p == ' ')
3221
 
            p++;
3222
 
 
3223
 
        /* parse the hour-minute-second part */
3224
 
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3225
 
            q = small_strptime(p, time_fmt[i], &dt);
3226
 
            if (q) {
3227
 
                break;
3228
 
            }
3229
 
        }
3230
 
    } else {
3231
 
        /* parse datestr as a duration */
3232
 
        if (p[0] == '-') {
3233
 
            negative = 1;
3234
 
            ++p;
3235
 
        }
3236
 
        /* parse datestr as HH:MM:SS */
3237
 
        q = small_strptime(p, time_fmt[0], &dt);
3238
 
        if (!q) {
3239
 
            /* parse datestr as S+ */
3240
 
            dt.tm_sec = strtol(p, (char **)&q, 10);
3241
 
            if (q == p)
3242
 
                /* the parsing didn't succeed */
3243
 
                return INT64_MIN;
3244
 
            dt.tm_min = 0;
3245
 
            dt.tm_hour = 0;
3246
 
        }
3247
 
    }
3248
 
 
3249
 
    /* Now we have all the fields that we can get */
3250
 
    if (!q) {
3251
 
        return INT64_MIN;
3252
 
    }
3253
 
 
3254
 
    if (duration) {
3255
 
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3256
 
    } else {
3257
 
        dt.tm_isdst = -1;       /* unknown */
3258
 
        if (is_utc) {
3259
 
            t = mktimegm(&dt);
3260
 
        } else {
3261
 
            t = mktime(&dt);
3262
 
        }
3263
 
    }
3264
 
 
3265
 
    t *= 1000000;
3266
 
 
3267
 
    /* parse the .m... part */
3268
 
    if (*q == '.') {
3269
 
        int val, n;
3270
 
        q++;
3271
 
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3272
 
            if (!isdigit(*q))
3273
 
                break;
3274
 
            val += n * (*q - '0');
3275
 
        }
3276
 
        t += val;
3277
 
    }
3278
 
    return negative ? -t : t;
 
3416
    int64_t timeval;
 
3417
    av_parse_time(&timeval, timestr, duration);
 
3418
    return timeval;
3279
3419
}
 
3420
#endif
 
3421
 
 
3422
#if FF_API_FIND_INFO_TAG
 
3423
#include "libavutil/parseutils.h"
3280
3424
 
3281
3425
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3282
3426
{
3283
 
    const char *p;
3284
 
    char tag[128], *q;
3285
 
 
3286
 
    p = info;
3287
 
    if (*p == '?')
3288
 
        p++;
3289
 
    for(;;) {
3290
 
        q = tag;
3291
 
        while (*p != '\0' && *p != '=' && *p != '&') {
3292
 
            if ((q - tag) < sizeof(tag) - 1)
3293
 
                *q++ = *p;
3294
 
            p++;
3295
 
        }
3296
 
        *q = '\0';
3297
 
        q = arg;
3298
 
        if (*p == '=') {
3299
 
            p++;
3300
 
            while (*p != '&' && *p != '\0') {
3301
 
                if ((q - arg) < arg_size - 1) {
3302
 
                    if (*p == '+')
3303
 
                        *q++ = ' ';
3304
 
                    else
3305
 
                        *q++ = *p;
3306
 
                }
3307
 
                p++;
3308
 
            }
3309
 
            *q = '\0';
3310
 
        }
3311
 
        if (!strcmp(tag, tag1))
3312
 
            return 1;
3313
 
        if (*p != '&')
3314
 
            break;
3315
 
        p++;
3316
 
    }
3317
 
    return 0;
 
3427
    return av_find_info_tag(arg, arg_size, tag1, info);
3318
3428
}
 
3429
#endif
3319
3430
 
3320
3431
int av_get_frame_filename(char *buf, int buf_size,
3321
3432
                          const char *path, int number)
3411
3522
    hex_dump_internal(avcl, NULL, level, buf, size);
3412
3523
}
3413
3524
 
3414
 
 //FIXME needs to know the time_base
3415
 
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
 
3525
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3416
3526
{
3417
3527
#undef fprintf
3418
3528
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3419
3529
    PRINT("stream #%d:\n", pkt->stream_index);
3420
3530
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3421
 
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
 
3531
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3422
3532
    /* DTS is _always_ valid after av_read_frame() */
3423
3533
    PRINT("  dts=");
3424
3534
    if (pkt->dts == AV_NOPTS_VALUE)
3425
3535
        PRINT("N/A");
3426
3536
    else
3427
 
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
 
3537
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3428
3538
    /* PTS may not be known if B-frames are present. */
3429
3539
    PRINT("  pts=");
3430
3540
    if (pkt->pts == AV_NOPTS_VALUE)
3431
3541
        PRINT("N/A");
3432
3542
    else
3433
 
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
 
3543
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3434
3544
    PRINT("\n");
3435
3545
    PRINT("  size=%d\n", pkt->size);
3436
3546
#undef PRINT
3438
3548
        av_hex_dump(f, pkt->data, pkt->size);
3439
3549
}
3440
3550
 
 
3551
#if FF_API_PKT_DUMP
3441
3552
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3442
3553
{
3443
 
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3444
 
}
3445
 
 
 
3554
    AVRational tb = { 1, AV_TIME_BASE };
 
3555
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
 
3556
}
 
3557
#endif
 
3558
 
 
3559
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
 
3560
{
 
3561
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
 
3562
}
 
3563
 
 
3564
#if FF_API_PKT_DUMP
3446
3565
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3447
3566
{
3448
 
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3449
 
}
3450
 
 
 
3567
    AVRational tb = { 1, AV_TIME_BASE };
 
3568
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
 
3569
}
 
3570
#endif
 
3571
 
 
3572
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
 
3573
                      AVStream *st)
 
3574
{
 
3575
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
 
3576
}
 
3577
 
 
3578
#if FF_API_URL_SPLIT
 
3579
attribute_deprecated
3451
3580
void ff_url_split(char *proto, int proto_size,
3452
3581
                  char *authorization, int authorization_size,
3453
3582
                  char *hostname, int hostname_size,
3455
3584
                  char *path, int path_size,
3456
3585
                  const char *url)
3457
3586
{
 
3587
    av_url_split(proto, proto_size,
 
3588
                 authorization, authorization_size,
 
3589
                 hostname, hostname_size,
 
3590
                 port_ptr,
 
3591
                 path, path_size,
 
3592
                 url);
 
3593
}
 
3594
#endif
 
3595
 
 
3596
void av_url_split(char *proto, int proto_size,
 
3597
                  char *authorization, int authorization_size,
 
3598
                  char *hostname, int hostname_size,
 
3599
                  int *port_ptr,
 
3600
                  char *path, int path_size,
 
3601
                  const char *url)
 
3602
{
3458
3603
    const char *p, *ls, *at, *col, *brk;
3459
3604
 
3460
3605
    if (port_ptr)               *port_ptr = -1;
3530
3675
    return buff;
3531
3676
}
3532
3677
 
 
3678
int ff_hex_to_data(uint8_t *data, const char *p)
 
3679
{
 
3680
    int c, len, v;
 
3681
 
 
3682
    len = 0;
 
3683
    v = 1;
 
3684
    for (;;) {
 
3685
        p += strspn(p, SPACE_CHARS);
 
3686
        if (*p == '\0')
 
3687
            break;
 
3688
        c = toupper((unsigned char) *p++);
 
3689
        if (c >= '0' && c <= '9')
 
3690
            c = c - '0';
 
3691
        else if (c >= 'A' && c <= 'F')
 
3692
            c = c - 'A' + 10;
 
3693
        else
 
3694
            break;
 
3695
        v = (v << 4) | c;
 
3696
        if (v & 0x100) {
 
3697
            if (data)
 
3698
                data[len] = v;
 
3699
            len++;
 
3700
            v = 1;
 
3701
        }
 
3702
    }
 
3703
    return len;
 
3704
}
 
3705
 
3533
3706
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3534
3707
                     unsigned int pts_num, unsigned int pts_den)
3535
3708
{
 
3709
    AVRational new_tb;
 
3710
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
 
3711
        if(new_tb.num != pts_num)
 
3712
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
 
3713
    }else
 
3714
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
 
3715
 
 
3716
    if(new_tb.num <= 0 || new_tb.den <= 0) {
 
3717
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
 
3718
        return;
 
3719
    }
 
3720
    s->time_base = new_tb;
3536
3721
    s->pts_wrap_bits = pts_wrap_bits;
3537
 
 
3538
 
    if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3539
 
        if(s->time_base.num != pts_num)
3540
 
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3541
 
    }else
3542
 
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3543
 
 
3544
 
    if(!s->time_base.num || !s->time_base.den)
3545
 
        s->time_base.num= s->time_base.den= 0;
3546
3722
}
3547
3723
 
3548
3724
int ff_url_join(char *str, int size, const char *proto,
3556
3732
    str[0] = '\0';
3557
3733
    if (proto)
3558
3734
        av_strlcatf(str, size, "%s://", proto);
3559
 
    if (authorization)
 
3735
    if (authorization && authorization[0])
3560
3736
        av_strlcatf(str, size, "%s@", authorization);
3561
3737
#if CONFIG_NETWORK && defined(AF_INET6)
3562
3738
    /* Determine if hostname is a numerical IPv6 address,
3589
3765
    }
3590
3766
    return strlen(str);
3591
3767
}
 
3768
 
 
3769
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
 
3770
                     AVFormatContext *src)
 
3771
{
 
3772
    AVPacket local_pkt;
 
3773
 
 
3774
    local_pkt = *pkt;
 
3775
    local_pkt.stream_index = dst_stream;
 
3776
    if (pkt->pts != AV_NOPTS_VALUE)
 
3777
        local_pkt.pts = av_rescale_q(pkt->pts,
 
3778
                                     src->streams[pkt->stream_index]->time_base,
 
3779
                                     dst->streams[dst_stream]->time_base);
 
3780
    if (pkt->dts != AV_NOPTS_VALUE)
 
3781
        local_pkt.dts = av_rescale_q(pkt->dts,
 
3782
                                     src->streams[pkt->stream_index]->time_base,
 
3783
                                     dst->streams[dst_stream]->time_base);
 
3784
    return av_write_frame(dst, &local_pkt);
 
3785
}
 
3786
 
 
3787
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
 
3788
                        void *context)
 
3789
{
 
3790
    const char *ptr = str;
 
3791
 
 
3792
    /* Parse key=value pairs. */
 
3793
    for (;;) {
 
3794
        const char *key;
 
3795
        char *dest = NULL, *dest_end;
 
3796
        int key_len, dest_len = 0;
 
3797
 
 
3798
        /* Skip whitespace and potential commas. */
 
3799
        while (*ptr && (isspace(*ptr) || *ptr == ','))
 
3800
            ptr++;
 
3801
        if (!*ptr)
 
3802
            break;
 
3803
 
 
3804
        key = ptr;
 
3805
 
 
3806
        if (!(ptr = strchr(key, '=')))
 
3807
            break;
 
3808
        ptr++;
 
3809
        key_len = ptr - key;
 
3810
 
 
3811
        callback_get_buf(context, key, key_len, &dest, &dest_len);
 
3812
        dest_end = dest + dest_len - 1;
 
3813
 
 
3814
        if (*ptr == '\"') {
 
3815
            ptr++;
 
3816
            while (*ptr && *ptr != '\"') {
 
3817
                if (*ptr == '\\') {
 
3818
                    if (!ptr[1])
 
3819
                        break;
 
3820
                    if (dest && dest < dest_end)
 
3821
                        *dest++ = ptr[1];
 
3822
                    ptr += 2;
 
3823
                } else {
 
3824
                    if (dest && dest < dest_end)
 
3825
                        *dest++ = *ptr;
 
3826
                    ptr++;
 
3827
                }
 
3828
            }
 
3829
            if (*ptr == '\"')
 
3830
                ptr++;
 
3831
        } else {
 
3832
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
 
3833
                if (dest && dest < dest_end)
 
3834
                    *dest++ = *ptr;
 
3835
        }
 
3836
        if (dest)
 
3837
            *dest = 0;
 
3838
    }
 
3839
}
 
3840
 
 
3841
int ff_find_stream_index(AVFormatContext *s, int id)
 
3842
{
 
3843
    int i;
 
3844
    for (i = 0; i < s->nb_streams; i++) {
 
3845
        if (s->streams[i]->id == id)
 
3846
            return i;
 
3847
    }
 
3848
    return -1;
 
3849
}
 
3850
 
 
3851
void ff_make_absolute_url(char *buf, int size, const char *base,
 
3852
                          const char *rel)
 
3853
{
 
3854
    char *sep;
 
3855
    /* Absolute path, relative to the current server */
 
3856
    if (base && strstr(base, "://") && rel[0] == '/') {
 
3857
        if (base != buf)
 
3858
            av_strlcpy(buf, base, size);
 
3859
        sep = strstr(buf, "://");
 
3860
        if (sep) {
 
3861
            sep += 3;
 
3862
            sep = strchr(sep, '/');
 
3863
            if (sep)
 
3864
                *sep = '\0';
 
3865
        }
 
3866
        av_strlcat(buf, rel, size);
 
3867
        return;
 
3868
    }
 
3869
    /* If rel actually is an absolute url, just copy it */
 
3870
    if (!base || strstr(rel, "://") || rel[0] == '/') {
 
3871
        av_strlcpy(buf, rel, size);
 
3872
        return;
 
3873
    }
 
3874
    if (base != buf)
 
3875
        av_strlcpy(buf, base, size);
 
3876
    /* Remove the file name from the base url */
 
3877
    sep = strrchr(buf, '/');
 
3878
    if (sep)
 
3879
        sep[1] = '\0';
 
3880
    else
 
3881
        buf[0] = '\0';
 
3882
    while (av_strstart(rel, "../", NULL) && sep) {
 
3883
        /* Remove the path delimiter at the end */
 
3884
        sep[0] = '\0';
 
3885
        sep = strrchr(buf, '/');
 
3886
        /* If the next directory name to pop off is "..", break here */
 
3887
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
 
3888
            /* Readd the slash we just removed */
 
3889
            av_strlcat(buf, "/", size);
 
3890
            break;
 
3891
        }
 
3892
        /* Cut off the directory name */
 
3893
        if (sep)
 
3894
            sep[1] = '\0';
 
3895
        else
 
3896
            buf[0] = '\0';
 
3897
        rel += 3;
 
3898
    }
 
3899
    av_strlcat(buf, rel, size);
 
3900
}