flvenc.c 39.5 KB
Newer Older
1
/*
2
 * FLV muxer
3
 * Copyright (c) 2003 The FFmpeg Project
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21 22

#include "libavutil/intreadwrite.h"
23
#include "libavutil/dict.h"
24
#include "libavutil/intfloat.h"
25
#include "libavutil/avassert.h"
26
#include "libavutil/mathematics.h"
27 28
#include "avio_internal.h"
#include "avio.h"
29
#include "avc.h"
30
#include "avformat.h"
31
#include "flv.h"
32
#include "internal.h"
Tomás Touceda's avatar
Tomás Touceda committed
33
#include "metadata.h"
34 35 36
#include "libavutil/opt.h"
#include "libavcodec/put_bits.h"
#include "libavcodec/aacenctab.h"
37

Michael Niedermayer's avatar
Michael Niedermayer committed
38

39
static const AVCodecTag flv_video_codec_ids[] = {
40
    { AV_CODEC_ID_FLV1,     FLV_CODECID_H263 },
41 42
    { AV_CODEC_ID_H263,     FLV_CODECID_REALH263 },
    { AV_CODEC_ID_MPEG4,    FLV_CODECID_MPEG4 },
43 44 45
    { AV_CODEC_ID_FLASHSV,  FLV_CODECID_SCREEN },
    { AV_CODEC_ID_FLASHSV2, FLV_CODECID_SCREEN2 },
    { AV_CODEC_ID_VP6F,     FLV_CODECID_VP6 },
46
    { AV_CODEC_ID_VP6,      FLV_CODECID_VP6 },
47
    { AV_CODEC_ID_VP6A,     FLV_CODECID_VP6A },
48 49
    { AV_CODEC_ID_H264,     FLV_CODECID_H264 },
    { AV_CODEC_ID_NONE,     0 }
50 51
};

52
static const AVCodecTag flv_audio_codec_ids[] = {
53 54 55 56 57 58 59 60 61 62 63
    { AV_CODEC_ID_MP3,        FLV_CODECID_MP3        >> FLV_AUDIO_CODECID_OFFSET },
    { AV_CODEC_ID_PCM_U8,     FLV_CODECID_PCM        >> FLV_AUDIO_CODECID_OFFSET },
    { AV_CODEC_ID_PCM_S16BE,  FLV_CODECID_PCM        >> FLV_AUDIO_CODECID_OFFSET },
    { AV_CODEC_ID_PCM_S16LE,  FLV_CODECID_PCM_LE     >> FLV_AUDIO_CODECID_OFFSET },
    { AV_CODEC_ID_ADPCM_SWF,  FLV_CODECID_ADPCM      >> FLV_AUDIO_CODECID_OFFSET },
    { AV_CODEC_ID_AAC,        FLV_CODECID_AAC        >> FLV_AUDIO_CODECID_OFFSET },
    { AV_CODEC_ID_NELLYMOSER, FLV_CODECID_NELLYMOSER >> FLV_AUDIO_CODECID_OFFSET },
    { AV_CODEC_ID_PCM_MULAW,  FLV_CODECID_PCM_MULAW  >> FLV_AUDIO_CODECID_OFFSET },
    { AV_CODEC_ID_PCM_ALAW,   FLV_CODECID_PCM_ALAW   >> FLV_AUDIO_CODECID_OFFSET },
    { AV_CODEC_ID_SPEEX,      FLV_CODECID_SPEEX      >> FLV_AUDIO_CODECID_OFFSET },
    { AV_CODEC_ID_NONE,       0 }
64 65
};

66 67
typedef enum {
    FLV_AAC_SEQ_HEADER_DETECT = (1 << 0),
68
    FLV_NO_SEQUENCE_END = (1 << 1),
69
    FLV_ADD_KEYFRAME_INDEX = (1 << 2),
70
    FLV_NO_METADATA = (1 << 3),
71
    FLV_NO_DURATION_FILESIZE = (1 << 4),
72 73
} FLVFlags;

74 75 76 77 78 79
typedef struct FLVFileposition {
    int64_t keyframe_position;
    double keyframe_timestamp;
    struct FLVFileposition *next;
} FLVFileposition;

80
typedef struct FLVContext {
81
    AVClass *av_class;
82
    int     reserved;
83 84
    int64_t duration_offset;
    int64_t filesize_offset;
85
    int64_t duration;
86
    int64_t delay;      ///< first dts delay (needed for AVC & Speex)
87

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
    int64_t datastart_offset;
    int64_t datasize_offset;
    int64_t datasize;
    int64_t videosize_offset;
    int64_t videosize;
    int64_t audiosize_offset;
    int64_t audiosize;

    int64_t metadata_size_pos;
    int64_t metadata_totalsize_pos;
    int64_t metadata_totalsize;
    int64_t keyframe_index_size;

    int64_t lasttimestamp_offset;
    double lasttimestamp;
    int64_t lastkeyframetimestamp_offset;
    double lastkeyframetimestamp;
    int64_t lastkeyframelocation_offset;
    int64_t lastkeyframelocation;

    int acurframeindex;
    int64_t keyframes_info_offset;

    int64_t filepositions_count;
    FLVFileposition *filepositions;
    FLVFileposition *head_filepositions;

115 116
    AVCodecParameters *audio_par;
    AVCodecParameters *video_par;
117
    double framerate;
118
    AVCodecParameters *data_par;
119 120

    int flags;
121 122
} FLVContext;

123 124 125 126
typedef struct FLVStreamContext {
    int64_t last_ts;    ///< last timestamp for each stream
} FLVStreamContext;

127
static int get_audio_flags(AVFormatContext *s, AVCodecParameters *par)
128
{
129
    int flags = (par->bits_per_coded_sample == 16) ? FLV_SAMPLESSIZE_16BIT
130
                                                   : FLV_SAMPLESSIZE_8BIT;
131

132
    if (par->codec_id == AV_CODEC_ID_AAC) // specs force these parameters
133 134
        return FLV_CODECID_AAC | FLV_SAMPLERATE_44100HZ |
               FLV_SAMPLESSIZE_16BIT | FLV_STEREO;
135 136
    else if (par->codec_id == AV_CODEC_ID_SPEEX) {
        if (par->sample_rate != 16000) {
137
            av_log(s, AV_LOG_ERROR,
138
                   "FLV only supports wideband (16kHz) Speex audio\n");
139
            return AVERROR(EINVAL);
140
        }
141
        if (par->channels != 1) {
142
            av_log(s, AV_LOG_ERROR, "FLV only supports mono Speex audio\n");
143
            return AVERROR(EINVAL);
144 145 146
        }
        return FLV_CODECID_SPEEX | FLV_SAMPLERATE_11025HZ | FLV_SAMPLESSIZE_16BIT;
    } else {
147
        switch (par->sample_rate) {
148 149 150 151 152 153 154 155
        case 48000:
            // 48khz mp3 is stored with 44k1 samplerate identifer
            if (par->codec_id == AV_CODEC_ID_MP3) {
                flags |= FLV_SAMPLERATE_44100HZ;
                break;
            } else {
                goto error;
            }
156
        case 44100:
157
            flags |= FLV_SAMPLERATE_44100HZ;
158
            break;
159
        case 22050:
160
            flags |= FLV_SAMPLERATE_22050HZ;
161
            break;
162
        case 11025:
163
            flags |= FLV_SAMPLERATE_11025HZ;
164
            break;
165 166 167
        case 16000: // nellymoser only
        case  8000: // nellymoser only
        case  5512: // not MP3
168
            if (par->codec_id != AV_CODEC_ID_MP3) {
Michael Niedermayer's avatar
Michael Niedermayer committed
169 170
                flags |= FLV_SAMPLERATE_SPECIAL;
                break;
171
            }
172
        default:
173
error:
174
            av_log(s, AV_LOG_ERROR,
175
                   "FLV does not support sample rate %d, "
176
                   "choose from (44100, 22050, 11025)\n", par->sample_rate);
177
            return AVERROR(EINVAL);
178
        }
179
    }
180

181
    if (par->channels > 1)
182
        flags |= FLV_STEREO;
183

184
    switch (par->codec_id) {
185
    case AV_CODEC_ID_MP3:
186
        flags |= FLV_CODECID_MP3    | FLV_SAMPLESSIZE_16BIT;
187
        break;
188
    case AV_CODEC_ID_PCM_U8:
189
        flags |= FLV_CODECID_PCM    | FLV_SAMPLESSIZE_8BIT;
190
        break;
191
    case AV_CODEC_ID_PCM_S16BE:
192
        flags |= FLV_CODECID_PCM    | FLV_SAMPLESSIZE_16BIT;
193
        break;
194
    case AV_CODEC_ID_PCM_S16LE:
195
        flags |= FLV_CODECID_PCM_LE | FLV_SAMPLESSIZE_16BIT;
196
        break;
197
    case AV_CODEC_ID_ADPCM_SWF:
198
        flags |= FLV_CODECID_ADPCM  | FLV_SAMPLESSIZE_16BIT;
199
        break;
200
    case AV_CODEC_ID_NELLYMOSER:
201
        if (par->sample_rate == 8000)
202
            flags |= FLV_CODECID_NELLYMOSER_8KHZ_MONO  | FLV_SAMPLESSIZE_16BIT;
203
        else if (par->sample_rate == 16000)
204
            flags |= FLV_CODECID_NELLYMOSER_16KHZ_MONO | FLV_SAMPLESSIZE_16BIT;
205 206
        else
            flags |= FLV_CODECID_NELLYMOSER            | FLV_SAMPLESSIZE_16BIT;
207
        break;
208
    case AV_CODEC_ID_PCM_MULAW:
209 210
        flags = FLV_CODECID_PCM_MULAW | FLV_SAMPLERATE_SPECIAL | FLV_SAMPLESSIZE_16BIT;
        break;
211
    case AV_CODEC_ID_PCM_ALAW:
212
        flags = FLV_CODECID_PCM_ALAW  | FLV_SAMPLERATE_SPECIAL | FLV_SAMPLESSIZE_16BIT;
213
        break;
214
    case 0:
215
        flags |= par->codec_tag << 4;
216 217
        break;
    default:
218
        av_log(s, AV_LOG_ERROR, "Audio codec '%s' not compatible with FLV\n",
219
               avcodec_get_name(par->codec_id));
220
        return AVERROR(EINVAL);
221
    }
222

223 224 225
    return flags;
}

226
static void put_amf_string(AVIOContext *pb, const char *str)
227 228
{
    size_t len = strlen(str);
229 230
    avio_wb16(pb, len);
    avio_write(pb, str, len);
231 232
}

233 234 235 236 237 238
// FLV timestamps are 32 bits signed, RTMP timestamps should be 32-bit unsigned
static void put_timestamp(AVIOContext *pb, int64_t ts) {
    avio_wb24(pb, ts & 0xFFFFFF);
    avio_w8(pb, (ts >> 24) & 0x7F);
}

239 240
static void put_avc_eos_tag(AVIOContext *pb, unsigned ts)
{
241
    avio_w8(pb, FLV_TAG_TYPE_VIDEO);
242
    avio_wb24(pb, 5);               /* Tag Data Size */
