utils.c 116 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1
/*
2
 * various utility functions for use within Libav
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
Fabrice Bellard's avatar
Fabrice Bellard committed
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
11
 *
12
 * Libav is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with Libav; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Fabrice Bellard's avatar
Fabrice Bellard committed
20
 */
21 22 23

/* #define DEBUG */

Fabrice Bellard's avatar
Fabrice Bellard committed
24
#include "avformat.h"
25
#include "avio_internal.h"
26
#include "internal.h"
27
#include "libavcodec/internal.h"
28
#include "libavcodec/bytestream.h"
29
#include "libavutil/opt.h"
30
#include "libavutil/dict.h"
31
#include "libavutil/pixdesc.h"
32
#include "metadata.h"
33
#include "id3v2.h"
34
#include "libavutil/avassert.h"
35
#include "libavutil/avstring.h"
36
#include "libavutil/mathematics.h"
37
#include "libavutil/parseutils.h"
38
#include "libavutil/time.h"
39
#include "riff.h"
40
#include "audiointerleave.h"
41
#include "url.h"
42 43 44 45
#include <stdarg.h>
#if CONFIG_NETWORK
#include "network.h"
#endif
46

47 48 49
#undef NDEBUG
#include <assert.h>

50
/**
51
 * @file
52
 * various utility functions for use within Libav
53 54
 */

55 56 57 58 59
unsigned avformat_version(void)
{
    return LIBAVFORMAT_VERSION_INT;
}

60
const char *avformat_configuration(void)
61
{
62
    return LIBAV_CONFIGURATION;
63 64
}

65
const char *avformat_license(void)
66 67
{
#define LICENSE_PREFIX "libavformat license: "
68
    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
69 70
}

71
/** head of registered input format linked list */
72
static AVInputFormat *first_iformat = NULL;
73
/** head of registered output format linked list */
74
static AVOutputFormat *first_oformat = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
75

76 77 78 79 80 81 82 83 84 85 86 87
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
{
    if(f) return f->next;
    else  return first_iformat;
}

AVOutputFormat *av_oformat_next(AVOutputFormat *f)
{
    if(f) return f->next;
    else  return first_oformat;
}

88
void av_register_input_format(AVInputFormat *format)
Fabrice Bellard's avatar
Fabrice Bellard committed
89
{
90 91 92 93 94 95 96 97 98 99 100
    AVInputFormat **p;
    p = &first_iformat;
    while (*p != NULL) p = &(*p)->next;
    *p = format;
    format->next = NULL;
}

void av_register_output_format(AVOutputFormat *format)
{
    AVOutputFormat **p;
    p = &first_oformat;
Fabrice Bellard's avatar
Fabrice Bellard committed
101 102 103 104 105
    while (*p != NULL) p = &(*p)->next;
    *p = format;
    format->next = NULL;
}

106
int av_match_ext(const char *filename, const char *extensions)
Fabrice Bellard's avatar
Fabrice Bellard committed
107 108 109 110
{
    const char *ext, *p;
    char ext1[32], *q;

Michael Niedermayer's avatar
Michael Niedermayer committed
111 112
    if(!filename)
        return 0;
113

Fabrice Bellard's avatar
Fabrice Bellard committed
114 115 116 117 118 119
    ext = strrchr(filename, '.');
    if (ext) {
        ext++;
        p = extensions;
        for(;;) {
            q = ext1;
120
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
Fabrice Bellard's avatar
Fabrice Bellard committed
121 122
                *q++ = *p++;
            *q = '\0';
123
            if (!av_strcasecmp(ext1, ext))
Fabrice Bellard's avatar
Fabrice Bellard committed
124
                return 1;
125
            if (*p == '\0')
Fabrice Bellard's avatar
Fabrice Bellard committed
126 127 128 129 130 131 132
                break;
            p++;
        }
    }
    return 0;
}

133 134 135 136 137 138 139 140 141 142 143
static int match_format(const char *name, const char *names)
{
    const char *p;
    int len, namelen;

    if (!name || !names)
        return 0;

    namelen = strlen(name);
    while ((p = strchr(names, ','))) {
        len = FFMAX(p - names, namelen);
144
        if (!av_strncasecmp(name, names, len))
145 146 147
            return 1;
        names = p+1;
    }
148
    return !av_strcasecmp(name, names);
149 150
}

151 152
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
                                const char *mime_type)
Fabrice Bellard's avatar
Fabrice Bellard committed
153
{
154
    AVOutputFormat *fmt = NULL, *fmt_found;
Fabrice Bellard's avatar
Fabrice Bellard committed
155 156
    int score_max, score;

157
    /* specific test for image sequences */
158
#if CONFIG_IMAGE2_MUXER
159
    if (!short_name && filename &&
160
        av_filename_number_test(filename) &&
161
        ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
162
        return av_guess_format("image2", NULL, NULL);
163
    }
164
#endif
165
    /* Find the proper file type. */
Fabrice Bellard's avatar
Fabrice Bellard committed
166 167
    fmt_found = NULL;
    score_max = 0;
168
    while ((fmt = av_oformat_next(fmt))) {
Fabrice Bellard's avatar
Fabrice Bellard committed
169
        score = 0;
170
        if (fmt->name && short_name && !av_strcasecmp(fmt->name, short_name))
Fabrice Bellard's avatar
Fabrice Bellard committed
171 172 173
            score += 100;
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
            score += 10;
174
        if (filename && fmt->extensions &&
175
            av_match_ext(filename, fmt->extensions)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
176 177 178 179 180 181 182 183
            score += 5;
        }
        if (score > score_max) {
            score_max = score;
            fmt_found = fmt;
        }
    }
    return fmt_found;
184
}
Fabrice Bellard's avatar
Fabrice Bellard committed
185

186
enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
187 188
                            const char *filename, const char *mime_type, enum AVMediaType type){
    if(type == AVMEDIA_TYPE_VIDEO){
189
        enum AVCodecID codec_id= AV_CODEC_ID_NONE;
190

191
#if CONFIG_IMAGE2_MUXER
192
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
193
            codec_id= ff_guess_image2_codec(filename);
194
        }
195
#endif
196
        if(codec_id == AV_CODEC_ID_NONE)
197 198
            codec_id= fmt->video_codec;
        return codec_id;
199
    }else if(type == AVMEDIA_TYPE_AUDIO)
200
        return fmt->audio_codec;
201 202
    else if (type == AVMEDIA_TYPE_SUBTITLE)
        return fmt->subtitle_codec;
203
    else
204
        return AV_CODEC_ID_NONE;
205 206
}

207 208
AVInputFormat *av_find_input_format(const char *short_name)
{
209 210
    AVInputFormat *fmt = NULL;
    while ((fmt = av_iformat_next(fmt))) {
211
        if (match_format(short_name, fmt->name))
212 213 214 215 216
            return fmt;
    }
    return NULL;
}

217 218
/* an arbitrarily chosen "sane" max packet size -- 50M */
#define SANE_CHUNK_SIZE (50000000)
Fabrice Bellard's avatar
Fabrice Bellard committed
219

220 221 222 223 224
/*
 * Read the data in sane-sized chunks and append to pkt.
 * Return the number of bytes read or an error.
 */
static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
Michael Niedermayer's avatar
Michael Niedermayer committed
225
{
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
    int64_t chunk_size = size;
    int orig_pos       = pkt->pos; // av_grow_packet might reset pos
    int orig_size      = pkt->size;
    int ret = 0;

    do {
        int prev_size = pkt->size;
        int read_size;

        /*
         * When the caller requests a lot of data, limit it to the amount left
         * in file or SANE_CHUNK_SIZE when it is not known
         */
        if (size > SANE_CHUNK_SIZE) {
            int64_t filesize = avio_size(s) - avio_tell(s);
            chunk_size = FFMAX(filesize, SANE_CHUNK_SIZE);
        }
        read_size = FFMIN(size, chunk_size);

        ret = av_grow_packet(pkt, read_size);
        if (ret < 0)
            break;
Michael Niedermayer's avatar
Michael Niedermayer committed
248

249 250 251 252 253
        ret = avio_read(s, pkt->data + prev_size, read_size);
        if (ret != read_size) {
            av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
            break;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
254

255 256
        size -= read_size;
    } while (size > 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
257

258 259
    pkt->pos = orig_pos;
    if (!pkt->size)
Michael Niedermayer's avatar
Michael Niedermayer committed
260
        av_free_packet(pkt);
261 262 263 264 265 266 267 268 269
    return pkt->size > orig_size ? pkt->size - orig_size : ret;
}

int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
{
    av_init_packet(pkt);
    pkt->data = NULL;
    pkt->size = 0;
    pkt->pos  = avio_tell(s);
Michael Niedermayer's avatar
Michael Niedermayer committed
270

271
    return append_packet_chunked(s, pkt, size);
Michael Niedermayer's avatar
Michael Niedermayer committed
272 273
}

274
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
275 276 277
{
    if (!pkt->size)
        return av_get_packet(s, pkt, size);
278
    return append_packet_chunked(s, pkt, size);
279 280
}

281

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

288
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
289
{
290
    AVProbeData lpd = *pd;
291
    AVInputFormat *fmt1 = NULL, *fmt;
292
    int score, id3 = 0;
293

294 295 296 297 298 299
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
        int id3len = ff_id3v2_tag_len(lpd.buf);
        if (lpd.buf_size > id3len + 16) {
            lpd.buf += id3len;
            lpd.buf_size -= id3len;
        }
300
        id3 = 1;
301 302
    }

303
    fmt = NULL;
304
    while ((fmt1 = av_iformat_next(fmt1))) {
305
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
306 307
            continue;
        score = 0;
308
        if (fmt1->read_probe) {
309
            score = fmt1->read_probe(&lpd);
310
        } else if (fmt1->extensions) {
311
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
312 313
                score = 50;
            }
314
        }
315 316
        if (score > *score_max) {
            *score_max = score;
317
            fmt = fmt1;
318 319
        }else if (score == *score_max)
            fmt = NULL;
320
    }
321 322

    /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
323
    if (!fmt && is_opened && *score_max < AVPROBE_SCORE_MAX/4) {
324 325 326 327 328 329 330
        while ((fmt = av_iformat_next(fmt)))
            if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
                *score_max = AVPROBE_SCORE_MAX/4;
                break;
            }
    }

331 332 333 334 335 336 337 338
    if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4-1) {
        while ((fmt = av_iformat_next(fmt)))
            if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
                *score_max = AVPROBE_SCORE_MAX/4-1;
                break;
            }
    }

339 340 341
    return fmt;
}

342 343 344 345 346
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
    int score=0;
    return av_probe_input_format2(pd, is_opened, &score);
}

