flvdec.c 15.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 "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 43
    if (d[0] == 'F' && d[1] == 'L' && d[2] == 'V' && d[3] < 5 && d[5]==0) {
        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 85
        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
86 87 88
        case FLV_CODECID_VP6A  :
            if(flv_codecid == FLV_CODECID_VP6A)
                vcodec->codec_id = CODEC_ID_VP6A;
Allan Hsu's avatar
Allan Hsu committed
89 90 91 92
            if(vcodec->extradata_size != 1) {
                vcodec->extradata_size = 1;
                vcodec->extradata = av_malloc(1);
            }
93
            vcodec->extradata[0] = get_byte(s->pb);
Allan Hsu's avatar
Allan Hsu committed
94
            return 1; // 1 byte body size adjustment for flv_read_packet()
95 96 97
        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
98 99 100 101 102 103 104 105
        default:
            av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid);
            vcodec->codec_tag = flv_codecid;
    }

    return 0;
}

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

    get_buffer(ioc, buffer, length);

    buffer[length] = '\0';

    return length;
}

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

    num_val = 0;
128
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
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 188

    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) {
189 190
            av_strlcpy(str_val, num_val > 0 ? "true" : "false", sizeof(str_val));
            av_metadata_set(&s->metadata, key, str_val);
Allan Hsu's avatar
Allan Hsu committed
191
        } else if(amf_type == AMF_DATA_TYPE_NUMBER) {
192 193
            snprintf(str_val, sizeof(str_val), "%.f", num_val);
            av_metadata_set(&s->metadata, key, str_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 198
        } else if (amf_type == AMF_DATA_TYPE_STRING)
          av_metadata_set(&s->metadata, key, str_val);
Allan Hsu's avatar
Allan Hsu committed
199 200 201 202 203
    }

    return 0;
}

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

    astream = NULL;
    vstream = NULL;
213
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233

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

234 235 236 237 238
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
239
    av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
240 241 242
    return st;
}

243 244 245
static int flv_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
{
246
    int offset, flags;
247

248 249
    url_fskip(s->pb, 4);
    flags = get_byte(s->pb);
250 251 252 253 254 255
    /* 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");
    }
256

Michael Niedermayer's avatar
Michael Niedermayer committed
257 258 259 260
    if((flags & (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
             != (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
        s->ctx_flags |= AVFMTCTX_NOHEADER;

261
    if(flags & FLV_HEADER_FLAG_HASVIDEO){
262
        if(!create_stream(s, 0))
263
            return AVERROR(ENOMEM);
264 265
    }
    if(flags & FLV_HEADER_FLAG_HASAUDIO){
266
        if(!create_stream(s, 1))
267
            return AVERROR(ENOMEM);
268 269
    }

270 271
    offset = get_be32(s->pb);
    url_fseek(s->pb, offset, SEEK_SET);
272

273 274
    s->start_time = 0;

275 276 277
    return 0;
}

278 279 280 281 282 283 284 285 286 287 288
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;
}

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

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
297
 for(;;){
298 299 300 301
    pos = url_ftell(s->pb);
    url_fskip(s->pb, 4); /* size of previous packet */
    type = get_byte(s->pb);
    size = get_be24(s->pb);
302 303 304
    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);
305
    if (url_feof(s->pb))
306
        return AVERROR_EOF;
307
    url_fskip(s->pb, 3); /* stream id, always 0 */
308
    flags = 0;
309

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
310 311
    if(size == 0)
        continue;
312

313
    next= size + url_ftell(s->pb);
314

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

335 336 337 338
    /* skip empty data packets */
    if (!size)
        continue;

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

363
    // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
364
    if(!url_is_streamed(s->pb) && s->duration==AV_NOPTS_VALUE){
365
        int size;
Pascal Massimino's avatar
Pascal Massimino committed
366 367
        const int64_t pos= url_ftell(s->pb);
        const int64_t fsize= url_fsize(s->pb);
368 369 370 371 372
        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;
373
        }
374
        url_fseek(s->pb, pos, SEEK_SET);
375 376
    }

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

390 391 392 393 394
    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
395 396 397 398 399 400 401 402
            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;
403 404
        }
        if (type == 0) {
405
            if ((ret = flv_get_extradata(s, st, size)) < 0)
406
                return ret;
407 408 409 410 411 412 413 414 415 416 417 418
            if (st->codec->codec_id == CODEC_ID_AAC) {
                MPEG4AudioConfig cfg;
                ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
                                         st->codec->extradata_size);
                if (cfg.chan_config > 7)
                    return -1;
                st->codec->channels = ff_mpeg4audio_channels[cfg.chan_config];
                st->codec->sample_rate = cfg.sample_rate;
                dprintf(s, "mp4a config channels %d sample rate %d\n",
                        st->codec->channels, st->codec->sample_rate);
            }

419
            return AVERROR(EAGAIN);
420 421 422
        }
    }

423 424 425 426
    /* skip empty data packets */
    if (!size)
        return AVERROR(EAGAIN);

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

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

441 442 443
    return ret;
}

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