flvdec.c 16.3 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

Baptiste Coudurier's avatar
Baptiste Coudurier committed
29 30 31 32
typedef struct {
    int wrong_dts; ///< wrong dts due to negative cts
} FLVContext;

33 34 35 36 37
static int flv_probe(AVProbeData *p)
{
    const uint8_t *d;

    d = p->buf;
38 39
    if (d[0] == 'F' && d[1] == 'L' && d[2] == 'V' && d[3] < 5 && d[5]==0) {
        return AVPROBE_SCORE_MAX;
40 41 42 43
    }
    return 0;
}

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

    return 0;
}

102
static int amf_get_string(ByteIOContext *ioc, char *buffer, int buffsize) {
Michael Niedermayer's avatar
Michael Niedermayer committed
103
    int length = get_be16(ioc);
104 105
    if(length >= buffsize) {
        url_fskip(ioc, length);
Michael Niedermayer's avatar
Michael Niedermayer committed
106
        return -1;
107 108 109 110 111 112 113 114 115
    }

    get_buffer(ioc, buffer, length);

    buffer[length] = '\0';

    return length;
}

Pascal Massimino's avatar
Pascal Massimino committed
116
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
117 118 119 120 121 122 123
    AVCodecContext *acodec, *vcodec;
    ByteIOContext *ioc;
    AMFDataType amf_type;
    char str_val[256];
    double num_val;

    num_val = 0;
124
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
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 181 182 183 184 185 186 187

    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;
188 189
//            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;
190 191 192 193 194
            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) {
195
                acodec->bits_per_coded_sample = num_val;
Allan Hsu's avatar
Allan Hsu committed
196 197 198 199 200 201
                //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
202
                if (!acodec->sample_rate) {
Benjamin Larsson's avatar
Benjamin Larsson committed
203 204 205 206 207 208 209
                    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;
                    }
210
                }
Allan Hsu's avatar
Allan Hsu committed
211 212 213 214 215 216 217
            }
        }
    }

    return 0;
}

Pascal Massimino's avatar
Pascal Massimino committed
218
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
Allan Hsu's avatar
Allan Hsu committed
219 220 221 222 223 224 225 226 227
    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;
228
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248

    //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;
}

249 250 251 252 253
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
254
    av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
255 256 257
    return st;
}

258 259 260
static int flv_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
{
261
    int offset, flags;
262

263 264
    url_fskip(s->pb, 4);
    flags = get_byte(s->pb);
265 266 267 268 269 270
    /* 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");
    }
271

Michael Niedermayer's avatar
Michael Niedermayer committed
272 273 274 275
    if((flags & (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
             != (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
        s->ctx_flags |= AVFMTCTX_NOHEADER;

276
    if(flags & FLV_HEADER_FLAG_HASVIDEO){
277
        if(!create_stream(s, 0))
278
            return AVERROR(ENOMEM);
279 280
    }
    if(flags & FLV_HEADER_FLAG_HASAUDIO){
281
        if(!create_stream(s, 1))
282
            return AVERROR(ENOMEM);
283 284
    }

285 286
    offset = get_be32(s->pb);
    url_fseek(s->pb, offset, SEEK_SET);
287

288 289
    s->start_time = 0;

290 291 292
    return 0;
}

293 294 295 296 297 298 299 300 301 302 303
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;
}

304 305
static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
{
Baptiste Coudurier's avatar
Baptiste Coudurier committed
306
    FLVContext *flv = s->priv_data;
Pascal Massimino's avatar
Pascal Massimino committed
307 308
    int ret, i, type, size, flags, is_audio;
    int64_t next, pos;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
309
    int64_t dts, pts = AV_NOPTS_VALUE;
Alex Beregszaszi's avatar
Alex Beregszaszi committed
310
    AVStream *st = NULL;
311

312
 retry:
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
313
 for(;;){
314 315 316 317
    pos = url_ftell(s->pb);
    url_fskip(s->pb, 4); /* size of previous packet */
    type = get_byte(s->pb);
    size = get_be24(s->pb);
318 319 320
    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);
321
    if (url_feof(s->pb))
322
        return AVERROR(EIO);
