flvdec.c 36.8 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
static int probe(AVProbeData *p, int live)
60
{
61 62
    const uint8_t *d = p->buf;
    unsigned offset = AV_RB32(d + 5);
63

64 65 66 67
    if (d[0] == 'F' &&
        d[1] == 'L' &&
        d[2] == 'V' &&
        d[3] < 5 && d[5] == 0 &&
68 69 70 71 72 73
        offset + 100 < p->buf_size &&
        offset > 8) {
        int is_live = !memcmp(d + offset + 40, "NGINX RTMP", 10);

        if (live == is_live)
            return AVPROBE_SCORE_MAX;
74 75 76 77
    }
    return 0;
}

78 79 80 81 82 83 84 85 86 87
static int flv_probe(AVProbeData *p)
{
    return probe(p, 0);
}

static int live_flv_probe(AVProbeData *p)
{
    return probe(p, 1);
}

88
static AVStream *create_stream(AVFormatContext *s, int codec_type)
89 90 91 92 93
{
    AVStream *st = avformat_new_stream(s, NULL);
    if (!st)
        return NULL;
    st->codec->codec_type = codec_type;
94
    if (s->nb_streams>=3 ||(   s->nb_streams==2
95 96 97 98
                           && s->streams[0]->codec->codec_type != AVMEDIA_TYPE_DATA
                           && s->streams[1]->codec->codec_type != AVMEDIA_TYPE_DATA))
        s->ctx_flags &= ~AVFMTCTX_NOHEADER;

99 100 101
    avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
    return st;
}
102

103 104 105
static int flv_same_audio_codec(AVCodecContext *acodec, int flags)
{
    int bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
106
    int flv_codecid           = flags & FLV_AUDIO_CODECID_MASK;
107 108 109 110 111 112 113 114
    int codec_id;

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

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

115 116
    switch (flv_codecid) {
    // no distinction between S16 and S8 PCM codec flags
117
    case FLV_CODECID_PCM:
118 119
        codec_id = bits_per_coded_sample == 8
                   ? AV_CODEC_ID_PCM_U8
120
#if HAVE_BIGENDIAN
121
                   : AV_CODEC_ID_PCM_S16BE;
122
#else
123
                   : AV_CODEC_ID_PCM_S16LE;
124 125 126
#endif
        return codec_id == acodec->codec_id;
    case FLV_CODECID_PCM_LE:
127 128 129
        codec_id = bits_per_coded_sample == 8
                   ? AV_CODEC_ID_PCM_U8
                   : AV_CODEC_ID_PCM_S16LE;
130 131
        return codec_id == acodec->codec_id;
    case FLV_CODECID_AAC:
132
        return acodec->codec_id == AV_CODEC_ID_AAC;
133
    case FLV_CODECID_ADPCM:
134
        return acodec->codec_id == AV_CODEC_ID_ADPCM_SWF;
135
    case FLV_CODECID_SPEEX:
136
        return acodec->codec_id == AV_CODEC_ID_SPEEX;
137
    case FLV_CODECID_MP3:
138
        return acodec->codec_id == AV_CODEC_ID_MP3;
139 140 141
    case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
    case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
    case FLV_CODECID_NELLYMOSER:
142
        return acodec->codec_id == AV_CODEC_ID_NELLYMOSER;
143 144
    case FLV_CODECID_PCM_MULAW:
        return acodec->sample_rate == 8000 &&
145
               acodec->codec_id    == AV_CODEC_ID_PCM_MULAW;
146
    case FLV_CODECID_PCM_ALAW:
147
        return acodec->sample_rate == 8000 &&
148
               acodec->codec_id    == AV_CODEC_ID_PCM_ALAW;
149 150 151 152
    default:
        return acodec->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
    }
}
153

154 155 156 157 158 159 160 161
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
162
#if HAVE_BIGENDIAN
163
                           : AV_CODEC_ID_PCM_S16BE;
Michael Niedermayer's avatar
Michael Niedermayer committed
164
#else
165
                           : AV_CODEC_ID_PCM_S16LE;
Michael Niedermayer's avatar
Michael Niedermayer committed
166
#endif
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 194 195 196 197 198 199 200 201 202 203 204 205 206 207
        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:
208
        avpriv_request_sample(s, "Audio codec (%x)",
209 210
               flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
        acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;
211 212 213
    }
}

214 215 216 217 218 219 220 221
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) {
222 223 224 225 226 227 228 229 230 231 232 233 234 235
    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;
236 237 238
    }
}

