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

    return 0;
}

107 108 109 110 111 112
static int amf_get_string(ByteIOContext *ioc, char *buffer, int buffsize) {
    int length = get_be16(ioc);
    if(length >= buffsize) {
        url_fskip(ioc, length);
        return -1;
    }
113

114
    get_buffer(ioc, buffer, length);
115

116
    buffer[length] = '\0';
117

118
    return length;
119 120
}

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

    num_val = 0;
129
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
130 131 132 133 134 135 136 137 138

    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:
139
            if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
Allan Hsu's avatar
Allan Hsu committed
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
                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
160
            while(url_ftell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
Allan Hsu's avatar
Allan Hsu committed
161
                //this is the only case in which we would want a nested parse to not skip over the object
162
                if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0)
Allan Hsu's avatar
Allan Hsu committed
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
                    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) {
190
            av_strlcpy(str_val, num_val > 0 ? "true" : "false", sizeof(str_val));
191
            av_metadata_set2(&s->metadata, key, str_val, 0);
Allan Hsu's avatar
Allan Hsu committed
192
        } else if(amf_type == AMF_DATA_TYPE_NUMBER) {
193
            snprintf(str_val, sizeof(str_val), "%.f", num_val);
194
            av_metadata_set2(&s->metadata, key, str_val, 0);
Allan Hsu's avatar
Allan Hsu committed
195
            if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE;
196 197
            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
198 199
            else if(!strcmp(key, "audiodatarate") && acodec && 0 <= (int)(num_val * 1024.0))
                acodec->bit_rate = num_val * 1024.0;
200
        } else if (amf_type == AMF_DATA_TYPE_STRING)
201
            av_metadata_set2(&s->metadata, key, str_val, 0);
Allan Hsu's avatar
Allan Hsu committed
202 203 204 205 206
    }

    return 0;
}

Pascal Massimino's avatar
Pascal Massimino committed
207
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
Allan Hsu's avatar
Allan Hsu committed
208 209 210
    AMFDataType type;
    AVStream *stream, *astream, *vstream;
    ByteIOContext *ioc;
211
    int i;
212
    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
213 214 215

    astream = NULL;
    vstream = NULL;
216
    ioc = s->pb;
Allan Hsu's avatar
Allan Hsu committed
217 218 219

    //first object needs to be "onMetaData" string
    type = get_byte(ioc);
220
    if(type != AMF_DATA_TYPE_STRING || amf_get_string(ioc, buffer, sizeof(buffer)) < 0 || strcmp(buffer, "onMetaData"))
Allan Hsu's avatar
Allan Hsu committed
221 222 223 224 225
        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];
226 227
        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
228 229 230
    }

    //parse the second object (we want a mixed array)
231
    if(amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
Allan Hsu's avatar
Allan Hsu committed
232 233 234 235 236
        return -1;

    return 0;
}

237 238 239 240
static AVStream *create_stream(AVFormatContext *s, int is_audio){
    AVStream *st = av_new_stream(s, is_audio);
    if (!st)
        return NULL;
241
    st->codec->codec_type = is_audio ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
242
    av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
243 244 245
    return st;
}

