flvdec.c 20 KB
Newer Older
1
/*
2
 * FLV demuxer
3
 * Copyright (c) 2003 The Libav 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
 * This file is part of Libav.
11
 *
12
 * Libav 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
 * Libav 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 Libav; 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 "avio_internal.h"
32
#include "flv.h"
33

34 35 36 37
#define KEYFRAMES_TAG            "keyframes"
#define KEYFRAMES_TIMESTAMP_TAG  "times"
#define KEYFRAMES_BYTEOFFSET_TAG "filepositions"

Baptiste Coudurier's avatar
Baptiste Coudurier committed
38 39 40 41
typedef struct {
    int wrong_dts; ///< wrong dts due to negative cts
} FLVContext;

42 43 44 45 46
static int flv_probe(AVProbeData *p)
{
    const uint8_t *d;

    d = p->buf;
47
    if (d[0] == 'F' && d[1] == 'L' && d[2] == 'V' && d[3] < 5 && d[5]==0 && AV_RB32(d+5)>8) {
48
        return AVPROBE_SCORE_MAX;
49 50 51 52
    }
    return 0;
}

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

    return 0;
}

118
static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize) {
119
    int length = avio_rb16(ioc);
120
    if(length >= buffsize) {
121
        avio_skip(ioc, length);
122 123
        return -1;
    }
124

125
    avio_read(ioc, buffer, length);
126

127
    buffer[length] = '\0';
128

129
    return length;
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
static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc, AVStream *vstream, int64_t max_pos) {
    unsigned int arraylen = 0, timeslen = 0, fileposlen = 0, i;
    double num_val;
    char str_val[256];
    int64_t *times = NULL;
    int64_t *filepositions = NULL;
    int ret = 0;

    while (avio_tell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
        int64_t* current_array;

        // Expect array object in context
        if (avio_r8(ioc) != AMF_DATA_TYPE_ARRAY)
            break;

        arraylen = avio_rb32(ioc);
        /*
         * Expect only 'times' or 'filepositions' sub-arrays in other case refuse to use such metadata
         * for indexing
         */
        if (!strcmp(KEYFRAMES_TIMESTAMP_TAG, str_val) && !times) {
            if (!(times = av_mallocz(sizeof(*times) * arraylen))) {
                ret = AVERROR(ENOMEM);
                goto finish;
            }
            timeslen = arraylen;
            current_array = times;
        } else if (!strcmp(KEYFRAMES_BYTEOFFSET_TAG, str_val) && !filepositions) {
            if (!(filepositions = av_mallocz(sizeof(*filepositions) * arraylen))) {
                ret = AVERROR(ENOMEM);
                goto finish;
            }
            fileposlen = arraylen;
            current_array = filepositions;
        } else // unexpected metatag inside keyframes, will not use such metadata for indexing
            break;

        for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++) {
            if (avio_r8(ioc) != AMF_DATA_TYPE_NUMBER)
                goto finish;
            num_val = av_int2dbl(avio_rb64(ioc));
            current_array[i] = num_val;
        }
    }

    if (timeslen == fileposlen)
         for(i = 0; i < arraylen; i++)
             av_add_index_entry(vstream, filepositions[i], times[i]*1000, 0, 0, AVINDEX_KEYFRAME);
    else
        av_log(s, AV_LOG_WARNING, "Invalid keyframes object, skipping.\n");

finish:
    av_freep(&times);
    av_freep(&filepositions);
    avio_seek(ioc, max_pos, SEEK_SET);
    return ret;
}

Pascal Massimino's avatar
Pascal Massimino committed
190
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
191
    AVCodecContext *acodec, *vcodec;
192
    AVIOContext *ioc;
Allan Hsu's avatar
Allan Hsu committed
193
    AMFDataType amf_type;
194
    char str_val[256];
Allan Hsu's avatar
Allan Hsu committed
195 196 197
    double num_val;

    num_val = 0;
198
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
199

200
    amf_type = avio_r8(ioc);