347
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
348
{
349
    static const struct {
350
        const char *name; enum AVCodecID id; enum AVMediaType type;
351
    } fmt_id_type[] = {
352 353 354 355 356 357 358 359
        { "aac"      , AV_CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
        { "ac3"      , AV_CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
        { "dts"      , AV_CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
        { "eac3"     , AV_CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
        { "h264"     , AV_CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
        { "m4v"      , AV_CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
        { "mp3"      , AV_CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
        { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
360 361 362
        { 0 }
    };
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
363 364

    if (fmt) {
365
        int i;
366 367
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
368 369 370 371 372 373
        for (i = 0; fmt_id_type[i].name; i++) {
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
                st->codec->codec_id   = fmt_id_type[i].id;
                st->codec->codec_type = fmt_id_type[i].type;
                break;
            }
374
        }
375 376 377 378
    }
    return !!fmt;
}

379 380
/************************************************************/
/* input media file */
381

382
/** size of probe buffer, for guessing file type from file contents */
383
#define PROBE_BUF_MIN 2048
384
#define PROBE_BUF_MAX (1<<20)
385

386
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
                          const char *filename, void *logctx,
                          unsigned int offset, unsigned int max_probe_size)
{
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
    unsigned char *buf = NULL;
    int ret = 0, probe_size;

    if (!max_probe_size) {
        max_probe_size = PROBE_BUF_MAX;
    } else if (max_probe_size > PROBE_BUF_MAX) {
        max_probe_size = PROBE_BUF_MAX;
    } else if (max_probe_size < PROBE_BUF_MIN) {
        return AVERROR(EINVAL);
    }

    if (offset >= max_probe_size) {
        return AVERROR(EINVAL);
    }

406
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
407
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
408
        int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
409 410 411 412 413 414 415 416
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;

        if (probe_size < offset) {
            continue;
        }

        /* read probe data */
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
417
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
418 419 420 421 422 423
            /* fail if error was not end of file, otherwise, lower score */
            if (ret != AVERROR_EOF) {
                av_free(buf);
                return ret;
            }
            score = 0;
424
            ret = 0;            /* error was end of file, nothing read */
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
        }
        pd.buf_size += ret;
        pd.buf = &buf[offset];

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

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

441
    if (!*fmt) {
442
        av_free(buf);
443 444 445
        return AVERROR_INVALIDDATA;
    }

446
    /* rewind. reuse probe buffer to avoid seeking */
447
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
448
        av_free(buf);
449

450
    return ret;
451 452
}

453
/* open input file and probe the format if necessary */
454
static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
455 456 457 458 459 460 461
{
    int ret;
    AVProbeData pd = {filename, NULL, 0};

    if (s->pb) {
        s->flags |= AVFMT_FLAG_CUSTOM_IO;
        if (!s->iformat)
462
            return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
463 464 465 466 467 468 469 470 471
        else if (s->iformat->flags & AVFMT_NOFILE)
            return AVERROR(EINVAL);
        return 0;
    }

    if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
        (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
        return 0;

472
    if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
473
                          &s->interrupt_callback, options)) < 0)
474
        return ret;
475 476
    if (s->iformat)
        return 0;
477
    return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
478 479
}

480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
                               AVPacketList **plast_pktl){
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
    if (!pktl)
        return NULL;

    if (*packet_buffer)
        (*plast_pktl)->next = pktl;
    else
        *packet_buffer = pktl;

    /* add the packet in the buffered packet list */
    *plast_pktl = pktl;
    pktl->pkt= *pkt;
    return &pktl->pkt;
}

497
static int queue_attached_pictures(AVFormatContext *s)
498 499 500
{
    int i;
    for (i = 0; i < s->nb_streams; i++)
501 502
        if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
            s->streams[i]->discard < AVDISCARD_ALL) {
503
            AVPacket copy = s->streams[i]->attached_pic;
504 505 506 507
            copy.buf      = av_buffer_ref(copy.buf);
            if (!copy.buf)
                return AVERROR(ENOMEM);

508 509
            add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
        }
510
    return 0;
511 512
}

513 514 515
int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
{
    AVFormatContext *s = *ps;
516
    int ret = 0;
517
    AVDictionary *tmp = NULL;
518
    ID3v2ExtraMeta *id3v2_extra_meta = NULL;
519 520 521 522 523 524 525 526 527 528 529 530

    if (!s && !(s = avformat_alloc_context()))
        return AVERROR(ENOMEM);
    if (fmt)
        s->iformat = fmt;

    if (options)
        av_dict_copy(&tmp, *options, 0);

    if ((ret = av_opt_set_dict(s, &tmp)) < 0)
        goto fail;

531
    if ((ret = init_input(s, filename, &tmp)) < 0)
532 533 534 535 536 537 538 539 540 541 542
        goto fail;

    /* check filename in case an image number is expected */
    if (s->iformat->flags & AVFMT_NEEDNUMBER) {
        if (!av_filename_number_test(filename)) {
            ret = AVERROR(EINVAL);
            goto fail;
        }
    }

    s->duration = s->start_time = AV_NOPTS_VALUE;
543
    av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560

    /* allocate private data */
    if (s->iformat->priv_data_size > 0) {
        if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
        if (s->iformat->priv_class) {
            *(const AVClass**)s->priv_data = s->iformat->priv_class;
            av_opt_set_defaults(s->priv_data);
            if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
                goto fail;
        }
    }

    /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
    if (s->pb)
561
        ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
562 563

    if (s->iformat->read_header)
564
        if ((ret = s->iformat->read_header(s)) < 0)
565 566
            goto fail;

567 568 569 570 571
    if (id3v2_extra_meta &&
        (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
        goto fail;
    ff_id3v2_free_extra_meta(&id3v2_extra_meta);

572 573
    if ((ret = queue_attached_pictures(s)) < 0)
        goto fail;
574

575 576 577 578 579 580 581 582 583 584 585 586 587
    if (s->pb && !s->data_offset)
        s->data_offset = avio_tell(s->pb);

    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;

    if (options) {
        av_dict_free(options);
        *options = tmp;
    }
    *ps = s;
    return 0;

fail:
588
    ff_id3v2_free_extra_meta(&id3v2_extra_meta);
589 590 591 592 593 594 595 596
    av_dict_free(&tmp);
    if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
        avio_close(s->pb);
    avformat_free_context(s);
    *ps = NULL;
    return ret;
}

597 598
/*******************************************************/

599 600
static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
{
601
    if(st->codec->codec_id == AV_CODEC_ID_PROBE){
602 603 604 605
        AVProbeData *pd = &st->probe_data;
        av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
        --st->probe_packets;

606 607 608 609 610 611 612
        if (pkt) {
            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
            pd->buf_size += pkt->size;
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
        } else {
            st->probe_packets = 0;
613 614 615 616 617
            if (!pd->buf_size) {
                av_log(s, AV_LOG_ERROR, "nothing to probe for stream %d\n",
                       st->index);
                return;
            }
618
        }
619

620 621
        if (!st->probe_packets ||
            av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
622
            set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
623
            if(st->codec->codec_id != AV_CODEC_ID_PROBE){
624 625 626 627 628 629 630 631
                pd->buf_size=0;
                av_freep(&pd->buf);
                av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
            }
        }
    }
}

632
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
633
{
634
    int ret, i;
635
    AVStream *st;
636 637 638 639 640 641

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

        if (pktl) {
            *pkt = pktl->pkt;
642
            st = s->streams[pkt->stream_index];
643
            if (st->codec->codec_id != AV_CODEC_ID_PROBE || !st->probe_packets ||
644 645 646 647 648 649
                s->raw_packet_buffer_remaining_size < pkt->size) {
                AVProbeData *pd;
                if (st->probe_packets) {
                    probe_codec(s, st, NULL);
                }
                pd = &st->probe_data;
650 651
                av_freep(&pd->buf);
                pd->buf_size = 0;
652
                s->raw_packet_buffer = pktl->next;
653
                s->raw_packet_buffer_remaining_size += pkt->size;
654 655 656 657 658
                av_free(pktl);
                return 0;
            }
        }

659 660
        pkt->data = NULL;
        pkt->size = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
661 662
        av_init_packet(pkt);
        ret= s->iformat->read_packet(s, pkt);
663 664 665
        if (ret < 0) {
            if (!pktl || ret == AVERROR(EAGAIN))
                return ret;
666 667 668 669 670 671
            for (i = 0; i < s->nb_streams; i++) {
                st = s->streams[i];
                if (st->probe_packets) {
                    probe_codec(s, st, NULL);
                }
            }
672 673
            continue;
        }
674 675 676 677 678 679

        if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
            (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
            av_log(s, AV_LOG_WARNING,
                   "Dropped corrupted packet (stream = %d)\n",
                   pkt->stream_index);
680
            av_free_packet(pkt);
681 682 683
            continue;
        }

Michael Niedermayer's avatar
Michael Niedermayer committed
684
        st= s->streams[pkt->stream_index];
685

Michael Niedermayer's avatar
Michael Niedermayer committed
686
        switch(st->codec->codec_type){
687
        case AVMEDIA_TYPE_VIDEO:
Michael Niedermayer's avatar
Michael Niedermayer committed
688 689
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
            break;
690
        case AVMEDIA_TYPE_AUDIO:
Michael Niedermayer's avatar
Michael Niedermayer committed
691 692
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
            break;
693
        case AVMEDIA_TYPE_SUBTITLE:
Michael Niedermayer's avatar
Michael Niedermayer committed
694 695 696
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
            break;
        }
697

698
        if(!pktl && (st->codec->codec_id != AV_CODEC_ID_PROBE ||
699
                     !st->probe_packets))
700 701
            return ret;

702
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
703
        s->raw_packet_buffer_remaining_size -= pkt->size;
704

705
        probe_codec(s, st, pkt);
706
    }
707 708 709 710
}

/**********************************************************/

711
/**
712
 * Get the number of samples of an audio frame. Return -1 on error.
713
 */
714
int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
715 716 717
{
    int frame_size;

718 719 720
    /* give frame_size priority if demuxing */
    if (!mux && enc->frame_size > 1)
        return enc->frame_size;
721

722 723 724 725 726 727 728 729
    if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
        return frame_size;

    /* fallback to using frame_size if muxing */
    if (enc->frame_size > 1)
        return enc->frame_size;

    return -1;
730 731 732
}


733
/**
734
 * Return the frame duration in seconds. Return 0 if not available.
735
 */
736 737
void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
                               AVCodecParserContext *pc, AVPacket *pkt)
738 739 740 741 742
{
    int frame_size;

    *pnum = 0;
    *pden = 0;
743
    switch(st->codec->codec_type) {
744
    case AVMEDIA_TYPE_VIDEO:
745 746 747
        if (st->avg_frame_rate.num) {
            *pnum = st->avg_frame_rate.den;
            *pden = st->avg_frame_rate.num;
748
        } else if(st->time_base.num*1000LL > st->time_base.den) {
749 750
            *pnum = st->time_base.num;
            *pden = st->time_base.den;
751 752 753
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
            *pnum = st->codec->time_base.num;
            *pden = st->codec->time_base.den;
754
            if (pc && pc->repeat_pict) {
755 756 757 758
                if (*pnum > INT_MAX / (1 + pc->repeat_pict))
                    *pden /= 1 + pc->repeat_pict;
                else
                    *pnum *= 1 + pc->repeat_pict;
759
            }
760 761 762 763 764
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
            //Thus if we have no parser in such case leave duration undefined.
            if(st->codec->ticks_per_frame>1 && !pc){
                *pnum = *pden = 0;
            }
765 766
        }
        break;
767
    case AVMEDIA_TYPE_AUDIO:
768
        frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
769
        if (frame_size <= 0 || st->codec->sample_rate <= 0)
770 771
            break;
        *pnum = frame_size;
772
        *pden = st->codec->sample_rate;
773 774 775 776 777 778
        break;
    default:
        break;
    }
}

779 780 781 782 783 784 785 786
static int is_intra_only(enum AVCodecID id)
{
    const AVCodecDescriptor *d = avcodec_descriptor_get(id);
    if (!d)
        return 0;
    if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
        return 0;
    return 1;
787 788
}

789 790 791
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
                                      int64_t dts, int64_t pts)
{
792 793 794
    AVStream *st= s->streams[stream_index];
    AVPacketList *pktl= s->packet_buffer;

795
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
796 797 798 799 800 801 802 803 804 805 806 807 808 809
        return;

    st->first_dts= dts - st->cur_dts;
    st->cur_dts= dts;

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

        if(pktl->pkt.dts != AV_NOPTS_VALUE)
            pktl->pkt.dts += st->first_dts;
810 811 812

        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
            st->start_time= pktl->pkt.pts;
813
    }
814 815
    if (st->start_time == AV_NOPTS_VALUE)
        st->start_time = pts;
816 817
}

818 819
static void update_initial_durations(AVFormatContext *s, AVStream *st,
                                     int stream_index, int duration)
820 821
{
    AVPacketList *pktl= s->packet_buffer;
822 823 824 825 826
    int64_t cur_dts= 0;

    if(st->first_dts != AV_NOPTS_VALUE){
        cur_dts= st->first_dts;
        for(; pktl; pktl= pktl->next){
827
            if(pktl->pkt.stream_index == stream_index){
828 829
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
                    break;
830
                cur_dts -= duration;
831 832 833 834 835 836
            }
        }
        pktl= s->packet_buffer;
        st->first_dts = cur_dts;
    }else if(st->cur_dts)
        return;
837 838

    for(; pktl; pktl= pktl->next){
839
        if(pktl->pkt.stream_index != stream_index)
840
            continue;
841 842
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
           && !pktl->pkt.duration){
843
            pktl->pkt.dts= cur_dts;
844
            if(!st->codec->has_b_frames)
845
                pktl->pkt.pts= cur_dts;
846 847 848
            cur_dts += duration;
            if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
                pktl->pkt.duration = duration;
849 850 851
        }else
            break;
    }
852 853
    if(st->first_dts == AV_NOPTS_VALUE)
        st->cur_dts= cur_dts;
854 855
}

856
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
857 858
                               AVCodecParserContext *pc, AVPacket *pkt)
{
859
    int num, den, presentation_delayed, delay, i;
860
    int64_t offset;
861

862 863 864
    if (s->flags & AVFMT_FLAG_NOFILLIN)
        return;

865 866 867
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
        pkt->dts= AV_NOPTS_VALUE;

868 869 870
    /* do we have a video B-frame ? */
    delay= st->codec->has_b_frames;
    presentation_delayed = 0;
871

872 873 874
    /* XXX: need has_b_frame, but cannot get it if the codec is
        not initialized */
    if (delay &&
875
        pc && pc->pict_type != AV_PICTURE_TYPE_B)
876 877
        presentation_delayed = 1;

878 879 880 881 882
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
        pkt->dts -= 1LL<<st->pts_wrap_bits;
    }

883 884 885 886
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
    // we take the conservative approach and discard both
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
887
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
888 889 890
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
    }

891
    if (pkt->duration == 0 && st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
892
        ff_compute_frame_duration(&num, &den, st, pc, pkt);
893
        if (den && num) {
894
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
895

896
            if(pkt->duration != 0 && s->packet_buffer)
897
                update_initial_durations(s, st, pkt->stream_index, pkt->duration);
898 899 900
        }
    }

901 902
    /* correct timestamps with byte offset if demuxers only have timestamps
       on packet boundaries */
903 904 905 906 907 908 909 910 911
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
        /* this will estimate bitrate based on this frame's duration and size */
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
        if(pkt->pts != AV_NOPTS_VALUE)
            pkt->pts += offset;
        if(pkt->dts != AV_NOPTS_VALUE)
            pkt->dts += offset;
    }

912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
    if (pc && pc->dts_sync_point >= 0) {
        // we have synchronization info from the parser
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
        if (den > 0) {
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
            if (pkt->dts != AV_NOPTS_VALUE) {
                // got DTS from the stream, update reference timestamp
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
                // compute DTS based on reference timestamp
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
            }
            if (pc->dts_sync_point > 0)
                st->reference_dts = pkt->dts; // new reference
        }
    }

Diego Biurrun's avatar
Diego Biurrun committed
931
    /* This may be redundant, but it should not hurt. */
Michael Niedermayer's avatar
Michael Niedermayer committed
932 933
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
        presentation_delayed = 1;
934