243
    put_timestamp(pb, ts);
244 245 246 247 248
    avio_wb24(pb, 0);               /* StreamId = 0 */
    avio_w8(pb, 23);                /* ub[4] FrameType = 1, ub[4] CodecId = 7 */
    avio_w8(pb, 2);                 /* AVC end of sequence */
    avio_wb24(pb, 0);               /* Always 0 for AVC EOS. */
    avio_wb32(pb, 16);              /* Size of FLV tag */
249 250
}

251
static void put_amf_double(AVIOContext *pb, double d)
252
{
253
    avio_w8(pb, AMF_DATA_TYPE_NUMBER);
254
    avio_wb64(pb, av_double2int(d));
255 256
}

257 258 259 260 261 262 263 264 265 266 267
static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
{
    avio_w8(pb, abyte);
}

static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
{
    avio_w8(pb, AMF_DATA_TYPE_ARRAY);
    avio_wb32(pb, dw);
}

268 269
static void put_amf_bool(AVIOContext *pb, int b)
{
270 271
    avio_w8(pb, AMF_DATA_TYPE_BOOL);
    avio_w8(pb, !!b);
272 273
}

274
static void write_metadata(AVFormatContext *s, unsigned int ts)
275
{
276
    AVIOContext *pb = s->pb;
277
    FLVContext *flv = s->priv_data;
278
    int write_duration_filesize = !(flv->flags & FLV_NO_DURATION_FILESIZE);
279
    int metadata_count = 0;
280
    int64_t metadata_count_pos;
281
    AVDictionaryEntry *tag = NULL;
282

283
    /* write meta_tag */
284 285
    avio_w8(pb, FLV_TAG_TYPE_META);            // tag type META
    flv->metadata_size_pos = avio_tell(pb);
286
    avio_wb24(pb, 0);           // size of data part (sum of all parts below)
287
    avio_wb24(pb, ts);          // timestamp
288
    avio_wb32(pb, 0);           // reserved
289 290 291 292

    /* now data of data_size size */

    /* first event name as a string */
293
    avio_w8(pb, AMF_DATA_TYPE_STRING);
294 295 296
    put_amf_string(pb, "onMetaData"); // 12 bytes

    /* mixed array (hash) with size and string/type/data tuples */
297
    avio_w8(pb, AMF_DATA_TYPE_MIXEDARRAY);
298
    metadata_count_pos = avio_tell(pb);
299 300
    metadata_count = 4 * !!flv->video_par +
                     5 * !!flv->audio_par +
301
                     1 * !!flv->data_par;
302
    if (write_duration_filesize) {
303 304
        metadata_count += 2; // +2 for duration and file size
    }
305
    avio_wb32(pb, metadata_count);
306

307
    if (write_duration_filesize) {
308 309 310 311 312
        put_amf_string(pb, "duration");
        flv->duration_offset = avio_tell(pb);
        // fill in the guessed duration, it'll be corrected later if incorrect
        put_amf_double(pb, s->duration / AV_TIME_BASE);
    }
313

314
    if (flv->video_par) {
315
        put_amf_string(pb, "width");
316
        put_amf_double(pb, flv->video_par->width);
317 318

        put_amf_string(pb, "height");
319
        put_amf_double(pb, flv->video_par->height);
320 321

        put_amf_string(pb, "videodatarate");
322
        put_amf_double(pb, flv->video_par->bit_rate / 1024.0);
323

324
        if (flv->framerate != 0.0) {
325
            put_amf_string(pb, "framerate");
326
            put_amf_double(pb, flv->framerate);
327
            metadata_count++;
328
        }
329 330

        put_amf_string(pb, "videocodecid");
331
        put_amf_double(pb, flv->video_par->codec_tag);
332 333
    }

334
    if (flv->audio_par) {
335
        put_amf_string(pb, "audiodatarate");
336
        put_amf_double(pb, flv->audio_par->bit_rate / 1024.0);
337

338
        put_amf_string(pb, "audiosamplerate");
339
        put_amf_double(pb, flv->audio_par->sample_rate);
340 341

        put_amf_string(pb, "audiosamplesize");
342
        put_amf_double(pb, flv->audio_par->codec_id == AV_CODEC_ID_PCM_U8 ? 8 : 16);
343 344

        put_amf_string(pb, "stereo");
345
        put_amf_bool(pb, flv->audio_par->channels == 2);
346 347

        put_amf_string(pb, "audiocodecid");
348
        put_amf_double(pb, flv->audio_par->codec_tag);
349 350
    }

351
    if (flv->data_par) {
352 353 354 355
        put_amf_string(pb, "datastream");
        put_amf_double(pb, 0.0);
    }

356
    ff_standardize_creation_time(s);
357
    while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
358 359 360 361 362 363 364 365 366 367 368 369
        if(   !strcmp(tag->key, "width")
            ||!strcmp(tag->key, "height")
            ||!strcmp(tag->key, "videodatarate")
            ||!strcmp(tag->key, "framerate")
            ||!strcmp(tag->key, "videocodecid")
            ||!strcmp(tag->key, "audiodatarate")
            ||!strcmp(tag->key, "audiosamplerate")
            ||!strcmp(tag->key, "audiosamplesize")
            ||!strcmp(tag->key, "stereo")
            ||!strcmp(tag->key, "audiocodecid")
            ||!strcmp(tag->key, "duration")
            ||!strcmp(tag->key, "onMetaData")
370 371 372 373 374 375 376 377
            ||!strcmp(tag->key, "datasize")
            ||!strcmp(tag->key, "lasttimestamp")
            ||!strcmp(tag->key, "totalframes")
            ||!strcmp(tag->key, "hasAudio")
            ||!strcmp(tag->key, "hasVideo")
            ||!strcmp(tag->key, "hasCuePoints")
            ||!strcmp(tag->key, "hasMetadata")
            ||!strcmp(tag->key, "hasKeyframes")
378
        ){
379
            av_log(s, AV_LOG_DEBUG, "Ignoring metadata for %s\n", tag->key);
380 381
            continue;
        }
Tomás Touceda's avatar
Tomás Touceda committed
382
        put_amf_string(pb, tag->key);
383
        avio_w8(pb, AMF_DATA_TYPE_STRING);
Tomás Touceda's avatar
Tomás Touceda committed
384
        put_amf_string(pb, tag->value);
385
        metadata_count++;
Tomás Touceda's avatar
Tomás Touceda committed
386 387
    }