239 240 241
static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream,
                               int flv_codecid, int read)
{
242
    AVCodecContext *vcodec = vstream->codec;
243 244 245 246
    switch (flv_codecid) {
    case FLV_CODECID_H263:
        vcodec->codec_id = AV_CODEC_ID_FLV1;
        break;
247 248 249
    case FLV_CODECID_REALH263:
        vcodec->codec_id = AV_CODEC_ID_H263;
        break; // Really mean it this time
250 251 252 253 254 255 256 257 258 259 260 261 262
    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) {
263
                ff_alloc_extradata(vcodec, 1);
264
            }
265 266 267 268 269 270 271 272
            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;
273
        vstream->need_parsing = AVSTREAM_PARSE_HEADERS;
274
        return 3;     // not 4, reading packet type will consume one byte
275 276 277
    case FLV_CODECID_MPEG4:
        vcodec->codec_id = AV_CODEC_ID_MPEG4;
        return 3;
278
    default:
279
        avpriv_request_sample(s, "Video codec (%x)", flv_codecid);
280
        vcodec->codec_tag = flv_codecid;
281 282 283 284 285
    }

    return 0;
}

286 287
static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize)
{
288
    int length = avio_rb16(ioc);
289
    if (length >= buffsize) {
290
        avio_skip(ioc, length);
291 292
        return -1;
    }
293

294
    avio_read(ioc, buffer, length);
295

296
    buffer[length] = '\0';
297

298
    return length;
299 300
}

301 302 303 304
static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc,
                                 AVStream *vstream, int64_t max_pos)
{
    FLVContext *flv       = s->priv_data;
305
    unsigned int timeslen = 0, fileposlen = 0, i;
306
    char str_val[256];
307
    int64_t *times         = NULL;
308
    int64_t *filepositions = NULL;
309 310
    int ret                = AVERROR(ENOSYS);
    int64_t initial_pos    = avio_tell(ioc);
311

312
    if (vstream->nb_index_entries>0) {
Michael Niedermayer's avatar
Michael Niedermayer committed
313
        av_log(s, AV_LOG_WARNING, "Skipping duplicate index\n");
314 315 316
        return 0;
    }

317 318 319
    if (s->flags & AVFMT_FLAG_IGNIDX)
        return 0;

320 321
    while (avio_tell(ioc) < max_pos - 2 &&
           amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
322
        int64_t **current_array;
323
        unsigned int arraylen;
324 325 326 327 328 329

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

        arraylen = avio_rb32(ioc);
330
        if (arraylen>>28)
331 332
            break;

333 334
        if       (!strcmp(KEYFRAMES_TIMESTAMP_TAG , str_val) && !times) {
            current_array = &times;
335 336 337
            timeslen      = arraylen;
        } else if (!strcmp(KEYFRAMES_BYTEOFFSET_TAG, str_val) &&
                   !filepositions) {
338
            current_array = &filepositions;
339 340 341 342
            fileposlen    = arraylen;
        } else
            // unexpected metatag inside keyframes, will not use such
            // metadata for indexing
343 344 345 346 347 348 349
            break;

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

350 351
        for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++) {
            if (avio_r8(ioc) != AMF_DATA_TYPE_NUMBER)
352
                goto invalid;
353
            current_array[0][i] = av_int2double(avio_rb64(ioc));
354
        }
355 356 357 358 359 360
        if (times && filepositions) {
            // All done, exiting at a position allowing amf_parse_object
            // to finish parsing the object
            ret = 0;
            break;
        }
361 362
    }

363
    if (timeslen == fileposlen && fileposlen>1 && max_pos <= filepositions[0]) {
364
        for (i = 0; i < fileposlen; i++) {
365
            av_add_index_entry(vstream, filepositions[i], times[i] * 1000,
366
                               0, 0, AVINDEX_KEYFRAME);
367 368 369
            if (i < 2) {
                flv->validate_index[i].pos = filepositions[i];
                flv->validate_index[i].dts = times[i] * 1000;
370
                flv->validate_count        = i + 1;
371 372
            }
        }
373 374
    } else {
invalid:
375
        av_log(s, AV_LOG_WARNING, "Invalid keyframes object, skipping.\n");
376
    }
377 378 379 380

finish:
    av_freep(&times);
    av_freep(&filepositions);
381
    avio_seek(ioc, initial_pos, SEEK_SET);
382 383 384
    return ret;
}