246 247 248
static int flv_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
{
249
    int offset, flags;
250

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

Michael Niedermayer's avatar
Michael Niedermayer committed
260 261 262 263
    if((flags & (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
             != (FLV_HEADER_FLAG_HASVIDEO|FLV_HEADER_FLAG_HASAUDIO))
        s->ctx_flags |= AVFMTCTX_NOHEADER;

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

273 274
    offset = get_be32(s->pb);
    url_fseek(s->pb, offset, SEEK_SET);
Howard Chu's avatar
Howard Chu committed
275
    url_fskip(s->pb, 4);
276

277 278
    s->start_time = 0;

279 280 281
    return 0;
}

282 283 284 285 286 287 288 289 290 291 292
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;
}

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

Howard Chu's avatar
Howard Chu committed
301
 for(;;url_fskip(s->pb, 4)){ /* pkt size is repeated at end. skip it */
302 303 304
    pos = url_ftell(s->pb);
    type = get_byte(s->pb);
    size = get_be24(s->pb);
305 306 307
    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);
308
    if (url_feof(s->pb))
309
        return AVERROR_EOF;
310
    url_fskip(s->pb, 3); /* stream id, always 0 */
311
    flags = 0;
312

Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
313 314
    if(size == 0)
        continue;
315

316
    next= size + url_ftell(s->pb);
317

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

338 339 340 341
    /* skip empty data packets */
    if (!size)
        continue;

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

366
    // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
367
    if(!url_is_streamed(s->pb) && (!s->duration || s->duration==AV_NOPTS_VALUE)){
368
        int size;
Pascal Massimino's avatar
Pascal Massimino committed
369 370
        const int64_t pos= url_ftell(s->pb);
        const int64_t fsize= url_fsize(s->pb);
371 372 373 374
        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){
375 376 377
            uint32_t ts = get_be24(s->pb);
            ts |= get_byte(s->pb) << 24;
            s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
378
        }
379
        url_fseek(s->pb, pos, SEEK_SET);
380 381
    }

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

395 396 397 398 399
    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
400 401 402 403 404 405 406 407
            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;
408 409
        }
        if (type == 0) {
410
            if ((ret = flv_get_extradata(s, st, size)) < 0)
411
                return ret;
412 413 414 415
            if (st->codec->codec_id == CODEC_ID_AAC) {
                MPEG4AudioConfig cfg;
                ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
                                         st->codec->extradata_size);
416
                st->codec->channels = cfg.channels;
417 418 419 420
                if (cfg.ext_sample_rate)
                    st->codec->sample_rate = cfg.ext_sample_rate;
                else
                    st->codec->sample_rate = cfg.sample_rate;
421 422 423 424
                dprintf(s, "mp4a config channels %d sample rate %d\n",
                        st->codec->channels, st->codec->sample_rate);
            }

Howard Chu's avatar
Howard Chu committed
425 426
            ret = AVERROR(EAGAIN);
            goto leave;
427 428 429
        }
    }

430
    /* skip empty data packets */
Howard Chu's avatar
Howard Chu committed
431 432 433 434
    if (!size) {
        ret = AVERROR(EAGAIN);
        goto leave;
    }
435

436
    ret= av_get_packet(s->pb, pkt, size);
437
    if (ret < 0) {
438
        return AVERROR(EIO);
439 440 441 442
    }
    /* note: we need to modify the packet size here to handle the last
       packet */
    pkt->size = ret;
443
    pkt->dts = dts;
Baptiste Coudurier's avatar
Baptiste Coudurier committed
444
    pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
445
    pkt->stream_index = st->index;
446

447
    if (is_audio || ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY))
448
        pkt->flags |= AV_PKT_FLAG_KEY;
449

Howard Chu's avatar
Howard Chu committed
450 451
leave:
    url_fskip(s->pb, 4);
452 453 454
    return ret;
}

Howard Chu's avatar
Howard Chu committed
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
static int flv_read_seek(AVFormatContext *s, int stream_index,
    int64_t ts, int flags)
{
    return av_url_read_fseek(s->pb, stream_index, ts, flags);
}

#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);
        }
        ret = av_url_read_fseek(s->pb, stream_index, ts, flags);
    }

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

488
AVInputFormat flv_demuxer = {
489
    "flv",
490
    NULL_IF_CONFIG_SMALL("FLV format"),
Baptiste Coudurier's avatar
Baptiste Coudurier committed
491
    sizeof(FLVContext),
492 493 494
    flv_probe,
    flv_read_header,
    flv_read_packet,
Howard Chu's avatar
Howard Chu committed
495 496 497 498
    .read_seek = flv_read_seek,
#if 0
    .read_seek2 = flv_read_seek2,
#endif
499 500 501
    .extensions = "flv",
    .value = CODEC_ID_FLV1,
};