flvdec.c 36.1 KB
Newer Older
1
/*
2
 * FLV demuxer
3
 * Copyright (c) 2003 The FFmpeg Project
4
 *
5 6 7 8 9
 * This demuxer will generate a 1 byte extradata for VP6F content.
 * It is composed of:
 *  - upper 4bits: difference between encoded width and visible width
 *  - lower 4bits: difference between encoded height and visible height
 *
10 11 12
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
13 14
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
15
 * version 2.1 of the License, or (at your option) any later version.
16
 *
17
 * FFmpeg is distributed in the hope that it will be useful,
18 19 20 21 22
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
23
 * License along with FFmpeg; if not, write to the Free Software
24
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25
 */
26

27
#include "libavutil/avstring.h"
28
#include "libavutil/channel_layout.h"
29
#include "libavutil/dict.h"
30
#include "libavutil/opt.h"
31
#include "libavutil/intfloat.h"
32
#include "libavutil/mathematics.h"
33
#include "libavcodec/bytestream.h"
34
#include "libavcodec/mpeg4audio.h"
35
#include "avformat.h"
36
#include "internal.h"
37
#include "avio_internal.h"
38
#include "flv.h"
39

40 41
#define VALIDATE_INDEX_TS_THRESH 2500

42
typedef struct {
43
    const AVClass *class; ///< Class for private options.
44 45
    int trust_metadata;   ///< configure streams according onMetaData
    int wrong_dts;        ///< wrong dts due to negative cts
46
    uint8_t *new_extradata[FLV_STREAM_TYPE_NB];
47
    int new_extradata_size[FLV_STREAM_TYPE_NB];
48 49
    int last_sample_rate;
    int last_channels;
50 51 52 53 54 55
    struct {
        int64_t dts;
        int64_t pos;
    } validate_index[2];
    int validate_next;
    int validate_count;
56
    int searched_for_end;
57 58
} FLVContext;

59 60 61 62 63
static int flv_probe(AVProbeData *p)
{
    const uint8_t *d;

    d = p->buf;
64 65 66 67 68
    if (d[0] == 'F' &&
        d[1] == 'L' &&
        d[2] == 'V' &&
        d[3] < 5 && d[5] == 0 &&
        AV_RB32(d + 5) > 8) {
69
        return AVPROBE_SCORE_MAX;
70 71 72 73
    }
    return 0;
}

74
static AVStream *create_stream(AVFormatContext *s, int codec_type)
75 76 77 78 79
{
    AVStream *st = avformat_new_stream(s, NULL);
    if (!st)
        return NULL;
    st->codec->codec_type = codec_type;
80
    if (s->nb_streams>=3 ||(   s->nb_streams==2
81 82 83 84
                           && s->streams[0]->codec->codec_type != AVMEDIA_TYPE_DATA
                           && s->streams[1]->codec->codec_type != AVMEDIA_TYPE_DATA))
        s->ctx_flags &= ~AVFMTCTX_NOHEADER;

85 86 87
    avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
    return st;
}
88

89 90 91
static int flv_same_audio_codec(AVCodecContext *acodec, int flags)
{
    int bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
92
    int flv_codecid           = flags & FLV_AUDIO_CODECID_MASK;
93 94 95 96 97 98 99 100
    int codec_id;

    if (!acodec->codec_id && !acodec->codec_tag)
        return 1;

    if (acodec->bits_per_coded_sample != bits_per_coded_sample)
        return 0;

101 102
    switch (flv_codecid) {
    // no distinction between S16 and S8 PCM codec flags
103
    case FLV_CODECID_PCM:
104 105
        codec_id = bits_per_coded_sample == 8
                   ? AV_CODEC_ID_PCM_U8
106
#if HAVE_BIGENDIAN
107
                   : AV_CODEC_ID_PCM_S16BE;
108
#else
109
                   : AV_CODEC_ID_PCM_S16LE;
110 111 112
#endif
        return codec_id == acodec->codec_id;
    case FLV_CODECID_PCM_LE:
113 114 115
        codec_id = bits_per_coded_sample == 8
                   ? AV_CODEC_ID_PCM_U8
                   : AV_CODEC_ID_PCM_S16LE;
116 117
        return codec_id == acodec->codec_id;
    case FLV_CODECID_AAC:
118
        return acodec->codec_id == AV_CODEC_ID_AAC;
119
    case FLV_CODECID_ADPCM:
120
        return acodec->codec_id == AV_CODEC_ID_ADPCM_SWF;
121
    case FLV_CODECID_SPEEX:
122
        return acodec->codec_id == AV_CODEC_ID_SPEEX;
123
    case FLV_CODECID_MP3:
124
        return acodec->codec_id == AV_CODEC_ID_MP3;
125 126 127
    case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
    case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
    case FLV_CODECID_NELLYMOSER:
128
        return acodec->codec_id == AV_CODEC_ID_NELLYMOSER;
129 130
    case FLV_CODECID_PCM_MULAW:
        return acodec->sample_rate == 8000 &&
131
               acodec->codec_id    == AV_CODEC_ID_PCM_MULAW;
132
    case FLV_CODECID_PCM_ALAW:
133
        return acodec->sample_rate == 8000 &&
134
               acodec->codec_id    == AV_CODEC_ID_PCM_ALAW;
135 136 137 138
    default:
        return acodec->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
    }
}
139