385 386 387 388
static int amf_parse_object(AVFormatContext *s, AVStream *astream,
                            AVStream *vstream, const char *key,
                            int64_t max_pos, int depth)
{
389
    AVCodecContext *acodec, *vcodec;
390
    FLVContext *flv = s->priv_data;
391
    AVIOContext *ioc;
392
    AMFDataType amf_type;
393
    char str_val[256];
394 395
    double num_val;

396 397
    num_val  = 0;
    ioc      = s->pb;
398
    amf_type = avio_r8(ioc);
399

400 401 402 403 404 405 406 407 408 409 410 411 412
    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 &&
413
            ioc->seekable &&
414 415 416
            !strcmp(KEYFRAMES_TAG, key) && depth == 1)
            if (parse_keyframes_index(s, ioc, vstream ? vstream : astream,
                                      max_pos) < 0)
417
                av_log(s, AV_LOG_ERROR, "Keyframe index parsing failed\n");
418

419 420 421 422 423 424
        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)
425
            return -1;
426 427 428 429 430 431 432 433 434 435 436 437 438
        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)
439
                return -1;
440
        if (avio_r8(ioc) != AMF_END_OF_OBJECT)
441
            return -1;
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
        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;
459 460
    }

461 462
    // only look for metadata values when we are not nested and key != NULL
    if (depth == 1 && key) {
463 464 465
        acodec = astream ? astream->codec : NULL;
        vcodec = vstream ? vstream->codec : NULL;

466 467
        if (amf_type == AMF_DATA_TYPE_NUMBER ||
            amf_type == AMF_DATA_TYPE_BOOL) {
468 469
            if (!strcmp(key, "duration"))
                s->duration = num_val * AV_TIME_BASE;
470 471
            else if (!strcmp(key, "videodatarate") && vcodec &&
                     0 <= (int)(num_val * 1024.0))
472
                vcodec->bit_rate = num_val * 1024.0;
473 474
            else if (!strcmp(key, "audiodatarate") && acodec &&
                     0 <= (int)(num_val * 1024.0))
475
                acodec->bit_rate = num_val * 1024.0;
476
            else if (!strcmp(key, "datastream")) {
477
                AVStream *st = create_stream(s, AVMEDIA_TYPE_DATA);
478 479
                if (!st)
                    return AVERROR(ENOMEM);
480
                st->codec->codec_id = AV_CODEC_ID_TEXT;
481 482
            } else if (flv->trust_metadata) {
                if (!strcmp(key, "videocodecid") && vcodec) {
483
                    flv_set_video_codec(s, vstream, num_val, 0);
484
                } else if (!strcmp(key, "audiocodecid") && acodec) {
485 486
                    int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET;
                    flv_set_audio_codec(s, astream, acodec, id);
487
                } else if (!strcmp(key, "audiosamplerate") && acodec) {
488
                    acodec->sample_rate = num_val;
489 490 491
                } else if (!strcmp(key, "audiosamplesize") && acodec) {
                    acodec->bits_per_coded_sample = num_val;
                } else if (!strcmp(key, "stereo") && acodec) {
492
                    acodec->channels       = num_val + 1;
493 494 495
                    acodec->channel_layout = acodec->channels == 2 ?
                                             AV_CH_LAYOUT_STEREO :
                                             AV_CH_LAYOUT_MONO;
496
                } else if (!strcmp(key, "width") && vcodec) {
497
                    vcodec->width = num_val;
498
                } else if (!strcmp(key, "height") && vcodec) {
499 500
                    vcodec->height = num_val;
                }
501
            }
502 503
        }

504 505 506 507 508
        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

509 510 511 512 513 514 515 516 517 518 519
        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")          ||
520 521
            !strcmp(key, "audiocodecid")    ||
            !strcmp(key, "datastream"))
522 523
            return 0;

524 525 526
        if (amf_type == AMF_DATA_TYPE_BOOL) {
            av_strlcpy(str_val, num_val > 0 ? "true" : "false",
                       sizeof(str_val));
527
            av_dict_set(&s->metadata, key, str_val, 0);
528
        } else if (amf_type == AMF_DATA_TYPE_NUMBER) {
529
            snprintf(str_val, sizeof(str_val), "%.f", num_val);
530
            av_dict_set(&s->metadata, key, str_val, 0);
531
        } else if (amf_type == AMF_DATA_TYPE_STRING)
532
            av_dict_set(&s->metadata, key, str_val, 0);