935 936 937 938
    av_dlog(NULL,
            "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);
939
    /* interpolate PTS and DTS if they are not present */
940
    //We skip H264 currently because delay and has_b_frames are not reliably set
941
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
Michael Niedermayer's avatar
Michael Niedermayer committed
942
        if (presentation_delayed) {
943 944
            /* DTS = decompression timestamp */
            /* PTS = presentation timestamp */
Michael Niedermayer's avatar
Michael Niedermayer committed
945
            if (pkt->dts == AV_NOPTS_VALUE)
Michael Niedermayer's avatar
Michael Niedermayer committed
946
                pkt->dts = st->last_IP_pts;
947
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
Michael Niedermayer's avatar
Michael Niedermayer committed
948 949 950 951
            if (pkt->dts == AV_NOPTS_VALUE)
                pkt->dts = st->cur_dts;

            /* this is tricky: the dts must be incremented by the duration
952
            of the frame we are displaying, i.e. the last I- or P-frame */
Michael Niedermayer's avatar
Michael Niedermayer committed
953 954
            if (st->last_IP_duration == 0)
                st->last_IP_duration = pkt->duration;
955
            if(pkt->dts != AV_NOPTS_VALUE)
Michael Niedermayer's avatar
Michael Niedermayer committed
956
                st->cur_dts = pkt->dts + st->last_IP_duration;
Michael Niedermayer's avatar
Michael Niedermayer committed
957 958
            st->last_IP_duration  = pkt->duration;
            st->last_IP_pts= pkt->pts;
Michael Niedermayer's avatar
Michael Niedermayer committed
959
            /* cannot compute PTS if not present (we can compute it only
960
            by knowing the future */
961 962 963 964 965 966
        } else if (pkt->pts != AV_NOPTS_VALUE ||
                   pkt->dts != AV_NOPTS_VALUE ||
                   pkt->duration              ||
                   st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
            int duration = pkt->duration;
            if (!duration && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
967
                ff_compute_frame_duration(&num, &den, st, pc, pkt);
968 969 970 971 972 973 974 975 976 977 978
                if (den && num) {
                    duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den,
                                                 den * (int64_t)st->time_base.num,
                                                 AV_ROUND_DOWN);
                    if (duration != 0 && s->packet_buffer) {
                        update_initial_durations(s, st, pkt->stream_index,
                                                 duration);
                    }
                }
            }

979 980
            if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE ||
                duration) {
Justin Ruggles's avatar
Justin Ruggles committed
981 982 983 984 985 986 987 988 989 990
                /* presentation is not delayed : PTS and DTS are the same */
                if (pkt->pts == AV_NOPTS_VALUE)
                    pkt->pts = pkt->dts;
                update_initial_timestamps(s, pkt->stream_index, pkt->pts,
                                          pkt->pts);
                if (pkt->pts == AV_NOPTS_VALUE)
                    pkt->pts = st->cur_dts;
                pkt->dts = pkt->pts;
                if (pkt->pts != AV_NOPTS_VALUE)
                    st->cur_dts = pkt->pts + duration;
991
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
992
        }
993
    }
994

995
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
996 997 998 999 1000
        st->pts_buffer[0]= pkt->pts;
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
        if(pkt->dts == AV_NOPTS_VALUE)
            pkt->dts= st->pts_buffer[0];
1001
        if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1002
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1003
        }
1004 1005 1006 1007
        if(pkt->dts > st->cur_dts)
            st->cur_dts = pkt->dts;
    }

1008 1009 1010
    av_dlog(NULL,
            "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n",
            presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
1011

1012
    /* update flags */
1013
    if (is_intra_only(st->codec->codec_id))
1014
        pkt->flags |= AV_PKT_FLAG_KEY;
1015 1016
    if (pc)
        pkt->convergence_duration = pc->convergence_duration;
1017 1018
}

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
{
    while (*pkt_buf) {
        AVPacketList *pktl = *pkt_buf;
        *pkt_buf = pktl->next;
        av_free_packet(&pktl->pkt);
        av_freep(&pktl);
    }
    *pkt_buf_end = NULL;
}

1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
/**
 * Parse a packet, add all split parts to parse_queue
 *
 * @param pkt packet to parse, NULL when flushing the parser at end of stream
 */
static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
{
    AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
    AVStream     *st = s->streams[stream_index];
    uint8_t    *data = pkt ? pkt->data : NULL;
    int         size = pkt ? pkt->size : 0;
    int ret = 0, got_output = 0;

    if (!pkt) {
        av_init_packet(&flush_pkt);
        pkt = &flush_pkt;
        got_output = 1;
    }

    while (size > 0 || (pkt == &flush_pkt && got_output)) {
        int len;

        av_init_packet(&out_pkt);
        len = av_parser_parse2(st->parser,  st->codec,
                               &out_pkt.data, &out_pkt.size, data, size,
                               pkt->pts, pkt->dts, pkt->pos);

        pkt->pts = pkt->dts = AV_NOPTS_VALUE;
        /* increment read pointer */
        data += len;
        size -= len;

        got_output = !!out_pkt.size;

        if (!out_pkt.size)
            continue;

        /* set the duration */
        out_pkt.duration = 0;
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
            if (st->codec->sample_rate > 0) {
                out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
                                                    (AVRational){ 1, st->codec->sample_rate },
                                                    st->time_base,
                                                    AV_ROUND_DOWN);
            }
        } else if (st->codec->time_base.num != 0 &&
                   st->codec->time_base.den != 0) {
            out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
                                                st->codec->time_base,
                                                st->time_base,
                                                AV_ROUND_DOWN);
        }

        out_pkt.stream_index = st->index;
        out_pkt.pts = st->parser->pts;
        out_pkt.dts = st->parser->dts;
        out_pkt.pos = st->parser->pos;

        if (st->parser->key_frame == 1 ||
            (st->parser->key_frame == -1 &&
             st->parser->pict_type == AV_PICTURE_TYPE_I))
            out_pkt.flags |= AV_PKT_FLAG_KEY;

        compute_pkt_fields(s, st, st->parser, &out_pkt);

        if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
            out_pkt.flags & AV_PKT_FLAG_KEY) {
            ff_reduce_index(s, st->index);
            av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
                               0, 0, AVINDEX_KEYFRAME);
        }

        if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1104 1105 1106
            out_pkt.buf   = pkt->buf;
            pkt->buf      = NULL;
#if FF_API_DESTRUCT_PACKET
1107 1108
            out_pkt.destruct = pkt->destruct;
            pkt->destruct = NULL;
1109
#endif
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
        }
        if ((ret = av_dup_packet(&out_pkt)) < 0)
            goto fail;

        if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
            av_free_packet(&out_pkt);
            ret = AVERROR(ENOMEM);
            goto fail;
        }
    }


    /* end of the stream => close and free the parser */
    if (pkt == &flush_pkt) {
        av_parser_close(st->parser);
        st->parser = NULL;
    }

fail:
    av_free_packet(pkt);
    return ret;
}

1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
static int read_from_packet_buffer(AVPacketList **pkt_buffer,
                                   AVPacketList **pkt_buffer_end,
                                   AVPacket      *pkt)
{
    AVPacketList *pktl;
    av_assert0(*pkt_buffer);
    pktl = *pkt_buffer;
    *pkt = pktl->pkt;
    *pkt_buffer = pktl->next;
    if (!pktl->next)
        *pkt_buffer_end = NULL;
    av_freep(&pktl);
    return 0;
}

1148
static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1149
{
1150
    int ret = 0, i, got_packet = 0;
1151

1152 1153
    av_init_packet(pkt);

1154 1155 1156
    while (!got_packet && !s->parse_queue) {
        AVStream *st;
        AVPacket cur_pkt;
1157

1158
        /* read next packet */
1159
        ret = ff_read_packet(s, &cur_pkt);
1160 1161
        if (ret < 0) {
            if (ret == AVERROR(EAGAIN))
1162
                return ret;
1163 1164 1165 1166 1167
            /* flush the parsers */
            for(i = 0; i < s->nb_streams; i++) {
                st = s->streams[i];
                if (st->parser && st->need_parsing)
                    parse_packet(s, NULL, st->index);
1168
            }
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
            /* all remaining packets are now in parse_queue =>
             * really terminate parsing */
            break;
        }
        ret = 0;
        st  = s->streams[cur_pkt.stream_index];

        if (cur_pkt.pts != AV_NOPTS_VALUE &&
            cur_pkt.dts != AV_NOPTS_VALUE &&
            cur_pkt.pts < cur_pkt.dts) {
            av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
                   cur_pkt.stream_index,
                   cur_pkt.pts,
                   cur_pkt.dts,
                   cur_pkt.size);
        }
        if (s->debug & FF_FDEBUG_TS)
1186
            av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
                   cur_pkt.stream_index,
                   cur_pkt.pts,
                   cur_pkt.dts,
                   cur_pkt.size,
                   cur_pkt.duration,
                   cur_pkt.flags);

        if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
            st->parser = av_parser_init(st->codec->codec_id);
            if (!st->parser) {
                /* no parser available: just output the raw packets */
                st->need_parsing = AVSTREAM_PARSE_NONE;
            } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
            } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
                st->parser->flags |= PARSER_FLAG_ONCE;
1203
            }
1204
        }
1205

1206 1207 1208 1209 1210 1211 1212 1213
        if (!st->need_parsing || !st->parser) {
            /* no parsing needed: we just output the packet as is */
            *pkt = cur_pkt;
            compute_pkt_fields(s, st, NULL, pkt);
            if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
                (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
                ff_reduce_index(s, st->index);
                av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1214
            }
1215 1216 1217 1218 1219 1220 1221
            got_packet = 1;
        } else if (st->discard < AVDISCARD_ALL) {
            if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
                return ret;
        } else {
            /* free packet */
            av_free_packet(&cur_pkt);
1222 1223
        }
    }
1224 1225 1226 1227

    if (!got_packet && s->parse_queue)
        ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);

1228
    if(s->debug & FF_FDEBUG_TS)
1229
        av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1230 1231 1232
            pkt->stream_index,
            pkt->pts,
            pkt->dts,
1233
            pkt->size,
1234
            pkt->duration,
1235
            pkt->flags);
1236

1237
    return ret;
1238 1239 1240
}

int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Fabrice Bellard's avatar
Fabrice Bellard committed
1241
{
1242 1243
    const int genpts = s->flags & AVFMT_FLAG_GENPTS;
    int          eof = 0;
1244

1245
    if (!genpts)
1246 1247 1248
        return s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
                                                          &s->packet_buffer_end,
                                                          pkt) :
1249 1250
                                  read_frame_internal(s, pkt);

1251
    for (;;) {
1252
        int ret;
1253
        AVPacketList *pktl = s->packet_buffer;
1254

1255
        if (pktl) {
1256
            AVPacket *next_pkt = &pktl->pkt;
1257

1258
            if (next_pkt->dts != AV_NOPTS_VALUE) {
1259
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1260 1261 1262 1263 1264
                while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
                    if (pktl->pkt.stream_index == next_pkt->stream_index &&
                        (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
                         av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
                        next_pkt->pts = pktl->pkt.dts;
1265
                    }
1266
                    pktl = pktl->next;
1267 1268 1269
                }
                pktl = s->packet_buffer;
            }
1270

1271 1272 1273
            /* read packet from packet buffer, if there is data */
            if (!(next_pkt->pts == AV_NOPTS_VALUE &&
                  next_pkt->dts != AV_NOPTS_VALUE && !eof))
1274 1275
                return read_from_packet_buffer(&s->packet_buffer,
                                               &s->packet_buffer_end, pkt);
1276
        }
1277

1278 1279 1280 1281 1282 1283 1284
        ret = read_frame_internal(s, pkt);
        if (ret < 0) {
            if (pktl && ret != AVERROR(EAGAIN)) {
                eof = 1;
                continue;
            } else
                return ret;
1285
        }
1286 1287 1288 1289

        if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
                          &s->packet_buffer_end)) < 0)
            return AVERROR(ENOMEM);
1290 1291 1292 1293 1294 1295
    }
}

/* XXX: suppress the packet queue */
static void flush_packet_queue(AVFormatContext *s)
{
1296
    free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1297 1298
    free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
    free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1299

1300
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1301 1302
}

1303 1304 1305
/*******************************************************/
/* seek support */

1306 1307
int av_find_default_stream_index(AVFormatContext *s)
{
1308
    int first_audio_index = -1;
1309 1310 1311 1312 1313 1314 1315
    int i;
    AVStream *st;

    if (s->nb_streams <= 0)
        return -1;
    for(i = 0; i < s->nb_streams; i++) {
        st = s->streams[i];
1316 1317
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
            !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1318 1319
            return i;
        }
1320
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1321
            first_audio_index = i;
1322
    }
1323
    return first_audio_index >= 0 ? first_audio_index : 0;
1324 1325
}

1326 1327 1328
/**
 * Flush the frame reader.
 */
1329
void ff_read_frame_flush(AVFormatContext *s)
1330 1331
{
    AVStream *st;
1332
    int i, j;
1333 1334 1335 1336 1337 1338

    flush_packet_queue(s);

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

1340 1341 1342 1343
        if (st->parser) {
            av_parser_close(st->parser);
            st->parser = NULL;
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1344
        st->last_IP_pts = AV_NOPTS_VALUE;
1345
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1346
        st->reference_dts = AV_NOPTS_VALUE;
1347 1348

        st->probe_packets = MAX_PROBE_PACKETS;
1349 1350 1351

        for(j=0; j<MAX_REORDER_DELAY+1; j++)
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1352 1353 1354
    }
}

1355 1356
void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
{
1357 1358 1359
    int i;

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

1362
        st->cur_dts = av_rescale(timestamp,
1363 1364
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1365 1366 1367
    }
}

1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
void ff_reduce_index(AVFormatContext *s, int stream_index)
{
    AVStream *st= s->streams[stream_index];
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);

    if((unsigned)st->nb_index_entries >= max_entries){
        int i;
        for(i=0; 2*i<st->nb_index_entries; i++)
            st->index_entries[i]= st->index_entries[2*i];
        st->nb_index_entries= i;
    }
}