Allan Hsu's avatar
Allan Hsu committed
201 202 203

    switch(amf_type) {
        case AMF_DATA_TYPE_NUMBER:
204
            num_val = av_int2dbl(avio_rb64(ioc)); break;
Allan Hsu's avatar
Allan Hsu committed
205
        case AMF_DATA_TYPE_BOOL:
206
            num_val = avio_r8(ioc); break;
Allan Hsu's avatar
Allan Hsu committed
207
        case AMF_DATA_TYPE_STRING:
208
            if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
Allan Hsu's avatar
Allan Hsu committed
209 210 211 212 213
                return -1;
            break;
        case AMF_DATA_TYPE_OBJECT: {
            unsigned int keylen;

214 215 216 217
            if (!strcmp(KEYFRAMES_TAG, key) && depth == 1)
                if (parse_keyframes_index(s, ioc, vstream, max_pos) < 0)
                    return -1;

218
            while(avio_tell(ioc) < max_pos - 2 && (keylen = avio_rb16(ioc))) {
219
                avio_skip(ioc, keylen); //skip key string
Allan Hsu's avatar
Allan Hsu committed
220 221 222
                if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
                    return -1; //if we couldn't skip, bomb out.
            }
223
            if(avio_r8(ioc) != AMF_END_OF_OBJECT)
Allan Hsu's avatar
Allan Hsu committed
224 225 226 227 228 229 230 231
                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:
232
            avio_skip(ioc, 4); //skip 32-bit max array index
233
            while(avio_tell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
Allan Hsu's avatar
Allan Hsu committed
234
                //this is the only case in which we would want a nested parse to not skip over the object
235
                if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0)
Allan Hsu's avatar
Allan Hsu committed
236 237
                    return -1;
            }
238
            if(avio_r8(ioc) != AMF_END_OF_OBJECT)
Allan Hsu's avatar
Allan Hsu committed
239 240 241 242 243
                return -1;
            break;
        case AMF_DATA_TYPE_ARRAY: {
            unsigned int arraylen, i;

244
            arraylen = avio_rb32(ioc);
245
            for(i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++) {
Allan Hsu's avatar
Allan Hsu committed
246 247 248 249 250 251
                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:
252
            avio_skip(ioc, 8 + 2); //timestamp (double) and UTC offset (int16)
Allan Hsu's avatar
Allan Hsu committed
253 254 255 256 257 258 259 260 261 262
            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) {
263
            av_strlcpy(str_val, num_val > 0 ? "true" : "false", sizeof(str_val));
264
            av_metadata_set2(&s->metadata, key, str_val, 0);
Allan Hsu's avatar
Allan Hsu committed
265
        } else if(amf_type == AMF_DATA_TYPE_NUMBER) {
266
            snprintf(str_val, sizeof(str_val), "%.f", num_val);
267
            av_metadata_set2(&s->metadata, key, str_val, 0);
Allan Hsu's avatar
Allan Hsu committed
268
            if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE;
269 270
            else if(!strcmp(key, "videodatarate") && vcodec && 0 <= (int)(num_val * 1024.0))
                vcodec->bit_rate = num_val * 1024.0;
Howard Chu's avatar
Howard Chu committed
271 272
            else if(!strcmp(key, "audiodatarate") && acodec && 0 <= (int)(num_val * 1024.0))
                acodec->bit_rate = num_val * 1024.0;
273
        } else if (amf_type == AMF_DATA_TYPE_STRING)
274
            av_metadata_set2(&s->metadata, key, str_val, 0);
Allan Hsu's avatar
Allan Hsu committed
275 276 277 278 279
    }

    return 0;
}

Pascal Massimino's avatar
Pascal Massimino committed
280
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
Allan Hsu's avatar
Allan Hsu committed
281 282
    AMFDataType type;
    AVStream *stream, *astream, *vstream;
283
    AVIOContext *ioc;
284
    int i;
285
    char buffer[11]; //only needs to hold the string "onMetaData". Anything longer is something we don't want.
Allan Hsu's avatar
Allan Hsu committed
286 287 288

    astream = NULL;
    vstream = NULL;
289
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
290 291

    //first object needs to be "onMetaData" string
292
    type = avio_r8(ioc);
293
    if(type != AMF_DATA_TYPE_STRING || amf_get_string(ioc, buffer, sizeof(buffer)) < 0 || strcmp(buffer, "onMetaData"))
Allan Hsu's avatar
Allan Hsu committed
294 295 296 297 298
        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];
299 300
        if     (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO) astream = stream;
        else if(stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) vstream = stream;
Allan Hsu's avatar
Allan Hsu committed
301 302 303
    }

    //parse the second object (we want a mixed array)
304
    if(amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
Allan Hsu's avatar
Allan Hsu committed
305 306 307 308 309
        return -1;

    return 0;
}

310 311 312 313
static AVStream *create_stream(AVFormatContext *s, int is_audio){
    AVStream *st = av_new_stream(s, is_audio);
    if (!st)
        return NULL;
314
    st->codec->codec_type = is_audio ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
315
    av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
316 317 318
    return st;
}

