flvdec.c 15.9 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 "libavcodec/bytestream.h"
29
#include "libavcodec/mpeg4audio.h"
30
#include "avformat.h"
31
#include "flv.h"
32

Baptiste Coudurier's avatar
Baptiste Coudurier committed
33 34 35 36
typedef struct {
    int wrong_dts; ///< wrong dts due to negative cts
} FLVContext;

37 38 39 40 41
static int flv_probe(AVProbeData *p)
{
    const uint8_t *d;

    d = p->buf;
42
    if (d[0] == 'F' && d[1] == 'L' && d[2] == 'V' && d[3] < 5 && d[5]==0 && AV_RB32(d+5)>8) {
43
        return AVPROBE_SCORE_MAX;
44 45 46 47
    }
    return 0;
}

Allan Hsu's avatar
Allan Hsu committed
48 49 50 51
static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream, int flv_codecid) {
    AVCodecContext *acodec = astream->codec;
    switch(flv_codecid) {
        //no distinction between S16 and S8 PCM codec flags
52
        case FLV_CODECID_PCM:
53
            acodec->codec_id = acodec->bits_per_coded_sample == 8 ? CODEC_ID_PCM_S8 :
54
#if HAVE_BIGENDIAN
Michael Niedermayer's avatar
Michael Niedermayer committed
55 56 57 58 59
                                CODEC_ID_PCM_S16BE;
#else
                                CODEC_ID_PCM_S16LE;
#endif
            break;
Allan Hsu's avatar
Allan Hsu committed
60
        case FLV_CODECID_PCM_LE:
61
            acodec->codec_id = acodec->bits_per_coded_sample == 8 ? CODEC_ID_PCM_S8 : CODEC_ID_PCM_S16LE; break;
62
        case FLV_CODECID_AAC  : acodec->codec_id = CODEC_ID_AAC;                                    break;
Allan Hsu's avatar
Allan Hsu committed
63
        case FLV_CODECID_ADPCM: acodec->codec_id = CODEC_ID_ADPCM_SWF;                              break;
64 65 66 67
        case FLV_CODECID_SPEEX:
            acodec->codec_id = CODEC_ID_SPEEX;
            acodec->sample_rate = 16000;
            break;
Aurelien Jacobs's avatar
Aurelien Jacobs committed
68
        case FLV_CODECID_MP3  : acodec->codec_id = CODEC_ID_MP3      ; astream->need_parsing = AVSTREAM_PARSE_FULL; break;
69
        case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
Allan Hsu's avatar
Allan Hsu committed
70 71
            acodec->sample_rate = 8000; //in case metadata does not otherwise declare samplerate
        case FLV_CODECID_NELLYMOSER:
Benjamin Larsson's avatar
Benjamin Larsson committed
72 73
            acodec->codec_id = CODEC_ID_NELLYMOSER;
            break;
Allan Hsu's avatar
Allan Hsu committed
74 75 76 77 78 79 80 81 82 83 84
        default:
            av_log(s, AV_LOG_INFO, "Unsupported audio codec (%x)\n", flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
            acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;
    }
}

static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, int flv_codecid) {
    AVCodecContext *vcodec = vstream->codec;
    switch(flv_codecid) {
        case FLV_CODECID_H263  : vcodec->codec_id = CODEC_ID_FLV1   ; break;
        case FLV_CODECID_SCREEN: vcodec->codec_id = CODEC_ID_FLASHSV; break;
85
        case FLV_CODECID_SCREEN2: vcodec->codec_id = CODEC_ID_FLASHSV2; break;
Allan Hsu's avatar
Allan Hsu committed
86
        case FLV_CODECID_VP6   : vcodec->codec_id = CODEC_ID_VP6F   ;
Aurelien Jacobs's avatar
Aurelien Jacobs committed
87 88 89
        case FLV_CODECID_VP6A  :
            if(flv_codecid == FLV_CODECID_VP6A)
                vcodec->codec_id = CODEC_ID_VP6A;
Allan Hsu's avatar
Allan Hsu committed
90 91 92 93
            if(vcodec->extradata_size != 1) {
                vcodec->extradata_size = 1;
                vcodec->extradata = av_malloc(1);
            }
94
            vcodec->extradata[0] = get_byte(s->pb);
Allan Hsu's avatar
Allan Hsu committed
95
            return 1; // 1 byte body size adjustment for flv_read_packet()
96 97 98
        case FLV_CODECID_H264:
            vcodec->codec_id = CODEC_ID_H264;
            return 3; // not 4, reading packet type will consume one byte
Allan Hsu's avatar
Allan Hsu committed
99 100 101 102 103 104 105 106
        default:
            av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid);
            vcodec->codec_tag = flv_codecid;
    }

    return 0;
}