533 534 535 536 537
    }

    return 0;
}

538 539
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)
{
540
    AMFDataType type;
541 542
    AVStream *stream, *astream, *vstream;
    AVStream av_unused *dstream;
543
    AVIOContext *ioc;
544
    int i;
545 546 547
    // only needs to hold the string "onMetaData".
    // Anything longer is something we don't want.
    char buffer[11];
548 549 550

    astream = NULL;
    vstream = NULL;
551
    dstream = NULL;
552
    ioc     = s->pb;
553

554
    // first object needs to be "onMetaData" string
555
    type = avio_r8(ioc);
556 557 558 559 560 561 562 563
    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"))
564 565
        return -1;

566 567 568
    // 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++) {
569
        stream = s->streams[i];
570
        if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO)
571
            vstream = stream;
572 573 574 575
        else if (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO)
            astream = stream;
        else if (stream->codec->codec_type == AVMEDIA_TYPE_DATA)
            dstream = stream;
576 577
    }

578 579
    // parse the second object (we want a mixed array)
    if (amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
580 581 582 583 584
        return -1;

    return 0;
}

585
static int flv_read_header(AVFormatContext *s)
586
{
587
    int offset, flags;
588

589
    avio_skip(s->pb, 4);
590
    flags = avio_r8(s->pb);
591

592
    s->ctx_flags |= AVFMTCTX_NOHEADER;
Michael Niedermayer's avatar
Michael Niedermayer committed
593

594 595
    if (flags & FLV_HEADER_FLAG_HASVIDEO)
        if (!create_stream(s, AVMEDIA_TYPE_VIDEO))
596
            return AVERROR(ENOMEM);
597 598
    if (flags & FLV_HEADER_FLAG_HASAUDIO)
        if (!create_stream(s, AVMEDIA_TYPE_AUDIO))
599
            return AVERROR(ENOMEM);
600 601
    // Flag doesn't indicate whether or not there is script-data present. Must
    // create that stream if it's encountered.
602

603
    offset = avio_rb32(s->pb);
604
    avio_seek(s->pb, offset, SEEK_SET);
605
    avio_skip(s->pb, 4);
606

607 608
    s->start_time = 0;

609 610 611
    return 0;
}

612 613
static int flv_read_close(AVFormatContext *s)
{
614
    int i;
615
    FLVContext *flv = s->priv_data;
616
    for (i=0; i<FLV_STREAM_TYPE_NB; i++)
617
        av_freep(&flv->new_extradata[i]);
618 619 620
    return 0;
}

621 622 623
static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
{
    av_free(st->codec->extradata);
624
    if (ff_get_extradata(st->codec, s->pb, size) < 0)
625 626 627 628
        return AVERROR(ENOMEM);
    return 0;
}

629 630 631 632
static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream,
                               int size)
{
    av_free(flv->new_extradata[stream]);
633 634
    flv->new_extradata[stream] = av_mallocz(size +
                                            FF_INPUT_BUFFER_PADDING_SIZE);
635 636 637 638 639 640 641
    if (!flv->new_extradata[stream])
        return AVERROR(ENOMEM);
    flv->new_extradata_size[stream] = size;
    avio_read(pb, flv->new_extradata[stream], size);
    return 0;
}

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

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 693 694 695 696 697 698
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;
}

699 700 701 702
static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
                           int64_t dts, int64_t next)
{
    AVIOContext *pb = s->pb;
703
    AVStream *st    = NULL;
704
    char buf[20];
705 706
    int ret = AVERROR_INVALIDDATA;
    int i, length = -1;
707

708 709
    switch (avio_r8(pb)) {
    case AMF_DATA_TYPE_MIXEDARRAY:
710
        avio_seek(pb, 4, SEEK_CUR);
711 712 713 714 715
    case AMF_DATA_TYPE_OBJECT:
        break;
    default:
        goto skip;
    }
716

717 718 719 720 721 722 723 724 725 726 727 728 729 730
    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;
        }
    }
731

732 733 734 735
    if (length < 0) {
        ret = AVERROR_INVALIDDATA;
        goto skip;
    }
736 737 738

    for (i = 0; i < s->nb_streams; i++) {
        st = s->streams[i];
739
        if (st->codec->codec_type == AVMEDIA_TYPE_DATA)
740 741 742 743
            break;
    }

    if (i == s->nb_streams) {
744
        st = create_stream(s, AVMEDIA_TYPE_DATA);
745
        if (!st)
746
            return AVERROR_INVALIDDATA;
747
        st->codec->codec_id = AV_CODEC_ID_TEXT;
748 749 750 751 752 753 754
    }

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

    pkt->stream_index = st->index;
