flvdec.c 17.1 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 "libavcodec/mpeg4audio.h"
28
#include "avformat.h"
29
#include "flv.h"
30

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

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

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

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

    return 0;
}

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

    get_buffer(ioc, buffer, length);

    buffer[length] = '\0';

    return length;
}

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

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

    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;
190 191
//            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;
192 193
            else if(!strcmp(key, "videodatarate") && vcodec && 0 <= (int)(num_val * 1024.0))
                vcodec->bit_rate = num_val * 1024.0;
194 195 196 197 198
            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) {
199
                acodec->bits_per_coded_sample = num_val;
Allan Hsu's avatar
Allan Hsu committed
200 201 202 203 204 205
                //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
206
                if (!acodec->sample_rate) {
Benjamin Larsson's avatar
Benjamin Larsson committed
207 208 209 210 211 212 213
                    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;
                    }
214
                }
Allan Hsu's avatar
Allan Hsu committed
215 216 217 218 219 220 221
            }
        }
    }

    return 0;
}

Pascal Massimino's avatar
Pascal Massimino committed
222
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
Allan Hsu's avatar
Allan Hsu committed
223 224 225
    AMFDataType type;
    AVStream *stream, *astream, *vstream;
    ByteIOContext *ioc;
226
    int i;
Allan Hsu's avatar
Allan Hsu committed
227 228 229 230
    char buffer[11]; //only needs to hold the string "onMetaData". Anything longer is something we don't want.

    astream = NULL;
    vstream = NULL;
231
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251

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

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

261 262 263
static int flv_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
{
264
    int offset, flags;
265

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

Michael Niedermayer's avatar
Michael Niedermayer committed
275 276 277 278
    if((flags & (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
             != (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
        s->ctx_flags |= AVFMTCTX_NOHEADER;

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

288 289
    offset = get_be32(s->pb);
    url_fseek(s->pb, offset, SEEK_SET);
290

291 292
    s->start_time = 0;

293 294 295
    return 0;
}

296 297 298 299 300 301 302 303 304 305 306
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;
}

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

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

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

331
    next= size + url_ftell(s->pb);
332

333
    if (type == FLV_TAG_TYPE_AUDIO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
334
        is_audio=1;
335
        flags = get_byte(s->pb);
336
        size--;
337
    } else if (type == FLV_TAG_TYPE_VIDEO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
338
        is_audio=0;
339
        flags = get_byte(s->pb);
340
        size--;
341 342
        if ((flags & 0xf0) == 0x50) /* video info / command frame */
            goto skip;
343
    } else {
344
        if (type == FLV_TAG_TYPE_META && size > 13+1+4 && 0)
Allan Hsu's avatar
Allan Hsu committed
345 346
            flv_read_metabody(s, next);
        else /* skip packet */
347
            av_log(s, AV_LOG_DEBUG, "skipping flv packet: type %d, size %d, flags %d\n", type, size, flags);
348
    skip:
349
        url_fseek(s->pb, next, SEEK_SET);
350
        continue;
351 352
    }

353 354 355 356
    /* skip empty data packets */
    if (!size)
        continue;

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

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

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

408 409 410 411 412
    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
413 414 415 416 417 418 419 420
            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;
421 422
        }
        if (type == 0) {
423
            if ((ret = flv_get_extradata(s, st, size)) < 0)
424
                return ret;
425 426 427 428 429 430 431 432 433 434 435 436
            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);
            }

437
            return AVERROR(EAGAIN);
438 439 440
        }
    }

441 442 443 444
    /* skip empty data packets */
    if (!size)
        return AVERROR(EAGAIN);

445
    ret= av_get_packet(s->pb, pkt, size);
446
    if (ret < 0) {
447
        return AVERROR(EIO);
448 449 450 451
    }
    /* note: we need to modify the packet size here to handle the last
       packet */
    pkt->size = ret;
452
    pkt->dts = dts;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
453
    pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
454
    pkt->stream_index = st->index;
455

456
    if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))
457
        pkt->flags |= PKT_FLAG_KEY;
458

459 460 461
    return ret;
}

462
AVInputFormat flv_demuxer = {
463
    "flv",
464
    NULL_IF_CONFIG_SMALL("FLV format"),
Baptiste Coudurier's avatar
Baptiste Coudurier committed
465
    sizeof(FLVContext),
466 467 468 469 470 471
    flv_probe,
    flv_read_header,
    flv_read_packet,
    .extensions = "flv",
    .value = CODEC_ID_FLV1,
};