319 320 321
static int flv_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
{
322
    int offset, flags;
323

324
    avio_skip(s->pb, 4);
325
    flags = avio_r8(s->pb);
326 327 328 329 330 331
    /* 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");
    }
332

Michael Niedermayer's avatar
Michael Niedermayer committed
333 334 335 336
    if((flags & (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
             != (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
        s->ctx_flags |= AVFMTCTX_NOHEADER;

337
    if(flags & FLV_HEADER_FLAG_HASVIDEO){
338
        if(!create_stream(s, 0))
339
            return AVERROR(ENOMEM);
340 341
    }
    if(flags & FLV_HEADER_FLAG_HASAUDIO){
342
        if(!create_stream(s, 1))
343
            return AVERROR(ENOMEM);
344 345
    }

346
    offset = avio_rb32(s->pb);
347
    avio_seek(s->pb, offset, SEEK_SET);
348
    avio_skip(s->pb, 4);
349

350 351
    s->start_time = 0;

352 353 354
    return 0;
}

355 356 357 358 359 360 361
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;
362
    avio_read(s->pb, st->codec->extradata, st->codec->extradata_size);
363 364 365
    return 0;
}

366 367
static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
{
Baptiste Coudurier's avatar
Baptiste Coudurier committed
368
    FLVContext *flv = s->priv_data;
Pascal Massimino's avatar
Pascal Massimino committed
369 370
    int ret, i, type, size, flags, is_audio;
    int64_t next, pos;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
371
    int64_t dts, pts = AV_NOPTS_VALUE;
Alex Beregszaszi's avatar
Alex Beregszaszi committed
372
    AVStream *st = NULL;
373

374
 for(;;avio_skip(s->pb, 4)){ /* pkt size is repeated at end. skip it */
375
    pos = avio_tell(s->pb);
376 377 378 379
    type = avio_r8(s->pb);
    size = avio_rb24(s->pb);
    dts = avio_rb24(s->pb);
    dts |= avio_r8(s->pb) << 24;
380
//    av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, dts:%d\n", type, size, dts);
Anton Khirnov's avatar
Anton Khirnov committed
381
    if (s->pb->eof_reached)
382
        return AVERROR_EOF;
383
    avio_skip(s->pb, 3); /* stream id, always 0 */
384
    flags = 0;
385

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
386 387
    if(size == 0)
        continue;
388

389
    next= size + avio_tell(s->pb);
390

391
    if (type == FLV_TAG_TYPE_AUDIO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
392
        is_audio=1;
393
        flags = avio_r8(s->pb);
394
        size--;
395
    } else if (type == FLV_TAG_TYPE_VIDEO) {
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
396
        is_audio=0;
397
        flags = avio_r8(s->pb);
398
        size--;
399 400
        if ((flags & 0xf0) == 0x50) /* video info / command frame */
            goto skip;
401
    } else {
402
        if (type == FLV_TAG_TYPE_META && size > 13+1+4)
Allan Hsu's avatar
Allan Hsu committed
403 404
            flv_read_metabody(s, next);
        else /* skip packet */
405
            av_log(s, AV_LOG_DEBUG, "skipping flv packet: type %d, size %d, flags %d\n", type, size, flags);
406
    skip:
407
        avio_seek(s->pb, next, SEEK_SET);
408
        continue;
409 410
    }

411 412 413 414
    /* skip empty data packets */
    if (!size)
        continue;

415 416 417
    /* now find stream */
    for(i=0;i<s->nb_streams;i++) {
        st = s->streams[i];
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
418 419
        if (st->id == is_audio)
            break;
420
    }
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
421
    if(i == s->nb_streams){
422
        av_log(s, AV_LOG_ERROR, "invalid stream\n");
423
        st= create_stream(s, is_audio);
424
        s->ctx_flags &= ~AVFMTCTX_NOHEADER;
425
    }
426
//    av_log(s, AV_LOG_DEBUG, "%d %X %d \n", is_audio, flags, st->discard);
427 428
    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))
429 430
       || st->discard >= AVDISCARD_ALL
       ){
431
        avio_seek(s->pb, next, SEEK_SET);
432
        continue;
433
    }
434
    if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY)
435
        av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
436 437 438
    break;
 }

439
    // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
440
    if(!url_is_streamed(s->pb) && (!s->duration || s->duration==AV_NOPTS_VALUE)){
441
        int size;
442
        const int64_t pos= avio_tell(s->pb);
443
        const int64_t fsize= avio_size(s->pb);
444
        avio_seek(s->pb, fsize-4, SEEK_SET);
445
        size= avio_rb32(s->pb);
446
        avio_seek(s->pb, fsize-3-size, SEEK_SET);
447 448 449
        if(size == avio_rb24(s->pb) + 11){
            uint32_t ts = avio_rb24(s->pb);
            ts |= avio_r8(s->pb) << 24;
450
            s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
451
        }
452
        avio_seek(s->pb, pos, SEEK_SET);
453 454
    }

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
455
    if(is_audio){
456
        if(!st->codec->channels || !st->codec->sample_rate || !st->codec->bits_per_coded_sample) {
457
            st->codec->channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
458
            st->codec->sample_rate = (44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >> FLV_AUDIO_SAMPLERATE_OFFSET) >> 3);
459
            st->codec->bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
460 461
        }
        if(!st->codec->codec_id){
Allan Hsu's avatar
Allan Hsu committed
462
            flv_set_audio_codec(s, st, flags & FLV_AUDIO_CODECID_MASK);
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
463 464
        }
    }else{
Allan Hsu's avatar
Allan Hsu committed
465
        size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK);