1381 1382 1383 1384
int ff_add_index_entry(AVIndexEntry **index_entries,
                       int *nb_index_entries,
                       unsigned int *index_entries_allocated_size,
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1385 1386
{
    AVIndexEntry *entries, *ie;
1387
    int index;
1388

1389
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1390
        return -1;
1391

1392 1393 1394
    entries = av_fast_realloc(*index_entries,
                              index_entries_allocated_size,
                              (*nb_index_entries + 1) *
1395
                              sizeof(AVIndexEntry));
1396 1397 1398
    if(!entries)
        return -1;

1399
    *index_entries= entries;
1400

1401
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1402

1403
    if(index<0){
1404
        index= (*nb_index_entries)++;
1405
        ie= &entries[index];
1406 1407 1408 1409
        assert(index==0 || ie[-1].timestamp < timestamp);
    }else{
        ie= &entries[index];
        if(ie->timestamp != timestamp){
1410 1411
            if(ie->timestamp <= timestamp)
                return -1;
1412 1413
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
            (*nb_index_entries)++;
Diego Biurrun's avatar
Diego Biurrun committed
1414
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1415
            distance= ie->min_distance;
1416
    }
1417

1418 1419
    ie->pos = pos;
    ie->timestamp = timestamp;
1420
    ie->min_distance= distance;
1421
    ie->size= size;
1422
    ie->flags = flags;
1423

1424
    return index;
1425 1426
}

1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
int av_add_index_entry(AVStream *st,
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
{
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
                              &st->index_entries_allocated_size, pos,
                              timestamp, size, distance, flags);
}

int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
                              int64_t wanted_timestamp, int flags)
1437 1438 1439 1440
{
    int a, b, m;
    int64_t timestamp;

1441 1442
    a = - 1;
    b = nb_entries;
1443

1444 1445 1446 1447
    //optimize appending index entries at the end
    if(b && entries[b-1].timestamp < wanted_timestamp)
        a= b-1;

1448 1449
    while (b - a > 1) {
        m = (a + b) >> 1;
1450
        timestamp = entries[m].timestamp;
1451 1452 1453
        if(timestamp >= wanted_timestamp)
            b = m;
        if(timestamp <= wanted_timestamp)
1454
            a = m;
1455
    }
1456
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1457

1458 1459 1460 1461 1462
    if(!(flags & AVSEEK_FLAG_ANY)){
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
        }
    }
1463

1464
    if(m == nb_entries)
1465 1466
        return -1;
    return  m;
1467 1468
}

1469 1470 1471 1472 1473 1474 1475
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
                              int flags)
{
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
                                     wanted_timestamp, flags);
}

1476 1477
int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
{
1478
    AVInputFormat *avif= s->iformat;
1479
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1480
    int64_t ts_min, ts_max, ts;
1481
    int index;
1482
    int64_t ret;
1483 1484
    AVStream *st;

1485 1486
    if (stream_index < 0)
        return -1;
1487

1488
    av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1489 1490 1491

    ts_max=
    ts_min= AV_NOPTS_VALUE;
Diego Biurrun's avatar
Diego Biurrun committed
1492
    pos_limit= -1; //gcc falsely says it may be uninitialized
1493 1494 1495 1496 1497

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

1498
        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()
1499
        index= FFMAX(index, 0);
1500 1501 1502 1503 1504
        e= &st->index_entries[index];

        if(e->timestamp <= target_ts || e->pos == e->min_distance){
            pos_min= e->pos;
            ts_min= e->timestamp;
1505 1506
            av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
                    pos_min,ts_min);
1507 1508 1509
        }else{
            assert(index==0);
        }
1510 1511

        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1512 1513
        assert(index < st->nb_index_entries);
        if(index >= 0){
1514 1515 1516 1517 1518
            e= &st->index_entries[index];
            assert(e->timestamp >= target_ts);
            pos_max= e->pos;
            ts_max= e->timestamp;
            pos_limit= pos_max - e->min_distance;
1519 1520
            av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
                    pos_max,pos_limit, ts_max);
1521 1522 1523
        }
    }

1524
    pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1525 1526 1527 1528
    if(pos<0)
        return -1;

    /* do the seek */
1529
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1530
        return ret;
1531

1532
    ff_update_cur_dts(s, st, ts);
1533 1534 1535 1536

    return 0;
}

1537 1538 1539 1540 1541
int64_t ff_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 ))
{
1542 1543 1544 1545
    int64_t pos, ts;
    int64_t start_pos, filesize;
    int no_change;

1546
    av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1547

1548 1549
    if(ts_min == AV_NOPTS_VALUE){
        pos_min = s->data_offset;
1550
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1551 1552 1553 1554 1555 1556
        if (ts_min == AV_NOPTS_VALUE)
            return -1;
    }

    if(ts_max == AV_NOPTS_VALUE){
        int step= 1024;
1557
        filesize = avio_size(s->pb);
1558
        pos_max = filesize - 1;
1559 1560
        do{
            pos_max -= step;
1561
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1562 1563 1564 1565
            step += step;
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
        if (ts_max == AV_NOPTS_VALUE)
            return -1;
1566

1567 1568
        for(;;){
            int64_t tmp_pos= pos_max + 1;
1569
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1570 1571 1572 1573
            if(tmp_ts == AV_NOPTS_VALUE)
                break;
            ts_max= tmp_ts;
            pos_max= tmp_pos;
1574 1575
            if(tmp_pos >= filesize)
                break;
1576 1577 1578 1579
        }
        pos_limit= pos_max;
    }

1580 1581 1582 1583 1584 1585
    if(ts_min > ts_max){
        return -1;
    }else if(ts_min == ts_max){
        pos_limit= pos_min;
    }

1586 1587
    no_change=0;
    while (pos_min < pos_limit) {
1588 1589
        av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
                pos_min, pos_max, ts_min, ts_max);
1590 1591 1592 1593 1594
        assert(pos_limit <= pos_max);

        if(no_change==0){
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
            // interpolate position (better than dichotomy)
1595 1596
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
                + pos_min - approximate_keyframe_distance;
1597 1598 1599 1600
        }else if(no_change==1){
            // bisection, if interpolation failed to change min or max pos last time
            pos = (pos_min + pos_limit)>>1;
        }else{
1601 1602
            /* linear search if bisection failed, can only happen if there
               are very few or no keyframes between min/max */
1603 1604 1605 1606 1607 1608 1609 1610
            pos=pos_min;
        }
        if(pos <= pos_min)
            pos= pos_min + 1;
        else if(pos > pos_limit)
            pos= pos_limit;
        start_pos= pos;

1611
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1612 1613 1614 1615
        if(pos == pos_max)
            no_change++;
        else
            no_change=0;
1616 1617 1618
        av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
                pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
                pos_limit, start_pos, no_change);
1619 1620 1621 1622
        if(ts == AV_NOPTS_VALUE){
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
            return -1;
        }
1623
        assert(ts != AV_NOPTS_VALUE);
1624
        if (target_ts <= ts) {
1625 1626 1627
            pos_limit = start_pos - 1;
            pos_max = pos;
            ts_max = ts;
1628 1629
        }
        if (target_ts >= ts) {
1630 1631 1632 1633
            pos_min = pos;
            ts_min = ts;
        }
    }
1634

1635 1636
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1637
    pos_min = pos;
1638
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1639
    pos_min++;
1640
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1641 1642
    av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
            pos, ts_min, target_ts, ts_max);
1643 1644
    *ts_ret= ts;
    return pos;
1645 1646
}

1647
static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1648 1649 1650
    int64_t pos_min, pos_max;

    pos_min = s->data_offset;
1651
    pos_max = avio_size(s->pb) - 1;
1652 1653 1654 1655

    if     (pos < pos_min) pos= pos_min;
    else if(pos > pos_max) pos= pos_max;

1656
    avio_seek(s->pb, pos, SEEK_SET);
1657 1658 1659 1660

    return 0;
}

1661
static int seek_frame_generic(AVFormatContext *s,
1662
                                 int stream_index, int64_t timestamp, int flags)
1663
{
1664 1665
    int index;
    int64_t ret;
1666 1667 1668 1669
    AVStream *st;
    AVIndexEntry *ie;

    st = s->streams[stream_index];
1670

1671
    index = av_index_search_timestamp(st, timestamp, flags);
1672

1673 1674 1675
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
        return -1;

1676
    if(index < 0 || index==st->nb_index_entries-1){
1677 1678
        AVPacket pkt;

Michael Niedermayer's avatar
Michael Niedermayer committed
1679 1680
        if(st->nb_index_entries){
            assert(st->index_entries);
1681
            ie= &st->index_entries[st->nb_index_entries-1];
1682
            if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1683
                return ret;
1684
            ff_update_cur_dts(s, st, ie->timestamp);
1685
        }else{
1686
            if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1687 1688
                return ret;
        }
1689
        for (;;) {
1690
            int read_status;
1691
            do{
1692 1693 1694
                read_status = av_read_frame(s, &pkt);
            } while (read_status == AVERROR(EAGAIN));
            if (read_status < 0)
1695 1696 1697
                break;
            av_free_packet(&pkt);
            if(stream_index == pkt.stream_index){
1698
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1699 1700 1701 1702 1703
                    break;
            }
        }
        index = av_index_search_timestamp(st, timestamp, flags);
    }
1704 1705 1706
    if (index < 0)
        return -1;

1707
    ff_read_frame_flush(s);
1708 1709 1710 1711 1712
    if (s->iformat->read_seek){
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
            return 0;
    }
    ie = &st->index_entries[index];
1713
    if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1714
        return ret;
1715
    ff_update_cur_dts(s, st, ie->timestamp);
1716

1717 1718 1719
    return 0;
}

1720 1721
static int seek_frame_internal(AVFormatContext *s, int stream_index,
                               int64_t timestamp, int flags)
1722 1723
{
    int ret;
1724
    AVStream *st;
1725

1726
    if (flags & AVSEEK_FLAG_BYTE) {
1727 1728
        if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
            return -1;
1729
        ff_read_frame_flush(s);
1730
        return seek_frame_byte(s, stream_index, timestamp, flags);
1731
    }
1732

1733 1734 1735 1736
    if(stream_index < 0){
        stream_index= av_find_default_stream_index(s);
        if(stream_index < 0)
            return -1;
1737

1738
        st= s->streams[stream_index];
1739
        /* timestamp for default must be expressed in AV_TIME_BASE units */
1740
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1741 1742
    }

1743
    /* first, we try the format specific seek */
1744 1745
    if (s->iformat->read_seek) {
        ff_read_frame_flush(s);
1746
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1747
    } else
1748 1749 1750 1751
        ret = -1;
    if (ret >= 0) {
        return 0;
    }
1752

1753 1754
    if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
        ff_read_frame_flush(s);
1755
        return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1756 1757
    } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
        ff_read_frame_flush(s);
1758
        return seek_frame_generic(s, stream_index, timestamp, flags);
1759
    }
1760 1761
    else
        return -1;
1762 1763
}

1764 1765 1766 1767 1768
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
{
    int ret = seek_frame_internal(s, stream_index, timestamp, flags);

    if (ret >= 0)
1769
        ret = queue_attached_pictures(s);
1770 1771 1772 1773

    return ret;
}

1774 1775 1776 1777 1778
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
{
    if(min_ts > ts || max_ts < ts)
        return -1;

1779
    if (s->iformat->read_seek2) {
1780
        int ret;
1781
        ff_read_frame_flush(s);
1782 1783 1784
        ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);

        if (ret >= 0)
1785
            ret = queue_attached_pictures(s);
1786
        return ret;
1787
    }
1788 1789 1790 1791 1792 1793 1794 1795

    if(s->iformat->read_timestamp){
        //try to seek via read_timestamp()
    }

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

1798
    // try some generic seek like seek_frame_generic() but with new ts semantics
1799 1800
}

1801
/*******************************************************/
1802

1803
/**
1804
 * Return TRUE if the stream has accurate duration in any stream.
1805
 *
1806
 * @return TRUE if the stream has accurate duration for at least one component.
1807
 */
1808
static int has_duration(AVFormatContext *ic)
1809 1810 1811 1812 1813 1814
{
    int i;
    AVStream *st;

    for(i = 0;i < ic->nb_streams; i++) {
        st = ic->streams[i];
1815
        if (st->duration != AV_NOPTS_VALUE)
1816 1817
            return 1;
    }
1818
    if (ic->duration != AV_NOPTS_VALUE)
1819
        return 1;
1820 1821 1822
    return 0;
}

1823 1824 1825 1826 1827
/**
 * Estimate the stream timings from the one of each components.
 *
 * Also computes the global bitrate if possible.
 */
1828
static void update_stream_timings(AVFormatContext *ic)
1829
{
1830
    int64_t start_time, start_time1, end_time, end_time1;
1831
    int64_t duration, duration1, filesize;
1832 1833 1834
    int i;
    AVStream *st;

1835 1836
    start_time = INT64_MAX;
    end_time = INT64_MIN;
1837
    duration = INT64_MIN;
1838 1839
    for(i = 0;i < ic->nb_streams; i++) {
        st = ic->streams[i];
1840
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1841
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1842
            start_time = FFMIN(start_time, start_time1);
1843
            if (st->duration != AV_NOPTS_VALUE) {
1844 1845
                end_time1 = start_time1
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1846
                end_time = FFMAX(end_time, end_time1);
1847 1848
            }
        }
1849 1850
        if (st->duration != AV_NOPTS_VALUE) {
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1851
            duration = FFMAX(duration, duration1);
1852
        }
1853
    }
1854
    if (start_time != INT64_MAX) {
1855
        ic->start_time = start_time;
1856 1857
        if (end_time != INT64_MIN)
            duration = FFMAX(duration, end_time - start_time);
1858 1859 1860
    }
    if (duration != INT64_MIN) {
        ic->duration = duration;
1861
        if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1862
            /* compute the bitrate */
1863
            ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1864
                (double)ic->duration;
1865 1866 1867 1868 1869 1870 1871 1872 1873
        }
    }
}

