flvdec.c 14.1 KB
Newer Older
1
/*
2
 * FLV demuxer
3 4
 * Copyright (c) 2003 The FFmpeg Project.
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13 14 15 16 17
 * 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
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 21 22 23 24 25
 *
 *
 * 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
26 27
 */
#include "avformat.h"
28
#include "flv.h"
29 30 31 32 33 34

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

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

Allan Hsu's avatar
Allan Hsu committed
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
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
        case FLV_CODECID_PCM_BE:
            acodec->codec_id = acodec->bits_per_sample == 8 ? CODEC_ID_PCM_S8 : CODEC_ID_PCM_S16BE; break;
        case FLV_CODECID_PCM_LE:
            acodec->codec_id = acodec->bits_per_sample == 8 ? CODEC_ID_PCM_S8 : CODEC_ID_PCM_S16LE; break;
        case FLV_CODECID_ADPCM: acodec->codec_id = CODEC_ID_ADPCM_SWF;                              break;
        case FLV_CODECID_MP3  : acodec->codec_id = CODEC_ID_MP3      ; astream->need_parsing = 1  ; break;
        case FLV_CODECID_NELLYMOSER_8HZ_MONO:
            acodec->sample_rate = 8000; //in case metadata does not otherwise declare samplerate
        case FLV_CODECID_NELLYMOSER:
        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   ;
            if(vcodec->extradata_size != 1) {
                vcodec->extradata_size = 1;
                vcodec->extradata = av_malloc(1);
            }
            vcodec->extradata[0] = get_byte(&s->pb);
            return 1; // 1 byte body size adjustment for flv_read_packet()
        default:
            av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid);
            vcodec->codec_tag = flv_codecid;
    }

    return 0;
}

80
static int amf_get_string(ByteIOContext *ioc, char *buffer, int buffsize) {
Michael Niedermayer's avatar
Michael Niedermayer committed
81
    int length = get_be16(ioc);
82 83
    if(length >= buffsize) {
        url_fskip(ioc, length);
Michael Niedermayer's avatar
Michael Niedermayer committed
84
        return -1;
85 86 87 88 89 90 91 92 93
    }

    get_buffer(ioc, buffer, length);

    buffer[length] = '\0';

    return length;
}

Allan Hsu's avatar
Allan Hsu committed
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 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
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;
    ioc = &s->pb;

    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;
166 167
//            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;
Allan Hsu's avatar
Allan Hsu committed
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 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
            else if(!strcmp(key, "audiocodecid") && acodec) flv_set_audio_codec(s, astream, (int)num_val << FLV_AUDIO_CODECID_OFFSET);
            else if(!strcmp(key, "videocodecid") && vcodec) flv_set_video_codec(s, vstream, (int)num_val);
            else if(!strcmp(key, "audiosamplesize") && acodec && num_val >= 0) {
                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
                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;
                }
            }
        }
    }

    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;
    ioc = &s->pb;

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

223 224 225
static int flv_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
{
226
    int offset, flags;
227
    AVStream *st;
228 229 230

    url_fskip(&s->pb, 4);
    flags = get_byte(&s->pb);
231 232 233 234 235 236
    /* 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");
    }
237

238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
    if(flags & FLV_HEADER_FLAG_HASVIDEO){
        st = av_new_stream(s, 0);
        if (!st)
            return AVERROR_NOMEM;
        st->codec->codec_type = CODEC_TYPE_VIDEO;
        av_set_pts_info(st, 24, 1, 1000); /* 24 bit pts in ms */
    }
    if(flags & FLV_HEADER_FLAG_HASAUDIO){
        st = av_new_stream(s, 1);
        if (!st)
            return AVERROR_NOMEM;
        st->codec->codec_type = CODEC_TYPE_AUDIO;
        av_set_pts_info(st, 24, 1, 1000); /* 24 bit pts in ms */
    }

253 254 255
    offset = get_be32(&s->pb);
    url_fseek(&s->pb, offset, SEEK_SET);

256 257
    s->start_time = 0;

258 259 260 261 262
    return 0;
}