388
    if (write_duration_filesize) {
389 390 391 392
        put_amf_string(pb, "filesize");
        flv->filesize_offset = avio_tell(pb);
        put_amf_double(pb, 0); // delayed write
    }
393

394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
    if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
        flv->acurframeindex = 0;
        flv->keyframe_index_size = 0;

        put_amf_string(pb, "hasVideo");
        put_amf_bool(pb, !!flv->video_par);
        metadata_count++;

        put_amf_string(pb, "hasKeyframes");
        put_amf_bool(pb, 1);
        metadata_count++;

        put_amf_string(pb, "hasAudio");
        put_amf_bool(pb, !!flv->audio_par);
        metadata_count++;

        put_amf_string(pb, "hasMetadata");
        put_amf_bool(pb, 1);
        metadata_count++;

        put_amf_string(pb, "canSeekToEnd");
        put_amf_bool(pb, 1);
        metadata_count++;

        put_amf_string(pb, "datasize");
        flv->datasize_offset = avio_tell(pb);
        flv->datasize = 0;
        put_amf_double(pb, flv->datasize);
        metadata_count++;

        put_amf_string(pb, "videosize");
        flv->videosize_offset = avio_tell(pb);
        flv->videosize = 0;
        put_amf_double(pb, flv->videosize);
        metadata_count++;

        put_amf_string(pb, "audiosize");
        flv->audiosize_offset = avio_tell(pb);
        flv->audiosize = 0;
        put_amf_double(pb, flv->audiosize);
        metadata_count++;

        put_amf_string(pb, "lasttimestamp");
        flv->lasttimestamp_offset = avio_tell(pb);
        flv->lasttimestamp = 0;
        put_amf_double(pb, 0);
        metadata_count++;

        put_amf_string(pb, "lastkeyframetimestamp");
        flv->lastkeyframetimestamp_offset = avio_tell(pb);
        flv->lastkeyframetimestamp = 0;
        put_amf_double(pb, 0);
        metadata_count++;

        put_amf_string(pb, "lastkeyframelocation");
        flv->lastkeyframelocation_offset = avio_tell(pb);
        flv->lastkeyframelocation = 0;
        put_amf_double(pb, 0);
        metadata_count++;

        put_amf_string(pb, "keyframes");
        put_amf_byte(pb, AMF_DATA_TYPE_OBJECT);
        metadata_count++;

        flv->keyframes_info_offset = avio_tell(pb);
    }