static void fill_all_stream_timings(AVFormatContext *ic)
{
    int i;
    AVStream *st;

1874
    update_stream_timings(ic);
1875 1876 1877
    for(i = 0;i < ic->nb_streams; i++) {
        st = ic->streams[i];
        if (st->start_time == AV_NOPTS_VALUE) {
1878 1879 1880 1881
            if(ic->start_time != AV_NOPTS_VALUE)
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
            if(ic->duration != AV_NOPTS_VALUE)
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1882 1883 1884 1885
        }
    }
}

1886
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1887 1888 1889 1890 1891 1892
{
    int64_t filesize, duration;
    int bit_rate, i;
    AVStream *st;

    /* if bit_rate is already set, we believe it */
1893
    if (ic->bit_rate <= 0) {
1894 1895 1896
        bit_rate = 0;
        for(i=0;i<ic->nb_streams;i++) {
            st = ic->streams[i];
1897
            if (st->codec->bit_rate > 0)
1898
            bit_rate += st->codec->bit_rate;
1899 1900 1901 1902 1903
        }
        ic->bit_rate = bit_rate;
    }

    /* if duration is already set, we believe it */
1904
    if (ic->duration == AV_NOPTS_VALUE &&
1905 1906
        ic->bit_rate != 0) {
        filesize = ic->pb ? avio_size(ic->pb) : 0;
1907 1908 1909
        if (filesize > 0) {
            for(i = 0; i < ic->nb_streams; i++) {
                st = ic->streams[i];
1910
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1911
                if (st->duration == AV_NOPTS_VALUE)
1912 1913 1914 1915 1916 1917 1918
                    st->duration = duration;
            }
        }
    }
}

#define DURATION_MAX_READ_SIZE 250000
1919
#define DURATION_MAX_RETRY 3
1920 1921

/* only usable for MPEG-PS streams */
1922
static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1923 1924 1925 1926
{
    AVPacket pkt1, *pkt = &pkt1;
    AVStream *st;
    int read_size, i, ret;
1927
    int64_t end_time;
1928
    int64_t filesize, offset, duration;
1929
    int retry=0;
1930

1931 1932 1933
    /* flush packet queue */
    flush_packet_queue(ic);

1934
    for (i=0; i<ic->nb_streams; i++) {
1935
        st = ic->streams[i];
1936
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1937
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1938

1939 1940 1941 1942 1943
        if (st->parser) {
            av_parser_close(st->parser);
            st->parser= NULL;
        }
    }
1944

1945 1946
    /* estimate the end time (duration) */
    /* XXX: may need to support wrapping */
1947
    filesize = ic->pb ? avio_size(ic->pb) : 0;
1948 1949
    end_time = AV_NOPTS_VALUE;
    do{
1950 1951 1952
        offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
        if (offset < 0)
            offset = 0;
1953

1954 1955 1956 1957 1958
        avio_seek(ic->pb, offset, SEEK_SET);
        read_size = 0;
        for(;;) {
            if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
                break;
1959

1960
            do {
1961
                ret = ff_read_packet(ic, pkt);
1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980
            } while(ret == AVERROR(EAGAIN));
            if (ret != 0)
                break;
            read_size += pkt->size;
            st = ic->streams[pkt->stream_index];
            if (pkt->pts != AV_NOPTS_VALUE &&
                (st->start_time != AV_NOPTS_VALUE ||
                 st->first_dts  != AV_NOPTS_VALUE)) {
                duration = end_time = pkt->pts;
                if (st->start_time != AV_NOPTS_VALUE)
                    duration -= st->start_time;
                else
                    duration -= st->first_dts;
                if (duration < 0)
                    duration += 1LL<<st->pts_wrap_bits;
                if (duration > 0) {
                    if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
                        st->duration = duration;
                }
1981
            }
1982
            av_free_packet(pkt);
1983
        }
1984 1985 1986
    }while(   end_time==AV_NOPTS_VALUE
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
           && ++retry <= DURATION_MAX_RETRY);
1987

1988
    fill_all_stream_timings(ic);
1989

1990
    avio_seek(ic->pb, old_offset, SEEK_SET);
1991
    for (i=0; i<ic->nb_streams; i++) {
1992 1993
        st= ic->streams[i];
        st->cur_dts= st->first_dts;
Michael Niedermayer's avatar
Michael Niedermayer committed
1994
        st->last_IP_pts = AV_NOPTS_VALUE;
1995
        st->reference_dts = AV_NOPTS_VALUE;
1996
    }
1997 1998
}

1999
static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2000 2001 2002 2003 2004 2005 2006
{
    int64_t file_size;

    /* get the file size, if possible */
    if (ic->iformat->flags & AVFMT_NOFILE) {
        file_size = 0;
    } else {
2007
        file_size = avio_size(ic->pb);
2008
        file_size = FFMAX(0, file_size);
2009 2010
    }

2011 2012
    if ((!strcmp(ic->iformat->name, "mpeg") ||
         !strcmp(ic->iformat->name, "mpegts")) &&
2013
        file_size && ic->pb->seekable) {
2014
        /* get accurate estimate from the PTSes */
2015 2016
        estimate_timings_from_pts(ic, old_offset);
    } else if (has_duration(ic)) {
2017
        /* at least one component has timings - we use them for all
2018 2019 2020
           the components */
        fill_all_stream_timings(ic);
    } else {
2021
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2022
        /* less precise: use bitrate info */
2023
        estimate_timings_from_bit_rate(ic);
2024
    }
2025
    update_stream_timings(ic);
2026 2027 2028

    {
        int i;
2029
        AVStream av_unused *st;
2030 2031
        for(i = 0;i < ic->nb_streams; i++) {
            st = ic->streams[i];
2032 2033 2034
            av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
                    (double) st->start_time / AV_TIME_BASE,
                    (double) st->duration   / AV_TIME_BASE);
2035
        }
2036 2037 2038 2039
        av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
                (double) ic->start_time / AV_TIME_BASE,
                (double) ic->duration   / AV_TIME_BASE,
                ic->bit_rate / 1000);
2040 2041 2042
    }
}

2043
static int has_codec_parameters(AVStream *st)
2044
{
2045
    AVCodecContext *avctx = st->codec;
2046
    int val;
2047
    switch (avctx->codec_type) {
2048
    case AVMEDIA_TYPE_AUDIO:
2049 2050 2051
        val = avctx->sample_rate && avctx->channels;
        if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
            return 0;
2052
        break;
2053
    case AVMEDIA_TYPE_VIDEO:
2054
        val = avctx->width;
2055
        if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2056
            return 0;
2057 2058 2059 2060 2061
        break;
    default:
        val = 1;
        break;
    }
2062
    return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
2063 2064
}

2065 2066
static int has_decode_delay_been_guessed(AVStream *st)
{
2067
    return st->codec->codec_id != AV_CODEC_ID_H264 ||
2068
        st->info->nb_decoded_frames >= 6;
2069 2070
}

2071
/* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2072
static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2073
{
2074
    const AVCodec *codec;
2075
    int got_picture = 1, ret = 0;
2076
    AVFrame *frame = avcodec_alloc_frame();
2077
    AVPacket pkt = *avpkt;
2078

2079 2080 2081
    if (!frame)
        return AVERROR(ENOMEM);

2082
    if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2083 2084
        AVDictionary *thread_opt = NULL;

2085 2086 2087
        codec = st->codec->codec ? st->codec->codec :
                                   avcodec_find_decoder(st->codec->codec_id);

2088 2089
        if (!codec) {
            st->info->found_decoder = -1;
2090 2091
            ret = -1;
            goto fail;
2092
        }
2093 2094 2095 2096 2097 2098 2099

        /* force thread count to 1 since the h264 decoder will not extract SPS
         *  and PPS to extradata during multi-threaded decoding */
        av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
        ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
        if (!options)
            av_dict_free(&thread_opt);
2100 2101
        if (ret < 0) {
            st->info->found_decoder = -1;
2102
            goto fail;
2103 2104 2105 2106 2107
        }
        st->info->found_decoder = 1;
    } else if (!st->info->found_decoder)
        st->info->found_decoder = 1;

2108 2109 2110 2111
    if (st->info->found_decoder < 0) {
        ret = -1;
        goto fail;
    }
2112

2113 2114
    while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
           ret >= 0 &&
2115
           (!has_codec_parameters(st)         ||
2116 2117 2118
           !has_decode_delay_been_guessed(st) ||
           (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
        got_picture = 0;
2119
        avcodec_get_frame_defaults(frame);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
2120
        switch(st->codec->codec_type) {
2121
        case AVMEDIA_TYPE_VIDEO:
2122
            ret = avcodec_decode_video2(st->codec, frame,
2123
                                        &got_picture, &pkt);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
2124
            break;
2125
        case AVMEDIA_TYPE_AUDIO:
2126
            ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
2127 2128 2129 2130
            break;
        default:
            break;
        }
2131 2132 2133 2134 2135
        if (ret >= 0) {
            if (got_picture)
                st->info->nb_decoded_frames++;
            pkt.data += ret;
            pkt.size -= ret;
2136
            ret       = got_picture;
2137
        }
2138
    }
2139 2140 2141

fail:
    avcodec_free_frame(&frame);
2142 2143 2144
    return ret;
}

2145
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2146
{
2147
    while (tags->id != AV_CODEC_ID_NONE) {
2148 2149 2150 2151 2152 2153 2154
        if (tags->id == id)
            return tags->tag;
        tags++;
    }
    return 0;
}

2155
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2156
{
2157
    int i;
2158
    for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2159 2160 2161
        if(tag == tags[i].tag)
            return tags[i].id;
    }
2162
    for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2163
        if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2164
            return tags[i].id;
2165
    }
2166
    return AV_CODEC_ID_NONE;
2167 2168
}

2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198
enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
{
    if (flt) {
        switch (bps) {
        case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
        case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
        default: return AV_CODEC_ID_NONE;
        }
    } else {
        bps >>= 3;
        if (sflags & (1 << (bps - 1))) {
            switch (bps) {
            case 1:  return AV_CODEC_ID_PCM_S8;
            case 2:  return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
            case 3:  return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
            case 4:  return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
            default: return AV_CODEC_ID_NONE;
            }
        } else {
            switch (bps) {
            case 1:  return AV_CODEC_ID_PCM_U8;
            case 2:  return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
            case 3:  return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
            case 4:  return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
            default: return AV_CODEC_ID_NONE;
            }
        }
    }
}

2199
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2200 2201 2202
{
    int i;
    for(i=0; tags && tags[i]; i++){
2203
        int tag= ff_codec_get_tag(tags[i], id);
2204 2205 2206 2207 2208
        if(tag) return tag;
    }
    return 0;
}

2209
enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2210 2211 2212
{
    int i;
    for(i=0; tags && tags[i]; i++){
2213 2214
        enum AVCodecID id= ff_codec_get_id(tags[i], tag);
        if(id!=AV_CODEC_ID_NONE) return id;
2215
    }
2216
    return AV_CODEC_ID_NONE;
2217 2218
}

2219 2220
static void compute_chapters_end(AVFormatContext *s)
{
2221
    unsigned int i, j;
2222
    int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2223

2224
    for (i = 0; i < s->nb_chapters; i++)
2225
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236
            AVChapter *ch = s->chapters[i];
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
                                     : INT64_MAX;

            for (j = 0; j < s->nb_chapters; j++) {
                AVChapter *ch1 = s->chapters[j];
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
                if (j != i && next_start > ch->start && next_start < end)
                    end = next_start;
            }
            ch->end = (end == INT64_MAX) ? ch->start : end;
2237 2238 2239
        }
}

2240 2241
static int get_std_framerate(int i){
    if(i<60*12) return i*1001;
2242
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2243 2244
}

2245 2246 2247 2248
/*
 * Is the time base unreliable.
 * This is a heuristic to balance between quick acceptance of the values in
 * the headers vs. some extra checks.
2249 2250
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2251 2252 2253 2254 2255
 * And there are "variable" fps files this needs to detect as well.
 */
static int tb_unreliable(AVCodecContext *c){
    if(   c->time_base.den >= 101L*c->time_base.num
       || c->time_base.den <    5L*c->time_base.num
2256 2257
/*       || c->codec_tag == AV_RL32("DIVX")
       || c->codec_tag == AV_RL32("XVID")*/
2258 2259
       || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
       || c->codec_id == AV_CODEC_ID_H264
2260
       )
2261 2262 2263 2264
        return 1;
    return 0;
}

2265
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2266
{
2267
    int i, count, ret, read_size, j;
2268
    AVStream *st;
2269
    AVPacket pkt1, *pkt;
2270
    int64_t old_offset = avio_tell(ic->pb);
2271
    int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2272

2273
    for(i=0;i<ic->nb_streams;i++) {
2274
        const AVCodec *codec;
2275
        AVDictionary *thread_opt = NULL;
2276
        st = ic->streams[i];
2277

2278
        //only for the split stuff
2279
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2280
            st->parser = av_parser_init(st->codec->codec_id);
2281
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2282 2283
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
            }
2284
        }
2285 2286
        codec = st->codec->codec ? st->codec->codec :
                                   avcodec_find_decoder(st->codec->codec_id);
2287

2288 2289 2290 2291
        /* force thread count to 1 since the h264 decoder will not extract SPS
         *  and PPS to extradata during multi-threaded decoding */
        av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);

2292 2293 2294
        /* Ensure that subtitle_header is properly set. */
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
            && codec && !st->codec->codec)
2295 2296
            avcodec_open2(st->codec, codec, options ? &options[i]
                              : &thread_opt);