755
    pkt->flags       |= AV_PKT_FLAG_KEY;
756

757
skip:
758
    avio_seek(s->pb, next + 4, SEEK_SET);
759

760 761 762
    return ret;
}

763 764
static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
{
765
    FLVContext *flv = s->priv_data;
766 767
    int ret, i, type, size, flags;
    int stream_type=-1;
768
    int64_t next, pos, meta_pos;
769
    int64_t dts, pts = AV_NOPTS_VALUE;
770 771
    int av_uninit(channels);
    int av_uninit(sample_rate);
772 773 774 775 776 777 778 779 780
    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;
781
        av_dlog(s, "type:%d, size:%d, dts:%"PRId64" pos:%"PRId64"\n", type, size, dts, avio_tell(s->pb));
782
        if (url_feof(s->pb))
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
            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) {
798 799 800 801 802
                clear_index_entries(s, validate_pos);
                flv->validate_count = 0;
            }
        }

803 804
        if (size == 0)
            continue;
805

806
        next = size + avio_tell(s->pb);
807

808
        if (type == FLV_TAG_TYPE_AUDIO) {
809
            stream_type = FLV_STREAM_TYPE_AUDIO;
810 811 812
            flags    = avio_r8(s->pb);
            size--;
        } else if (type == FLV_TAG_TYPE_VIDEO) {
813
            stream_type = FLV_STREAM_TYPE_VIDEO;
814 815
            flags    = avio_r8(s->pb);
            size--;
816
            if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_VIDEO_INFO_CMD)
817
                goto skip;
818 819 820 821 822 823 824 825
        } 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);
826
            }
827
        } else {
828
            av_log(s, AV_LOG_DEBUG,
829
                   "Skipping flv packet: type %d, size %d, flags %d.\n",
830
                   type, size, flags);
831 832 833
skip:
            avio_seek(s->pb, next, SEEK_SET);
            continue;
834
        }
835

836 837 838 839 840 841 842
        /* skip empty data packets */
        if (!size)
            continue;

        /* now find stream */
        for (i = 0; i < s->nb_streams; i++) {
            st = s->streams[i];
843 844 845
            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)))
846
                    break;
847 848 849 850 851 852
            } 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)
853
                    break;
854 855
            }
        }
856 857 858 859 860 861
        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);
862

863 864 865 866 867 868
        }
        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
        ) {
869 870 871
            avio_seek(s->pb, next, SEEK_SET);
            continue;
        }
872
        if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || stream_type == FLV_STREAM_TYPE_AUDIO)
873 874
            av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
        break;
875
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
876

877 878
    // if not streamed and no duration from metadata then seek to end to find
    // the duration from the timestamps
879
    if (s->pb->seekable && (!s->duration || s->duration == AV_NOPTS_VALUE) && !flv->searched_for_end) {
880
        int size;
881
        const int64_t pos   = avio_tell(s->pb);
882
        int64_t fsize       = avio_size(s->pb);
883
retry_duration:
884 885 886 887
        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) {
888
            uint32_t ts = avio_rb24(s->pb);
889
            ts         |= avio_r8(s->pb) << 24;
890
            if (ts)
891
                s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
892
            else if (fsize >= 8 && fsize - 8 >= size) {
893 894 895
                fsize -= size+4;
                goto retry_duration;
            }
896
        }
897

898
        avio_seek(s->pb, pos, SEEK_SET);
899
        flv->searched_for_end = 1;
900 901
    }

902
    if (stream_type == FLV_STREAM_TYPE_AUDIO) {
903
        int bits_per_coded_sample;
904 905 906
        channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
        sample_rate = 44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >>
                                FLV_AUDIO_SAMPLERATE_OFFSET) >> 3;
907
        bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
908 909
        if (!st->codec->channels || !st->codec->sample_rate ||
            !st->codec->bits_per_coded_sample) {
910
            st->codec->channels              = channels;
911 912 913
            st->codec->channel_layout        = channels == 1
                                               ? AV_CH_LAYOUT_MONO
                                               : AV_CH_LAYOUT_STEREO;
914 915
            st->codec->sample_rate           = sample_rate;
            st->codec->bits_per_coded_sample = bits_per_coded_sample;
916
        }
917 918 919 920 921 922 923
        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;