107 108 109
static int amf_get_string(ByteIOContext *ioc, char **buf)
{
    uint16_t len = get_be16(ioc);
110

111 112 113
    *buf = av_malloc(len+1);
    if (!*buf)
        return AVERROR_NOMEM;
114

115 116
    get_buffer(ioc, *buf, len);
    (*buf)[len] = '\0';
117

118
    return len;
119 120
}

Pascal Massimino's avatar
Pascal Massimino committed
121
static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, int64_t max_pos, int depth) {
Allan Hsu's avatar
Allan Hsu committed
122 123 124
    AVCodecContext *acodec, *vcodec;
    ByteIOContext *ioc;
    AMFDataType amf_type;
125
    char *str = NULL;
Allan Hsu's avatar
Allan Hsu committed
126 127 128
    double num_val;

    num_val = 0;
129
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
130 131 132 133 134 135 136 137 138

    amf_type = get_byte(ioc);

    switch(amf_type) {
        case AMF_DATA_TYPE_NUMBER:
            num_val = av_int2dbl(get_be64(ioc)); break;
        case AMF_DATA_TYPE_BOOL:
            num_val = get_byte(ioc); break;
        case AMF_DATA_TYPE_STRING:
139
            if(amf_get_string(ioc, &str) < 0)
Allan Hsu's avatar
Allan Hsu committed
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
                return -1;
            break;
        case AMF_DATA_TYPE_OBJECT: {
            unsigned int keylen;

            while(url_ftell(ioc) < max_pos - 2 && (keylen = get_be16(ioc))) {
                url_fskip(ioc, keylen); //skip key string
                if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
                    return -1; //if we couldn't skip, bomb out.
            }
            if(get_byte(ioc) != AMF_END_OF_OBJECT)
                return -1;
        }
            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:
            url_fskip(ioc, 4); //skip 32-bit max array index
160
            while(url_ftell(ioc) < max_pos - 2 && amf_get_string(ioc, &str) > 0) {
Allan Hsu's avatar
Allan Hsu committed
161
                //this is the only case in which we would want a nested parse to not skip over the object
162
                if(amf_parse_object(s, astream, vstream, str, max_pos, depth + 1) < 0)
Allan Hsu's avatar
Allan Hsu committed
163
                    return -1;
164
                av_freep(&str);
Allan Hsu's avatar
Allan Hsu committed
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
            }
            if(get_byte(ioc) != AMF_END_OF_OBJECT)
                return -1;
            break;
        case AMF_DATA_TYPE_ARRAY: {
            unsigned int arraylen, i;

            arraylen = get_be32(ioc);
            for(i = 0; i < arraylen && url_ftell(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:
            url_fskip(ioc, 8 + 2); //timestamp (double) and UTC offset (int16)
            break;
        default: //unsupported type, we couldn't skip
            return -1;
    }

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

        if(amf_type == AMF_DATA_TYPE_BOOL) {
191
            av_metadata_set2(&s->metadata, key, av_d2str(num_val), AV_METADATA_DONT_STRDUP_VAL);
Allan Hsu's avatar
Allan Hsu committed
192
        } else if(amf_type == AMF_DATA_TYPE_NUMBER) {
193
            av_metadata_set2(&s->metadata, key, av_d2str(num_val), AV_METADATA_DONT_STRDUP_VAL);
Allan Hsu's avatar
Allan Hsu committed
194
            if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE;
195 196
            else if(!strcmp(key, "videodatarate") && vcodec && 0 <= (int)(num_val * 1024.0))
                vcodec->bit_rate = num_val * 1024.0;
197
        } else if (amf_type == AMF_DATA_TYPE_STRING)
198 199
            av_metadata_set2(&s->metadata, key, str,
                                   AV_METADATA_DONT_STRDUP_VAL);
Allan Hsu's avatar
Allan Hsu committed
200 201 202 203 204
    }

    return 0;
}

Pascal Massimino's avatar
Pascal Massimino committed
205
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
Allan Hsu's avatar
Allan Hsu committed
206 207 208
    AMFDataType type;
    AVStream *stream, *astream, *vstream;
    ByteIOContext *ioc;
209
    int i;
210
    char *buf = NULL; //only needs to hold the string "onMetaData". Anything longer is something we don't want.
Allan Hsu's avatar
Allan Hsu committed
211 212 213

    astream = NULL;
    vstream = NULL;
214
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
215 216 217

    //first object needs to be "onMetaData" string
    type = get_byte(ioc);
218 219 220
    if (type != AMF_DATA_TYPE_STRING ||
        amf_get_string(ioc, &buf) < 0 || strcmp(buf, "onMetaData")) {
        av_freep(&buf);
Allan Hsu's avatar
Allan Hsu committed
221
        return -1;
222
    }
Allan Hsu's avatar
Allan Hsu committed
223 224 225 226 227 228 229 230 231

    //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++) {
        stream = s->streams[i];
        if     (stream->codec->codec_type == CODEC_TYPE_AUDIO) astream = stream;
        else if(stream->codec->codec_type == CODEC_TYPE_VIDEO) vstream = stream;
    }

    //parse the second object (we want a mixed array)
232
    if(amf_parse_object(s, astream, vstream, buf, next_pos, 0) < 0)
Allan Hsu's avatar
Allan Hsu committed
233
        return -1;
234
    av_freep(&buf);
Allan Hsu's avatar
Allan Hsu committed
235 236 237 238

    return 0;
}