140 141 142 143 144 145 146 147
static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream,
                                AVCodecContext *acodec, int flv_codecid)
{
    switch (flv_codecid) {
    // no distinction between S16 and S8 PCM codec flags
    case FLV_CODECID_PCM:
        acodec->codec_id = acodec->bits_per_coded_sample == 8
                           ? AV_CODEC_ID_PCM_U8
148
#if HAVE_BIGENDIAN
149
                           : AV_CODEC_ID_PCM_S16BE;
Michael Niedermayer's avatar
Michael Niedermayer committed
150
#else
151
                           : AV_CODEC_ID_PCM_S16LE;
Michael Niedermayer's avatar
Michael Niedermayer committed
152
#endif
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
        break;
    case FLV_CODECID_PCM_LE:
        acodec->codec_id = acodec->bits_per_coded_sample == 8
                           ? AV_CODEC_ID_PCM_U8
                           : AV_CODEC_ID_PCM_S16LE;
        break;
    case FLV_CODECID_AAC:
        acodec->codec_id = AV_CODEC_ID_AAC;
        break;
    case FLV_CODECID_ADPCM:
        acodec->codec_id = AV_CODEC_ID_ADPCM_SWF;
        break;
    case FLV_CODECID_SPEEX:
        acodec->codec_id    = AV_CODEC_ID_SPEEX;
        acodec->sample_rate = 16000;
        break;
    case FLV_CODECID_MP3:
        acodec->codec_id      = AV_CODEC_ID_MP3;
        astream->need_parsing = AVSTREAM_PARSE_FULL;
        break;
    case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
        // in case metadata does not otherwise declare samplerate
        acodec->sample_rate = 8000;
        acodec->codec_id    = AV_CODEC_ID_NELLYMOSER;
        break;
    case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
        acodec->sample_rate = 16000;
        acodec->codec_id    = AV_CODEC_ID_NELLYMOSER;
        break;
    case FLV_CODECID_NELLYMOSER:
        acodec->codec_id = AV_CODEC_ID_NELLYMOSER;
        break;
    case FLV_CODECID_PCM_MULAW:
        acodec->sample_rate = 8000;
        acodec->codec_id    = AV_CODEC_ID_PCM_MULAW;
        break;
    case FLV_CODECID_PCM_ALAW:
        acodec->sample_rate = 8000;
        acodec->codec_id    = AV_CODEC_ID_PCM_ALAW;
        break;
    default:
194
        avpriv_request_sample(s, "Audio codec (%x)",
195 196
               flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
        acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;
197 198 199
    }
}

200 201 202 203 204 205 206 207
static int flv_same_video_codec(AVCodecContext *vcodec, int flags)
{
    int flv_codecid = flags & FLV_VIDEO_CODECID_MASK;

    if (!vcodec->codec_id && !vcodec->codec_tag)
        return 1;

    switch (flv_codecid) {
208 209 210 211 212 213 214 215 216 217 218 219 220 221
    case FLV_CODECID_H263:
        return vcodec->codec_id == AV_CODEC_ID_FLV1;
    case FLV_CODECID_SCREEN:
        return vcodec->codec_id == AV_CODEC_ID_FLASHSV;
    case FLV_CODECID_SCREEN2:
        return vcodec->codec_id == AV_CODEC_ID_FLASHSV2;
    case FLV_CODECID_VP6:
        return vcodec->codec_id == AV_CODEC_ID_VP6F;
    case FLV_CODECID_VP6A:
        return vcodec->codec_id == AV_CODEC_ID_VP6A;
    case FLV_CODECID_H264:
        return vcodec->codec_id == AV_CODEC_ID_H264;
    default:
        return vcodec->codec_tag == flv_codecid;
222 223 224
    }
}

225 226 227
static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream,
                               int flv_codecid, int read)
{
228
    AVCodecContext *vcodec = vstream->codec;
229 230 231 232
    switch (flv_codecid) {
    case FLV_CODECID_H263:
        vcodec->codec_id = AV_CODEC_ID_FLV1;
        break;
233 234 235
    case FLV_CODECID_REALH263:
        vcodec->codec_id = AV_CODEC_ID_H263;
        break; // Really mean it this time
236 237 238 239 240 241 242 243 244 245 246 247 248
    case FLV_CODECID_SCREEN:
        vcodec->codec_id = AV_CODEC_ID_FLASHSV;
        break;
    case FLV_CODECID_SCREEN2:
        vcodec->codec_id = AV_CODEC_ID_FLASHSV2;
        break;
    case FLV_CODECID_VP6:
        vcodec->codec_id = AV_CODEC_ID_VP6F;
    case FLV_CODECID_VP6A:
        if (flv_codecid == FLV_CODECID_VP6A)
            vcodec->codec_id = AV_CODEC_ID_VP6A;
        if (read) {
            if (vcodec->extradata_size != 1) {
249
                ff_alloc_extradata(vcodec, 1);
250
            }
251 252 253 254 255 256 257 258
            if (vcodec->extradata)
                vcodec->extradata[0] = avio_r8(s->pb);
            else
                avio_skip(s->pb, 1);
        }
        return 1;     // 1 byte body size adjustment for flv_read_packet()
    case FLV_CODECID_H264:
        vcodec->codec_id = AV_CODEC_ID_H264;
259
        vstream->need_parsing = AVSTREAM_PARSE_HEADERS;
260
        return 3;     // not 4, reading packet type will consume one byte
261 262 263
    case FLV_CODECID_MPEG4:
        vcodec->codec_id = AV_CODEC_ID_MPEG4;
        return 3;
264
    default:
265
        avpriv_request_sample(s, "Video codec (%x)", flv_codecid);
266
        vcodec->codec_tag = flv_codecid;
267 268 269 270 271
    }

    return 0;
}

