flvdec.c 17.5 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;
}

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
/**
 * Builds a Speex header.
 * This is not needed for the libavcodec libspeex decoder, but is needed for
 * stream copy and for decoders which require a header.
 */
static void flv_build_speex_header(uint8_t *extradata)
{
    memset(extradata, 0, 80);
    bytestream_put_buffer(&extradata, "Speex   ", 8);   // speex_string
    bytestream_put_buffer(&extradata, "1.2rc1",   6);   // speex_version
    extradata += 14;                                    // speex_version padding
    bytestream_put_le32(&extradata,     1);             // speex_version_id
    bytestream_put_le32(&extradata,    80);             // header_size
    bytestream_put_le32(&extradata, 16000);             // rate
    bytestream_put_le32(&extradata,     1);             // mode
    bytestream_put_le32(&extradata,     4);             // mode_bitstream_version
    bytestream_put_le32(&extradata,     1);             // nb_channels
    bytestream_put_le32(&extradata,    -1);             // bitrate
    bytestream_put_le32(&extradata,   320);             // frame_size
                                                        // vbr = 0
                                                        // frames_per_packet = 0
                                                        // extra_headers = 0
                                                        // reserved1 = 0
                                                        // reserved2 = 0
}

Allan Hsu's avatar
Allan Hsu committed
74 75 76 77
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
78
        case FLV_CODECID_PCM:
79
            acodec->codec_id = acodec->bits_per_coded_sample == 8 ? CODEC_ID_PCM_S8 :
Michael Niedermayer's avatar
Michael Niedermayer committed
80 81 82 83 84 85
#ifdef WORDS_BIGENDIAN
                                CODEC_ID_PCM_S16BE;
#else
                                CODEC_ID_PCM_S16LE;
#endif
            break;
Allan Hsu's avatar
Allan Hsu committed
86
        case FLV_CODECID_PCM_LE:
87
            acodec->codec_id = acodec->bits_per_coded_sample == 8 ? CODEC_ID_PCM_S8 : CODEC_ID_PCM_S16LE; break;
88
        case FLV_CODECID_AAC  : acodec->codec_id = CODEC_ID_AAC;                                    break;
Allan Hsu's avatar
Allan Hsu committed
89
        case FLV_CODECID_ADPCM: acodec->codec_id = CODEC_ID_ADPCM_SWF;                              break;
90 91 92
        case FLV_CODECID_SPEEX:
            acodec->codec_id = CODEC_ID_SPEEX;
            acodec->sample_rate = 16000;
93 94 95 96 97 98 99
            acodec->extradata = av_mallocz(80 + FF_INPUT_BUFFER_PADDING_SIZE);
            if (acodec->extradata) {
                acodec->extradata_size = 80;
                flv_build_speex_header(acodec->extradata);
            } else {
                av_log(s, AV_LOG_WARNING, "Unable to create Speex extradata\n");
            }
100
            break;
Aurelien Jacobs's avatar
Aurelien Jacobs committed
101
        case FLV_CODECID_MP3  : acodec->codec_id = CODEC_ID_MP3      ; astream->need_parsing = AVSTREAM_PARSE_FULL; break;
102
        case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
Allan Hsu's avatar
Allan Hsu committed
103 104
            acodec->sample_rate = 8000; //in case metadata does not otherwise declare samplerate
        case FLV_CODECID_NELLYMOSER:
Benjamin Larsson's avatar
Benjamin Larsson committed
105 106
            acodec->codec_id = CODEC_ID_NELLYMOSER;
            break;
Allan Hsu's avatar
Allan Hsu committed
107 108 109 110 111 112 113 114 115 116 117 118
        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
119 120 121
        case FLV_CODECID_VP6A  :
            if(flv_codecid == FLV_CODECID_VP6A)
                vcodec->codec_id = CODEC_ID_VP6A;
Allan Hsu's avatar
Allan Hsu committed
122 123 124 125
            if(vcodec->extradata_size != 1) {
                vcodec->extradata_size = 1;
                vcodec->extradata = av_malloc(1);
            }
126
            vcodec->extradata[0] = get_byte(s->pb);
Allan Hsu's avatar
Allan Hsu committed
127
            return 1; // 1 byte body size adjustment for flv_read_packet()
128 129 130
        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