2297

2298
        //try to just open decoders, in case this is enough to get parameters
2299
        if (!has_codec_parameters(st)) {
2300
            if (codec && !st->codec->codec)
2301 2302
                avcodec_open2(st->codec, codec, options ? &options[i]
                              : &thread_opt);
2303
        }
2304 2305
        if (!options)
            av_dict_free(&thread_opt);
2306 2307
    }

2308
    for (i=0; i<ic->nb_streams; i++) {
2309 2310
        ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
        ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2311
    }
2312

2313 2314 2315
    count = 0;
    read_size = 0;
    for(;;) {
2316
        if (ff_check_interrupt(&ic->interrupt_callback)){
2317
            ret= AVERROR_EXIT;
2318
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2319 2320 2321
            break;
        }

2322 2323
        /* check if one codec still needs to be handled */
        for(i=0;i<ic->nb_streams;i++) {
2324 2325
            int fps_analyze_framecount = 20;

2326
            st = ic->streams[i];
2327
            if (!has_codec_parameters(st))
2328
                break;
2329 2330 2331 2332 2333
            /* if the timebase is coarse (like the usual millisecond precision
               of mkv), we need to analyze more frames to reliably arrive at
               the correct fps */
            if (av_q2d(st->time_base) > 0.0005)
                fps_analyze_framecount *= 2;
2334 2335
            if (ic->fps_probe_size >= 0)
                fps_analyze_framecount = ic->fps_probe_size;
2336
            /* variable fps and no guess at the real fps */
2337 2338
            if(   tb_unreliable(st->codec) && !st->avg_frame_rate.num
               && st->codec_info_nb_frames < fps_analyze_framecount
2339
               && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2340
                break;
2341
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2342
                break;
2343 2344 2345
            if (st->first_dts == AV_NOPTS_VALUE &&
                (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
                 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2346
                break;
2347 2348 2349 2350 2351
        }
        if (i == ic->nb_streams) {
            /* NOTE: if the format has no header, then we need to read
               some packets to get most of the streams, so we cannot
               stop here */
2352
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2353 2354
                /* if we found the info for all the codecs, we can stop */
                ret = count;
2355
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2356 2357
                break;
            }
2358
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
2359
        /* we did not get all the codec info, but we read too much data */
2360
        if (read_size >= ic->probesize) {
Michael Niedermayer's avatar
Michael Niedermayer committed
2361
            ret = count;
2362
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
Michael Niedermayer's avatar
Michael Niedermayer committed
2363 2364
            break;
        }
2365

2366 2367
        /* NOTE: a new stream can be added there if no header in file
           (AVFMTCTX_NOHEADER) */
2368
        ret = read_frame_internal(ic, &pkt1);
2369 2370 2371 2372
        if (ret == AVERROR(EAGAIN))
            continue;

        if (ret < 0) {
2373 2374
            /* EOF or error*/
            AVPacket empty_pkt = { 0 };
2375
            int err = 0;
2376 2377
            av_init_packet(&empty_pkt);

2378
            ret = -1; /* we could not have all the codec parameters before EOF */
2379 2380
            for(i=0;i<ic->nb_streams;i++) {
                st = ic->streams[i];
2381 2382

                /* flush the decoders */
2383
                if (st->info->found_decoder == 1) {
Justin Ruggles's avatar
Justin Ruggles committed
2384 2385 2386 2387 2388
                    do {
                        err = try_decode_frame(st, &empty_pkt,
                                               (options && i < orig_nb_streams) ?
                                               &options[i] : NULL);
                    } while (err > 0 && !has_codec_parameters(st));
2389
                }
2390 2391 2392 2393

                if (err < 0) {
                    av_log(ic, AV_LOG_WARNING,
                           "decoding for stream %d failed\n", st->index);
2394
                } else if (!has_codec_parameters(st)) {
2395 2396
                    char buf[256];
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2397 2398
                    av_log(ic, AV_LOG_WARNING,
                           "Could not find codec parameters (%s)\n", buf);
2399 2400
                } else {
                    ret = 0;
2401
                }
2402
            }
2403 2404 2405
            break;
        }

2406 2407 2408 2409 2410 2411 2412 2413
        if (ic->flags & AVFMT_FLAG_NOBUFFER) {
            pkt = &pkt1;
        } else {
            pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
                                &ic->packet_buffer_end);
            if ((ret = av_dup_packet(pkt)) < 0)
                goto find_stream_info_err;
        }
2414

2415
        read_size += pkt->size;
2416 2417

        st = ic->streams[pkt->stream_index];
2418 2419 2420 2421 2422 2423 2424 2425 2426 2427
        if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
            /* check for non-increasing dts */
            if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
                st->info->fps_last_dts >= pkt->dts) {
                av_log(ic, AV_LOG_WARNING, "Non-increasing DTS in stream %d: "
                       "packet %d with DTS %"PRId64", packet %d with DTS "
                       "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
                       st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
                st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
            }
2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440
            /* check for a discontinuity in dts - if the difference in dts
             * is more than 1000 times the average packet duration in the sequence,
             * we treat it as a discontinuity */
            if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
                st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
                (pkt->dts - st->info->fps_last_dts) / 1000 >
                (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
                av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
                       "packet %d with DTS %"PRId64", packet %d with DTS "
                       "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
                       st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
                st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
            }
2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452

            /* update stored dts values */
            if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
                st->info->fps_first_dts     = pkt->dts;
                st->info->fps_first_dts_idx = st->codec_info_nb_frames;
            }
            st->info->fps_last_dts = pkt->dts;
            st->info->fps_last_dts_idx = st->codec_info_nb_frames;

            /* check max_analyze_duration */
            if (av_rescale_q(pkt->dts - st->info->fps_first_dts, st->time_base,
                             AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2453
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2454
                break;
2455
            }
2456
        }
2457 2458
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2459
            if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2460
                st->codec->extradata_size= i;
2461
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2462 2463
                if (!st->codec->extradata)
                    return AVERROR(ENOMEM);
2464
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2465
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2466 2467
            }
        }
2468

2469 2470
        /* if still no information, we try to open the codec and to
           decompress the frame. We try to avoid that in most cases as
2471
           it takes longer and uses more memory. For MPEG-4, we need to
2472 2473 2474 2475 2476 2477
           decompress for QuickTime.

           If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
           least one frame of codec data, this makes sure the codec initializes
           the channel configuration and does not only trust the values from the container.
        */
2478
        try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2479

2480
        st->codec_info_nb_frames++;
2481 2482 2483
        count++;
    }

Diego Biurrun's avatar
Diego Biurrun committed
2484
    // close codecs which were opened in try_decode_frame()
2485 2486
    for(i=0;i<ic->nb_streams;i++) {
        st = ic->streams[i];
2487
        avcodec_close(st->codec);
2488
    }
2489 2490
    for(i=0;i<ic->nb_streams;i++) {
        st = ic->streams[i];
2491
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2492 2493 2494 2495
            /* estimate average framerate if not set by demuxer */
            if (!st->avg_frame_rate.num && st->info->fps_last_dts != st->info->fps_first_dts) {
                int64_t delta_dts = st->info->fps_last_dts - st->info->fps_first_dts;
                int delta_packets = st->info->fps_last_dts_idx - st->info->fps_first_dts_idx;
2496 2497
                int      best_fps = 0;
                double best_error = 0.01;
2498

2499
                av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2500 2501
                          delta_packets*(int64_t)st->time_base.den,
                          delta_dts*(int64_t)st->time_base.num, 60000);
2502 2503 2504 2505

                /* round guessed framerate to a "standard" framerate if it's
                 * within 1% of the original estimate*/
                for (j = 1; j < MAX_STD_TIMEBASES; j++) {
2506
                    AVRational std_fps = { get_std_framerate(j), 12*1001 };
2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517
                    double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);

                    if (error < best_error) {
                        best_error = error;
                        best_fps   = std_fps.num;
                    }
                }
                if (best_fps) {
                    av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
                              best_fps, 12*1001, INT_MAX);
                }
2518
            }
2519
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2520 2521
            if(!st->codec->bits_per_coded_sample)
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534
            // set stream disposition based on audio service type
            switch (st->codec->audio_service_type) {
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
                st->disposition = AV_DISPOSITION_COMMENT;          break;
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
            }
2535
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
2536
    }
2537

2538
    estimate_timings(ic, old_offset);
John Donaghy's avatar
John Donaghy committed
2539

2540 2541
    compute_chapters_end(ic);

2542
 find_stream_info_err:
2543 2544 2545
    for (i=0; i < ic->nb_streams; i++) {
        if (ic->streams[i]->codec)
            ic->streams[i]->codec->thread_count = 0;
2546
        av_freep(&ic->streams[i]->info);
2547
    }
2548
    return ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
2549 2550
}

2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
{
    int i, j;

    for (i = 0; i < ic->nb_programs; i++)
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
            if (ic->programs[i]->stream_index[j] == s)
                return ic->programs[i];
    return NULL;
}

int av_find_best_stream(AVFormatContext *ic,
                        enum AVMediaType type,
                        int wanted_stream_nb,
                        int related_stream,
                        AVCodec **decoder_ret,
                        int flags)
{
2569
    int i, nb_streams = ic->nb_streams;
2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
    unsigned *program = NULL;
    AVCodec *decoder = NULL, *best_decoder = NULL;

    if (related_stream >= 0 && wanted_stream_nb < 0) {
        AVProgram *p = find_program_from_stream(ic, related_stream);
        if (p) {
            program = p->stream_index;
            nb_streams = p->nb_stream_indexes;
        }
    }
    for (i = 0; i < nb_streams; i++) {
2582 2583
        int real_stream_index = program ? program[i] : i;
        AVStream *st = ic->streams[real_stream_index];
2584 2585 2586
        AVCodecContext *avctx = st->codec;
        if (avctx->codec_type != type)
            continue;
2587
        if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2588
            continue;
2589 2590
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
            continue;
2591
        if (decoder_ret) {
2592
            decoder = avcodec_find_decoder(st->codec->codec_id);
2593 2594 2595 2596 2597 2598 2599 2600 2601
            if (!decoder) {
                if (ret < 0)
                    ret = AVERROR_DECODER_NOT_FOUND;
                continue;
            }
        }
        if (best_count >= st->codec_info_nb_frames)
            continue;
        best_count = st->codec_info_nb_frames;
2602
        ret = real_stream_index;
2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614
        best_decoder = decoder;
        if (program && i == nb_streams - 1 && ret < 0) {
            program = NULL;
            nb_streams = ic->nb_streams;
            i = 0; /* no related stream found, try again with everything */
        }
    }
    if (decoder_ret)
        *decoder_ret = best_decoder;
    return ret;
}

2615 2616 2617 2618
/*******************************************************/

int av_read_play(AVFormatContext *s)
{
2619 2620
    if (s->iformat->read_play)
        return s->iformat->read_play(s);
2621
    if (s->pb)
2622
        return avio_pause(s->pb, 0);
2623
    return AVERROR(ENOSYS);
2624 2625 2626 2627
}

int av_read_pause(AVFormatContext *s)
{
2628 2629
    if (s->iformat->read_pause)
        return s->iformat->read_pause(s);
2630
    if (s->pb)
2631
        return avio_pause(s->pb, 1);
2632
    return AVERROR(ENOSYS);
2633 2634
}

2635 2636 2637 2638 2639
void avformat_free_context(AVFormatContext *s)
{
    int i;
    AVStream *st;

2640
    av_opt_free(s);
2641
    if (s->iformat && s->iformat->priv_class && s->priv_data)
2642 2643
        av_opt_free(s->priv_data);

Fabrice Bellard's avatar
Fabrice Bellard committed
2644
    for(i=0;i<s->nb_streams;i++) {
2645 2646
        /* free all data in a stream component */
        st = s->streams[i];
2647 2648
        if (st->parser) {
            av_parser_close(st->parser);
Fabrice Bellard's avatar
Fabrice Bellard committed
2649
        }
2650 2651
        if (st->attached_pic.data)
            av_free_packet(&st->attached_pic);
2652
        av_dict_free(&st->metadata);
2653
        av_freep(&st->probe_data.buf);
2654
        av_free(st->index_entries);
2655
        av_free(st->codec->extradata);
2656
        av_free(st->codec->subtitle_header);
2657
        av_free(st->codec);
2658
        av_free(st->priv_data);
2659
        av_free(st->info);
2660
        av_free(st);
Fabrice Bellard's avatar
Fabrice Bellard committed
2661
    }
2662
    for(i=s->nb_programs-1; i>=0; i--) {
2663
        av_dict_free(&s->programs[i]->metadata);
2664
        av_freep(&s->programs[i]->stream_index);
2665 2666
        av_freep(&s->programs[i]);
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
2667
    av_freep(&s->programs);
2668
    av_freep(&s->priv_data);
2669
    while(s->nb_chapters--) {
2670
        av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2671
        av_free(s->chapters[s->nb_chapters]);
2672 2673
    }
    av_freep(&s->chapters);
2674
    av_dict_free(&s->metadata);
2675
    av_freep(&s->streams);
2676
    av_free(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
2677 2678
}

2679 2680 2681
void avformat_close_input(AVFormatContext **ps)
{
    AVFormatContext *s = *ps;
2682 2683
    AVIOContext *pb = s->pb;

2684
    if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
2685 2686 2687
        (s->flags & AVFMT_FLAG_CUSTOM_IO))
        pb = NULL;

2688
    flush_packet_queue(s);
2689 2690 2691 2692 2693 2694

    if (s->iformat) {
        if (s->iformat->read_close)
            s->iformat->read_close(s);
    }

2695
    avformat_free_context(s);
2696

2697
    *ps = NULL;
2698 2699

    avio_close(pb);
2700 2701
}

2702
AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2703 2704
{
    AVStream *st;
2705
    int i;
2706
    AVStream **streams;
2707

2708 2709 2710 2711 2712 2713
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
        return NULL;
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
    if (!streams)
        return NULL;
    s->streams = streams;
2714 2715 2716 2717

    st = av_mallocz(sizeof(AVStream));
    if (!st)
        return NULL;
2718 2719 2720 2721
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
        av_free(st);
        return NULL;
    }
2722

2723
    st->codec = avcodec_alloc_context3(c);
2724 2725
    if (s->iformat) {
        /* no default bitrate if decoding */
2726
        st->codec->bit_rate = 0;
2727
    }
2728
    st->index = s->nb_streams;
2729 2730
    st->start_time = AV_NOPTS_VALUE;
    st->duration = AV_NOPTS_VALUE;
2731 2732 2733 2734 2735
        /* we set the current DTS to 0 so that formats without any timestamps
           but durations get some timestamps, formats with some unknown
           timestamps have their first few packets buffered and the
           timestamps corrected before they are returned to the user */
    st->cur_dts = 0;
2736
    st->first_dts = AV_NOPTS_VALUE;
2737
    st->probe_packets = MAX_PROBE_PACKETS;
2738

2739
    /* default pts setting is MPEG-like */
2740
    avpriv_set_pts_info(st, 33, 1, 90000);
Michael Niedermayer's avatar
Michael Niedermayer committed
2741
    st->last_IP_pts = AV_NOPTS_VALUE;
2742 2743
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2744
    st->reference_dts = AV_NOPTS_VALUE;
2745

2746 2747
    st->sample_aspect_ratio = (AVRational){0,1};

2748 2749 2750
    st->info->fps_first_dts = AV_NOPTS_VALUE;
    st->info->fps_last_dts  = AV_NOPTS_VALUE;

2751 2752 2753 2754
    s->streams[s->nb_streams++] = st;
    return st;
}