461
    put_amf_string(pb, "");
462
    avio_w8(pb, AMF_END_OF_OBJECT);
463 464

    /* write total size of tag */
465
    flv->metadata_totalsize = avio_tell(pb) - flv->metadata_size_pos - 10;
466 467 468 469

    avio_seek(pb, metadata_count_pos, SEEK_SET);
    avio_wb32(pb, metadata_count);

470 471 472 473 474
    avio_seek(pb, flv->metadata_size_pos, SEEK_SET);
    avio_wb24(pb, flv->metadata_totalsize);
    avio_skip(pb, flv->metadata_totalsize + 10 - 3);
    flv->metadata_totalsize_pos = avio_tell(pb);
    avio_wb32(pb, flv->metadata_totalsize + 11);
475 476
}

477 478 479 480 481 482 483 484 485 486 487
static int unsupported_codec(AVFormatContext *s,
                             const char* type, int codec_id)
{
    const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
    av_log(s, AV_LOG_ERROR,
           "%s codec %s not compatible with flv\n",
            type,
            desc ? desc->name : "unknown");
    return AVERROR(ENOSYS);
}

488
static void flv_write_codec_header(AVFormatContext* s, AVCodecParameters* par, int64_t ts) {
489 490 491 492 493 494 495 496 497 498 499
    int64_t data_size;
    AVIOContext *pb = s->pb;
    FLVContext *flv = s->priv_data;

    if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
            || par->codec_id == AV_CODEC_ID_MPEG4) {
        int64_t pos;
        avio_w8(pb,
                par->codec_type == AVMEDIA_TYPE_VIDEO ?
                        FLV_TAG_TYPE_VIDEO : FLV_TAG_TYPE_AUDIO);
        avio_wb24(pb, 0); // size patched later
500
        put_timestamp(pb, ts);
501 502 503 504 505 506
        avio_wb24(pb, 0); // streamid
        pos = avio_tell(pb);
        if (par->codec_id == AV_CODEC_ID_AAC) {
            avio_w8(pb, get_audio_flags(s, par));
            avio_w8(pb, 0); // AAC sequence header

507
            if (!par->extradata_size && (flv->flags & FLV_AAC_SEQ_HEADER_DETECT)) {
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
                PutBitContext pbc;
                int samplerate_index;
                int channels = flv->audio_par->channels
                        - (flv->audio_par->channels == 8 ? 1 : 0);
                uint8_t data[2];

                for (samplerate_index = 0; samplerate_index < 16;
                        samplerate_index++)
                    if (flv->audio_par->sample_rate
                            == mpeg4audio_sample_rates[samplerate_index])
                        break;

                init_put_bits(&pbc, data, sizeof(data));
                put_bits(&pbc, 5, flv->audio_par->profile + 1); //profile
                put_bits(&pbc, 4, samplerate_index); //sample rate index
                put_bits(&pbc, 4, channels);
                put_bits(&pbc, 1, 0); //frame length - 1024 samples
                put_bits(&pbc, 1, 0); //does not depend on core coder
                put_bits(&pbc, 1, 0); //is not extension
                flush_put_bits(&pbc);

                avio_w8(pb, data[0]);
                avio_w8(pb, data[1]);

                av_log(s, AV_LOG_WARNING, "AAC sequence header: %02x %02x.\n",
                        data[0], data[1]);
            }
            avio_write(pb, par->extradata, par->extradata_size);
        } else {
            avio_w8(pb, par->codec_tag | FLV_FRAME_KEY); // flags
            avio_w8(pb, 0); // AVC sequence header
            avio_wb24(pb, 0); // composition time
            ff_isom_write_avcc(pb, par->extradata, par->extradata_size);
        }
        data_size = avio_tell(pb) - pos;
        avio_seek(pb, -data_size - 10, SEEK_CUR);
        avio_wb24(pb, data_size);
        avio_skip(pb, data_size + 10 - 3);
        avio_wb32(pb, data_size + 11); // previous tag size
    }
}