239 240 241 242 243
static AVStream *create_stream(AVFormatContext *s, int is_audio){
    AVStream *st = av_new_stream(s, is_audio);
    if (!st)
        return NULL;
    st->codec->codec_type = is_audio ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
244
    av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
245 246 247
    return st;
}

248 249 250
static int flv_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
{
251
    int offset, flags;
252

253 254
    url_fskip(s->pb, 4);
    flags = get_byte(s->pb);
255 256 257 258 259 260
    /* old flvtool cleared this field */
    /* FIXME: better fix needed */
    if (!flags) {
        flags = FLV_HEADER_FLAG_HASVIDEO | FLV_HEADER_FLAG_HASAUDIO;
        av_log(s, AV_LOG_WARNING, "Broken FLV file, which says no streams present, this might fail\n");
    }
261

Michael Niedermayer's avatar
Michael Niedermayer committed
262 263 264 265
    if((flags & (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
             != (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
        s->ctx_flags |= AVFMTCTX_NOHEADER;

266
    if(flags & FLV_HEADER_FLAG_HASVIDEO){
267
        if(!create_stream(s, 0))
268
            return AVERROR(ENOMEM);
269 270
    }
    if(flags & FLV_HEADER_FLAG_HASAUDIO){
271
        if(!create_stream(s, 1))
272
            return AVERROR(ENOMEM);
273 274
    }

275 276
    offset = get_be32(s->pb);
    url_fseek(s->pb, offset, SEEK_SET);
277

278 279
    s->start_time = 0;

280 281 282
    return 0;
}

283 284 285 286 287 288 289 290 291 292 293
static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
{
    av_free(st->codec->extradata);
    st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
    if (!st->codec->extradata)
        return AVERROR(ENOMEM);
    st->codec->extradata_size = size;
    get_buffer(s->pb, st->codec->extradata, st->codec->extradata_size);
    return 0;
}

294 295
static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
{
Baptiste Coudurier's avatar
Baptiste Coudurier committed
296
    FLVContext *flv = s->priv_data;
Pascal Massimino's avatar
Pascal Massimino committed
297 298
    int ret, i, type, size, flags, is_audio;
    int64_t next, pos;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
299
    int64_t dts, pts = AV_NOPTS_VALUE;
Alex Beregszaszi's avatar
Alex Beregszaszi committed
300
    AVStream *st = NULL;
301

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
302
 for(;;){
303 304 305 306
    pos = url_ftell(s->pb);
    url_fskip(s->pb, 4); /* size of previous packet */
    type = get_byte(s->pb);
    size = get_be24(s->pb);
307 308 309
    dts = get_be24(s->pb);
    dts |= get_byte(s->pb) << 24;
//    av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, dts:%d\n", type, size, dts);
310
    if (url_feof(s->pb))
311
        return AVERROR_EOF;
312
    url_fskip(s->pb, 3); /* stream id, always 0 */
313
    flags = 0;
314

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
315 316
    if(size == 0)
        continue;
317

318
    next= size + url_ftell(s->pb);
319

320
    if (type == FLV_TAG_TYPE_AUDIO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
321
        is_audio=1;
322
        flags = get_byte(s->pb);
323
        size--;
324
    } else if (type == FLV_TAG_TYPE_VIDEO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
325
        is_audio=0;
326
        flags = get_byte(s->pb);
327
        size--;
328 329
        if ((flags & 0xf0) == 0x50) /* video info / command frame */
            goto skip;
330
    } else {
331
        if (type == FLV_TAG_TYPE_META && size > 13+1+4)
Allan Hsu's avatar
Allan Hsu committed
332 333
            flv_read_metabody(s, next);
        else /* skip packet */
334
            av_log(s, AV_LOG_DEBUG, "skipping flv packet: type %d, size %d, flags %d\n", type, size, flags);
335
    skip:
336
        url_fseek(s->pb, next, SEEK_SET);
337
        continue;
338 339
    }

340 341 342 343
    /* skip empty data packets */
    if (!size)
        continue;

344 345 346
    /* now find stream */
    for(i=0;i<s->nb_streams;i++) {
        st = s->streams[i];
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
347 348
        if (st->id == is_audio)
            break;
349
    }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
350
    if(i == s->nb_streams){
351
        av_log(s, AV_LOG_ERROR, "invalid stream\n");
352
        st= create_stream(s, is_audio);
353
        s->ctx_flags &= ~AVFMTCTX_NOHEADER;
354
    }
355
//    av_log(s, AV_LOG_DEBUG, "%d %X %d \n", is_audio, flags, st->discard);
356 357
    if(  (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY ||         is_audio))
       ||(st->discard >= AVDISCARD_BIDIR  &&  ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_DISP_INTER && !is_audio))
358 359
       || st->discard >= AVDISCARD_ALL
       ){
360
        url_fseek(s->pb, next, SEEK_SET);
361
        continue;
362
    }
363
    if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY)
364
        av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
365 366 367
    break;
 }

368
    // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
369
    if(!url_is_streamed(s->pb) && s->duration==AV_NOPTS_VALUE){
370
        int size;
Pascal Massimino's avatar
Pascal Massimino committed
371 372
        const int64_t pos= url_ftell(s->pb);
        const int64_t fsize= url_fsize(s->pb);
373 374 375 376
        url_fseek(s->pb, fsize-4, SEEK_SET);
        size= get_be32(s->pb);
        url_fseek(s->pb, fsize-3-size, SEEK_SET);
        if(size == get_be24(s->pb) + 11){
377 378 379
            uint32_t ts = get_be24(s->pb);
            ts |= get_byte(s->pb) << 24;
            s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
380
        }
381
        url_fseek(s->pb, pos, SEEK_SET);
382 383
    }

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
384
    if(is_audio){
385
        if(!st->codec->channels || !st->codec->sample_rate || !st->codec->bits_per_coded_sample) {
386
            st->codec->channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
387
            st->codec->sample_rate = (44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >> FLV_AUDIO_SAMPLERATE_OFFSET) >> 3);
388
            st->codec->bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
389 390
        }
        if(!st->codec->codec_id){
Allan Hsu's avatar
Allan Hsu committed
391
            flv_set_audio_codec(s, st, flags & FLV_AUDIO_CODECID_MASK);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
392 393
        }
    }else{
Allan Hsu's avatar
Allan Hsu committed
394
        size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK);
Michael Niedermayer's avatar
Michael Niedermayer committed
395 396
    }