272 273
static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize)
{
274
    int length = avio_rb16(ioc);
275
    if (length >= buffsize) {
276
        avio_skip(ioc, length);
277 278
        return -1;
    }
279

280
    avio_read(ioc, buffer, length);
281

282
    buffer[length] = '\0';
283

284
    return length;
285 286
}

287 288 289 290
static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc,
                                 AVStream *vstream, int64_t max_pos)
{
    FLVContext *flv       = s->priv_data;
291
    unsigned int timeslen = 0, fileposlen = 0, i;
292
    char str_val[256];
293
    int64_t *times         = NULL;
294
    int64_t *filepositions = NULL;
295 296
    int ret                = AVERROR(ENOSYS);
    int64_t initial_pos    = avio_tell(ioc);
297

298
    if (vstream->nb_index_entries>0) {
299 300 301 302
        av_log(s, AV_LOG_WARNING, "Skiping duplicate index\n");
        return 0;
    }

303 304 305
    if (s->flags & AVFMT_FLAG_IGNIDX)
        return 0;

306 307
    while (avio_tell(ioc) < max_pos - 2 &&
           amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
308
        int64_t **current_array;
309
        unsigned int arraylen;
310 311 312 313 314 315

        // Expect array object in context
        if (avio_r8(ioc) != AMF_DATA_TYPE_ARRAY)
            break;

        arraylen = avio_rb32(ioc);
316
        if (arraylen>>28)
317 318
            break;

319 320
        if       (!strcmp(KEYFRAMES_TIMESTAMP_TAG , str_val) && !times) {
            current_array = &times;
321 322 323
            timeslen      = arraylen;
        } else if (!strcmp(KEYFRAMES_BYTEOFFSET_TAG, str_val) &&
                   !filepositions) {
324
            current_array = &filepositions;
325 326 327 328
            fileposlen    = arraylen;
        } else
            // unexpected metatag inside keyframes, will not use such
            // metadata for indexing
329 330 331 332 333 334 335
            break;

        if (!(*current_array = av_mallocz(sizeof(**current_array) * arraylen))) {
            ret = AVERROR(ENOMEM);
            goto finish;
        }

336 337
        for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++) {
            if (avio_r8(ioc) != AMF_DATA_TYPE_NUMBER)
338
                goto invalid;
339
            current_array[0][i] = av_int2double(avio_rb64(ioc));
340
        }
341 342 343 344 345 346
        if (times && filepositions) {
            // All done, exiting at a position allowing amf_parse_object
            // to finish parsing the object
            ret = 0;
            break;
        }
347 348
    }

349
    if (timeslen == fileposlen && fileposlen>1 && max_pos <= filepositions[0]) {
350
        for (i = 0; i < fileposlen; i++) {
351
            av_add_index_entry(vstream, filepositions[i], times[i] * 1000,
352
                               0, 0, AVINDEX_KEYFRAME);
353 354 355
            if (i < 2) {
                flv->validate_index[i].pos = filepositions[i];
                flv->validate_index[i].dts = times[i] * 1000;
356
                flv->validate_count        = i + 1;
357 358
            }
        }
359 360
    } else {
invalid:
361
        av_log(s, AV_LOG_WARNING, "Invalid keyframes object, skipping.\n");
362
    }
363 364 365 366

finish:
    av_freep(&times);
    av_freep(&filepositions);
367
    avio_seek(ioc, initial_pos, SEEK_SET);
368 369 370
    return ret;
}