323
    url_fskip(s->pb, 3); /* stream id, always 0 */
324
    flags = 0;
325

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
326 327
    if(size == 0)
        continue;
328

329
    next= size + url_ftell(s->pb);
330

331
    if (type == FLV_TAG_TYPE_AUDIO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
332
        is_audio=1;
333
        flags = get_byte(s->pb);
334
        size--;
335
    } else if (type == FLV_TAG_TYPE_VIDEO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
336
        is_audio=0;
337
        flags = get_byte(s->pb);
338
        size--;
339 340
        if ((flags & 0xf0) == 0x50) /* video info / command frame */
            goto skip;
341
    } else {
Allan Hsu's avatar
Allan Hsu committed
342 343 344 345
        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);
346
    skip:
347
        url_fseek(s->pb, next, SEEK_SET);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
348
        continue;
349 350
    }

351 352 353 354
    /* skip empty data packets */
    if (!size)
        continue;

355 356 357
    /* now find stream */
    for(i=0;i<s->nb_streams;i++) {
        st = s->streams[i];
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
358 359
        if (st->id == is_audio)
            break;
360
    }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
361
    if(i == s->nb_streams){
362
        av_log(NULL, AV_LOG_ERROR, "invalid stream\n");
363
        st= create_stream(s, is_audio);
364
        s->ctx_flags &= ~AVFMTCTX_NOHEADER;
365
    }
366
//    av_log(NULL, AV_LOG_DEBUG, "%d %X %d \n", is_audio, flags, st->discard);
367 368
    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))
369 370
       || st->discard >= AVDISCARD_ALL
       ){
371
        url_fseek(s->pb, next, SEEK_SET);
372 373
        continue;
    }
374
    if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY)
375
        av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
376 377 378
    break;
 }

379
    // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
380
    if(!url_is_streamed(s->pb) && s->duration==AV_NOPTS_VALUE){
381
        int size;
Pascal Massimino's avatar
Pascal Massimino committed
382 383
        const int64_t pos= url_ftell(s->pb);
        const int64_t fsize= url_fsize(s->pb);
384 385 386 387 388
        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;
389
        }
390
        url_fseek(s->pb, pos, SEEK_SET);
391 392
    }

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
393
    if(is_audio){
394
        if(!st->codec->channels || !st->codec->sample_rate || !st->codec->bits_per_coded_sample || (!st->codec->codec_id && !st->codec->codec_tag)) {
395
            st->codec->channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
396
            st->codec->sample_rate = (44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >> FLV_AUDIO_SAMPLERATE_OFFSET) >> 3);
397
            st->codec->bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
Allan Hsu's avatar
Allan Hsu committed
398
            flv_set_audio_codec(s, st, flags & FLV_AUDIO_CODECID_MASK);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
399 400
        }
    }else{
Allan Hsu's avatar
Allan Hsu committed
401
        size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK);
Michael Niedermayer's avatar
Michael Niedermayer committed
402 403
    }

404 405 406 407 408
    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
409 410 411 412 413 414 415 416
            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;
417 418
        }
        if (type == 0) {
419
            if ((ret = flv_get_extradata(s, st, size)) < 0)
420 421 422 423 424
                return ret;
            goto retry;
        }
    }

425
    ret= av_get_packet(s->pb, pkt, size);
426
    if (ret <= 0) {
427
        return AVERROR(EIO);
428 429 430 431
    }
    /* note: we need to modify the packet size here to handle the last
       packet */
    pkt->size = ret;
432
    pkt->dts = dts;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
433
    pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
434
    pkt->stream_index = st->index;
435

436
    if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))
437
        pkt->flags |= PKT_FLAG_KEY;
438

439 440 441
    return ret;
}

442
AVInputFormat flv_demuxer = {
443
    "flv",
444
    NULL_IF_CONFIG_SMALL("FLV format"),
Baptiste Coudurier's avatar
Baptiste Coudurier committed
445
    sizeof(FLVContext),
446 447 448 449 450 451
    flv_probe,
    flv_read_header,
    flv_read_packet,
    .extensions = "flv",
    .value = CODEC_ID_FLV1,
};