550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582
static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
{
    FLVFileposition *position = av_malloc(sizeof(FLVFileposition));

    if (!position) {
        av_log(s, AV_LOG_WARNING, "no mem for add keyframe index!\n");
        return AVERROR(ENOMEM);
    }

    position->keyframe_timestamp = ts;
    position->keyframe_position = pos;

    if (!flv->filepositions_count) {
        flv->filepositions = position;
        flv->head_filepositions = flv->filepositions;
        position->next = NULL;
    } else {
        flv->filepositions->next = position;
        position->next = NULL;
        flv->filepositions = flv->filepositions->next;
    }

    flv->filepositions_count++;

    return 0;
}

static int shift_data(AVFormatContext *s)
{
    int ret = 0;
    int n = 0;
    int64_t metadata_size = 0;
    FLVContext *flv = s->priv_data;
583
    int64_t pos, pos_end = avio_tell(s->pb); /* Save the pre-shift size. */
584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
    uint8_t *buf, *read_buf[2];
    int read_buf_id = 0;
    int read_size[2];
    AVIOContext *read_pb;

    metadata_size = flv->filepositions_count * 9 * 2 + 10; /* filepositions and times value */
    metadata_size += 2 + 13; /* filepositions String */
    metadata_size += 2 + 5; /* times String */
    metadata_size += 3; /* Object end */

    flv->keyframe_index_size = metadata_size;

    if (metadata_size < 0)
        return metadata_size;

    buf = av_malloc_array(metadata_size, 2);
    if (!buf) {
        return AVERROR(ENOMEM);
    }
    read_buf[0] = buf;
    read_buf[1] = buf + metadata_size;

    avio_seek(s->pb, flv->metadata_size_pos, SEEK_SET);
    avio_wb24(s->pb, flv->metadata_totalsize + metadata_size);

    avio_seek(s->pb, flv->metadata_totalsize_pos, SEEK_SET);
    avio_wb32(s->pb, flv->metadata_totalsize + 11 + metadata_size);

    /* Shift the data: the AVIO context of the output can only be used for
     * writing, so we re-open the same output, but for reading. It also avoids
     * a read/seek/write/seek back and forth. */
    avio_flush(s->pb);
616
    ret = s->io_open(s, &read_pb, s->url, AVIO_FLAG_READ, NULL);
617 618
    if (ret < 0) {
        av_log(s, AV_LOG_ERROR, "Unable to re-open %s output file for "
619
               "the second pass (add_keyframe_index)\n", s->url);
620 621 622
        goto end;
    }

623
    /* Get ready for writing. */
624 625 626 627 628 629
    avio_seek(s->pb, flv->keyframes_info_offset + metadata_size, SEEK_SET);

    /* start reading at where the keyframe index information will be placed */
    avio_seek(read_pb, flv->keyframes_info_offset, SEEK_SET);
    pos = avio_tell(read_pb);

630
#define READ_BLOCK do {                                                             \
631
    read_size[read_buf_id] = avio_read(read_pb, read_buf[read_buf_id], metadata_size);  \
632 633
    read_buf_id ^= 1;                                                               \
} while (0)
634

635 636 637 638
    /* shift data by chunk of at most keyframe *filepositions* and *times* size */
    READ_BLOCK;
    do {
        READ_BLOCK;
639 640 641 642 643 644 645 646 647 648 649 650 651 652
        n = read_size[read_buf_id];
        if (n < 0)
            break;
        avio_write(s->pb, read_buf[read_buf_id], n);
        pos += n;
    } while (pos <= pos_end);

    ff_format_io_close(s, &read_pb);

end:
    av_free(buf);
    return ret;
}