371 372 373 374
static int amf_parse_object(AVFormatContext *s, AVStream *astream,
                            AVStream *vstream, const char *key,
                            int64_t max_pos, int depth)
{
375
    AVCodecContext *acodec, *vcodec;
376
    FLVContext *flv = s->priv_data;
377
    AVIOContext *ioc;
378
    AMFDataType amf_type;
379
    char str_val[256];
380 381
    double num_val;

382 383
    num_val  = 0;
    ioc      = s->pb;
384
    amf_type = avio_r8(ioc);
385

386 387 388 389 390 391 392 393 394 395 396 397 398
    switch (amf_type) {
    case AMF_DATA_TYPE_NUMBER:
        num_val = av_int2double(avio_rb64(ioc));
        break;
    case AMF_DATA_TYPE_BOOL:
        num_val = avio_r8(ioc);
        break;
    case AMF_DATA_TYPE_STRING:
        if (amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
            return -1;
        break;
    case AMF_DATA_TYPE_OBJECT:
        if ((vstream || astream) && key &&
399
            ioc->seekable &&
400 401 402
            !strcmp(KEYFRAMES_TAG, key) && depth == 1)
            if (parse_keyframes_index(s, ioc, vstream ? vstream : astream,
                                      max_pos) < 0)
403
                av_log(s, AV_LOG_ERROR, "Keyframe index parsing failed\n");
404

405 406 407 408 409 410
        while (avio_tell(ioc) < max_pos - 2 &&
               amf_get_string(ioc, str_val, sizeof(str_val)) > 0)
            if (amf_parse_object(s, astream, vstream, str_val, max_pos,
                                 depth + 1) < 0)
                return -1;     // if we couldn't skip, bomb out.
        if (avio_r8(ioc) != AMF_END_OF_OBJECT)
411
            return -1;
412 413 414 415 416 417 418 419 420 421 422 423 424
        break;
    case AMF_DATA_TYPE_NULL:
    case AMF_DATA_TYPE_UNDEFINED:
    case AMF_DATA_TYPE_UNSUPPORTED:
        break;     // these take up no additional space
    case AMF_DATA_TYPE_MIXEDARRAY:
        avio_skip(ioc, 4);     // skip 32-bit max array index
        while (avio_tell(ioc) < max_pos - 2 &&
               amf_get_string(ioc, str_val, sizeof(str_val)) > 0)
            // this is the only case in which we would want a nested
            // parse to not skip over the object
            if (amf_parse_object(s, astream, vstream, str_val, max_pos,
                                 depth + 1) < 0)
425
                return -1;
426
        if (avio_r8(ioc) != AMF_END_OF_OBJECT)
427
            return -1;
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
        break;
    case AMF_DATA_TYPE_ARRAY:
    {
        unsigned int arraylen, i;

        arraylen = avio_rb32(ioc);
        for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++)
            if (amf_parse_object(s, NULL, NULL, NULL, max_pos,
                                 depth + 1) < 0)
                return -1;      // if we couldn't skip, bomb out.
    }
    break;
    case AMF_DATA_TYPE_DATE:
        avio_skip(ioc, 8 + 2);  // timestamp (double) and UTC offset (int16)
        break;
    default:                    // unsupported type, we couldn't skip
        return -1;
445 446
    }

447 448
    // only look for metadata values when we are not nested and key != NULL
    if (depth == 1 && key) {
449 450 451
        acodec = astream ? astream->codec : NULL;
        vcodec = vstream ? vstream->codec : NULL;

452 453
        if (amf_type == AMF_DATA_TYPE_NUMBER ||
            amf_type == AMF_DATA_TYPE_BOOL) {
454 455
            if (!strcmp(key, "duration"))
                s->duration = num_val * AV_TIME_BASE;
456 457
            else if (!strcmp(key, "videodatarate") && vcodec &&
                     0 <= (int)(num_val * 1024.0))
458
                vcodec->bit_rate = num_val * 1024.0;
459 460
            else if (!strcmp(key, "audiodatarate") && acodec &&
                     0 <= (int)(num_val * 1024.0))
461
                acodec->bit_rate = num_val * 1024.0;
462
            else if (!strcmp(key, "datastream")) {
463
                AVStream *st = create_stream(s, AVMEDIA_TYPE_DATA);
464 465
                if (!st)
                    return AVERROR(ENOMEM);
466
                st->codec->codec_id = AV_CODEC_ID_TEXT;
467 468
            } else if (flv->trust_metadata) {
                if (!strcmp(key, "videocodecid") && vcodec) {
469
                    flv_set_video_codec(s, vstream, num_val, 0);
470
                } else if (!strcmp(key, "audiocodecid") && acodec) {
471 472
                    int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET;
                    flv_set_audio_codec(s, astream, acodec, id);
473
                } else if (!strcmp(key, "audiosamplerate") && acodec) {
474
                    acodec->sample_rate = num_val;
475 476 477
                } else if (!strcmp(key, "audiosamplesize") && acodec) {
                    acodec->bits_per_coded_sample = num_val;
                } else if (!strcmp(key, "stereo") && acodec) {
478
                    acodec->channels       = num_val + 1;
479 480 481
                    acodec->channel_layout = acodec->channels == 2 ?
                                             AV_CH_LAYOUT_STEREO :
                                             AV_CH_LAYOUT_MONO;
482
                } else if (!strcmp(key, "width") && vcodec) {
483
                    vcodec->width = num_val;
484
                } else if (!strcmp(key, "height") && vcodec) {
485 486
                    vcodec->height = num_val;
                }
487
            }
488 489
        }

490 491 492 493 494
        if (amf_type == AMF_DATA_TYPE_OBJECT && s->nb_streams == 1 &&
           ((!acodec && !strcmp(key, "audiocodecid")) ||
            (!vcodec && !strcmp(key, "videocodecid"))))
                s->ctx_flags &= ~AVFMTCTX_NOHEADER; //If there is either audio/video missing, codecid will be an empty object

495 496 497 498 499 500 501 502 503 504 505
        if (!strcmp(key, "duration")        ||
            !strcmp(key, "filesize")        ||
            !strcmp(key, "width")           ||
            !strcmp(key, "height")          ||
            !strcmp(key, "videodatarate")   ||
            !strcmp(key, "framerate")       ||
            !strcmp(key, "videocodecid")    ||
            !strcmp(key, "audiodatarate")   ||
            !strcmp(key, "audiosamplerate") ||
            !strcmp(key, "audiosamplesize") ||
            !strcmp(key, "stereo")          ||
506 507
            !strcmp(key, "audiocodecid")    ||
            !strcmp(key, "datastream"))
508 509
            return 0;

510 511 512
        if (amf_type == AMF_DATA_TYPE_BOOL) {
            av_strlcpy(str_val, num_val > 0 ? "true" : "false",
                       sizeof(str_val));
513
            av_dict_set(&s->metadata, key, str_val, 0);
514
        } else if (amf_type == AMF_DATA_TYPE_NUMBER) {
515
            snprintf(str_val, sizeof(str_val), "%.f", num_val);
516
            av_dict_set(&s->metadata, key, str_val, 0);
517
        } else if (amf_type == AMF_DATA_TYPE_STRING)
518
            av_dict_set(&s->metadata, key, str_val, 0);
519 520 521 522 523
    }

    return 0;
}