397 398 399 400 401
    if (st->codec->codec_id == CODEC_ID_AAC ||
        st->codec->codec_id == CODEC_ID_H264) {
        int type = get_byte(s->pb);
        size--;
        if (st->codec->codec_id == CODEC_ID_H264) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
402 403 404 405 406 407 408 409
            int32_t cts = (get_be24(s->pb)+0xff800000)^0xff800000; // sign extension
            pts = dts + cts;
            if (cts < 0) { // dts are wrong
                flv->wrong_dts = 1;
                av_log(s, AV_LOG_WARNING, "negative cts, previous timestamps might be wrong\n");
            }
            if (flv->wrong_dts)
                dts = AV_NOPTS_VALUE;
410 411
        }
        if (type == 0) {
412
            if ((ret = flv_get_extradata(s, st, size)) < 0)
413
                return ret;
414 415 416 417
            if (st->codec->codec_id == CODEC_ID_AAC) {
                MPEG4AudioConfig cfg;
                ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
                                         st->codec->extradata_size);
418
                st->codec->channels = cfg.channels;
419 420 421 422 423
                st->codec->sample_rate = cfg.sample_rate;
                dprintf(s, "mp4a config channels %d sample rate %d\n",
                        st->codec->channels, st->codec->sample_rate);
            }

424
            return AVERROR(EAGAIN);
425 426 427
        }
    }

428 429 430 431
    /* skip empty data packets */
    if (!size)
        return AVERROR(EAGAIN);

432
    ret= av_get_packet(s->pb, pkt, size);
433
    if (ret < 0) {
434
        return AVERROR(EIO);
435 436 437 438
    }
    /* note: we need to modify the packet size here to handle the last
       packet */
    pkt->size = ret;
439
    pkt->dts = dts;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
440
    pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
441
    pkt->stream_index = st->index;
442

443
    if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))
444
        pkt->flags |= PKT_FLAG_KEY;
445

446 447 448
    return ret;
}

449
AVInputFormat flv_demuxer = {
450
    "flv",
451
    NULL_IF_CONFIG_SMALL("FLV format"),
Baptiste Coudurier's avatar
Baptiste Coudurier committed
452
    sizeof(FLVContext),
453 454 455 456 457 458
    flv_probe,
    flv_read_header,
    flv_read_packet,
    .extensions = "flv",
    .value = CODEC_ID_FLV1,
};