653
static int flv_init(struct AVFormatContext *s)
654 655 656 657 658
{
    int i;
    FLVContext *flv = s->priv_data;

    for (i = 0; i < s->nb_streams; i++) {
659
        AVCodecParameters *par = s->streams[i]->codecpar;
660
        FLVStreamContext *sc;
661
        switch (par->codec_type) {
662 663 664 665 666
        case AVMEDIA_TYPE_VIDEO:
            if (s->streams[i]->avg_frame_rate.den &&
                s->streams[i]->avg_frame_rate.num) {
                flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
            }
667
            if (flv->video_par) {
668 669 670 671
                av_log(s, AV_LOG_ERROR,
                       "at most one video stream is supported in flv\n");
                return AVERROR(EINVAL);
            }
672 673 674
            flv->video_par = par;
            if (!ff_codec_get_tag(flv_video_codec_ids, par->codec_id))
                return unsupported_codec(s, "Video", par->codec_id);
675

676 677
            if (par->codec_id == AV_CODEC_ID_MPEG4 ||
                par->codec_id == AV_CODEC_ID_H263) {
678 679
                int error = s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL;
                av_log(s, error ? AV_LOG_ERROR : AV_LOG_WARNING,
680
                       "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(par->codec_id));
681 682 683 684 685 686

                if (error) {
                    av_log(s, AV_LOG_ERROR,
                           "use vstrict=-1 / -strict -1 to use it anyway.\n");
                    return AVERROR(EINVAL);
                }
687
            } else if (par->codec_id == AV_CODEC_ID_VP6) {
688 689
                av_log(s, AV_LOG_WARNING,
                       "Muxing VP6 in flv will produce flipped video on playback.\n");
690 691 692
            }
            break;
        case AVMEDIA_TYPE_AUDIO:
693
            if (flv->audio_par) {
694 695 696 697
                av_log(s, AV_LOG_ERROR,
                       "at most one audio stream is supported in flv\n");
                return AVERROR(EINVAL);
            }
698 699 700
            flv->audio_par = par;
            if (get_audio_flags(s, par) < 0)
                return unsupported_codec(s, "Audio", par->codec_id);
701
            if (par->codec_id == AV_CODEC_ID_PCM_S16BE)
702 703
                av_log(s, AV_LOG_WARNING,
                       "16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le\n");
704 705
            break;
        case AVMEDIA_TYPE_DATA:
706
            if (par->codec_id != AV_CODEC_ID_TEXT && par->codec_id != AV_CODEC_ID_NONE)
707 708
                return unsupported_codec(s, "Data", par->codec_id);
            flv->data_par = par;
709
            break;
710
        case AVMEDIA_TYPE_SUBTITLE:
711
            if (par->codec_id != AV_CODEC_ID_TEXT) {
712
                av_log(s, AV_LOG_ERROR, "Subtitle codec '%s' for stream %d is not compatible with FLV\n",
713
                       avcodec_get_name(par->codec_id), i);
714 715
                return AVERROR_INVALIDDATA;
            }
716
            flv->data_par = par;
717
            break;
718
        default:
719
            av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
720
                   av_get_media_type_string(par->codec_type), i);
721
            return AVERROR(EINVAL);
722 723 724 725 726 727 728 729 730 731 732 733
        }
        avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */

        sc = av_mallocz(sizeof(FLVStreamContext));
        if (!sc)
            return AVERROR(ENOMEM);
        s->streams[i]->priv_data = sc;
        sc->last_ts = -1;
    }

    flv->delay = AV_NOPTS_VALUE;

734 735 736 737 738 739 740 741 742
    return 0;
}

static int flv_write_header(AVFormatContext *s)
{
    int i;
    AVIOContext *pb = s->pb;
    FLVContext *flv = s->priv_data;

743 744
    avio_write(pb, "FLV", 3);
    avio_w8(pb, 1);
745 746
    avio_w8(pb, FLV_HEADER_FLAG_HASAUDIO * !!flv->audio_par +
                FLV_HEADER_FLAG_HASVIDEO * !!flv->video_par);
747 748 749 750
    avio_wb32(pb, 9);
    avio_wb32(pb, 0);

    for (i = 0; i < s->nb_streams; i++)
751
        if (s->streams[i]->codecpar->codec_tag == 5) {
752 753 754 755 756 757 758 759
            avio_w8(pb, 8);     // message type
            avio_wb24(pb, 0);   // include flags
            avio_wb24(pb, 0);   // time stamp
            avio_wb32(pb, 0);   // reserved
            avio_wb32(pb, 11);  // size
            flv->reserved = 5;
        }

760 761 762 763 764
    if (flv->flags & FLV_NO_METADATA) {
        pb->seekable = 0;
    } else {
        write_metadata(s, 0);
    }
765

766
    for (i = 0; i < s->nb_streams; i++) {
767
        flv_write_codec_header(s, s->streams[i]->codecpar, 0);
768 769
    }

770
    flv->datastart_offset = avio_tell(pb);
771 772 773 774 775
    return 0;
}

static int flv_write_trailer(AVFormatContext *s)
{
776
    int64_t file_size;
777
    AVIOContext *pb = s->pb;
778
    FLVContext *flv = s->priv_data;
779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
    int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
    int i, res;
    int64_t cur_pos = avio_tell(s->pb);

    if (build_keyframes_idx) {
        FLVFileposition *newflv_posinfo, *p;

        avio_seek(pb, flv->videosize_offset, SEEK_SET);
        put_amf_double(pb, flv->videosize);

        avio_seek(pb, flv->audiosize_offset, SEEK_SET);
        put_amf_double(pb, flv->audiosize);

        avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
        put_amf_double(pb, flv->lasttimestamp);

        avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
        put_amf_double(pb, flv->lastkeyframetimestamp);
797

798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838
        avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
        put_amf_double(pb, flv->lastkeyframelocation + flv->keyframe_index_size);
        avio_seek(pb, cur_pos, SEEK_SET);

        res = shift_data(s);
        if (res < 0) {
             goto end;
        }
        avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
        put_amf_string(pb, "filepositions");
        put_amf_dword_array(pb, flv->filepositions_count);
        for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
            put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
        }

        put_amf_string(pb, "times");
        put_amf_dword_array(pb, flv->filepositions_count);
        for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
            put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
        }

        newflv_posinfo = flv->head_filepositions;
        while (newflv_posinfo) {
            p = newflv_posinfo->next;
            if (p) {
                newflv_posinfo->next = p->next;
                av_free(p);
                p = NULL;
            } else {
                av_free(newflv_posinfo);
                newflv_posinfo = NULL;
            }
        }

        put_amf_string(pb, "");
        avio_w8(pb, AMF_END_OF_OBJECT);

        avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
    }