131 132 133 134 135 136 137 138
        default:
            av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid);
            vcodec->codec_tag = flv_codecid;
    }

    return 0;
}

139
static int amf_get_string(ByteIOContext *ioc, char *buffer, int buffsize) {
Michael Niedermayer's avatar
Michael Niedermayer committed
140
    int length = get_be16(ioc);
141 142
    if(length >= buffsize) {
        url_fskip(ioc, length);
Michael Niedermayer's avatar
Michael Niedermayer committed
143
        return -1;
144 145 146 147 148 149 150 151 152
    }

    get_buffer(ioc, buffer, length);

    buffer[length] = '\0';

    return length;
}

Pascal Massimino's avatar
Pascal Massimino committed
153
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
154 155 156 157 158 159 160
    AVCodecContext *acodec, *vcodec;
    ByteIOContext *ioc;
    AMFDataType amf_type;
    char str_val[256];
    double num_val;

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

    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) {
222 223
            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
224
        } else if(amf_type == AMF_DATA_TYPE_NUMBER) {
225 226
            snprintf(str_val, sizeof(str_val), "%.f", num_val);
            av_metadata_set(&s->metadata, key, str_val);
Allan Hsu's avatar
Allan Hsu committed
227
            if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE;
228 229
            else if(!strcmp(key, "videodatarate") && vcodec && 0 <= (int)(num_val * 1024.0))
                vcodec->bit_rate = num_val * 1024.0;
230 231
        } else if (amf_type == AMF_DATA_TYPE_STRING)
          av_metadata_set(&s->metadata, key, str_val);
Allan Hsu's avatar
Allan Hsu committed
232 233 234 235 236
    }

    return 0;
}

Pascal Massimino's avatar
Pascal Massimino committed
237
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
Allan Hsu's avatar
Allan Hsu committed
238 239 240
    AMFDataType type;
    AVStream *stream, *astream, *vstream;
    ByteIOContext *ioc;
241
    int i;
Allan Hsu's avatar
Allan Hsu committed
242 243 244 245
    char buffer[11]; //only needs to hold the string "onMetaData". Anything longer is something we don't want.

    astream = NULL;
    vstream = NULL;
246
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266

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

267 268 269 270 271
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
272
    av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
273 274 275
    return st;
}

276 277 278
static int flv_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
{
279
    int offset, flags;
280

281 282
    url_fskip(s->pb, 4);
    flags = get_byte(s->pb);
283 284 285 286 287 288
    /* 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");
    }
289

Michael Niedermayer's avatar
Michael Niedermayer committed
290 291 292 293
    if((flags & (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
             != (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
        s->ctx_flags |= AVFMTCTX_NOHEADER;

294
    if(flags & FLV_HEADER_FLAG_HASVIDEO){
295
        if(!create_stream(s, 0))
296
            return AVERROR(ENOMEM);
297 298
    }
    if(flags & FLV_HEADER_FLAG_HASAUDIO){
299
        if(!create_stream(s, 1))
300
            return AVERROR(ENOMEM);
301 302
    }

303 304
    offset = get_be32(s->pb);
    url_fseek(s->pb, offset, SEEK_SET);
305

306 307
    s->start_time = 0;

308 309 310
    return 0;
}

311 312 313 314 315 316 317 318 319 320 321
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;
}

322 323
static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
{
Baptiste Coudurier's avatar
Baptiste Coudurier committed
324
    FLVContext *flv = s->priv_data;
Pascal Massimino's avatar
Pascal Massimino committed
325 326
    int ret, i, type, size, flags, is_audio;
    int64_t next, pos;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
327
    int64_t dts, pts = AV_NOPTS_VALUE;
Alex Beregszaszi's avatar
Alex Beregszaszi committed
328
    AVStream *st = NULL;
329

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
330
 for(;;){
331 332 333 334
    pos = url_ftell(s->pb);
    url_fskip(s->pb, 4); /* size of previous packet */
    type = get_byte(s->pb);
    size = get_be24(s->pb);
335 336 337
    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);
338
    if (url_feof(s->pb))
339
        return AVERROR_EOF;
340
    url_fskip(s->pb, 3); /* stream id, always 0 */
341
    flags = 0;
342

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
343 344
    if(size == 0)
        continue;
345

346
    next= size + url_ftell(s->pb);
347