2755 2756 2757 2758 2759
AVProgram *av_new_program(AVFormatContext *ac, int id)
{
    AVProgram *program=NULL;
    int i;

2760
    av_dlog(ac, "new_program: id=0x%04x\n", id);
2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777

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

    if(!program){
        program = av_mallocz(sizeof(AVProgram));
        if (!program)
            return NULL;
        dynarray_add(&ac->programs, &ac->nb_programs, program);
        program->discard = AVDISCARD_NONE;
    }
    program->id = id;

    return program;
}

2778
AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2779
{
2780 2781 2782
    AVChapter *chapter = NULL;
    int i;

2783
    for(i=0; i<s->nb_chapters; i++)
2784 2785 2786 2787 2788
        if(s->chapters[i]->id == id)
            chapter = s->chapters[i];

    if(!chapter){
        chapter= av_mallocz(sizeof(AVChapter));
Michael Niedermayer's avatar
Michael Niedermayer committed
2789
        if(!chapter)
2790
            return NULL;
2791
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2792
    }
2793
    av_dict_set(&chapter->metadata, "title", title, 0);
2794
    chapter->id    = id;
2795
    chapter->time_base= time_base;
2796
    chapter->start = start;
Michael Niedermayer's avatar
Michael Niedermayer committed
2797
    chapter->end   = end;
2798

2799
    return chapter;
2800
}
2801

2802
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2803 2804 2805 2806 2807
{
    int i, j;
    AVProgram *program=NULL;
    void *tmp;

2808 2809 2810 2811 2812
    if (idx >= ac->nb_streams) {
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
        return;
    }

2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829
    for(i=0; i<ac->nb_programs; i++){
        if(ac->programs[i]->id != progid)
            continue;
        program = ac->programs[i];
        for(j=0; j<program->nb_stream_indexes; j++)
            if(program->stream_index[j] == idx)
                return;

        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
        if(!tmp)
            return;
        program->stream_index = tmp;
        program->stream_index[program->nb_stream_indexes++] = idx;
        return;
    }
}

2830 2831 2832 2833 2834 2835 2836
static void print_fps(double d, const char *postfix){
    uint64_t v= lrintf(d*100);
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
}

2837
static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
2838
{
2839
    if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
2840
        AVDictionaryEntry *tag=NULL;
2841 2842

        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2843
        while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
2844
            if(strcmp("language", tag->key))
Michael Niedermayer's avatar
Michael Niedermayer committed
2845
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
2846 2847 2848 2849
        }
    }
}

Fabrice Bellard's avatar
Fabrice Bellard committed
2850
/* "user interface" functions */
2851
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2852
{
2853
    char buf[256];
2854 2855
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
    AVStream *st = ic->streams[i];
2856
    int g = av_gcd(st->time_base.num, st->time_base.den);
2857
    AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
2858 2859 2860 2861 2862 2863
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
    /* the pid is an important information, so we display it */
    /* XXX: add a generic system */
    if (flags & AVFMT_SHOW_IDS)
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2864 2865
    if (lang)
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2866
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
2867
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878
    if (st->sample_aspect_ratio.num && // default
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
        AVRational display_aspect_ratio;
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
                  st->codec->width*st->sample_aspect_ratio.num,
                  st->codec->height*st->sample_aspect_ratio.den,
                  1024*1024);
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
                 display_aspect_ratio.num, display_aspect_ratio.den);
    }
2879
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2880 2881
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
            print_fps(av_q2d(st->avg_frame_rate), "fps");
2882
        if(st->time_base.den && st->time_base.num)
2883
            print_fps(1/av_q2d(st->time_base), "tbn");
2884
        if(st->codec->time_base.den && st->codec->time_base.num)
2885
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
2886
    }
2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904
    if (st->disposition & AV_DISPOSITION_DEFAULT)
        av_log(NULL, AV_LOG_INFO, " (default)");
    if (st->disposition & AV_DISPOSITION_DUB)
        av_log(NULL, AV_LOG_INFO, " (dub)");
    if (st->disposition & AV_DISPOSITION_ORIGINAL)
        av_log(NULL, AV_LOG_INFO, " (original)");
    if (st->disposition & AV_DISPOSITION_COMMENT)
        av_log(NULL, AV_LOG_INFO, " (comment)");
    if (st->disposition & AV_DISPOSITION_LYRICS)
        av_log(NULL, AV_LOG_INFO, " (lyrics)");
    if (st->disposition & AV_DISPOSITION_KARAOKE)
        av_log(NULL, AV_LOG_INFO, " (karaoke)");
    if (st->disposition & AV_DISPOSITION_FORCED)
        av_log(NULL, AV_LOG_INFO, " (forced)");
    if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
        av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
    if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
        av_log(NULL, AV_LOG_INFO, " (visual impaired)");
2905 2906
    if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
        av_log(NULL, AV_LOG_INFO, " (clean effects)");
2907
    av_log(NULL, AV_LOG_INFO, "\n");
2908
    dump_metadata(NULL, st->metadata, "    ");
2909
}
Fabrice Bellard's avatar
Fabrice Bellard committed
2910

2911 2912 2913 2914
void av_dump_format(AVFormatContext *ic,
                    int index,
                    const char *url,
                    int is_output)
Fabrice Bellard's avatar
Fabrice Bellard committed
2915
{
2916
    int i;
2917
    uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
2918 2919
    if (ic->nb_streams && !printed)
        return;
Fabrice Bellard's avatar
Fabrice Bellard committed
2920

2921
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
Fabrice Bellard's avatar
Fabrice Bellard committed
2922
            is_output ? "Output" : "Input",
2923 2924
            index,
            is_output ? ic->oformat->name : ic->iformat->name,
Fabrice Bellard's avatar
Fabrice Bellard committed
2925
            is_output ? "to" : "from", url);
2926
    dump_metadata(NULL, ic->metadata, "  ");
2927
    if (!is_output) {
2928
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2929 2930 2931 2932 2933 2934 2935 2936
        if (ic->duration != AV_NOPTS_VALUE) {
            int hours, mins, secs, us;
            secs = ic->duration / AV_TIME_BASE;
            us = ic->duration % AV_TIME_BASE;
            mins = secs / 60;
            secs %= 60;
            hours = mins / 60;
            mins %= 60;
2937 2938
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
                   (100 * us) / AV_TIME_BASE);
2939
        } else {
2940
            av_log(NULL, AV_LOG_INFO, "N/A");
2941
        }
2942 2943
        if (ic->start_time != AV_NOPTS_VALUE) {
            int secs, us;
2944
            av_log(NULL, AV_LOG_INFO, ", start: ");
2945
            secs = ic->start_time / AV_TIME_BASE;
2946
            us = abs(ic->start_time % AV_TIME_BASE);
2947
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2948 2949
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
        }
2950
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2951
        if (ic->bit_rate) {
2952
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2953
        } else {
2954
            av_log(NULL, AV_LOG_INFO, "N/A");
2955
        }
2956
        av_log(NULL, AV_LOG_INFO, "\n");
2957
    }
2958 2959 2960 2961 2962 2963 2964 2965
    for (i = 0; i < ic->nb_chapters; i++) {
        AVChapter *ch = ic->chapters[i];
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));

        dump_metadata(NULL, ch->metadata, "    ");
    }
2966
    if(ic->nb_programs) {
2967
        int j, k, total = 0;
2968
        for(j=0; j<ic->nb_programs; j++) {
2969
            AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
2970
                                                  "name", NULL, 0);
2971
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2972
                   name ? name->value : "");
2973
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
2974
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
2975
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2976 2977 2978 2979 2980 2981 2982
                printed[ic->programs[j]->stream_index[k]] = 1;
            }
            total += ic->programs[j]->nb_stream_indexes;
        }
        if (total < ic->nb_streams)
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
    }
2983 2984
    for(i=0;i<ic->nb_streams;i++)
        if (!printed[i])
2985
            dump_stream_format(ic, i, index, is_output);
2986 2987

    av_free(printed);
Fabrice Bellard's avatar
Fabrice Bellard committed
2988 2989
}

2990 2991 2992 2993 2994
uint64_t ff_ntp_time(void)
{
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
}

2995 2996
int av_get_frame_filename(char *buf, int buf_size,
                          const char *path, int number)
2997 2998
{
    const char *p;
2999 3000
    char *q, buf1[20], c;
    int nd, len, percentd_found;
3001 3002 3003 3004 3005 3006 3007 3008 3009

    q = buf;
    p = path;
    percentd_found = 0;
    for(;;) {
        c = *p++;
        if (c == '\0')
            break;
        if (c == '%') {
3010 3011
            do {
                nd = 0;
3012
                while (av_isdigit(*p)) {
3013 3014 3015
                    nd = nd * 10 + *p++ - '0';
                }
                c = *p++;
3016
            } while (av_isdigit(c));
3017

3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049
            switch(c) {
            case '%':
                goto addchar;
            case 'd':
                if (percentd_found)
                    goto fail;
                percentd_found = 1;
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
                len = strlen(buf1);
                if ((q - buf + len) > buf_size - 1)
                    goto fail;
                memcpy(q, buf1, len);
                q += len;
                break;
            default:
                goto fail;
            }
        } else {
        addchar:
            if ((q - buf) < buf_size - 1)
                *q++ = c;
        }
    }
    if (!percentd_found)
        goto fail;
    *q = '\0';
    return 0;
 fail:
    *q = '\0';
    return -1;
}

3050 3051
static void hex_dump_internal(void *avcl, FILE *f, int level,
                              const uint8_t *buf, int size)
3052 3053
{
    int len, i, j, c;
3054
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3055 3056 3057 3058 3059

    for(i=0;i<size;i+=16) {
        len = size - i;
        if (len > 16)
            len = 16;
3060
        PRINT("%08x ", i);
3061 3062
        for(j=0;j<16;j++) {
            if (j < len)
3063
                PRINT(" %02x", buf[i+j]);
3064
            else
3065
                PRINT("   ");
3066
        }
3067
        PRINT(" ");
3068 3069 3070 3071
        for(j=0;j<len;j++) {
            c = buf[i+j];
            if (c < ' ' || c > '~')
                c = '.';
3072
            PRINT("%c", c);
3073
        }
3074
        PRINT("\n");
3075
    }
3076 3077 3078
#undef PRINT
}

3079
void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3080 3081 3082 3083
{
    hex_dump_internal(NULL, f, 0, buf, size);
}

3084
void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3085 3086
{
    hex_dump_internal(avcl, NULL, level, buf, size);
3087 3088
}

3089
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3090
{
3091 3092
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
    PRINT("stream #%d:\n", pkt->stream_index);
3093
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3094
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3095
    /* DTS is _always_ valid after av_read_frame() */
3096
    PRINT("  dts=");
3097
    if (pkt->dts == AV_NOPTS_VALUE)
3098
        PRINT("N/A");
3099
    else
3100
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3101
    /* PTS may not be known if B-frames are present. */
3102
    PRINT("  pts=");
3103
    if (pkt->pts == AV_NOPTS_VALUE)
3104
        PRINT("N/A");
3105
    else
3106
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3107 3108 3109
    PRINT("\n");
    PRINT("  size=%d\n", pkt->size);
#undef PRINT
3110 3111 3112 3113
    if (dump_payload)
        av_hex_dump(f, pkt->data, pkt->size);
}

3114 3115 3116
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
{
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3117 3118
}

3119 3120 3121 3122
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
                      AVStream *st)
{
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3123 3124
}

3125 3126 3127 3128 3129 3130
void av_url_split(char *proto, int proto_size,
                  char *authorization, int authorization_size,
                  char *hostname, int hostname_size,
                  int *port_ptr,
                  char *path, int path_size,
                  const char *url)