end:
839 840 841 842 843 844 845 846 847 848 849
    if (flv->flags & FLV_NO_SEQUENCE_END) {
        av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
    } else {
        /* Add EOS tag */
        for (i = 0; i < s->nb_streams; i++) {
            AVCodecParameters *par = s->streams[i]->codecpar;
            FLVStreamContext *sc = s->streams[i]->priv_data;
            if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
                    (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4))
                put_avc_eos_tag(pb, sc->last_ts);
        }
850
    }
851

852
    file_size = avio_tell(pb);
853

854 855 856 857 858
    if (build_keyframes_idx) {
        flv->datasize = file_size - flv->datastart_offset;
        avio_seek(pb, flv->datasize_offset, SEEK_SET);
        put_amf_double(pb, flv->datasize);
    }
859 860 861 862 863 864 865 866 867 868 869 870 871
    if (!(flv->flags & FLV_NO_METADATA)) {
        if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
            /* update information */
            if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
                av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
            } else {
                put_amf_double(pb, flv->duration / (double)1000);
            }
            if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
                av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
            } else {
                put_amf_double(pb, file_size);
            }
872 873
        }
    }
874

875 876 877
    return 0;
}

878
static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
879
{
880
    AVIOContext *pb      = s->pb;
881
    AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
882
    FLVContext *flv      = s->priv_data;
883
    FLVStreamContext *sc = s->streams[pkt->stream_index]->priv_data;
884
    unsigned ts;
885 886
    int size = pkt->size;
    uint8_t *data = NULL;
887
    int flags = -1, flags_size, ret = 0;
888
    int64_t cur_offset = avio_tell(pb);
889

890 891 892 893 894
    if (par->codec_type == AVMEDIA_TYPE_AUDIO && !pkt->size) {
        av_log(s, AV_LOG_WARNING, "Empty audio Packet\n");
        return AVERROR(EINVAL);
    }

895
    if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
896
        par->codec_id == AV_CODEC_ID_VP6  || par->codec_id == AV_CODEC_ID_AAC)
897
        flags_size = 2;
898
    else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4)
899
        flags_size = 5;
900
    else
901
        flags_size = 1;
902

903 904 905 906 907
    if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
            || par->codec_id == AV_CODEC_ID_MPEG4) {
        int side_size = 0;
        uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
        if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
908 909 910
            ret = ff_alloc_extradata(par, side_size);
            if (ret < 0)
                return ret;
911
            memcpy(par->extradata, side, side_size);
912
            flv_write_codec_header(s, par, pkt->dts);
913 914 915
        }
    }

916 917 918 919 920 921 922 923
    if (flv->delay == AV_NOPTS_VALUE)
        flv->delay = -pkt->dts;

    if (pkt->dts < -flv->delay) {
        av_log(s, AV_LOG_WARNING,
               "Packets are not in the proper order with respect to DTS\n");
        return AVERROR(EINVAL);
    }
924 925 926 927 928 929
    if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
        if (pkt->pts == AV_NOPTS_VALUE) {
            av_log(s, AV_LOG_ERROR, "Packet is missing PTS\n");
            return AVERROR(EINVAL);
        }
    }
930

931
    ts = pkt->dts;
932 933 934 935 936 937

    if (s->event_flags & AVSTREAM_EVENT_FLAG_METADATA_UPDATED) {
        write_metadata(s, ts);
        s->event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
    }

938 939 940
    avio_write_marker(pb, av_rescale(ts, AV_TIME_BASE, 1000),
                      pkt->flags & AV_PKT_FLAG_KEY && (flv->video_par ? par->codec_type == AVMEDIA_TYPE_VIDEO : 1) ? AVIO_DATA_MARKER_SYNC_POINT : AVIO_DATA_MARKER_BOUNDARY_POINT);

941
    switch (par->codec_type) {
942
    case AVMEDIA_TYPE_VIDEO:
943
        avio_w8(pb, FLV_TAG_TYPE_VIDEO);
944

945
        flags = ff_codec_get_tag(flv_video_codec_ids, par->codec_id);
946

947
        flags |= pkt->flags & AV_PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER;
948 949
        break;
    case AVMEDIA_TYPE_AUDIO:
950
        flags = get_audio_flags(s, par);
951

952
        av_assert0(size);
Michael Niedermayer's avatar
Michael Niedermayer committed
953

954
        avio_w8(pb, FLV_TAG_TYPE_AUDIO);
955
        break;
956
    case AVMEDIA_TYPE_SUBTITLE:
957
    case AVMEDIA_TYPE_DATA:
958
        avio_w8(pb, FLV_TAG_TYPE_META);
959 960 961
        break;
    default:
        return AVERROR(EINVAL);
Michael Niedermayer's avatar
Michael Niedermayer committed
962
    }
963

964
    if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
965
        /* check if extradata looks like mp4 formatted */
966
        if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
967 968
            if ((ret = ff_avc_parse_nal_units_buf(pkt->data, &data, &size)) < 0)
                return ret;
969
    } else if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
970
               (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
971
        if (!s->streams[pkt->stream_index]->nb_frames) {
972 973 974 975
            av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
                   "use the audio bitstream filter 'aac_adtstoasc' to fix it "
                   "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
            return AVERROR_INVALIDDATA;
976 977
        }
        av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
978
    }
979

980
    /* check Speex packet duration */
981
    if (par->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160)
982 983 984 985
        av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
                                  "8 frames per packet. Adobe Flash "
                                  "Player cannot handle this!\n");

986 987
    if (sc->last_ts < ts)
        sc->last_ts = ts;
988