524 525
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)
{
526
    AMFDataType type;
527 528
    AVStream *stream, *astream, *vstream;
    AVStream av_unused *dstream;
529
    AVIOContext *ioc;
530
    int i;
531 532 533
    // only needs to hold the string "onMetaData".
    // Anything longer is something we don't want.
    char buffer[11];
534 535 536

    astream = NULL;
    vstream = NULL;
537
    dstream = NULL;
538
    ioc     = s->pb;
539

540
    // first object needs to be "onMetaData" string
541
    type = avio_r8(ioc);
542 543 544 545 546 547 548 549
    if (type != AMF_DATA_TYPE_STRING ||
        amf_get_string(ioc, buffer, sizeof(buffer)) < 0)
        return -1;

    if (!strcmp(buffer, "onTextData"))
        return 1;

    if (strcmp(buffer, "onMetaData"))
550 551
        return -1;

552 553 554
    // find the streams now so that amf_parse_object doesn't need to do
    // the lookup every time it is called.
    for (i = 0; i < s->nb_streams; i++) {
555
        stream = s->streams[i];
556
        if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO)
557
            vstream = stream;
558 559 560 561
        else if (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO)
            astream = stream;
        else if (stream->codec->codec_type == AVMEDIA_TYPE_DATA)
            dstream = stream;
562 563
    }

564 565
    // parse the second object (we want a mixed array)
    if (amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
566 567 568 569 570
        return -1;

    return 0;
}

571
static int flv_read_header(AVFormatContext *s)
572
{
573
    int offset, flags;
574

575
    avio_skip(s->pb, 4);
576
    flags = avio_r8(s->pb);
577 578 579 580
    /* old flvtool cleared this field */
    /* FIXME: better fix needed */
    if (!flags) {
        flags = FLV_HEADER_FLAG_HASVIDEO | FLV_HEADER_FLAG_HASAUDIO;
581 582 583
        av_log(s, AV_LOG_WARNING,
               "Broken FLV file, which says no streams present, "
               "this might fail\n");
584
    }
585

586
    s->ctx_flags |= AVFMTCTX_NOHEADER;
Michael Niedermayer's avatar
Michael Niedermayer committed
587

588 589
    if (flags & FLV_HEADER_FLAG_HASVIDEO)
        if (!create_stream(s, AVMEDIA_TYPE_VIDEO))
590
            return AVERROR(ENOMEM);
591 592
    if (flags & FLV_HEADER_FLAG_HASAUDIO)
        if (!create_stream(s, AVMEDIA_TYPE_AUDIO))
593
            return AVERROR(ENOMEM);
594 595
    // Flag doesn't indicate whether or not there is script-data present. Must
    // create that stream if it's encountered.
596

597
    offset = avio_rb32(s->pb);
598
    avio_seek(s->pb, offset, SEEK_SET);
599
    avio_skip(s->pb, 4);
600

601 602
    s->start_time = 0;

603 604 605
    return 0;
}

606 607
static int flv_read_close(AVFormatContext *s)
{
608
    int i;
609
    FLVContext *flv = s->priv_data;
610
    for (i=0; i<FLV_STREAM_TYPE_NB; i++)
611
        av_freep(&flv->new_extradata[i]);
612 613 614
    return 0;
}

615 616 617
static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
{
    av_free(st->codec->extradata);
618
    if (ff_get_extradata(st->codec, s->pb, size) < 0)
619 620 621 622
        return AVERROR(ENOMEM);
    return 0;
}

623 624 625 626
static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream,
                               int size)
{
    av_free(flv->new_extradata[stream]);
627 628
    flv->new_extradata[stream] = av_mallocz(size +
                                            FF_INPUT_BUFFER_PADDING_SIZE);
629 630 631 632 633 634 635
    if (!flv->new_extradata[stream])
        return AVERROR(ENOMEM);
    flv->new_extradata_size[stream] = size;
    avio_read(pb, flv->new_extradata[stream], size);
    return 0;
}

636 637 638
static void clear_index_entries(AVFormatContext *s, int64_t pos)
{
    int i, j, out;
639 640
    av_log(s, AV_LOG_WARNING,
           "Found invalid index entries, clearing the index.\n");
641 642 643 644
    for (i = 0; i < s->nb_streams; i++) {
        AVStream *st = s->streams[i];
        /* Remove all index entries that point to >= pos */
        out = 0;
645
        for (j = 0; j < st->nb_index_entries; j++)
646 647 648 649 650 651
            if (st->index_entries[j].pos < pos)
                st->index_entries[out++] = st->index_entries[j];
        st->nb_index_entries = out;
    }
}

