flvdec.c 15.9 KB
Newer Older
1
/*
2
 * FLV demuxer
3 4
 * Copyright (c) 2003 The FFmpeg Project.
 *
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
 */
#include "avformat.h"
27
#include "flv.h"
28 29 30 31 32 33

static int flv_probe(AVProbeData *p)
{
    const uint8_t *d;

    d = p->buf;
34 35
    if (d[0] == 'F' && d[1] == 'L' && d[2] == 'V' && d[3] < 5 && d[5]==0) {
        return AVPROBE_SCORE_MAX;
36 37 38 39
    }
    return 0;
}

Allan Hsu's avatar
Allan Hsu committed
40 41 42 43
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
44
        case FLV_CODECID_PCM:
Michael Niedermayer's avatar
Michael Niedermayer committed
45 46 47 48 49 50 51
            acodec->codec_id = acodec->bits_per_sample == 8 ? CODEC_ID_PCM_S8 :
#ifdef WORDS_BIGENDIAN
                                CODEC_ID_PCM_S16BE;
#else
                                CODEC_ID_PCM_S16LE;
#endif
            break;
Allan Hsu's avatar
Allan Hsu committed
52 53
        case FLV_CODECID_PCM_LE:
            acodec->codec_id = acodec->bits_per_sample == 8 ? CODEC_ID_PCM_S8 : CODEC_ID_PCM_S16LE; break;
54
        case FLV_CODECID_AAC  : acodec->codec_id = CODEC_ID_AAC;                                    break;
Allan Hsu's avatar
Allan Hsu committed
55
        case FLV_CODECID_ADPCM: acodec->codec_id = CODEC_ID_ADPCM_SWF;                              break;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
56
        case FLV_CODECID_SPEEX: acodec->codec_id = CODEC_ID_SPEEX;                                  break;
Aurelien Jacobs's avatar
Aurelien Jacobs committed
57
        case FLV_CODECID_MP3  : acodec->codec_id = CODEC_ID_MP3      ; astream->need_parsing = AVSTREAM_PARSE_FULL; break;
Allan Hsu's avatar
Allan Hsu committed
58 59 60
        case FLV_CODECID_NELLYMOSER_8HZ_MONO:
            acodec->sample_rate = 8000; //in case metadata does not otherwise declare samplerate
        case FLV_CODECID_NELLYMOSER:
Benjamin Larsson's avatar
Benjamin Larsson committed
61 62
            acodec->codec_id = CODEC_ID_NELLYMOSER;
            break;
Allan Hsu's avatar
Allan Hsu committed
63 64 65 66 67 68 69 70 71 72 73 74
        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;
        case FLV_CODECID_VP6   : vcodec->codec_id = CODEC_ID_VP6F   ;
Aurelien Jacobs's avatar
Aurelien Jacobs committed
75 76 77
        case FLV_CODECID_VP6A  :
            if(flv_codecid == FLV_CODECID_VP6A)
                vcodec->codec_id = CODEC_ID_VP6A;
Allan Hsu's avatar
Allan Hsu committed
78 79 80 81
            if(vcodec->extradata_size != 1) {
                vcodec->extradata_size = 1;
                vcodec->extradata = av_malloc(1);
            }
82
            vcodec->extradata[0] = get_byte(s->pb);
Allan Hsu's avatar
Allan Hsu committed
83
            return 1; // 1 byte body size adjustment for flv_read_packet()
84 85 86
        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
87 88 89 90 91 92 93 94
        default:
            av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid);
            vcodec->codec_tag = flv_codecid;
    }

    return 0;
}

95
static int amf_get_string(ByteIOContext *ioc, char *buffer, int buffsize) {
Michael Niedermayer's avatar
Michael Niedermayer committed
96
    int length = get_be16(ioc);
97 98
    if(length >= buffsize) {
        url_fskip(ioc, length);
Michael Niedermayer's avatar
Michael Niedermayer committed
99
        return -1;
100 101 102 103 104 105 106 107 108
    }

    get_buffer(ioc, buffer, length);

    buffer[length] = '\0';

    return length;
}