static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
{
263
    int ret, i, type, size, pts, flags, is_audio, next, pos;
Alex Beregszaszi's avatar
Alex Beregszaszi committed
264
    AVStream *st = NULL;
265

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
266
 for(;;){
267
    pos = url_ftell(&s->pb);
268 269 270 271
    url_fskip(&s->pb, 4); /* size of previous packet */
    type = get_byte(&s->pb);
    size = get_be24(&s->pb);
    pts = get_be24(&s->pb);
Michael Niedermayer's avatar
Michael Niedermayer committed
272
//    av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, pts:%d\n", type, size, pts);
273
    if (url_feof(&s->pb))
274
        return AVERROR_IO;
275 276
    url_fskip(&s->pb, 4); /* reserved */
    flags = 0;
277

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
278 279
    if(size == 0)
        continue;
280

281 282
    next= size + url_ftell(&s->pb);

283
    if (type == FLV_TAG_TYPE_AUDIO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
284
        is_audio=1;
285
        flags = get_byte(&s->pb);
286
    } else if (type == FLV_TAG_TYPE_VIDEO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
287
        is_audio=0;
288 289
        flags = get_byte(&s->pb);
    } else {
Allan Hsu's avatar
Allan Hsu committed
290 291 292 293
        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);
294
        url_fseek(&s->pb, next, SEEK_SET);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
295
        continue;
296 297 298 299 300
    }

    /* now find stream */
    for(i=0;i<s->nb_streams;i++) {
        st = s->streams[i];
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
301 302
        if (st->id == is_audio)
            break;
303
    }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
304
    if(i == s->nb_streams){
305 306 307
        av_log(NULL, AV_LOG_ERROR, "invalid stream\n");
        url_fseek(&s->pb, next, SEEK_SET);
        continue;
308
    }
309
//    av_log(NULL, AV_LOG_DEBUG, "%d %X %d \n", is_audio, flags, st->discard);
310 311
    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))
312 313
       || st->discard >= AVDISCARD_ALL
       ){
314
        url_fseek(&s->pb, next, SEEK_SET);
315 316
        continue;
    }
317
    if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY)
318
        av_add_index_entry(st, pos, pts, size, 0, AVINDEX_KEYFRAME);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
319 320 321
    break;
 }

322 323 324 325 326 327 328 329 330 331 332 333 334 335
    // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
    if(!url_is_streamed(&s->pb) && s->duration==AV_NOPTS_VALUE){
        int size;
        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;
        }
        url_fseek(&s->pb, pos, SEEK_SET);
    }

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
336
    if(is_audio){
Allan Hsu's avatar
Allan Hsu committed
337
        if(!st->codec->sample_rate || !st->codec->bits_per_sample || (!st->codec->codec_id && !st->codec->codec_tag)) {
338 339
            st->codec->channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
            if((flags & FLV_AUDIO_CODECID_MASK) == FLV_CODECID_NELLYMOSER_8HZ_MONO)
340
                st->codec->sample_rate= 8000;
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
341
            else
342 343
                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
344
            flv_set_audio_codec(s, st, flags & FLV_AUDIO_CODECID_MASK);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
345 346
        }
    }else{
Allan Hsu's avatar
Allan Hsu committed
347
        size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK);
Michael Niedermayer's avatar
Michael Niedermayer committed
348 349
    }

350
    ret= av_get_packet(&s->pb, pkt, size - 1);
351
    if (ret <= 0) {
352
        return AVERROR_IO;
353 354 355 356 357 358
    }
    /* note: we need to modify the packet size here to handle the last
       packet */
    pkt->size = ret;
    pkt->pts = pts;
    pkt->stream_index = st->index;
359

360
    if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))
361
        pkt->flags |= PKT_FLAG_KEY;
362

363 364 365 366 367 368 369 370
    return ret;
}

static int flv_read_close(AVFormatContext *s)
{
    return 0;
}

371 372 373 374 375 376 377 378 379 380 381
static int flv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
{
    AVStream *st = s->streams[stream_index];
    int index = av_index_search_timestamp(st, timestamp, flags);
    if (index < 0)
        return -1;
    url_fseek(&s->pb, st->index_entries[index].pos, SEEK_SET);

    return 0;
}

382
AVInputFormat flv_demuxer = {
383 384 385 386 387 388 389
    "flv",
    "flv format",
    0,
    flv_probe,
    flv_read_header,
    flv_read_packet,
    flv_read_close,
390
    flv_read_seek,
391 392 393
    .extensions = "flv",
    .value = CODEC_ID_FLV1,
};