652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
static int amf_skip_tag(AVIOContext *pb, AMFDataType type)
{
    int nb = -1, ret, parse_name = 1;

    switch (type) {
    case AMF_DATA_TYPE_NUMBER:
        avio_skip(pb, 8);
        break;
    case AMF_DATA_TYPE_BOOL:
        avio_skip(pb, 1);
        break;
    case AMF_DATA_TYPE_STRING:
        avio_skip(pb, avio_rb16(pb));
        break;
    case AMF_DATA_TYPE_ARRAY:
        parse_name = 0;
    case AMF_DATA_TYPE_MIXEDARRAY:
        nb = avio_rb32(pb);
    case AMF_DATA_TYPE_OBJECT:
        while(!pb->eof_reached && (nb-- > 0 || type != AMF_DATA_TYPE_ARRAY)) {
            if (parse_name) {
                int size = avio_rb16(pb);
                if (!size) {
                    avio_skip(pb, 1);
                    break;
                }
                avio_skip(pb, size);
            }
            if ((ret = amf_skip_tag(pb, avio_r8(pb))) < 0)
                return ret;
        }
        break;
    case AMF_DATA_TYPE_NULL:
    case AMF_DATA_TYPE_OBJECT_END:
        break;
    default:
        return AVERROR_INVALIDDATA;
    }
    return 0;
}

693 694 695 696
static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
                           int64_t dts, int64_t next)
{
    AVIOContext *pb = s->pb;
697
    AVStream *st    = NULL;
698
    char buf[20];
699 700
    int ret = AVERROR_INVALIDDATA;
    int i, length = -1;
701

702 703
    switch (avio_r8(pb)) {
    case AMF_DATA_TYPE_MIXEDARRAY:
704
        avio_seek(pb, 4, SEEK_CUR);
705 706 707 708 709
    case AMF_DATA_TYPE_OBJECT:
        break;
    default:
        goto skip;
    }
710

711 712 713 714 715 716 717 718 719 720 721 722 723 724
    while ((ret = amf_get_string(pb, buf, sizeof(buf))) > 0) {
        AMFDataType type = avio_r8(pb);
        if (type == AMF_DATA_TYPE_STRING && !strcmp(buf, "text")) {
            length = avio_rb16(pb);
            ret    = av_get_packet(pb, pkt, length);
            if (ret < 0)
                goto skip;
            else
                break;
        } else {
            if ((ret = amf_skip_tag(pb, type)) < 0)
                goto skip;
        }
    }
725

726 727 728 729
    if (length < 0) {
        ret = AVERROR_INVALIDDATA;
        goto skip;
    }
730 731 732

    for (i = 0; i < s->nb_streams; i++) {
        st = s->streams[i];
733
        if (st->codec->codec_type == AVMEDIA_TYPE_DATA)
734 735 736 737
            break;
    }

    if (i == s->nb_streams) {
738
        st = create_stream(s, AVMEDIA_TYPE_DATA);
739
        if (!st)
740
            return AVERROR_INVALIDDATA;
741
        st->codec->codec_id = AV_CODEC_ID_TEXT;
742 743 744 745 746 747 748
    }

    pkt->dts  = dts;
    pkt->pts  = dts;
    pkt->size = ret;

    pkt->stream_index = st->index;
749
    pkt->flags       |= AV_PKT_FLAG_KEY;
750

751
skip:
752
    avio_seek(s->pb, next + 4, SEEK_SET);
753

754 755 756
    return ret;
}

757 758
static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
{
759
    FLVContext *flv = s->priv_data;
760 761
    int ret, i, type, size, flags;
    int stream_type=-1;
762
    int64_t next, pos, meta_pos;
763
    int64_t dts, pts = AV_NOPTS_VALUE;
764 765
    int av_uninit(channels);
    int av_uninit(sample_rate);
766 767 768 769 770 771 772 773 774 775
    AVStream *st    = NULL;

    /* pkt size is repeated at end. skip it */
    for (;; avio_skip(s->pb, 4)) {
        pos  = avio_tell(s->pb);
        type = avio_r8(s->pb);
        size = avio_rb24(s->pb);
        dts  = avio_rb24(s->pb);
        dts |= avio_r8(s->pb) << 24;
        av_dlog(s, "type:%d, size:%d, dts:%"PRId64"\n", type, size, dts);
776
        if (url_feof(s->pb))
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
            return AVERROR_EOF;
        avio_skip(s->pb, 3); /* stream id, always 0 */
        flags = 0;

        if (flv->validate_next < flv->validate_count) {
            int64_t validate_pos = flv->validate_index[flv->validate_next].pos;
            if (pos == validate_pos) {
                if (FFABS(dts - flv->validate_index[flv->validate_next].dts) <=
                    VALIDATE_INDEX_TS_THRESH) {
                    flv->validate_next++;
                } else {
                    clear_index_entries(s, validate_pos);
                    flv->validate_count = 0;
                }
            } else if (pos > validate_pos) {
792 793 794 795 796
                clear_index_entries(s, validate_pos);
                flv->validate_count = 0;
            }
        }

797 798
        if (size == 0)
            continue;
799

800
        next = size + avio_tell(s->pb);
801

802
        if (type == FLV_TAG_TYPE_AUDIO) {
803
            stream_type = FLV_STREAM_TYPE_AUDIO;
804 805 806
            flags    = avio_r8(s->pb);
            size--;
        } else if (type == FLV_TAG_TYPE_VIDEO) {
807
            stream_type = FLV_STREAM_TYPE_VIDEO;
808 809
            flags    = avio_r8(s->pb);
            size--;
810
            if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_VIDEO_INFO_CMD)
811
                goto skip;
812 813 814 815 816 817 818 819
        } else if (type == FLV_TAG_TYPE_META) {
            stream_type=FLV_STREAM_TYPE_DATA;
            if (size > 13 + 1 + 4 && dts == 0) { // Header-type metadata stuff
                meta_pos = avio_tell(s->pb);
                if (flv_read_metabody(s, next) == 0) {
                    goto skip;
                }
                avio_seek(s->pb, meta_pos, SEEK_SET);
820
            }
821
        } else {
822 823 824
            av_log(s, AV_LOG_DEBUG,
                   "skipping flv packet: type %d, size %d, flags %d\n",
                   type, size, flags);
825 826 827
skip:
            avio_seek(s->pb, next, SEEK_SET);
            continue;
828
        }
829

830 831 832 833 834 835 836
        /* skip empty data packets */
        if (!size)
            continue;

        /* now find stream */
        for (i = 0; i < s->nb_streams; i++) {
            st = s->streams[i];
837 838 839
            if (stream_type == FLV_STREAM_TYPE_AUDIO) {
                if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
                    (s->audio_codec_id || flv_same_audio_codec(st->codec, flags)))
840
                    break;
841 842 843 844 845 846
            } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
                if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
                    (s->video_codec_id || flv_same_video_codec(st->codec, flags)))
                    break;
            } else if (stream_type == FLV_STREAM_TYPE_DATA) {
                if (st->codec->codec_type == AVMEDIA_TYPE_DATA)
847
                    break;
848 849
            }
        }