Allan Hsu's avatar
Allan Hsu committed
109 110 111 112 113 114 115 116
static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, unsigned int max_pos, int depth) {
    AVCodecContext *acodec, *vcodec;
    ByteIOContext *ioc;
    AMFDataType amf_type;
    char str_val[256];
    double num_val;

    num_val = 0;
117
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 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

    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:
            if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
                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
            while(url_ftell(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)
                    return -1;
            }
            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) {
            if(!strcmp(key, "stereo") && acodec) acodec->channels = num_val > 0 ? 2 : 1;
        } else if(amf_type == AMF_DATA_TYPE_NUMBER) {
            if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE;
181 182
//            else if(!strcmp(key, "width")  && vcodec && num_val > 0) vcodec->width  = num_val;
//            else if(!strcmp(key, "height") && vcodec && num_val > 0) vcodec->height = num_val;
183 184 185 186 187
            else if(!strcmp(key, "audiocodecid") && acodec && 0 <= (int)num_val)
                flv_set_audio_codec(s, astream, (int)num_val << FLV_AUDIO_CODECID_OFFSET);
            else if(!strcmp(key, "videocodecid") && vcodec && 0 <= (int)num_val)
                flv_set_video_codec(s, vstream, (int)num_val);
            else if(!strcmp(key, "audiosamplesize") && acodec && 0 < (int)num_val) {
Allan Hsu's avatar
Allan Hsu committed
188 189 190 191 192 193 194
                acodec->bits_per_sample = num_val;
                //we may have to rewrite a previously read codecid because FLV only marks PCM endianness.
                if(num_val == 8 && (acodec->codec_id == CODEC_ID_PCM_S16BE || acodec->codec_id == CODEC_ID_PCM_S16LE))
                    acodec->codec_id = CODEC_ID_PCM_S8;
            }
            else if(!strcmp(key, "audiosamplerate") && acodec && num_val >= 0) {
                //some tools, like FLVTool2, write consistently approximate metadata sample rates
195
                if (!acodec->sample_rate) {
Benjamin Larsson's avatar
Benjamin Larsson committed
196 197 198 199 200 201 202
                    switch((int)num_val) {
                        case 44000: acodec->sample_rate = 44100  ; break;
                        case 22000: acodec->sample_rate = 22050  ; break;
                        case 11000: acodec->sample_rate = 11025  ; break;
                        case 5000 : acodec->sample_rate = 5512   ; break;
                        default   : acodec->sample_rate = num_val;
                    }
203
                }
Allan Hsu's avatar
Allan Hsu committed
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
            }
        }
    }

    return 0;
}

static int flv_read_metabody(AVFormatContext *s, unsigned int next_pos) {
    AMFDataType type;
    AVStream *stream, *astream, *vstream;
    ByteIOContext *ioc;
    int i, keylen;
    char buffer[11]; //only needs to hold the string "onMetaData". Anything longer is something we don't want.

    astream = NULL;
    vstream = NULL;
    keylen = 0;
221
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241

    //first object needs to be "onMetaData" string
    type = get_byte(ioc);
    if(type != AMF_DATA_TYPE_STRING || amf_get_string(ioc, buffer, sizeof(buffer)) < 0 || strcmp(buffer, "onMetaData"))
        return -1;

    //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)
    if(amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
        return -1;

    return 0;
}

242 243 244 245 246
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
247
    av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
248 249 250
    return st;
}

251 252 253
static int flv_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
{
254
    int offset, flags;
255

256 257
    url_fskip(s->pb, 4);
    flags = get_byte(s->pb);
258 259 260 261 262 263
    /* 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");
    }
264

Michael Niedermayer's avatar
Michael Niedermayer committed
265 266 267 268
    if((flags & (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
             != (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
        s->ctx_flags |= AVFMTCTX_NOHEADER;

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

278 279
    offset = get_be32(s->pb);
    url_fseek(s->pb, offset, SEEK_SET);
280

281 282
    s->start_time = 0;

283 284 285
    return 0;
}

286 287 288 289 290 291 292 293 294 295 296
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;
}

297 298
static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
{
299
    int ret, i, type, size, flags, is_audio, next, pos;
300
    unsigned dts;
Alex Beregszaszi's avatar
Alex Beregszaszi committed
301
    AVStream *st = NULL;
302

303
 retry:
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
304
 for(;;){
305 306 307 308
    pos = url_ftell(s->pb);
    url_fskip(s->pb, 4); /* size of previous packet */
    type = get_byte(s->pb);
    size = get_be24(s->pb);
309 310 311
    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);
312
    if (url_feof(s->pb))
313
        return AVERROR(EIO);
314
    url_fskip(s->pb, 3); /* stream id, always 0 */
315
    flags = 0;
316

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

320
    next= size + url_ftell(s->pb);
321

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

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

367
    // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
368
    if(!url_is_streamed(s->pb) && s->duration==AV_NOPTS_VALUE){
369
        int size;
370 371 372 373 374 375 376
        const int pos= url_ftell(s->pb);
        const int fsize= url_fsize(s->pb);
        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){
            s->duration= get_be24(s->pb) * (int64_t)AV_TIME_BASE / 1000;
377
        }
378
        url_fseek(s->pb, pos, SEEK_SET);
379 380
    }

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

395 396 397 398 399 400 401 402 403 404
    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) {
            // cts offset ignored because it might to be signed
            // and would cause pts < dts
            get_be24(s->pb);
        }
        if (type == 0) {
405
            if ((ret = flv_get_extradata(s, st, size)) < 0)
406 407 408 409 410
                return ret;
            goto retry;
        }
    }

411
    ret= av_get_packet(s->pb, pkt, size);
412
    if (ret <= 0) {
413
        return AVERROR(EIO);
414 415 416 417
    }
    /* note: we need to modify the packet size here to handle the last
       packet */
    pkt->size = ret;
418
    pkt->dts = dts;
419
    pkt->stream_index = st->index;
420

421
    if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))
422
        pkt->flags |= PKT_FLAG_KEY;
423

424 425 426
    return ret;
}

427
AVInputFormat flv_demuxer = {
428
    "flv",
429
    NULL_IF_CONFIG_SMALL("FLV format"),
Aurelien Jacobs's avatar
Aurelien Jacobs committed
430
    0,
431 432 433 434 435 436
    flv_probe,
    flv_read_header,
    flv_read_packet,
    .extensions = "flv",
    .value = CODEC_ID_FLV1,
};