2003-07-09 23:10:59 +00:00
/*
2006-10-23 08:57:54 +00:00
* FLV muxer
2009-01-19 15:46:40 +00:00
* Copyright ( c ) 2003 The FFmpeg Project
2003-07-09 23:10:59 +00:00
*
2006-10-07 15:30:46 +00:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2003-07-09 23:10:59 +00:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 15:30:46 +00:00
* version 2.1 of the License , or ( at your option ) any later version .
2003-07-09 23:10:59 +00:00
*
2006-10-07 15:30:46 +00:00
* FFmpeg is distributed in the hope that it will be useful ,
2003-07-09 23:10:59 +00:00
* 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
2006-10-07 15:30:46 +00:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-12 22:43:26 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2003-07-09 23:10:59 +00:00
*/
2011-01-29 05:32:09 +00:00
# include "libavutil/intreadwrite.h"
2012-06-27 08:16:18 +00:00
# include "libavutil/dict.h"
2011-11-27 14:04:16 +00:00
# include "libavutil/intfloat.h"
2012-06-28 21:57:31 +00:00
# include "libavutil/avassert.h"
2016-05-04 19:06:43 +00:00
# include "libavutil/mathematics.h"
2022-09-21 01:03:07 +00:00
# include "libavcodec/codec_desc.h"
2021-02-10 18:37:37 +00:00
# include "libavcodec/mpeg4audio.h"
2016-11-08 11:27:21 +00:00
# include "avio.h"
2012-06-27 08:16:18 +00:00
# include "avc.h"
2003-07-09 23:10:59 +00:00
# include "avformat.h"
2006-12-06 00:23:04 +00:00
# include "flv.h"
2010-05-22 16:01:32 +00:00
# include "internal.h"
2022-05-06 13:01:33 +00:00
# include "mux.h"
2015-11-18 21:44:08 +00:00
# include "libavutil/opt.h"
# include "libavcodec/put_bits.h"
2003-07-09 23:10:59 +00:00
2004-04-17 12:04:59 +00:00
2007-01-21 01:39:17 +00:00
static const AVCodecTag flv_video_codec_ids [ ] = {
2012-08-05 09:11:04 +00:00
{ AV_CODEC_ID_FLV1 , FLV_CODECID_H263 } ,
2012-08-07 20:45:46 +00:00
{ AV_CODEC_ID_H263 , FLV_CODECID_REALH263 } ,
{ AV_CODEC_ID_MPEG4 , FLV_CODECID_MPEG4 } ,
2012-08-05 09:11:04 +00:00
{ AV_CODEC_ID_FLASHSV , FLV_CODECID_SCREEN } ,
{ AV_CODEC_ID_FLASHSV2 , FLV_CODECID_SCREEN2 } ,
{ AV_CODEC_ID_VP6F , FLV_CODECID_VP6 } ,
2013-10-31 00:24:07 +00:00
{ AV_CODEC_ID_VP6 , FLV_CODECID_VP6 } ,
2012-08-07 20:45:46 +00:00
{ AV_CODEC_ID_VP6A , FLV_CODECID_VP6A } ,
2012-08-05 09:11:04 +00:00
{ AV_CODEC_ID_H264 , FLV_CODECID_H264 } ,
{ AV_CODEC_ID_NONE , 0 }
2006-12-28 12:35:22 +00:00
} ;
2007-01-21 01:39:17 +00:00
static const AVCodecTag flv_audio_codec_ids [ ] = {
2012-08-05 09:11:04 +00:00
{ 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 }
2006-12-28 12:35:22 +00:00
} ;
2016-09-13 13:59:56 +00:00
typedef enum {
FLV_AAC_SEQ_HEADER_DETECT = ( 1 < < 0 ) ,
2016-09-14 02:00:52 +00:00
FLV_NO_SEQUENCE_END = ( 1 < < 1 ) ,
2016-11-08 11:27:21 +00:00
FLV_ADD_KEYFRAME_INDEX = ( 1 < < 2 ) ,
2016-11-21 12:26:11 +00:00
FLV_NO_METADATA = ( 1 < < 3 ) ,
2016-11-26 00:52:19 +00:00
FLV_NO_DURATION_FILESIZE = ( 1 < < 4 ) ,
2016-09-13 13:59:56 +00:00
} FLVFlags ;
2016-11-08 11:27:21 +00:00
typedef struct FLVFileposition {
int64_t keyframe_position ;
double keyframe_timestamp ;
struct FLVFileposition * next ;
} FLVFileposition ;
2003-07-09 23:10:59 +00:00
typedef struct FLVContext {
2015-11-18 21:44:08 +00:00
AVClass * av_class ;
2012-06-27 08:16:18 +00:00
int reserved ;
2008-10-03 10:16:29 +00:00
int64_t duration_offset ;
int64_t filesize_offset ;
2006-08-06 15:29:50 +00:00
int64_t duration ;
2011-10-26 16:43:18 +00:00
int64_t delay ; ///< first dts delay (needed for AVC & Speex)
2014-11-07 21:09:09 +00:00
2016-11-08 11:27:21 +00:00
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 ;
int64_t keyframes_info_offset ;
int64_t filepositions_count ;
FLVFileposition * filepositions ;
FLVFileposition * head_filepositions ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVCodecParameters * audio_par ;
AVCodecParameters * video_par ;
2014-11-07 21:09:09 +00:00
double framerate ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVCodecParameters * data_par ;
2015-11-18 21:44:08 +00:00
int flags ;
2023-04-07 14:56:38 +00:00
int64_t last_ts [ FLV_STREAM_TYPE_NB ] ;
2003-07-09 23:10:59 +00:00
} FLVContext ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
static int get_audio_flags ( AVFormatContext * s , AVCodecParameters * par )
2012-05-07 14:09:30 +00:00
{
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
int flags = ( par - > bits_per_coded_sample = = 16 ) ? FLV_SAMPLESSIZE_16BIT
2012-06-27 08:16:18 +00:00
: FLV_SAMPLESSIZE_8BIT ;
2004-07-02 19:26:51 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_id = = AV_CODEC_ID_AAC ) // specs force these parameters
2012-06-27 08:16:18 +00:00
return FLV_CODECID_AAC | FLV_SAMPLERATE_44100HZ |
FLV_SAMPLESSIZE_16BIT | FLV_STEREO ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
else if ( par - > codec_id = = AV_CODEC_ID_SPEEX ) {
if ( par - > sample_rate ! = 16000 ) {
2012-06-27 08:16:18 +00:00
av_log ( s , AV_LOG_ERROR ,
2012-09-06 13:10:21 +00:00
" FLV only supports wideband (16kHz) Speex audio \n " ) ;
2012-09-06 12:54:57 +00:00
return AVERROR ( EINVAL ) ;
2009-10-16 03:02:25 +00:00
}
2017-03-31 12:04:07 +00:00
if ( par - > ch_layout . nb_channels ! = 1 ) {
2012-09-06 13:10:21 +00:00
av_log ( s , AV_LOG_ERROR , " FLV only supports mono Speex audio \n " ) ;
2012-09-06 12:54:57 +00:00
return AVERROR ( EINVAL ) ;
2009-10-16 03:02:25 +00:00
}
return FLV_CODECID_SPEEX | FLV_SAMPLERATE_11025HZ | FLV_SAMPLESSIZE_16BIT ;
} else {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
switch ( par - > sample_rate ) {
2016-09-28 14:47:47 +00:00
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 ;
}
2012-06-27 08:16:18 +00:00
case 44100 :
2006-12-06 00:23:04 +00:00
flags | = FLV_SAMPLERATE_44100HZ ;
2004-07-02 19:26:51 +00:00
break ;
2012-06-27 08:16:18 +00:00
case 22050 :
2006-12-06 00:23:04 +00:00
flags | = FLV_SAMPLERATE_22050HZ ;
2004-07-02 19:26:51 +00:00
break ;
2012-06-27 08:16:18 +00:00
case 11025 :
2006-12-06 00:23:04 +00:00
flags | = FLV_SAMPLERATE_11025HZ ;
2004-07-02 19:26:51 +00:00
break ;
2012-06-27 08:16:18 +00:00
case 16000 : // nellymoser only
case 8000 : // nellymoser only
case 5512 : // not MP3
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_id ! = AV_CODEC_ID_MP3 ) {
2007-10-09 01:12:27 +00:00
flags | = FLV_SAMPLERATE_SPECIAL ;
break ;
2007-10-09 01:01:07 +00:00
}
2004-07-02 19:26:51 +00:00
default :
2016-09-28 14:47:47 +00:00
error :
2012-06-27 08:16:18 +00:00
av_log ( s , AV_LOG_ERROR ,
2012-09-06 13:10:21 +00:00
" FLV does not support sample rate %d, "
2016-04-10 19:58:15 +00:00
" choose from (44100, 22050, 11025) \n " , par - > sample_rate ) ;
2012-09-06 12:54:57 +00:00
return AVERROR ( EINVAL ) ;
2012-06-27 08:16:18 +00:00
}
2008-05-26 22:00:35 +00:00
}
2004-07-02 19:26:51 +00:00
2017-03-31 12:04:07 +00:00
if ( par - > ch_layout . nb_channels > 1 )
2006-12-06 00:23:04 +00:00
flags | = FLV_STEREO ;
2005-12-17 18:14:38 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
switch ( par - > codec_id ) {
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_MP3 :
2006-12-06 00:23:04 +00:00
flags | = FLV_CODECID_MP3 | FLV_SAMPLESSIZE_16BIT ;
2004-07-02 19:26:51 +00:00
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_PCM_U8 :
2008-02-24 00:57:15 +00:00
flags | = FLV_CODECID_PCM | FLV_SAMPLESSIZE_8BIT ;
2005-12-22 01:10:11 +00:00
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_PCM_S16BE :
2008-02-24 00:57:15 +00:00
flags | = FLV_CODECID_PCM | FLV_SAMPLESSIZE_16BIT ;
2005-12-22 01:10:11 +00:00
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_PCM_S16LE :
2006-12-06 00:23:04 +00:00
flags | = FLV_CODECID_PCM_LE | FLV_SAMPLESSIZE_16BIT ;
2005-12-22 01:10:11 +00:00
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_ADPCM_SWF :
2012-06-27 08:16:18 +00:00
flags | = FLV_CODECID_ADPCM | FLV_SAMPLESSIZE_16BIT ;
2005-12-22 01:10:11 +00:00
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_NELLYMOSER :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > sample_rate = = 8000 )
2012-06-27 08:16:18 +00:00
flags | = FLV_CODECID_NELLYMOSER_8KHZ_MONO | FLV_SAMPLESSIZE_16BIT ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
else if ( par - > sample_rate = = 16000 )
2011-12-15 13:10:57 +00:00
flags | = FLV_CODECID_NELLYMOSER_16KHZ_MONO | FLV_SAMPLESSIZE_16BIT ;
2012-06-27 08:16:18 +00:00
else
flags | = FLV_CODECID_NELLYMOSER | FLV_SAMPLESSIZE_16BIT ;
2008-05-02 19:35:31 +00:00
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_PCM_MULAW :
2012-06-28 14:28:56 +00:00
flags = FLV_CODECID_PCM_MULAW | FLV_SAMPLERATE_SPECIAL | FLV_SAMPLESSIZE_16BIT ;
break ;
2012-08-05 09:11:04 +00:00
case AV_CODEC_ID_PCM_ALAW :
2012-06-28 14:28:56 +00:00
flags = FLV_CODECID_PCM_ALAW | FLV_SAMPLERATE_SPECIAL | FLV_SAMPLESSIZE_16BIT ;
2008-05-02 19:35:31 +00:00
break ;
2004-07-02 19:26:51 +00:00
case 0 :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
flags | = par - > codec_tag < < 4 ;
2004-07-02 19:26:51 +00:00
break ;
default :
2012-09-06 13:10:21 +00:00
av_log ( s , AV_LOG_ERROR , " Audio codec '%s' not compatible with FLV \n " ,
2016-04-10 19:58:15 +00:00
avcodec_get_name ( par - > codec_id ) ) ;
2012-09-06 12:54:57 +00:00
return AVERROR ( EINVAL ) ;
2004-07-02 19:26:51 +00:00
}
2005-12-17 18:14:38 +00:00
2004-07-02 19:26:51 +00:00
return flags ;
}
2011-02-20 10:04:12 +00:00
static void put_amf_string ( AVIOContext * pb , const char * str )
2006-07-17 21:51:21 +00:00
{
size_t len = strlen ( str ) ;
2011-02-21 18:28:17 +00:00
avio_wb16 ( pb , len ) ;
avio_write ( pb , str , len ) ;
2006-07-17 21:51:21 +00:00
}
2018-05-11 01:08:01 +00:00
// 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 ) ;
}
2023-02-06 21:25:45 +00:00
static void put_eos_tag ( AVIOContext * pb , unsigned ts , enum AVCodecID codec_id )
2012-06-27 08:16:18 +00:00
{
2023-02-06 21:25:45 +00:00
uint32_t tag = ff_codec_get_tag ( flv_video_codec_ids , codec_id ) ;
/* ub[4] FrameType = 1, ub[4] CodecId */
tag | = 1 < < 4 ;
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , FLV_TAG_TYPE_VIDEO ) ;
2012-06-27 08:16:18 +00:00
avio_wb24 ( pb , 5 ) ; /* Tag Data Size */
2018-05-11 01:08:01 +00:00
put_timestamp ( pb , ts ) ;
2012-06-27 08:16:18 +00:00
avio_wb24 ( pb , 0 ) ; /* StreamId = 0 */
2023-02-06 21:25:45 +00:00
avio_w8 ( pb , tag ) ;
2012-06-27 08:16:18 +00:00
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 */
2010-08-18 09:39:21 +00:00
}
2011-02-20 10:04:12 +00:00
static void put_amf_double ( AVIOContext * pb , double d )
2006-07-17 21:51:21 +00:00
{
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , AMF_DATA_TYPE_NUMBER ) ;
2011-11-27 14:04:16 +00:00
avio_wb64 ( pb , av_double2int ( d ) ) ;
2006-07-17 21:51:21 +00:00
}
2016-11-08 11:27:21 +00:00
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 ) ;
}
2012-06-27 08:16:18 +00:00
static void put_amf_bool ( AVIOContext * pb , int b )
{
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , AMF_DATA_TYPE_BOOL ) ;
avio_w8 ( pb , ! ! b ) ;
2006-12-28 12:35:22 +00:00
}
2014-11-07 21:09:10 +00:00
static void write_metadata ( AVFormatContext * s , unsigned int ts )
2003-07-09 23:10:59 +00:00
{
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2003-07-09 23:10:59 +00:00
FLVContext * flv = s - > priv_data ;
2016-11-26 00:52:19 +00:00
int write_duration_filesize = ! ( flv - > flags & FLV_NO_DURATION_FILESIZE ) ;
2014-11-17 12:08:05 +00:00
int metadata_count = 0 ;
2016-11-08 11:27:21 +00:00
int64_t metadata_count_pos ;
2022-11-26 14:46:36 +00:00
const AVDictionaryEntry * tag = NULL ;
2003-07-09 23:10:59 +00:00
2006-07-17 21:51:21 +00:00
/* write meta_tag */
2016-11-08 11:27:21 +00:00
avio_w8 ( pb , FLV_TAG_TYPE_META ) ; // tag type META
flv - > metadata_size_pos = avio_tell ( pb ) ;
2012-06-27 08:16:18 +00:00
avio_wb24 ( pb , 0 ) ; // size of data part (sum of all parts below)
2021-11-26 16:27:18 +00:00
put_timestamp ( pb , ts ) ; // timestamp
avio_wb24 ( pb , 0 ) ; // reserved
2006-07-17 21:51:21 +00:00
/* now data of data_size size */
/* first event name as a string */
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , AMF_DATA_TYPE_STRING ) ;
2006-07-17 21:51:21 +00:00
put_amf_string ( pb , " onMetaData " ) ; // 12 bytes
/* mixed array (hash) with size and string/type/data tuples */
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , AMF_DATA_TYPE_MIXEDARRAY ) ;
2011-09-21 13:58:07 +00:00
metadata_count_pos = avio_tell ( pb ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
metadata_count = 4 * ! ! flv - > video_par +
5 * ! ! flv - > audio_par +
2016-10-12 10:11:41 +00:00
1 * ! ! flv - > data_par ;
2016-11-26 00:52:19 +00:00
if ( write_duration_filesize ) {
2016-10-12 10:11:41 +00:00
metadata_count + = 2 ; // +2 for duration and file size
}
2011-09-21 13:58:07 +00:00
avio_wb32 ( pb , metadata_count ) ;
2006-07-17 21:51:21 +00:00
2016-11-26 00:52:19 +00:00
if ( write_duration_filesize ) {
2016-10-12 10:11:41 +00:00
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 ) ;
}
2012-06-27 08:16:18 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( flv - > video_par ) {
2006-07-17 21:51:21 +00:00
put_amf_string ( pb , " width " ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_amf_double ( pb , flv - > video_par - > width ) ;
2006-07-17 21:51:21 +00:00
put_amf_string ( pb , " height " ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_amf_double ( pb , flv - > video_par - > height ) ;
2006-07-17 21:51:21 +00:00
put_amf_string ( pb , " videodatarate " ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_amf_double ( pb , flv - > video_par - > bit_rate / 1024.0 ) ;
2006-07-17 21:51:21 +00:00
2014-11-07 21:09:09 +00:00
if ( flv - > framerate ! = 0.0 ) {
2014-05-27 07:49:29 +00:00
put_amf_string ( pb , " framerate " ) ;
2014-11-07 21:09:09 +00:00
put_amf_double ( pb , flv - > framerate ) ;
2014-06-11 01:45:07 +00:00
metadata_count + + ;
2014-05-27 07:49:29 +00:00
}
2006-12-28 12:35:22 +00:00
put_amf_string ( pb , " videocodecid " ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_amf_double ( pb , flv - > video_par - > codec_tag ) ;
2006-07-17 21:51:21 +00:00
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( flv - > audio_par ) {
2009-02-02 16:10:46 +00:00
put_amf_string ( pb , " audiodatarate " ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_amf_double ( pb , flv - > audio_par - > bit_rate / 1024.0 ) ;
2009-02-02 16:10:46 +00:00
2006-07-17 21:51:21 +00:00
put_amf_string ( pb , " audiosamplerate " ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_amf_double ( pb , flv - > audio_par - > sample_rate ) ;
2006-12-28 12:35:22 +00:00
put_amf_string ( pb , " audiosamplesize " ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_amf_double ( pb , flv - > audio_par - > codec_id = = AV_CODEC_ID_PCM_U8 ? 8 : 16 ) ;
2006-12-28 12:35:22 +00:00
put_amf_string ( pb , " stereo " ) ;
2017-03-31 12:04:07 +00:00
put_amf_bool ( pb , flv - > audio_par - > ch_layout . nb_channels = = 2 ) ;
2006-12-28 12:35:22 +00:00
put_amf_string ( pb , " audiocodecid " ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_amf_double ( pb , flv - > audio_par - > codec_tag ) ;
2006-07-17 21:51:21 +00:00
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( flv - > data_par ) {
2012-05-09 21:35:58 +00:00
put_amf_string ( pb , " datastream " ) ;
put_amf_double ( pb , 0.0 ) ;
}
2016-02-28 02:11:34 +00:00
ff_standardize_creation_time ( s ) ;
2022-11-26 14:46:36 +00:00
while ( ( tag = av_dict_iterate ( s - > metadata , tag ) ) ) {
2011-10-06 01:20:57 +00:00
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 " )
2015-01-03 22:03:55 +00:00
| | ! 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 " )
2011-10-06 01:20:57 +00:00
) {
2012-09-06 13:10:21 +00:00
av_log ( s , AV_LOG_DEBUG , " Ignoring metadata for %s \n " , tag - > key ) ;
2011-10-06 01:20:57 +00:00
continue ;
}
2010-09-10 23:29:07 +00:00
put_amf_string ( pb , tag - > key ) ;
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , AMF_DATA_TYPE_STRING ) ;
2010-09-10 23:29:07 +00:00
put_amf_string ( pb , tag - > value ) ;
2011-09-21 13:58:07 +00:00
metadata_count + + ;
2010-09-10 23:29:07 +00:00
}
2016-11-26 00:52:19 +00:00
if ( write_duration_filesize ) {
2016-10-12 10:11:41 +00:00
put_amf_string ( pb , " filesize " ) ;
flv - > filesize_offset = avio_tell ( pb ) ;
put_amf_double ( pb , 0 ) ; // delayed write
}
2006-07-17 21:51:21 +00:00
2016-11-08 11:27:21 +00:00
if ( flv - > flags & FLV_ADD_KEYFRAME_INDEX ) {
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 ) ;
}
2006-07-17 21:51:21 +00:00
put_amf_string ( pb , " " ) ;
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , AMF_END_OF_OBJECT ) ;
2006-07-17 21:51:21 +00:00
/* write total size of tag */
2016-11-08 11:27:21 +00:00
flv - > metadata_totalsize = avio_tell ( pb ) - flv - > metadata_size_pos - 10 ;
2011-09-21 13:58:07 +00:00
avio_seek ( pb , metadata_count_pos , SEEK_SET ) ;
avio_wb32 ( pb , metadata_count ) ;
2016-11-08 11:27:21 +00:00
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 ) ;
2014-11-07 21:09:09 +00:00
}
2015-03-03 13:39:26 +00:00
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 ) ;
}
2018-04-26 20:46:28 +00:00
static void flv_write_codec_header ( AVFormatContext * s , AVCodecParameters * par , int64_t ts ) {
2016-06-10 02:12:09 +00:00
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
2018-04-26 20:46:28 +00:00
put_timestamp ( pb , ts ) ;
2016-06-10 02:12:09 +00:00
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
2016-09-14 00:31:11 +00:00
if ( ! par - > extradata_size & & ( flv - > flags & FLV_AAC_SEQ_HEADER_DETECT ) ) {
2016-06-10 02:12:09 +00:00
PutBitContext pbc ;
int samplerate_index ;
2023-04-06 19:31:40 +00:00
int channels = par - > ch_layout . nb_channels
- ( par - > ch_layout . nb_channels = = 8 ? 1 : 0 ) ;
2016-06-10 02:12:09 +00:00
uint8_t data [ 2 ] ;
for ( samplerate_index = 0 ; samplerate_index < 16 ;
samplerate_index + + )
2023-04-06 19:31:40 +00:00
if ( par - > sample_rate
2021-02-10 18:37:37 +00:00
= = ff_mpeg4audio_sample_rates [ samplerate_index ] )
2016-06-10 02:12:09 +00:00
break ;
init_put_bits ( & pbc , data , sizeof ( data ) ) ;
2023-04-06 19:31:40 +00:00
put_bits ( & pbc , 5 , par - > profile + 1 ) ; //profile
2016-06-10 02:12:09 +00:00
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
}
}
2016-11-08 11:27:21 +00:00
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 )
{
2021-12-11 18:00:06 +00:00
int ret ;
2016-11-08 11:27:21 +00:00
int64_t metadata_size = 0 ;
FLVContext * flv = s - > priv_data ;
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 ;
2021-12-11 18:00:06 +00:00
ret = ff_format_shift_data ( s , flv - > keyframes_info_offset , metadata_size ) ;
if ( ret < 0 )
return ret ;
2016-11-08 11:27:21 +00:00
avio_seek ( s - > pb , flv - > metadata_size_pos , SEEK_SET ) ;
avio_wb24 ( s - > pb , flv - > metadata_totalsize + metadata_size ) ;
2021-12-11 18:00:06 +00:00
avio_seek ( s - > pb , flv - > metadata_totalsize_pos + metadata_size , SEEK_SET ) ;
2016-11-08 11:27:21 +00:00
avio_wb32 ( s - > pb , flv - > metadata_totalsize + 11 + metadata_size ) ;
2021-12-11 18:00:06 +00:00
return 0 ;
2016-11-08 11:27:21 +00:00
}
2019-06-22 08:50:31 +00:00
static int flv_init ( struct AVFormatContext * s )
2014-11-07 21:09:09 +00:00
{
int i ;
FLVContext * flv = s - > priv_data ;
2023-04-07 14:56:38 +00:00
if ( s - > nb_streams > FLV_STREAM_TYPE_NB ) {
av_log ( s , AV_LOG_ERROR , " invalid number of streams %d \n " ,
s - > nb_streams ) ;
return AVERROR ( EINVAL ) ;
}
2014-11-07 21:09:09 +00:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVCodecParameters * par = s - > streams [ i ] - > codecpar ;
2023-04-07 14:56:38 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
switch ( par - > codec_type ) {
2014-11-07 21:09:09 +00:00
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 ) ;
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( flv - > video_par ) {
2014-11-07 21:09:09 +00:00
av_log ( s , AV_LOG_ERROR ,
" at most one video stream is supported in flv \n " ) ;
return AVERROR ( EINVAL ) ;
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
flv - > video_par = par ;
if ( ! ff_codec_get_tag ( flv_video_codec_ids , par - > codec_id ) )
return unsupported_codec ( s , " Video " , par - > codec_id ) ;
2015-03-04 19:42:33 +00:00
2016-04-10 19:58:15 +00:00
if ( par - > codec_id = = AV_CODEC_ID_MPEG4 | |
par - > codec_id = = AV_CODEC_ID_H263 ) {
2014-11-17 11:43:55 +00:00
int error = s - > strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL ;
av_log ( s , error ? AV_LOG_ERROR : AV_LOG_WARNING ,
2016-04-10 19:58:15 +00:00
" Codec %s is not supported in the official FLV specification, \n " , avcodec_get_name ( par - > codec_id ) ) ;
2014-11-17 11:43:55 +00:00
if ( error ) {
av_log ( s , AV_LOG_ERROR ,
" use vstrict=-1 / -strict -1 to use it anyway. \n " ) ;
return AVERROR ( EINVAL ) ;
}
2016-04-10 19:58:15 +00:00
} else if ( par - > codec_id = = AV_CODEC_ID_VP6 ) {
2014-11-23 12:22:27 +00:00
av_log ( s , AV_LOG_WARNING ,
" Muxing VP6 in flv will produce flipped video on playback. \n " ) ;
2014-11-07 21:09:09 +00:00
}
break ;
case AVMEDIA_TYPE_AUDIO :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( flv - > audio_par ) {
2014-11-07 21:09:09 +00:00
av_log ( s , AV_LOG_ERROR ,
" at most one audio stream is supported in flv \n " ) ;
return AVERROR ( EINVAL ) ;
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
flv - > audio_par = par ;
if ( get_audio_flags ( s , par ) < 0 )
return unsupported_codec ( s , " Audio " , par - > codec_id ) ;
2016-04-10 19:58:15 +00:00
if ( par - > codec_id = = AV_CODEC_ID_PCM_S16BE )
2014-11-17 11:43:55 +00:00
av_log ( s , AV_LOG_WARNING ,
" 16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le \n " ) ;
2014-11-07 21:09:09 +00:00
break ;
case AVMEDIA_TYPE_DATA :
2016-04-10 19:58:15 +00:00
if ( par - > codec_id ! = AV_CODEC_ID_TEXT & & par - > codec_id ! = AV_CODEC_ID_NONE )
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
return unsupported_codec ( s , " Data " , par - > codec_id ) ;
flv - > data_par = par ;
2014-11-07 21:09:09 +00:00
break ;
2015-01-20 22:55:09 +00:00
case AVMEDIA_TYPE_SUBTITLE :
2016-04-10 19:58:15 +00:00
if ( par - > codec_id ! = AV_CODEC_ID_TEXT ) {
2015-01-20 22:55:09 +00:00
av_log ( s , AV_LOG_ERROR , " Subtitle codec '%s' for stream %d is not compatible with FLV \n " ,
2016-04-10 19:58:15 +00:00
avcodec_get_name ( par - > codec_id ) , i ) ;
2015-01-20 22:55:09 +00:00
return AVERROR_INVALIDDATA ;
}
2016-04-10 19:58:15 +00:00
flv - > data_par = par ;
2015-01-20 22:55:09 +00:00
break ;
2014-11-07 21:09:09 +00:00
default :
2014-11-17 11:43:55 +00:00
av_log ( s , AV_LOG_ERROR , " Codec type '%s' for stream %d is not compatible with FLV \n " ,
2016-04-10 19:58:15 +00:00
av_get_media_type_string ( par - > codec_type ) , i ) ;
2014-11-17 11:43:55 +00:00
return AVERROR ( EINVAL ) ;
2014-11-07 21:09:09 +00:00
}
avpriv_set_pts_info ( s - > streams [ i ] , 32 , 1 , 1000 ) ; /* 32 bit pts in ms */
2023-04-07 14:56:38 +00:00
flv - > last_ts [ i ] = - 1 ;
2014-11-07 21:09:09 +00:00
}
flv - > delay = AV_NOPTS_VALUE ;
2019-06-22 08:50:31 +00:00
return 0 ;
}
static int flv_write_header ( AVFormatContext * s )
{
int i ;
AVIOContext * pb = s - > pb ;
FLVContext * flv = s - > priv_data ;
2014-11-07 21:09:09 +00:00
avio_write ( pb , " FLV " , 3 ) ;
avio_w8 ( pb , 1 ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
avio_w8 ( pb , FLV_HEADER_FLAG_HASAUDIO * ! ! flv - > audio_par +
FLV_HEADER_FLAG_HASVIDEO * ! ! flv - > video_par ) ;
2014-11-07 21:09:09 +00:00
avio_wb32 ( pb , 9 ) ;
avio_wb32 ( pb , 0 ) ;
for ( i = 0 ; i < s - > nb_streams ; i + + )
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( s - > streams [ i ] - > codecpar - > codec_tag = = 5 ) {
2014-11-07 21:09:09 +00:00
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 ;
}
2016-11-21 12:26:11 +00:00
if ( flv - > flags & FLV_NO_METADATA ) {
pb - > seekable = 0 ;
} else {
write_metadata ( s , 0 ) ;
}
2006-07-17 21:51:21 +00:00
2008-05-26 22:00:35 +00:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
2018-04-26 20:46:28 +00:00
flv_write_codec_header ( s , s - > streams [ i ] - > codecpar , 0 ) ;
2008-05-26 22:00:35 +00:00
}
2016-11-08 11:27:21 +00:00
flv - > datastart_offset = avio_tell ( pb ) ;
2003-07-09 23:10:59 +00:00
return 0 ;
}
static int flv_write_trailer ( AVFormatContext * s )
{
2003-07-10 23:18:09 +00:00
int64_t file_size ;
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2003-07-09 23:10:59 +00:00
FLVContext * flv = s - > priv_data ;
2016-11-08 11:27:21 +00:00
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 ) {
2019-10-23 12:59:42 +00:00
const FLVFileposition * newflv_posinfo ;
2016-11-08 11:27:21 +00:00
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 ) ;
2010-08-18 09:39:21 +00:00
2016-11-08 11:27:21 +00:00
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 ) ;
}
put_amf_string ( pb , " " ) ;
avio_w8 ( pb , AMF_END_OF_OBJECT ) ;
avio_seek ( pb , cur_pos + flv - > keyframe_index_size , SEEK_SET ) ;
}
end :
2016-09-14 02:00:52 +00:00
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 ;
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO & &
( par - > codec_id = = AV_CODEC_ID_H264 | | par - > codec_id = = AV_CODEC_ID_MPEG4 ) )
2023-04-07 14:56:38 +00:00
put_eos_tag ( pb , flv - > last_ts [ i ] , par - > codec_id ) ;
2016-09-14 02:00:52 +00:00
}
2010-08-18 09:39:21 +00:00
}
2003-07-09 23:10:59 +00:00
2011-03-03 19:11:45 +00:00
file_size = avio_tell ( pb ) ;
2006-08-06 15:29:50 +00:00
2016-11-08 11:27:21 +00:00
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 ) ;
}
2017-03-14 10:11:20 +00:00
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 ) ;
}
2016-10-12 10:11:41 +00:00
}
}
2017-03-14 10:11:20 +00:00
2003-07-09 23:10:59 +00:00
return 0 ;
}
2004-05-29 02:06:32 +00:00
static int flv_write_packet ( AVFormatContext * s , AVPacket * pkt )
2003-07-09 23:10:59 +00:00
{
2012-06-27 08:16:18 +00:00
AVIOContext * pb = s - > pb ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVCodecParameters * par = s - > streams [ pkt - > stream_index ] - > codecpar ;
2012-06-27 08:16:18 +00:00
FLVContext * flv = s - > priv_data ;
2008-05-26 22:00:35 +00:00
unsigned ts ;
2012-06-27 08:16:18 +00:00
int size = pkt - > size ;
uint8_t * data = NULL ;
2019-12-26 10:53:34 +00:00
int flags = - 1 , flags_size , ret = 0 ;
2016-11-08 11:27:21 +00:00
int64_t cur_offset = avio_tell ( pb ) ;
2003-07-09 23:10:59 +00:00
2018-07-28 13:03:50 +00:00
if ( par - > codec_type = = AVMEDIA_TYPE_AUDIO & & ! pkt - > size ) {
av_log ( s , AV_LOG_WARNING , " Empty audio Packet \n " ) ;
return AVERROR ( EINVAL ) ;
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_id = = AV_CODEC_ID_VP6F | | par - > codec_id = = AV_CODEC_ID_VP6A | |
2016-04-10 19:58:15 +00:00
par - > codec_id = = AV_CODEC_ID_VP6 | | par - > codec_id = = AV_CODEC_ID_AAC )
2012-06-27 08:16:18 +00:00
flags_size = 2 ;
2016-04-10 19:58:15 +00:00
else if ( par - > codec_id = = AV_CODEC_ID_H264 | | par - > codec_id = = AV_CODEC_ID_MPEG4 )
2012-06-27 08:16:18 +00:00
flags_size = 5 ;
2007-08-04 23:03:17 +00:00
else
2012-06-27 08:16:18 +00:00
flags_size = 1 ;
2007-08-04 23:03:17 +00:00
2016-06-10 02:12:10 +00:00
if ( par - > codec_id = = AV_CODEC_ID_AAC | | par - > codec_id = = AV_CODEC_ID_H264
| | par - > codec_id = = AV_CODEC_ID_MPEG4 ) {
2021-04-14 12:59:32 +00:00
size_t side_size ;
2016-06-10 02:12:10 +00:00
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 ) ) ) {
2019-12-10 01:41:44 +00:00
ret = ff_alloc_extradata ( par , side_size ) ;
if ( ret < 0 )
return ret ;
2016-06-10 02:12:10 +00:00
memcpy ( par - > extradata , side , side_size ) ;
2018-04-26 20:46:28 +00:00
flv_write_codec_header ( s , par , pkt - > dts ) ;
2016-06-10 02:12:10 +00:00
}
}
2014-11-07 21:09:10 +00:00
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 ) ;
}
2019-10-15 20:18:45 +00:00
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 ) ;
}
}
2014-11-07 21:09:10 +00:00
2016-01-25 12:43:40 +00:00
ts = pkt - > dts ;
2014-11-07 21:09:10 +00:00
if ( s - > event_flags & AVSTREAM_EVENT_FLAG_METADATA_UPDATED ) {
write_metadata ( s , ts ) ;
s - > event_flags & = ~ AVSTREAM_EVENT_FLAG_METADATA_UPDATED ;
}
2016-05-04 19:06:43 +00:00
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 ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
switch ( par - > codec_type ) {
2012-05-09 21:35:58 +00:00
case AVMEDIA_TYPE_VIDEO :
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , FLV_TAG_TYPE_VIDEO ) ;
2007-01-01 22:52:22 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
flags = ff_codec_get_tag ( flv_video_codec_ids , par - > codec_id ) ;
2007-01-01 22:52:22 +00:00
2010-03-31 12:29:58 +00:00
flags | = pkt - > flags & AV_PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER ;
2012-05-09 21:35:58 +00:00
break ;
case AVMEDIA_TYPE_AUDIO :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
flags = get_audio_flags ( s , par ) ;
2005-12-17 18:14:38 +00:00
2012-06-11 18:14:22 +00:00
av_assert0 ( size ) ;
2004-04-17 12:04:59 +00:00
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , FLV_TAG_TYPE_AUDIO ) ;
2012-05-09 21:35:58 +00:00
break ;
2015-01-20 22:55:09 +00:00
case AVMEDIA_TYPE_SUBTITLE :
2012-05-09 21:35:58 +00:00
case AVMEDIA_TYPE_DATA :
2011-08-27 00:42:22 +00:00
avio_w8 ( pb , FLV_TAG_TYPE_META ) ;
2012-05-09 21:35:58 +00:00
break ;
default :
return AVERROR ( EINVAL ) ;
2004-06-25 20:03:51 +00:00
}
2012-06-27 08:16:18 +00:00
2016-04-10 19:58:15 +00:00
if ( par - > codec_id = = AV_CODEC_ID_H264 | | par - > codec_id = = AV_CODEC_ID_MPEG4 ) {
2015-06-13 19:34:40 +00:00
/* check if extradata looks like mp4 formatted */
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > extradata_size > 0 & & * ( uint8_t * ) par - > extradata ! = 1 )
2012-09-06 12:54:57 +00:00
if ( ( ret = ff_avc_parse_nal_units_buf ( pkt - > data , & data , & size ) ) < 0 )
return ret ;
2016-04-10 19:58:15 +00:00
} else if ( par - > codec_id = = AV_CODEC_ID_AAC & & pkt - > size > 2 & &
2012-03-12 19:36:51 +00:00
( AV_RB16 ( pkt - > data ) & 0xfff0 ) = = 0xfff0 ) {
2013-03-26 14:16:07 +00:00
if ( ! s - > streams [ pkt - > stream_index ] - > nb_frames ) {
2019-11-02 11:59:45 +00:00
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 ;
2013-03-26 14:16:07 +00:00
}
av_log ( s , AV_LOG_WARNING , " aac bitstream error \n " ) ;
2008-05-26 22:00:35 +00:00
}
2012-06-27 08:16:18 +00:00
2011-10-19 17:20:15 +00:00
/* check Speex packet duration */
2023-04-07 14:56:38 +00:00
if ( par - > codec_id = = AV_CODEC_ID_SPEEX & & ts - flv - > last_ts [ pkt - > stream_index ] > 160 )
2011-10-19 17:20:15 +00:00
av_log ( s , AV_LOG_WARNING , " Warning: Speex stream has more than "
" 8 frames per packet. Adobe Flash "
" Player cannot handle this! \n " ) ;
2023-04-07 14:56:38 +00:00
if ( flv - > last_ts [ pkt - > stream_index ] < ts )
flv - > last_ts [ pkt - > stream_index ] = ts ;
2011-10-19 17:20:15 +00:00
2014-11-02 23:28:06 +00:00
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 ) ;
2019-12-26 10:53:35 +00:00
ret = AVERROR ( EINVAL ) ;
goto fail ;
2014-11-02 23:28:06 +00:00
}
2012-06-27 08:16:18 +00:00
avio_wb24 ( pb , size + flags_size ) ;
2018-05-11 01:08:01 +00:00
put_timestamp ( pb , ts ) ;
2012-06-27 08:16:18 +00:00
avio_wb24 ( pb , flv - > reserved ) ;
2011-08-27 00:42:22 +00:00
2016-04-10 19:58:15 +00:00
if ( par - > codec_type = = AVMEDIA_TYPE_DATA | |
par - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
2012-05-09 21:35:58 +00:00
int data_size ;
2013-12-19 06:38:15 +00:00
int64_t metadata_size_pos = avio_tell ( pb ) ;
2016-04-10 19:58:15 +00:00
if ( par - > codec_id = = AV_CODEC_ID_TEXT ) {
2014-09-30 04:06:38 +00:00
// 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 ) ;
}
2012-05-09 21:35:58 +00:00
/* 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 {
2012-08-30 03:20:51 +00:00
av_assert1 ( flags > = 0 ) ;
2012-06-27 08:16:18 +00:00
avio_w8 ( pb , flags ) ;
2016-04-10 19:58:15 +00:00
if ( par - > codec_id = = AV_CODEC_ID_VP6 )
2013-10-31 00:24:07 +00:00
avio_w8 ( pb , 0 ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
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 ] ) ;
2013-08-15 08:07:30 +00:00
else
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
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 )
2012-06-27 08:16:18 +00:00
avio_w8 ( pb , 1 ) ; // AAC raw
2016-04-10 19:58:15 +00:00
else if ( par - > codec_id = = AV_CODEC_ID_H264 | | par - > codec_id = = AV_CODEC_ID_MPEG4 ) {
2012-06-27 08:16:18 +00:00
avio_w8 ( pb , 1 ) ; // AVC NALU
avio_wb24 ( pb , pkt - > pts - pkt - > dts ) ;
}
2009-01-16 01:22:30 +00:00
2012-06-27 08:16:18 +00:00
avio_write ( pb , data ? data : pkt - > data , size ) ;
2009-01-16 01:22:30 +00:00
2012-06-27 08:16:18 +00:00
avio_wb32 ( pb , size + flags_size + 11 ) ; // previous tag size
flv - > duration = FFMAX ( flv - > duration ,
pkt - > pts + flv - > delay + pkt - > duration ) ;
2012-05-09 21:35:58 +00:00
}
2009-01-16 01:22:30 +00:00
2016-11-08 11:27:21 +00:00
if ( flv - > flags & FLV_ADD_KEYFRAME_INDEX ) {
switch ( par - > codec_type ) {
case AVMEDIA_TYPE_VIDEO :
flv - > videosize + = ( avio_tell ( pb ) - cur_offset ) ;
2022-07-29 04:43:08 +00:00
flv - > lasttimestamp = pkt - > dts / 1000.0 ;
2016-11-08 11:27:21 +00:00
if ( pkt - > flags & AV_PKT_FLAG_KEY ) {
2022-07-29 04:43:10 +00:00
flv - > lastkeyframetimestamp = flv - > lasttimestamp ;
flv - > lastkeyframelocation = cur_offset ;
ret = flv_append_keyframe_info ( s , flv , flv - > lasttimestamp , cur_offset ) ;
2019-12-26 10:53:34 +00:00
if ( ret < 0 )
goto fail ;
2016-11-08 11:27:21 +00:00
}
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 ;
}
}
2019-12-26 10:53:34 +00:00
fail :
2009-01-16 01:22:30 +00:00
av_free ( data ) ;
2019-12-26 10:53:34 +00:00
return ret ;
2003-07-09 23:10:59 +00:00
}
2021-11-18 20:48:49 +00:00
static int flv_check_bitstream ( AVFormatContext * s , AVStream * st ,
const AVPacket * pkt )
2019-06-22 08:50:31 +00:00
{
if ( st - > codecpar - > codec_id = = AV_CODEC_ID_AAC ) {
if ( pkt - > size > 2 & & ( AV_RB16 ( pkt - > data ) & 0xfff0 ) = = 0xfff0 )
2023-03-15 16:27:51 +00:00
return ff_stream_add_bitstream_filter ( st , " aac_adtstoasc " , NULL ) ;
2019-06-22 08:50:31 +00:00
}
2023-03-15 16:27:51 +00:00
if ( ! st - > codecpar - > extradata_size & &
( st - > codecpar - > codec_id = = AV_CODEC_ID_H264 | |
st - > codecpar - > codec_id = = AV_CODEC_ID_MPEG4 ) )
return ff_stream_add_bitstream_filter ( st , " extract_extradata " , NULL ) ;
return 1 ;
2019-06-22 08:50:31 +00:00
}
2019-10-23 12:59:42 +00:00
static void flv_deinit ( AVFormatContext * s )
{
FLVContext * flv = s - > priv_data ;
FLVFileposition * filepos = flv - > head_filepositions ;
while ( filepos ) {
FLVFileposition * next = filepos - > next ;
av_free ( filepos ) ;
filepos = next ;
}
flv - > filepositions = flv - > head_filepositions = NULL ;
flv - > filepositions_count = 0 ;
}
2015-11-18 21:44:08 +00:00
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 " } ,
2016-09-13 13:59:56 +00:00
{ " 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 " } ,
2016-09-14 02:00:52 +00:00
{ " 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 " } ,
2016-11-21 12:26:11 +00:00
{ " 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 " } ,
2016-11-26 00:52:19 +00:00
{ " 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 " } ,
2016-11-08 11:27:21 +00:00
{ " 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 " } ,
2015-11-18 21:44:08 +00:00
{ NULL } ,
} ;
static const AVClass flv_muxer_class = {
. class_name = " flv muxer " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2023-01-27 14:06:00 +00:00
const FFOutputFormat ff_flv_muxer = {
. p . name = " flv " ,
. p . long_name = NULL_IF_CONFIG_SMALL ( " FLV (Flash Video) " ) ,
. p . mime_type = " video/x-flv " ,
. p . extensions = " flv " ,
2011-07-16 20:18:12 +00:00
. priv_data_size = sizeof ( FLVContext ) ,
2023-01-27 14:06:00 +00:00
. p . audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF ,
. p . video_codec = AV_CODEC_ID_FLV1 ,
2019-06-22 08:50:31 +00:00
. init = flv_init ,
2011-07-16 20:18:12 +00:00
. write_header = flv_write_header ,
. write_packet = flv_write_packet ,
. write_trailer = flv_write_trailer ,
2019-10-23 12:59:42 +00:00
. deinit = flv_deinit ,
2019-06-22 08:50:31 +00:00
. check_bitstream = flv_check_bitstream ,
2023-01-27 14:06:00 +00:00
. p . codec_tag = ( const AVCodecTag * const [ ] ) {
2012-06-27 08:16:18 +00:00
flv_video_codec_ids , flv_audio_codec_ids , 0
} ,
2023-01-27 14:06:00 +00:00
. p . flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
2011-05-26 18:19:04 +00:00
AVFMT_TS_NONSTRICT ,
2023-01-27 14:06:00 +00:00
. p . priv_class = & flv_muxer_class ,
2003-07-09 23:10:59 +00:00
} ;