Fabrice Bellard's avatar
Fabrice Bellard committed
3131
{
3132
    const char *p, *ls, *at, *col, *brk;
3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145

    if (port_ptr)               *port_ptr = -1;
    if (proto_size > 0)         proto[0] = 0;
    if (authorization_size > 0) authorization[0] = 0;
    if (hostname_size > 0)      hostname[0] = 0;
    if (path_size > 0)          path[0] = 0;

    /* parse protocol */
    if ((p = strchr(url, ':'))) {
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
        p++; /* skip ':' */
        if (*p == '/') p++;
        if (*p == '/') p++;
Fabrice Bellard's avatar
Fabrice Bellard committed
3146
    } else {
3147 3148 3149 3150
        /* no protocol means plain filename */
        av_strlcpy(path, url, path_size);
        return;
    }
3151

3152
    /* separate path from hostname */
3153 3154 3155 3156
    ls = strchr(p, '/');
    if(!ls)
        ls = strchr(p, '?');
    if(ls)
Michael Niedermayer's avatar
Michael Niedermayer committed
3157
        av_strlcpy(path, ls, path_size);
3158
    else
3159 3160 3161 3162 3163 3164 3165 3166 3167
        ls = &p[strlen(p)]; // XXX

    /* the rest is hostname, use that to parse auth/port */
    if (ls != p) {
        /* authorization (user[:pass]@hostname) */
        if ((at = strchr(p, '@')) && at < ls) {
            av_strlcpy(authorization, p,
                       FFMIN(authorization_size, at + 1 - p));
            p = at + 1; /* skip '@' */
Fabrice Bellard's avatar
Fabrice Bellard committed
3168
        }
3169

3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
            /* [host]:port */
            av_strlcpy(hostname, p + 1,
                       FFMIN(hostname_size, brk - p));
            if (brk[1] == ':' && port_ptr)
                *port_ptr = atoi(brk + 2);
        } else if ((col = strchr(p, ':')) && col < ls) {
            av_strlcpy(hostname, p,
                       FFMIN(col + 1 - p, hostname_size));
            if (port_ptr) *port_ptr = atoi(col + 1);
        } else
            av_strlcpy(hostname, p,
                       FFMIN(ls + 1 - p, hostname_size));
Fabrice Bellard's avatar
Fabrice Bellard committed
3183 3184 3185
    }
}

3186
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3187 3188
{
    int i;
3189
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
Martin Storsjö's avatar
Martin Storsjö committed
3190 3191 3192
                                           '4', '5', '6', '7',
                                           '8', '9', 'A', 'B',
                                           'C', 'D', 'E', 'F' };
3193 3194 3195 3196 3197
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
                                           '4', '5', '6', '7',
                                           '8', '9', 'a', 'b',
                                           'c', 'd', 'e', 'f' };
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3198 3199

    for(i = 0; i < s; i++) {
3200 3201
        buff[i * 2]     = hex_table[src[i] >> 4];
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3202 3203 3204 3205 3206
    }

    return buff;
}

3207 3208 3209 3210 3211 3212 3213 3214 3215 3216
int ff_hex_to_data(uint8_t *data, const char *p)
{
    int c, len, v;

    len = 0;
    v = 1;
    for (;;) {
        p += strspn(p, SPACE_CHARS);
        if (*p == '\0')
            break;
3217
        c = av_toupper((unsigned char) *p++);
3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234
        if (c >= '0' && c <= '9')
            c = c - '0';
        else if (c >= 'A' && c <= 'F')
            c = c - 'A' + 10;
        else
            break;
        v = (v << 4) | c;
        if (v & 0x100) {
            if (data)
                data[len] = v;
            len++;
            v = 1;
        }
    }
    return len;
}

3235 3236
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
                         unsigned int pts_num, unsigned int pts_den)
Fabrice Bellard's avatar
Fabrice Bellard committed
3237
{
3238 3239 3240 3241
    AVRational new_tb;
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
        if(new_tb.num != pts_num)
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3242 3243
    }else
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3244

3245 3246 3247 3248 3249 3250
    if(new_tb.num <= 0 || new_tb.den <= 0) {
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
        return;
    }
    s->time_base = new_tb;
    s->pts_wrap_bits = pts_wrap_bits;
Fabrice Bellard's avatar
Fabrice Bellard committed
3251
}
3252 3253 3254 3255 3256 3257

int ff_url_join(char *str, int size, const char *proto,
                const char *authorization, const char *hostname,
                int port, const char *fmt, ...)
{
#if CONFIG_NETWORK
3258
    struct addrinfo hints = { 0 }, *ai;
3259 3260 3261 3262 3263
#endif

    str[0] = '\0';
    if (proto)
        av_strlcatf(str, size, "%s://", proto);
3264
    if (authorization && authorization[0])
3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295
        av_strlcatf(str, size, "%s@", authorization);
#if CONFIG_NETWORK && defined(AF_INET6)
    /* Determine if hostname is a numerical IPv6 address,
     * properly escape it within [] in that case. */
    hints.ai_flags = AI_NUMERICHOST;
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
        if (ai->ai_family == AF_INET6) {
            av_strlcat(str, "[", size);
            av_strlcat(str, hostname, size);
            av_strlcat(str, "]", size);
        } else {
            av_strlcat(str, hostname, size);
        }
        freeaddrinfo(ai);
    } else
#endif
        /* Not an IPv6 address, just output the plain string. */
        av_strlcat(str, hostname, size);

    if (port >= 0)
        av_strlcatf(str, size, ":%d", port);
    if (fmt) {
        va_list vl;
        int len = strlen(str);

        va_start(vl, fmt);
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
        va_end(vl);
    }
    return strlen(str);
}
3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314

int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
                     AVFormatContext *src)
{
    AVPacket local_pkt;

    local_pkt = *pkt;
    local_pkt.stream_index = dst_stream;
    if (pkt->pts != AV_NOPTS_VALUE)
        local_pkt.pts = av_rescale_q(pkt->pts,
                                     src->streams[pkt->stream_index]->time_base,
                                     dst->streams[dst_stream]->time_base);
    if (pkt->dts != AV_NOPTS_VALUE)
        local_pkt.dts = av_rescale_q(pkt->dts,
                                     src->streams[pkt->stream_index]->time_base,
                                     dst->streams[dst_stream]->time_base);
    return av_write_frame(dst, &local_pkt);
}

3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
                        void *context)
{
    const char *ptr = str;

    /* Parse key=value pairs. */
    for (;;) {
        const char *key;
        char *dest = NULL, *dest_end;
        int key_len, dest_len = 0;

        /* Skip whitespace and potential commas. */
3327
        while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359
            ptr++;
        if (!*ptr)
            break;

        key = ptr;

        if (!(ptr = strchr(key, '=')))
            break;
        ptr++;
        key_len = ptr - key;

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

        if (*ptr == '\"') {
            ptr++;
            while (*ptr && *ptr != '\"') {
                if (*ptr == '\\') {
                    if (!ptr[1])
                        break;
                    if (dest && dest < dest_end)
                        *dest++ = ptr[1];
                    ptr += 2;
                } else {
                    if (dest && dest < dest_end)
                        *dest++ = *ptr;
                    ptr++;
                }
            }
            if (*ptr == '\"')
                ptr++;
        } else {
3360
            for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3361 3362 3363 3364 3365 3366 3367 3368
                if (dest && dest < dest_end)
                    *dest++ = *ptr;
        }
        if (dest)
            *dest = 0;
    }
}

Peter Ross's avatar
Peter Ross committed
3369 3370 3371 3372 3373 3374 3375 3376 3377
int ff_find_stream_index(AVFormatContext *s, int id)
{
    int i;
    for (i = 0; i < s->nb_streams; i++) {
        if (s->streams[i]->id == id)
            return i;
    }
    return -1;
}
3378 3379 3380 3381

void ff_make_absolute_url(char *buf, int size, const char *base,
                          const char *rel)
{
3382
    char *sep, *path_query;
3383 3384 3385 3386 3387 3388
    /* Absolute path, relative to the current server */
    if (base && strstr(base, "://") && rel[0] == '/') {
        if (base != buf)
            av_strlcpy(buf, base, size);
        sep = strstr(buf, "://");
        if (sep) {
3389 3390 3391 3392 3393 3394 3395 3396 3397 3398
            /* Take scheme from base url */
            if (rel[1] == '/') {
                sep[1] = '\0';
            } else {
                /* Take scheme and host from base url */
                sep += 3;
                sep = strchr(sep, '/');
                if (sep)
                    *sep = '\0';
            }
3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409
        }
        av_strlcat(buf, rel, size);
        return;
    }
    /* If rel actually is an absolute url, just copy it */
    if (!base || strstr(rel, "://") || rel[0] == '/') {
        av_strlcpy(buf, rel, size);
        return;
    }
    if (base != buf)
        av_strlcpy(buf, base, size);
3410 3411 3412 3413 3414 3415

    /* Strip off any query string from base */
    path_query = strchr(buf, '?');
    if (path_query != NULL)
        *path_query = '\0';

3416 3417 3418 3419 3420 3421
    /* Is relative path just a new query part? */
    if (rel[0] == '?') {
        av_strlcat(buf, rel, size);
        return;
    }

3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446
    /* Remove the file name from the base url */
    sep = strrchr(buf, '/');
    if (sep)
        sep[1] = '\0';
    else
        buf[0] = '\0';
    while (av_strstart(rel, "../", NULL) && sep) {
        /* Remove the path delimiter at the end */
        sep[0] = '\0';
        sep = strrchr(buf, '/');
        /* If the next directory name to pop off is "..", break here */
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
            /* Readd the slash we just removed */
            av_strlcat(buf, "/", size);
            break;
        }
        /* Cut off the directory name */
        if (sep)
            sep[1] = '\0';
        else
            buf[0] = '\0';
        rel += 3;
    }
    av_strlcat(buf, rel, size);
}
3447 3448 3449

int64_t ff_iso8601_to_unix_time(const char *datestr)
{
3450
#if HAVE_STRPTIME
3451 3452 3453 3454 3455 3456 3457 3458
    struct tm time1 = {0}, time2 = {0};
    char *ret1, *ret2;
    ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
    ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
    if (ret2 && !ret1)
        return av_timegm(&time2);
    else
        return av_timegm(&time1);
3459 3460 3461 3462 3463
#else
    av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
                                 "the date string.\n");
    return 0;
#endif
3464
}
3465

3466
int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
3467 3468 3469 3470 3471 3472 3473 3474
{
    if (ofmt) {
        if (ofmt->query_codec)
            return ofmt->query_codec(codec_id, std_compliance);
        else if (ofmt->codec_tag)
            return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
        else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
                 codec_id == ofmt->subtitle_codec)
3475
            return 1;
3476 3477 3478
    }
    return AVERROR_PATCHWELCOME;
}
3479 3480 3481 3482 3483

int avformat_network_init(void)
{
#if CONFIG_NETWORK
    int ret;
3484
    ff_network_inited_globally = 1;
3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499
    if ((ret = ff_network_init()) < 0)
        return ret;
    ff_tls_init();
#endif
    return 0;
}

int avformat_network_deinit(void)
{
#if CONFIG_NETWORK
    ff_network_close();
    ff_tls_deinit();
#endif
    return 0;
}
3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541

int ff_add_param_change(AVPacket *pkt, int32_t channels,
                        uint64_t channel_layout, int32_t sample_rate,
                        int32_t width, int32_t height)
{
    uint32_t flags = 0;
    int size = 4;
    uint8_t *data;
    if (!pkt)
        return AVERROR(EINVAL);
    if (channels) {
        size += 4;
        flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
    }
    if (channel_layout) {
        size += 8;
        flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
    }
    if (sample_rate) {
        size += 4;
        flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
    }
    if (width || height) {
        size += 8;
        flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
    }
    data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
    if (!data)
        return AVERROR(ENOMEM);
    bytestream_put_le32(&data, flags);
    if (channels)
        bytestream_put_le32(&data, channels);
    if (channel_layout)
        bytestream_put_le64(&data, channel_layout);
    if (sample_rate)
        bytestream_put_le32(&data, sample_rate);
    if (width || height) {
        bytestream_put_le32(&data, width);
        bytestream_put_le32(&data, height);
    }
    return 0;
}
3542 3543 3544 3545 3546 3547 3548 3549 3550

const struct AVCodecTag *avformat_get_riff_video_tags(void)
{
    return ff_codec_bmp_tags;
}
const struct AVCodecTag *avformat_get_riff_audio_tags(void)
{
    return ff_codec_wav_tags;
}
3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604

static int match_host_pattern(const char *pattern, const char *hostname)
{
    int len_p, len_h;
    if (!strcmp(pattern, "*"))
        return 1;
    // Skip a possible *. at the start of the pattern
    if (pattern[0] == '*')
        pattern++;
    if (pattern[0] == '.')
        pattern++;
    len_p = strlen(pattern);
    len_h = strlen(hostname);
    if (len_p > len_h)
        return 0;
    // Simply check if the end of hostname is equal to 'pattern'
    if (!strcmp(pattern, &hostname[len_h - len_p])) {
        if (len_h == len_p)
            return 1; // Exact match
        if (hostname[len_h - len_p - 1] == '.')
            return 1; // The matched substring is a domain and not just a substring of a domain
    }
    return 0;
}

int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
{
    char *buf, *start;
    int ret = 0;
    if (!no_proxy)
        return 0;
    if (!hostname)
        return 0;
    buf = av_strdup(no_proxy);
    if (!buf)
        return 0;
    start = buf;
    while (start) {
        char *sep, *next = NULL;
        start += strspn(start, " ,");
        sep = start + strcspn(start, " ,");
        if (*sep) {
            next = sep + 1;
            *sep = '\0';
        }
        if (match_host_pattern(start, hostname)) {
            ret = 1;
            break;
        }
        start = next;
    }
    av_free(buf);
    return ret;
}