348
    if (type == FLV_TAG_TYPE_AUDIO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
349
        is_audio=1;
350
        flags = get_byte(s->pb);
351
        size--;
352
    } else if (type == FLV_TAG_TYPE_VIDEO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
353
        is_audio=0;
354
        flags = get_byte(s->pb);
355
        size--;
356 357
        if ((flags & 0xf0) == 0x50) /* video info / command frame */
            goto skip;
358
    } else {
359
        if (type == FLV_TAG_TYPE_META && size > 13+1+4)
Allan Hsu's avatar
Allan Hsu committed
360 361
            flv_read_metabody(s, next);
        else /* skip packet */
362
            av_log(s, AV_LOG_DEBUG, "skipping flv packet: type %d, size %d, flags %d\n", type, size, flags);
363
    skip:
364
        url_fseek(s->pb, next, SEEK_SET);
365
        continue;
366 367
    }

368 369 370 371
    /* skip empty data packets */
    if (!size)
        continue;

372 373 374
    /* now find stream */
    for(i=0;i<s->nb_streams;i++) {
        st = s->streams[i];
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
375 376
        if (st->id == is_audio)
            break;
377
    }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
378
    if(i == s->nb_streams){
379
        av_log(s, AV_LOG_ERROR, "invalid stream\n");
380
        st= create_stream(s, is_audio);
381
        s->ctx_flags &= ~AVFMTCTX_NOHEADER;
382
    }
383
//    av_log(s, AV_LOG_DEBUG, "%d %X %d \n", is_audio, flags, st->discard);
384 385
    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))
386 387
       || st->discard >= AVDISCARD_ALL
       ){
388
        url_fseek(s->pb, next, SEEK_SET);
389
        continue;
390
    }
391
    if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY)
392
        av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
393 394 395
    break;
 }

396
    // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
397
    if(!url_is_streamed(s->pb) && s->duration==AV_NOPTS_VALUE){
398
        int size;
Pascal Massimino's avatar
Pascal Massimino committed
399 400
        const int64_t pos= url_ftell(s->pb);
        const int64_t fsize= url_fsize(s->pb);
401 402 403 404 405
        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;
406
        }
407
        url_fseek(s->pb, pos, SEEK_SET);
408 409
    }

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
410
    if(is_audio){
411
        if(!st->codec->channels || !st->codec->sample_rate || !st->codec->bits_per_coded_sample) {
412
            st->codec->channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
413
            st->codec->sample_rate = (44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >> FLV_AUDIO_SAMPLERATE_OFFSET) >> 3);
414
            st->codec->bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
415 416
        }
        if(!st->codec->codec_id){
Allan Hsu's avatar
Allan Hsu committed
417
            flv_set_audio_codec(s, st, flags & FLV_AUDIO_CODECID_MASK);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
418 419
        }
    }else{
Allan Hsu's avatar
Allan Hsu committed
420
        size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK);
Michael Niedermayer's avatar
Michael Niedermayer committed
421 422
    }

423 424 425 426 427
    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
428 429 430 431 432 433 434 435
            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;
436 437
        }
        if (type == 0) {
438
            if ((ret = flv_get_extradata(s, st, size)) < 0)
439
                return ret;
440 441 442 443 444 445 446 447 448 449 450 451
            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);
            }

452
            return AVERROR(EAGAIN);
453 454 455
        }
    }

456 457 458 459
    /* skip empty data packets */
    if (!size)
        return AVERROR(EAGAIN);

460
    ret= av_get_packet(s->pb, pkt, size);
461
    if (ret < 0) {
462
        return AVERROR(EIO);
463 464 465 466
    }
    /* note: we need to modify the packet size here to handle the last
       packet */
    pkt->size = ret;
467
    pkt->dts = dts;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
468
    pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
469
    pkt->stream_index = st->index;
470

471
    if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))
472
        pkt->flags |= PKT_FLAG_KEY;
473

474 475 476
    return ret;
}

477
AVInputFormat flv_demuxer = {
478
    "flv",
479
    NULL_IF_CONFIG_SMALL("FLV format"),
Baptiste Coudurier's avatar
Baptiste Coudurier committed
480
    sizeof(FLVContext),
481 482 483 484 485 486
    flv_probe,
    flv_read_header,
    flv_read_packet,
    .extensions = "flv",
    .value = CODEC_ID_FLV1,
};