850 851 852 853 854 855
        if (i == s->nb_streams) {
            static const enum AVMediaType stream_types[] = {AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_DATA};
            av_log(s, AV_LOG_WARNING, "Stream discovered after head already parsed\n");
            st = create_stream(s, stream_types[stream_type]);
            if (!st)
                return AVERROR(ENOMEM);
856

857 858 859 860 861 862
        }
        av_dlog(s, "%d %X %d \n", stream_type, flags, st->discard);
        if (  (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || (stream_type == FLV_STREAM_TYPE_AUDIO)))
            ||(st->discard >= AVDISCARD_BIDIR  &&  ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_DISP_INTER && (stream_type == FLV_STREAM_TYPE_VIDEO)))
            || st->discard >= AVDISCARD_ALL
        ) {
863 864 865
            avio_seek(s->pb, next, SEEK_SET);
            continue;
        }
866
        if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || stream_type == FLV_STREAM_TYPE_AUDIO)
867 868
            av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
        break;
869
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
870

871 872
    // if not streamed and no duration from metadata then seek to end to find
    // the duration from the timestamps
873
    if (s->pb->seekable && (!s->duration || s->duration == AV_NOPTS_VALUE) && !flv->searched_for_end) {
874
        int size;
875
        const int64_t pos   = avio_tell(s->pb);
876
        int64_t fsize       = avio_size(s->pb);
877
retry_duration:
878 879 880 881
        avio_seek(s->pb, fsize - 4, SEEK_SET);
        size = avio_rb32(s->pb);
        avio_seek(s->pb, fsize - 3 - size, SEEK_SET);
        if (size == avio_rb24(s->pb) + 11) {
882
            uint32_t ts = avio_rb24(s->pb);
883
            ts         |= avio_r8(s->pb) << 24;
884
            if (ts)
885
                s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
886
            else if (fsize >= 8 && fsize - 8 >= size) {
887 888 889
                fsize -= size+4;
                goto retry_duration;
            }
890
        }
891

892
        avio_seek(s->pb, pos, SEEK_SET);
893
        flv->searched_for_end = 1;
894 895
    }

896
    if (stream_type == FLV_STREAM_TYPE_AUDIO) {
897
        int bits_per_coded_sample;
898 899 900
        channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
        sample_rate = 44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >>
                                FLV_AUDIO_SAMPLERATE_OFFSET) >> 3;
901
        bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
902 903
        if (!st->codec->channels || !st->codec->sample_rate ||
            !st->codec->bits_per_coded_sample) {
904
            st->codec->channels              = channels;
905 906 907
            st->codec->channel_layout        = channels == 1
                                               ? AV_CH_LAYOUT_MONO
                                               : AV_CH_LAYOUT_STEREO;
908 909
            st->codec->sample_rate           = sample_rate;
            st->codec->bits_per_coded_sample = bits_per_coded_sample;
910
        }
911 912 913 914 915 916 917
        if (!st->codec->codec_id) {
            flv_set_audio_codec(s, st, st->codec,
                                flags & FLV_AUDIO_CODECID_MASK);
            flv->last_sample_rate =
            sample_rate           = st->codec->sample_rate;
            flv->last_channels    =
            channels              = st->codec->channels;
918
        } else {
919
            AVCodecContext ctx = {0};
920 921 922
            ctx.sample_rate = sample_rate;
            flv_set_audio_codec(s, st, &ctx, flags & FLV_AUDIO_CODECID_MASK);
            sample_rate = ctx.sample_rate;
Michael Niedermayer's avatar
Michael Niedermayer committed
923
        }
924
    } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
925
        size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK, 1);
Michael Niedermayer's avatar
Michael Niedermayer committed
926 927
    }