989 990 991
    if (size + flags_size >= 1<<24) {
        av_log(s, AV_LOG_ERROR, "Too large packet with size %u >= %u\n",
               size + flags_size, 1<<24);
992 993
        ret = AVERROR(EINVAL);
        goto fail;
994 995
    }

996
    avio_wb24(pb, size + flags_size);
997
    put_timestamp(pb, ts);
998
    avio_wb24(pb, flv->reserved);
999

1000 1001
    if (par->codec_type == AVMEDIA_TYPE_DATA ||
        par->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
1002
        int data_size;
1003
        int64_t metadata_size_pos = avio_tell(pb);
1004
        if (par->codec_id == AV_CODEC_ID_TEXT) {
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
            // legacy FFmpeg magic?
            avio_w8(pb, AMF_DATA_TYPE_STRING);
            put_amf_string(pb, "onTextData");
            avio_w8(pb, AMF_DATA_TYPE_MIXEDARRAY);
            avio_wb32(pb, 2);
            put_amf_string(pb, "type");
            avio_w8(pb, AMF_DATA_TYPE_STRING);
            put_amf_string(pb, "Text");
            put_amf_string(pb, "text");
            avio_w8(pb, AMF_DATA_TYPE_STRING);
            put_amf_string(pb, pkt->data);
            put_amf_string(pb, "");
            avio_w8(pb, AMF_END_OF_OBJECT);
        } else {
            // just pass the metadata through
            avio_write(pb, data ? data : pkt->data, size);
        }
1022 1023 1024 1025 1026 1027 1028
        /* write total size of tag */
        data_size = avio_tell(pb) - metadata_size_pos;
        avio_seek(pb, metadata_size_pos - 10, SEEK_SET);
        avio_wb24(pb, data_size);
        avio_seek(pb, data_size + 10 - 3, SEEK_CUR);
        avio_wb32(pb, data_size + 11);
    } else {
1029
        av_assert1(flags>=0);
1030
        avio_w8(pb,flags);
1031
        if (par->codec_id == AV_CODEC_ID_VP6)
1032
            avio_w8(pb,0);
1033 1034 1035
        if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A) {
            if (par->extradata_size)
                avio_w8(pb, par->extradata[0]);
1036
            else
1037 1038 1039
                avio_w8(pb, ((FFALIGN(par->width,  16) - par->width) << 4) |
                             (FFALIGN(par->height, 16) - par->height));
        } else if (par->codec_id == AV_CODEC_ID_AAC)
1040
            avio_w8(pb, 1); // AAC raw
1041
        else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
1042 1043 1044
            avio_w8(pb, 1); // AVC NALU
            avio_wb24(pb, pkt->pts - pkt->dts);
        }
1045

1046
        avio_write(pb, data ? data : pkt->data, size);
1047

1048 1049 1050
        avio_wb32(pb, size + flags_size + 11); // previous tag size
        flv->duration = FFMAX(flv->duration,
                              pkt->pts + flv->delay + pkt->duration);
1051
    }
1052

1053 1054 1055 1056 1057
    if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
        switch (par->codec_type) {
            case AVMEDIA_TYPE_VIDEO:
                flv->videosize += (avio_tell(pb) - cur_offset);
                flv->lasttimestamp = flv->acurframeindex / flv->framerate;
1058
                flv->acurframeindex++;
1059
                if (pkt->flags & AV_PKT_FLAG_KEY) {
1060
                    double ts = flv->lasttimestamp;
1061 1062
                    int64_t pos = cur_offset;

1063
                    flv->lastkeyframetimestamp = ts;
1064
                    flv->lastkeyframelocation = pos;
1065 1066 1067
                    ret = flv_append_keyframe_info(s, flv, ts, pos);
                    if (ret < 0)
                        goto fail;
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
                }
                break;

            case AVMEDIA_TYPE_AUDIO:
                flv->audiosize += (avio_tell(pb) - cur_offset);
                break;

            default:
                av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
                break;
        }
    }
1080
fail:
1081 1082
    av_free(data);

1083
    return ret;
1084 1085
}

1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
static int flv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
{
    int ret = 1;
    AVStream *st = s->streams[pkt->stream_index];

    if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
        if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
            ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
    }
    return ret;
}

1098 1099
static const AVOption options[] = {
    { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1100
    { "aac_seq_header_detect", "Put AAC sequence header based on stream data", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_AAC_SEQ_HEADER_DETECT}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1101
    { "no_sequence_end", "disable sequence end for FLV", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_NO_SEQUENCE_END}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1102
    { "no_metadata", "disable metadata for FLV", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_NO_METADATA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1103
    { "no_duration_filesize", "disable duration and filesize zero value metadata for FLV", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_NO_DURATION_FILESIZE}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1104
    { "add_keyframe_index", "Add keyframe index metadata", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_ADD_KEYFRAME_INDEX}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
    { NULL },
};

static const AVClass flv_muxer_class = {
    .class_name = "flv muxer",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};

1115
AVOutputFormat ff_flv_muxer = {
1116
    .name           = "flv",
1117
    .long_name      = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1118 1119 1120
    .mime_type      = "video/x-flv",
    .extensions     = "flv",
    .priv_data_size = sizeof(FLVContext),
1121 1122
    .audio_codec    = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
    .video_codec    = AV_CODEC_ID_FLV1,
1123
    .init           = flv_init,
1124 1125 1126
    .write_header   = flv_write_header,
    .write_packet   = flv_write_packet,
    .write_trailer  = flv_write_trailer,
1127
    .check_bitstream= flv_check_bitstream,
1128 1129 1130
    .codec_tag      = (const AVCodecTag* const []) {
                          flv_video_codec_ids, flv_audio_codec_ids, 0
                      },
1131 1132
    .flags          = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
                      AVFMT_TS_NONSTRICT,
1133
    .priv_class     = &flv_muxer_class,
1134
};