Michael Niedermayer's avatar
Michael Niedermayer committed
466 467
    }

468 469
    if (st->codec->codec_id == CODEC_ID_AAC ||
        st->codec->codec_id == CODEC_ID_H264) {
470
        int type = avio_r8(s->pb);
471 472
        size--;
        if (st->codec->codec_id == CODEC_ID_H264) {
473
            int32_t cts = (avio_rb24(s->pb)+0xff800000)^0xff800000; // sign extension
Baptiste Coudurier's avatar
Baptiste Coudurier committed
474 475 476 477 478 479 480
            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;
481 482
        }
        if (type == 0) {
483
            if ((ret = flv_get_extradata(s, st, size)) < 0)
484
                return ret;
485 486 487 488
            if (st->codec->codec_id == CODEC_ID_AAC) {
                MPEG4AudioConfig cfg;
                ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
                                         st->codec->extradata_size);
489
                st->codec->channels = cfg.channels;
490 491 492 493
                if (cfg.ext_sample_rate)
                    st->codec->sample_rate = cfg.ext_sample_rate;
                else
                    st->codec->sample_rate = cfg.sample_rate;
Luca Barbato's avatar
Luca Barbato committed
494
                av_dlog(s, "mp4a config channels %d sample rate %d\n",
495 496 497
                        st->codec->channels, st->codec->sample_rate);
            }

Howard Chu's avatar
Howard Chu committed
498 499
            ret = AVERROR(EAGAIN);
            goto leave;
500 501 502
        }
    }

503
    /* skip empty data packets */
Howard Chu's avatar
Howard Chu committed
504 505 506 507
    if (!size) {
        ret = AVERROR(EAGAIN);
        goto leave;
    }
508

509
    ret= av_get_packet(s->pb, pkt, size);
510
    if (ret < 0) {
511
        return AVERROR(EIO);
512 513 514 515
    }
    /* note: we need to modify the packet size here to handle the last
       packet */
    pkt->size = ret;
516
    pkt->dts = dts;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
517
    pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
518
    pkt->stream_index = st->index;
519

520
    if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))
521
        pkt->flags |= AV_PKT_FLAG_KEY;
522

Howard Chu's avatar
Howard Chu committed
523
leave:
524
    avio_skip(s->pb, 4);
525 526 527
    return ret;
}

Howard Chu's avatar
Howard Chu committed
528 529 530
static int flv_read_seek(AVFormatContext *s, int stream_index,
    int64_t ts, int flags)
{
531
    return ffio_read_seek(s->pb, stream_index, ts, flags);
Howard Chu's avatar
Howard Chu committed
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
}

#if 0 /* don't know enough to implement this */
static int flv_read_seek2(AVFormatContext *s, int stream_index,
    int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
{
    int ret = AVERROR(ENOSYS);

    if (ts - min_ts > (uint64_t)(max_ts - ts)) flags |= AVSEEK_FLAG_BACKWARD;

    if (url_is_streamed(s->pb)) {
        if (stream_index < 0) {
            stream_index = av_find_default_stream_index(s);
            if (stream_index < 0)
                return -1;

            /* timestamp for default must be expressed in AV_TIME_BASE units */
            ts = av_rescale_rnd(ts, 1000, AV_TIME_BASE,
                flags & AVSEEK_FLAG_BACKWARD ? AV_ROUND_DOWN : AV_ROUND_UP);
        }
552
        ret = ffio_read_seek(s->pb, stream_index, ts, flags);
Howard Chu's avatar
Howard Chu committed
553 554 555 556 557 558 559 560
    }

    if (ret == AVERROR(ENOSYS))
        ret = av_seek_frame(s, stream_index, ts, flags);
    return ret;
}
#endif

561
AVInputFormat ff_flv_demuxer = {
562
    "flv",
563
    NULL_IF_CONFIG_SMALL("FLV format"),
Baptiste Coudurier's avatar
Baptiste Coudurier committed
564
    sizeof(FLVContext),
565 566 567
    flv_probe,
    flv_read_header,
    flv_read_packet,
Howard Chu's avatar
Howard Chu committed
568 569 570 571
    .read_seek = flv_read_seek,
#if 0
    .read_seek2 = flv_read_seek2,
#endif
572 573 574
    .extensions = "flv",
    .value = CODEC_ID_FLV1,
};