928
    if (st->codec->codec_id == AV_CODEC_ID_AAC ||
929 930
        st->codec->codec_id == AV_CODEC_ID_H264 ||
        st->codec->codec_id == AV_CODEC_ID_MPEG4) {
931
        int type = avio_r8(s->pb);
932
        size--;
933
        if (st->codec->codec_id == AV_CODEC_ID_H264 || st->codec->codec_id == AV_CODEC_ID_MPEG4) {
934 935
            // sign extension
            int32_t cts = (avio_rb24(s->pb) + 0xff800000) ^ 0xff800000;
936 937 938
            pts = dts + cts;
            if (cts < 0) { // dts are wrong
                flv->wrong_dts = 1;
939 940
                av_log(s, AV_LOG_WARNING,
                       "negative cts, previous timestamps might be wrong\n");
941 942 943 944
            } else if (FFABS(dts - pts) > 1000*60*15) {
                av_log(s, AV_LOG_WARNING,
                       "invalid timestamps %"PRId64" %"PRId64"\n", dts, pts);
                dts = pts = AV_NOPTS_VALUE;
945 946 947
            }
            if (flv->wrong_dts)
                dts = AV_NOPTS_VALUE;
948
        }
949
        if (type == 0 && (!st->codec->extradata || st->codec->codec_id == AV_CODEC_ID_AAC)) {
950 951
            AVDictionaryEntry *t;

952
            if (st->codec->extradata) {
953
                if ((ret = flv_queue_extradata(flv, s->pb, stream_type, size)) < 0)
954 955 956 957
                    return ret;
                ret = AVERROR(EAGAIN);
                goto leave;
            }
958
            if ((ret = flv_get_extradata(s, st, size)) < 0)
959
                return ret;
960

961 962 963 964 965
            /* Workaround for buggy Omnia A/XE encoder */
            t = av_dict_get(s->metadata, "Encoder", NULL, 0);
            if (st->codec->codec_id == AV_CODEC_ID_AAC && t && !strcmp(t->value, "Omnia A/XE"))
                st->codec->extradata_size = 2;

966
            if (st->codec->codec_id == AV_CODEC_ID_AAC && 0) {
967
                MPEG4AudioConfig cfg;
968

969 970
                if (avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata,
                                             st->codec->extradata_size * 8, 1) >= 0) {
971
                st->codec->channels       = cfg.channels;
972
                st->codec->channel_layout = 0;
973 974 975 976
                if (cfg.ext_sample_rate)
                    st->codec->sample_rate = cfg.ext_sample_rate;
                else
                    st->codec->sample_rate = cfg.sample_rate;
977
                av_dlog(s, "mp4a config channels %d sample rate %d\n",
978
                        st->codec->channels, st->codec->sample_rate);
979
                }
980 981
            }

Howard Chu's avatar
Howard Chu committed
982 983
            ret = AVERROR(EAGAIN);
            goto leave;
984 985 986
        }
    }

987
    /* skip empty data packets */
Howard Chu's avatar
Howard Chu committed
988 989 990 991
    if (!size) {
        ret = AVERROR(EAGAIN);
        goto leave;
    }
992

993
    ret = av_get_packet(s->pb, pkt, size);
994 995
    if (ret < 0)
        return ret;
996 997
    pkt->dts          = dts;
    pkt->pts          = pts == AV_NOPTS_VALUE ? dts : pts;
998
    pkt->stream_index = st->index;
999
    if (flv->new_extradata[stream_type]) {
1000
        uint8_t *side = av_packet_new_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,
1001
                                                flv->new_extradata_size[stream_type]);
1002
        if (side) {
1003 1004 1005 1006
            memcpy(side, flv->new_extradata[stream_type],
                   flv->new_extradata_size[stream_type]);
            av_freep(&flv->new_extradata[stream_type]);
            flv->new_extradata_size[stream_type] = 0;
1007 1008
        }
    }
1009 1010
    if (stream_type == FLV_STREAM_TYPE_AUDIO &&
                    (sample_rate != flv->last_sample_rate ||
1011
                     channels    != flv->last_channels)) {
1012 1013 1014 1015
        flv->last_sample_rate = sample_rate;
        flv->last_channels    = channels;
        ff_add_param_change(pkt, channels, 0, sample_rate, 0, 0);
    }
1016

1017
    if (    stream_type == FLV_STREAM_TYPE_AUDIO ||
1018
            ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY) ||
1019
            stream_type == FLV_STREAM_TYPE_DATA)
1020
        pkt->flags |= AV_PKT_FLAG_KEY;
1021

Howard Chu's avatar
Howard Chu committed
1022
leave:
1023
    avio_skip(s->pb, 4);
1024 1025 1026
    return ret;
}

1027
static int flv_read_seek(AVFormatContext *s, int stream_index,
1028
                         int64_t ts, int flags)
1029
{
1030 1031
    FLVContext *flv = s->priv_data;
    flv->validate_count = 0;
1032
    return avio_seek_time(s->pb, stream_index, ts, flags);
1033 1034
}

1035 1036 1037
#define OFFSET(x) offsetof(FLVContext, x)
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = {
Luca Barbato's avatar
Luca Barbato committed
1038
    { "flv_metadata", "Allocate streams according to the onMetaData array", OFFSET(trust_metadata), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
1039 1040 1041
    { NULL }
};

1042
static const AVClass flv_class = {
1043 1044 1045 1046 1047 1048
    .class_name = "flvdec",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

1049
AVInputFormat ff_flv_demuxer = {
1050
    .name           = "flv",
1051
    .long_name      = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1052 1053 1054 1055
    .priv_data_size = sizeof(FLVContext),
    .read_probe     = flv_probe,
    .read_header    = flv_read_header,
    .read_packet    = flv_read_packet,
1056 1057 1058
    .read_seek      = flv_read_seek,
    .read_close     = flv_read_close,
    .extensions     = "flv",
1059
    .priv_class     = &flv_class,
1060
};