924
        } else {
925
            AVCodecContext ctx = {0};
926 927 928
            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
929
        }
930
    } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
931
        size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK, 1);
Michael Niedermayer's avatar
Michael Niedermayer committed
932 933
    }

934
    if (st->codec->codec_id == AV_CODEC_ID_AAC ||
935 936
        st->codec->codec_id == AV_CODEC_ID_H264 ||
        st->codec->codec_id == AV_CODEC_ID_MPEG4) {
937
        int type = avio_r8(s->pb);
938
        size--;
939
        if (st->codec->codec_id == AV_CODEC_ID_H264 || st->codec->codec_id == AV_CODEC_ID_MPEG4) {
940 941
            // sign extension
            int32_t cts = (avio_rb24(s->pb) + 0xff800000) ^ 0xff800000;
942
            pts = dts + cts;
943 944 945 946
            if (cts < 0) { // dts might be wrong
                if (!flv->wrong_dts)
                    av_log(s, AV_LOG_WARNING,
                        "Negative cts, previous timestamps might be wrong.\n");
947
                flv->wrong_dts = 1;
948 949 950 951
            } 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;
952
            }
953
        }
954
        if (type == 0 && (!st->codec->extradata || st->codec->codec_id == AV_CODEC_ID_AAC)) {
955 956
            AVDictionaryEntry *t;

957
            if (st->codec->extradata) {
958
                if ((ret = flv_queue_extradata(flv, s->pb, stream_type, size)) < 0)
959 960 961 962
                    return ret;
                ret = AVERROR(EAGAIN);
                goto leave;
            }
963
            if ((ret = flv_get_extradata(s, st, size)) < 0)
964
                return ret;
965

966 967 968 969 970
            /* 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;

971
            if (st->codec->codec_id == AV_CODEC_ID_AAC && 0) {
972
                MPEG4AudioConfig cfg;
973

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

Howard Chu's avatar
Howard Chu committed
987 988
            ret = AVERROR(EAGAIN);
            goto leave;
989 990 991
        }
    }

992
    /* skip empty data packets */
Howard Chu's avatar
Howard Chu committed
993 994 995 996
    if (!size) {
        ret = AVERROR(EAGAIN);
        goto leave;
    }
997

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

1022
    if (    stream_type == FLV_STREAM_TYPE_AUDIO ||
1023
            ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY) ||
1024
            stream_type == FLV_STREAM_TYPE_DATA)
1025
        pkt->flags |= AV_PKT_FLAG_KEY;
1026

Howard Chu's avatar
Howard Chu committed
1027
leave:
1028
    avio_skip(s->pb, 4);
1029 1030 1031
    return ret;
}

1032
static int flv_read_seek(AVFormatContext *s, int stream_index,
1033
                         int64_t ts, int flags)
1034
{
1035 1036
    FLVContext *flv = s->priv_data;
    flv->validate_count = 0;
1037
    return avio_seek_time(s->pb, stream_index, ts, flags);
1038 1039
}

1040 1041 1042
#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
1043
    { "flv_metadata", "Allocate streams according to the onMetaData array", OFFSET(trust_metadata), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
1044 1045 1046
    { NULL }
};

1047
static const AVClass flv_class = {
1048 1049 1050 1051 1052 1053
    .class_name = "flvdec",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

1054
AVInputFormat ff_flv_demuxer = {
1055
    .name           = "flv",
1056
    .long_name      = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1057 1058 1059 1060
    .priv_data_size = sizeof(FLVContext),
    .read_probe     = flv_probe,
    .read_header    = flv_read_header,
    .read_packet    = flv_read_packet,
1061 1062 1063
    .read_seek      = flv_read_seek,
    .read_close     = flv_read_close,
    .extensions     = "flv",
1064
    .priv_class     = &flv_class,
1065
};
1066 1067

static const AVClass live_flv_class = {
1068
    .class_name = "live_flvdec",
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

AVInputFormat ff_live_flv_demuxer = {
    .name           = "live_flv",
    .long_name      = NULL_IF_CONFIG_SMALL("live RTMP FLV (Flash Video)"),
    .priv_data_size = sizeof(FLVContext),
    .read_probe     = live_flv_probe,
    .read_header    = flv_read_header,
    .read_packet    = flv_read_packet,
    .read_seek      = flv_read_seek,
    .read_close     = flv_read_close,
    .extensions     = "flv",
    .priv_class     = &live_flv_class,
    .flags          = AVFMT_TS_DISCONT
};