2001-07-22 16:18:56 +02:00
/*
2006-10-23 10:57:54 +02:00
* AVI muxer
2009-01-19 16:46:40 +01:00
* Copyright ( c ) 2000 Fabrice Bellard
2001-07-22 16:18:56 +02:00
*
2006-10-07 17:30:46 +02:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2002-05-26 00:34:32 +02:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 17:30:46 +02:00
* version 2.1 of the License , or ( at your option ) any later version .
2001-07-22 16:18:56 +02:00
*
2006-10-07 17:30:46 +02:00
* FFmpeg is distributed in the hope that it will be useful ,
2001-07-22 16:18:56 +02:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
2002-05-26 00:34:32 +02:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
2001-07-22 16:18:56 +02:00
*
2002-05-26 00:34:32 +02:00
* You should have received a copy of the GNU Lesser General Public
2006-10-07 17:30:46 +02:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-12 23:43:26 +01:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2001-07-22 16:18:56 +02:00
*/
2012-10-31 13:55:00 +01:00
//#define DEBUG
2017-01-25 09:53:03 +01:00
# include <math.h>
2001-07-22 16:18:56 +02:00
# include "avformat.h"
2011-11-29 19:28:15 +01:00
# include "internal.h"
2001-07-22 16:18:56 +02:00
# include "avi.h"
2011-02-24 07:36:02 +01:00
# include "avio_internal.h"
2006-07-12 02:09:34 +02:00
# include "riff.h"
2014-05-23 16:20:22 +02:00
# include "mpegts.h"
2013-11-09 20:26:00 +01:00
# include "libavformat/avlanguage.h"
# include "libavutil/avstring.h"
2017-01-25 09:53:03 +01:00
# include "libavutil/avutil.h"
2015-08-18 02:45:35 +02:00
# include "libavutil/internal.h"
2010-02-06 13:32:44 +01:00
# include "libavutil/intreadwrite.h"
2011-05-22 12:46:29 +02:00
# include "libavutil/dict.h"
2012-06-17 17:10:05 +02:00
# include "libavutil/avassert.h"
2012-10-31 13:55:00 +01:00
# include "libavutil/timestamp.h"
2015-09-10 14:04:18 +02:00
# include "libavutil/opt.h"
2014-04-11 23:35:11 +02:00
# include "libavutil/pixdesc.h"
# include "libavcodec/raw.h"
2001-07-22 16:18:56 +02:00
/*
2005-12-17 19:14:38 +01:00
* TODO :
2001-07-22 16:18:56 +02:00
* - fill all fields if non streamed ( nb_frames for example )
*/
2003-04-23 04:04:40 +02:00
typedef struct AVIIentry {
2016-03-12 16:18:36 +01:00
char tag [ 4 ] ;
unsigned int flags ;
unsigned int pos ;
unsigned int len ;
2003-04-23 04:04:40 +02:00
} AVIIentry ;
# define AVI_INDEX_CLUSTER_SIZE 16384
2017-01-25 09:53:03 +01:00
# define AVI_MASTER_INDEX_PREFIX_SIZE (8+2+1+1+4+8+4+4)
# define AVI_MASTER_INDEX_ENTRY_SIZE 16 /* bytes per entry */
# define AVI_MASTER_INDEX_SIZE_DEFAULT 256 /* number of entries */
2003-04-23 04:04:40 +02:00
typedef struct AVIIndex {
2008-10-03 12:16:29 +02:00
int64_t indx_start ;
2015-03-03 13:29:05 +01:00
int64_t audio_strm_offset ;
2003-04-23 04:04:40 +02:00
int entry ;
int ents_allocated ;
2015-03-19 16:40:12 +01:00
int master_odml_riff_id_base ;
2003-04-23 04:04:40 +02:00
AVIIentry * * cluster ;
2001-07-22 16:18:56 +02:00
} AVIIndex ;
2014-09-22 09:19:33 +02:00
typedef struct AVIContext {
2015-09-10 14:04:18 +02:00
const AVClass * class ;
2008-10-03 12:16:29 +02:00
int64_t riff_start , movi_list , odml_list ;
2010-01-28 03:45:17 +01:00
int64_t frames_hdr_all ;
2003-04-23 04:04:40 +02:00
int riff_id ;
2017-01-25 09:53:03 +01:00
int reserve_index_space ;
int master_index_max_size ;
2015-09-10 14:04:18 +02:00
int write_channel_mask ;
2001-07-22 16:18:56 +02:00
} AVIContext ;
2014-09-22 09:19:33 +02:00
typedef struct AVIStream {
2010-01-28 03:45:17 +01:00
int64_t frames_hdr_strm ;
2013-04-11 16:57:24 +02:00
int64_t audio_strm_length ;
2010-01-28 03:45:17 +01:00
int packet_count ;
2010-01-28 04:37:22 +01:00
int entry ;
2014-05-19 00:05:40 +02:00
int max_size ;
2015-03-03 13:29:05 +01:00
int sample_requested ;
2010-01-28 03:45:17 +01:00
2014-11-19 19:59:44 +01:00
int64_t last_dts ;
2010-01-28 03:45:17 +01:00
AVIIndex indexes ;
2016-03-05 12:16:57 +01:00
int64_t strh_flags_offset ;
uint32_t palette [ AVPALETTE_COUNT ] ;
uint32_t old_palette [ AVPALETTE_COUNT ] ;
int64_t pal_offset ;
2014-02-28 19:58:20 +01:00
} AVIStream ;
2010-01-28 03:45:17 +01:00
2016-02-17 13:37:13 +01:00
static int avi_write_packet_internal ( AVFormatContext * s , AVPacket * pkt ) ;
2014-11-19 19:30:49 +01:00
2014-09-24 18:33:55 +02:00
static inline AVIIentry * avi_get_ientry ( const AVIIndex * idx , int ent_id )
2003-04-23 04:04:40 +02:00
{
int cl = ent_id / AVI_INDEX_CLUSTER_SIZE ;
int id = ent_id % AVI_INDEX_CLUSTER_SIZE ;
return & idx - > cluster [ cl ] [ id ] ;
}
2016-03-12 16:18:36 +01:00
static int avi_add_ientry ( AVFormatContext * s , int stream_index , char * tag ,
unsigned int flags , unsigned int size )
{
AVIContext * avi = s - > priv_data ;
AVIOContext * pb = s - > pb ;
AVIStream * avist = s - > streams [ stream_index ] - > priv_data ;
AVIIndex * idx = & avist - > indexes ;
int cl = idx - > entry / AVI_INDEX_CLUSTER_SIZE ;
int id = idx - > entry % AVI_INDEX_CLUSTER_SIZE ;
if ( idx - > ents_allocated < = idx - > entry ) {
idx - > cluster = av_realloc_f ( idx - > cluster , sizeof ( void * ) , cl + 1 ) ;
if ( ! idx - > cluster ) {
idx - > ents_allocated = 0 ;
idx - > entry = 0 ;
return AVERROR ( ENOMEM ) ;
}
idx - > cluster [ cl ] =
av_malloc ( AVI_INDEX_CLUSTER_SIZE * sizeof ( AVIIentry ) ) ;
if ( ! idx - > cluster [ cl ] )
return AVERROR ( ENOMEM ) ;
idx - > ents_allocated + = AVI_INDEX_CLUSTER_SIZE ;
}
if ( tag )
memcpy ( idx - > cluster [ cl ] [ id ] . tag , tag , 4 ) ;
else
2016-03-13 16:09:45 +01:00
memset ( idx - > cluster [ cl ] [ id ] . tag , 0 , 4 ) ;
2016-03-12 16:18:36 +01:00
idx - > cluster [ cl ] [ id ] . flags = flags ;
idx - > cluster [ cl ] [ id ] . pos = avio_tell ( pb ) - avi - > movi_list ;
idx - > cluster [ cl ] [ id ] . len = size ;
avist - > max_size = FFMAX ( avist - > max_size , size ) ;
idx - > entry + + ;
return 0 ;
}
2017-01-25 09:53:03 +01:00
static av_cold int avi_init ( struct AVFormatContext * s )
{
AVIContext * avi = s - > priv_data ;
if ( avi - > reserve_index_space > 0 ) {
avi - > master_index_max_size = ( avi - > reserve_index_space - AVI_MASTER_INDEX_PREFIX_SIZE ) / AVI_MASTER_INDEX_ENTRY_SIZE ;
avi - > master_index_max_size = FFMAX ( avi - > master_index_max_size , 16 ) ;
} else
avi - > master_index_max_size = AVI_MASTER_INDEX_SIZE_DEFAULT ;
av_log ( s , AV_LOG_DEBUG , " reserve_index_space:%d master_index_max_size:%d \n " ,
avi - > reserve_index_space , avi - > master_index_max_size ) ;
return 1 ; /* stream initialization continues in avi_write_header */
}
2011-02-20 11:04:12 +01:00
static int64_t avi_start_new_riff ( AVFormatContext * s , AVIOContext * pb ,
2014-02-28 19:58:20 +01:00
const char * riff_tag , const char * list_tag )
2003-04-08 11:51:15 +02:00
{
2014-02-28 19:58:20 +01:00
AVIContext * avi = s - > priv_data ;
2008-10-03 12:16:29 +02:00
int64_t loff ;
2003-04-23 04:04:40 +02:00
int i ;
2005-12-17 19:14:38 +01:00
2003-04-23 04:04:40 +02:00
avi - > riff_id + + ;
2014-02-28 19:58:20 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVIStream * avist = s - > streams [ i ] - > priv_data ;
2015-03-03 13:29:05 +01:00
avist - > indexes . audio_strm_offset = avist - > audio_strm_length ;
2010-01-28 03:45:17 +01:00
avist - > indexes . entry = 0 ;
}
2005-12-17 19:14:38 +01:00
2009-06-23 01:09:34 +02:00
avi - > riff_start = ff_start_tag ( pb , " RIFF " ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , riff_tag ) ;
2009-06-23 01:09:34 +02:00
loff = ff_start_tag ( pb , " LIST " ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , list_tag ) ;
2003-04-08 11:51:15 +02:00
return loff ;
}
2014-02-28 19:58:20 +01:00
static char * avi_stream2fourcc ( char * tag , int index , enum AVMediaType type )
2003-04-23 04:04:40 +02:00
{
2014-02-28 19:58:20 +01:00
tag [ 0 ] = ' 0 ' + index / 10 ;
tag [ 1 ] = ' 0 ' + index % 10 ;
2010-03-31 01:30:55 +02:00
if ( type = = AVMEDIA_TYPE_VIDEO ) {
2003-04-23 04:04:40 +02:00
tag [ 2 ] = ' d ' ;
tag [ 3 ] = ' c ' ;
2010-03-31 01:30:55 +02:00
} else if ( type = = AVMEDIA_TYPE_SUBTITLE ) {
2009-06-19 15:26:10 +02:00
// note: this is not an official code
tag [ 2 ] = ' s ' ;
tag [ 3 ] = ' b ' ;
2003-04-23 04:04:40 +02:00
} else {
tag [ 2 ] = ' w ' ;
tag [ 3 ] = ' b ' ;
}
tag [ 4 ] = ' \0 ' ;
return tag ;
}
2014-02-28 19:58:20 +01:00
static int avi_write_counters ( AVFormatContext * s , int riff_id )
2006-08-24 10:22:26 +02:00
{
2011-02-20 11:04:12 +01:00
AVIOContext * pb = s - > pb ;
2006-08-24 10:22:26 +02:00
AVIContext * avi = s - > priv_data ;
int n , au_byterate , au_ssize , au_scale , nb_frames = 0 ;
2008-10-03 12:16:29 +02:00
int64_t file_size ;
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 20:42:52 +02:00
AVCodecParameters * par ;
2006-08-24 10:22:26 +02:00
2011-03-03 20:11:45 +01:00
file_size = avio_tell ( pb ) ;
2014-02-28 19:58:20 +01:00
for ( n = 0 ; n < s - > nb_streams ; n + + ) {
AVIStream * avist = s - > streams [ n ] - > priv_data ;
2010-01-28 03:45:17 +01:00
2012-06-17 17:10:05 +02:00
av_assert0 ( avist - > frames_hdr_strm ) ;
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 20:42:52 +02:00
par = s - > streams [ n ] - > codecpar ;
2011-02-28 14:57:54 +01:00
avio_seek ( pb , avist - > frames_hdr_strm , SEEK_SET ) ;
2014-05-30 07:17:28 +02:00
ff_parse_specific_params ( s - > streams [ n ] , & au_byterate , & au_ssize , & au_scale ) ;
2014-02-28 19:58:20 +01:00
if ( au_ssize = = 0 )
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , avist - > packet_count ) ;
2014-02-28 19:58:20 +01:00
else
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , avist - > audio_strm_length / au_ssize ) ;
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 20:42:52 +02:00
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO )
2010-01-28 03:45:17 +01:00
nb_frames = FFMAX ( nb_frames , avist - > packet_count ) ;
2006-08-24 10:22:26 +02:00
}
2014-02-28 19:58:20 +01:00
if ( riff_id = = 1 ) {
2012-06-17 17:10:05 +02:00
av_assert0 ( avi - > frames_hdr_all ) ;
2011-02-28 14:57:54 +01:00
avio_seek ( pb , avi - > frames_hdr_all , SEEK_SET ) ;
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , nb_frames ) ;
2006-08-24 10:22:26 +02:00
}
2011-02-28 14:57:54 +01:00
avio_seek ( pb , file_size , SEEK_SET ) ;
2006-08-24 10:22:26 +02:00
return 0 ;
}
2015-03-19 03:02:42 +01:00
static void write_odml_master ( AVFormatContext * s , int stream_index )
{
AVIOContext * pb = s - > pb ;
2017-01-25 09:53:03 +01:00
AVIContext * avi = s - > priv_data ;
2015-03-19 03:02:42 +01:00
AVStream * st = s - > streams [ stream_index ] ;
2016-04-10 21:58:15 +02:00
AVCodecParameters * par = st - > codecpar ;
2015-03-19 03:02:42 +01:00
AVIStream * avist = st - > priv_data ;
unsigned char tag [ 5 ] ;
int j ;
/* Starting to lay out AVI OpenDML master index.
* We want to make it JUNK entry for now , since we ' d
* like to get away without making AVI an OpenDML one
* for compatibility reasons . */
avist - > indexes . indx_start = ff_start_tag ( pb , " JUNK " ) ;
avio_wl16 ( pb , 4 ) ; /* wLongsPerEntry */
avio_w8 ( pb , 0 ) ; /* bIndexSubType (0 == frame index) */
avio_w8 ( pb , 0 ) ; /* bIndexType (0 == AVI_INDEX_OF_INDEXES) */
avio_wl32 ( pb , 0 ) ; /* nEntriesInUse (will fill out later on) */
2016-04-10 21:58:15 +02:00
ffio_wfourcc ( pb , avi_stream2fourcc ( tag , stream_index , par - > codec_type ) ) ;
2015-03-19 03:02:42 +01:00
/* dwChunkId */
avio_wl64 ( pb , 0 ) ; /* dwReserved[3] */
2015-03-19 16:37:16 +01:00
avio_wl32 ( pb , 0 ) ; /* Must be 0. */
2017-01-25 09:53:03 +01:00
for ( j = 0 ; j < avi - > master_index_max_size * 2 ; j + + )
2015-03-19 03:02:42 +01:00
avio_wl64 ( pb , 0 ) ;
ff_end_tag ( pb , avist - > indexes . indx_start ) ;
}
2001-07-22 16:18:56 +02:00
static int avi_write_header ( AVFormatContext * s )
{
2002-05-20 18:31:13 +02:00
AVIContext * avi = s - > priv_data ;
2011-02-20 11:04:12 +01:00
AVIOContext * pb = s - > pb ;
2002-03-01 23:28:30 +01:00
int bitrate , n , i , nb_frames , au_byterate , au_ssize , au_scale ;
2017-01-25 09:53:03 +01:00
int64_t max_stream_duration = 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 20:42:52 +02:00
AVCodecParameters * video_par ;
2014-05-18 12:12:59 +02:00
AVStream * video_st = NULL ;
2008-10-03 12:16:29 +02:00
int64_t list1 , list2 , strh , strf ;
2011-05-22 12:46:29 +02:00
AVDictionaryEntry * t = NULL ;
2014-01-24 02:22:50 +01:00
int padding ;
2001-07-22 16:18:56 +02:00
2011-02-23 16:43:21 +01:00
if ( s - > nb_streams > AVI_MAX_STREAM_COUNT ) {
av_log ( s , AV_LOG_ERROR , " AVI does not support >%d streams \n " ,
AVI_MAX_STREAM_COUNT ) ;
2012-11-16 12:02:22 +01:00
return AVERROR ( EINVAL ) ;
2011-02-23 16:43:21 +01:00
}
2014-02-28 19:58:20 +01:00
for ( n = 0 ; n < s - > nb_streams ; n + + ) {
s - > streams [ n ] - > priv_data = av_mallocz ( sizeof ( AVIStream ) ) ;
if ( ! s - > streams [ n ] - > priv_data )
2010-01-28 03:45:17 +01:00
return AVERROR ( ENOMEM ) ;
}
2001-07-22 16:18:56 +02:00
/* header list */
2003-04-23 04:04:40 +02:00
avi - > riff_id = 0 ;
2010-01-28 03:45:17 +01:00
list1 = avi_start_new_riff ( s , pb , " AVI " , " hdrl " ) ;
2001-07-22 16:18:56 +02:00
/* avi header */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " avih " ) ;
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 14 * 4 ) ;
2001-07-22 16:18:56 +02:00
bitrate = 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 20:42:52 +02:00
video_par = NULL ;
2014-02-28 19:58:20 +01:00
for ( n = 0 ; n < s - > nb_streams ; n + + ) {
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 20:42:52 +02:00
AVCodecParameters * par = s - > streams [ n ] - > codecpar ;
2017-01-25 09:53:03 +01:00
AVStream * st = s - > streams [ n ] ;
bitrate = FFMIN ( bitrate + par - > bit_rate , INT32_MAX ) ;
if ( st - > duration > 0 ) {
int64_t stream_duration = av_rescale_q ( st - > duration , st - > time_base , AV_TIME_BASE_Q ) ;
max_stream_duration = FFMAX ( stream_duration , max_stream_duration ) ;
}
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 20:42:52 +02:00
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
video_par = par ;
2017-01-25 09:53:03 +01:00
video_st = st ;
2014-05-18 12:12:59 +02:00
}
2001-07-22 16:18:56 +02:00
}
2005-12-17 19:14:38 +01:00
2017-01-25 09:53:03 +01:00
/* guess master index size based on bitrate and duration */
if ( ! avi - > reserve_index_space ) {
double duration_est , filesize_est ;
if ( s - > duration > 0 )
duration_est = ( double ) s - > duration / AV_TIME_BASE ;
else if ( max_stream_duration > 0 )
duration_est = ( double ) max_stream_duration / AV_TIME_BASE ;
else
duration_est = 10 * 60 * 60 ; /* default to 10 hours */
filesize_est = duration_est * ( bitrate / 8 ) * 1.10 ; /* add 10% safety margin for muxer+bitrate */
avi - > master_index_max_size = FFMAX ( ( int ) ceil ( filesize_est / AVI_MAX_RIFF_SIZE ) + 1 ,
avi - > master_index_max_size ) ;
av_log ( s , AV_LOG_DEBUG , " duration_est:%0.3f, filesize_est:%0.1fGiB, master_index_max_size:%d \n " ,
duration_est , filesize_est / ( 1024 * 1024 * 1024 ) , avi - > master_index_max_size ) ;
}
2001-07-22 16:18:56 +02:00
nb_frames = 0 ;
2014-05-18 12:12:59 +02:00
// TODO: should be avg_frame_rate
if ( video_st )
avio_wl32 ( pb , ( uint32_t ) ( INT64_C ( 1000000 ) * video_st - > time_base . num /
video_st - > time_base . den ) ) ;
2014-02-28 19:58:20 +01:00
else
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 0 ) ;
avio_wl32 ( pb , bitrate / 8 ) ; /* XXX: not quite exact */
avio_wl32 ( pb , 0 ) ; /* padding */
2016-09-27 16:26:37 +02:00
if ( ! ( pb - > seekable & AVIO_SEEKABLE_NORMAL ) )
2014-02-28 19:58:20 +01:00
avio_wl32 ( pb , AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED ) ; /* flags */
2005-11-13 04:32:12 +01:00
else
2014-02-28 19:58:20 +01:00
avio_wl32 ( pb , AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED ) ; /* flags */
2011-03-03 20:11:45 +01:00
avi - > frames_hdr_all = avio_tell ( pb ) ; /* remember this offset to fill later */
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , nb_frames ) ; /* nb frames, filled later */
avio_wl32 ( pb , 0 ) ; /* initial frame */
avio_wl32 ( pb , s - > nb_streams ) ; /* nb streams */
avio_wl32 ( pb , 1024 * 1024 ) ; /* suggested buffer size */
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 20:42:52 +02:00
if ( video_par ) {
avio_wl32 ( pb , video_par - > width ) ;
avio_wl32 ( pb , video_par - > height ) ;
2003-01-27 03:18:41 +01:00
} else {
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 0 ) ;
avio_wl32 ( pb , 0 ) ;
2005-12-17 19:14:38 +01:00
}
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 0 ) ; /* reserved */
avio_wl32 ( pb , 0 ) ; /* reserved */
avio_wl32 ( pb , 0 ) ; /* reserved */
avio_wl32 ( pb , 0 ) ; /* reserved */
2005-12-17 19:14:38 +01:00
2001-07-22 16:18:56 +02:00
/* stream list */
2014-02-28 19:58:20 +01:00
for ( i = 0 ; i < n ; i + + ) {
2014-05-11 10:07:35 +02:00
AVStream * st = s - > 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 20:42:52 +02:00
AVCodecParameters * par = st - > codecpar ;
2014-05-11 10:07:35 +02:00
AVIStream * avist = st - > priv_data ;
2009-06-23 01:09:34 +02:00
list2 = ff_start_tag ( pb , " LIST " ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " strl " ) ;
2005-12-17 19:14:38 +01:00
2001-07-22 16:18:56 +02:00
/* stream generic header */
2009-06-23 01:09:34 +02:00
strh = ff_start_tag ( pb , " strh " ) ;
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 20:42:52 +02:00
switch ( par - > codec_type ) {
2010-03-31 01:30:55 +02:00
case AVMEDIA_TYPE_SUBTITLE :
2009-06-19 15:26:10 +02:00
// XSUB subtitles behave like video tracks, other subtitles
// are not (yet) supported.
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 20:42:52 +02:00
if ( par - > codec_id ! = AV_CODEC_ID_XSUB ) {
2015-12-16 18:01:34 +01:00
avpriv_report_missing_feature ( s , " Subtitle streams other than DivX XSUB " ) ;
2010-06-25 06:29:02 +02:00
return AVERROR_PATCHWELCOME ;
}
2014-02-28 19:58:20 +01:00
case AVMEDIA_TYPE_VIDEO :
ffio_wfourcc ( pb , " vids " ) ;
break ;
case AVMEDIA_TYPE_AUDIO :
ffio_wfourcc ( pb , " auds " ) ;
break ;
// case AVMEDIA_TYPE_TEXT:
// ffio_wfourcc(pb, "txts");
// break;
case AVMEDIA_TYPE_DATA :
ffio_wfourcc ( pb , " dats " ) ;
break ;
2001-07-22 16:18:56 +02: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 20:42:52 +02:00
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO | |
par - > codec_id = = AV_CODEC_ID_XSUB )
avio_wl32 ( pb , par - > codec_tag ) ;
2005-06-03 10:50:46 +02:00
else
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 1 ) ;
2016-03-05 18:38:40 +01:00
avist - > strh_flags_offset = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 0 ) ; /* flags */
avio_wl16 ( pb , 0 ) ; /* priority */
avio_wl16 ( pb , 0 ) ; /* language */
avio_wl32 ( pb , 0 ) ; /* initial frame */
2005-06-03 10:50:46 +02:00
2014-05-30 07:17:28 +02:00
ff_parse_specific_params ( st , & au_byterate , & au_ssize , & au_scale ) ;
2005-06-03 10:50:46 +02:00
2016-04-10 21:58:15 +02:00
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO
& & par - > codec_id ! = AV_CODEC_ID_XSUB
2012-11-01 19:54:47 +01:00
& & au_byterate > 1000LL * au_scale ) {
au_byterate = 600 ;
au_scale = 1 ;
}
2014-05-18 14:14:33 +02:00
avpriv_set_pts_info ( st , 64 , au_scale , au_byterate ) ;
2016-04-10 21:58:15 +02:00
if ( par - > codec_id = = AV_CODEC_ID_XSUB )
2012-05-27 22:45:52 +02:00
au_scale = au_byterate = 0 ;
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , au_scale ) ; /* scale */
avio_wl32 ( pb , au_byterate ) ; /* rate */
2005-06-03 10:50:46 +02:00
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 0 ) ; /* start */
2014-02-28 19:58:20 +01:00
/* remember this offset to fill later */
avist - > frames_hdr_strm = avio_tell ( pb ) ;
2016-09-27 16:26:37 +02:00
if ( ! ( pb - > seekable & AVIO_SEEKABLE_NORMAL ) )
2014-02-28 19:58:20 +01:00
/* FIXME: this may be broken, but who cares */
avio_wl32 ( pb , AVI_MAX_RIFF_SIZE ) ;
2005-12-22 02:10:11 +01:00
else
2014-02-28 19:58:20 +01:00
avio_wl32 ( pb , 0 ) ; /* length, XXX: filled later */
2005-12-17 19:14:38 +01:00
2014-05-19 00:05:40 +02:00
/* suggested buffer size, is set to largest chunk size in avi_write_trailer */
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 20:42:52 +02:00
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO )
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 1024 * 1024 ) ;
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 20:42:52 +02:00
else if ( par - > codec_type = = AVMEDIA_TYPE_AUDIO )
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 12 * 1024 ) ;
2005-06-03 10:50:46 +02:00
else
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 0 ) ;
avio_wl32 ( pb , - 1 ) ; /* quality */
avio_wl32 ( pb , au_ssize ) ; /* sample size */
avio_wl32 ( 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 20:42:52 +02:00
avio_wl16 ( pb , par - > width ) ;
avio_wl16 ( pb , par - > height ) ;
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , strh ) ;
2001-07-22 16:18:56 +02: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 20:42:52 +02:00
if ( par - > codec_type ! = AVMEDIA_TYPE_DATA ) {
2015-09-10 14:04:18 +02:00
int ret , flags ;
2014-04-11 23:35:11 +02:00
enum AVPixelFormat pix_fmt ;
2014-03-04 22:17:51 +01:00
2014-02-28 19:58:20 +01:00
strf = ff_start_tag ( pb , " strf " ) ;
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 20:42:52 +02:00
switch ( par - > codec_type ) {
2014-02-28 19:58:20 +01:00
case AVMEDIA_TYPE_SUBTITLE :
/* XSUB subtitles behave like video tracks, other subtitles
* are not ( yet ) supported . */
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 20:42:52 +02:00
if ( par - > codec_id ! = AV_CODEC_ID_XSUB )
2014-02-28 19:58:20 +01:00
break ;
case AVMEDIA_TYPE_VIDEO :
2014-04-14 15:34:38 +02:00
/* WMP expects RGB 5:5:5 rawvideo in avi to have bpp set to 16. */
2016-04-10 21:58:15 +02:00
if ( ! par - > codec_tag
& & par - > codec_id = = AV_CODEC_ID_RAWVIDEO
& & par - > format = = AV_PIX_FMT_RGB555LE
& & par - > bits_per_coded_sample = = 15 )
par - > bits_per_coded_sample = 16 ;
2016-03-05 18:38:40 +01:00
avist - > pal_offset = avio_tell ( pb ) + 40 ;
2016-04-10 21:58:15 +02:00
ff_put_bmp_header ( pb , par , ff_codec_bmp_tags , 0 , 0 ) ;
2014-04-11 23:35:11 +02:00
pix_fmt = avpriv_find_pix_fmt ( avpriv_pix_fmt_bps_avi ,
2016-04-10 21:58:15 +02:00
par - > bits_per_coded_sample ) ;
if ( ! par - > codec_tag
& & par - > codec_id = = AV_CODEC_ID_RAWVIDEO
& & par - > format ! = pix_fmt
& & par - > format ! = AV_PIX_FMT_NONE )
2014-04-11 23:35:11 +02:00
av_log ( s , AV_LOG_ERROR , " %s rawvideo cannot be written to avi, output file will be unreadable \n " ,
2016-04-10 21:58:15 +02:00
av_get_pix_fmt_name ( par - > format ) ) ;
2014-02-28 19:58:20 +01:00
break ;
case AVMEDIA_TYPE_AUDIO :
2015-09-10 14:04:18 +02:00
flags = ( avi - > write_channel_mask = = 0 ) ? FF_PUT_WAV_HEADER_SKIP_CHANNELMASK : 0 ;
2016-04-10 21:58:15 +02:00
if ( ( ret = ff_put_wav_header ( s , pb , par , flags ) ) < 0 )
2014-03-04 22:17:51 +01:00
return ret ;
2014-02-28 19:58:20 +01:00
break ;
default :
2014-03-04 22:17:51 +01:00
av_log ( s , AV_LOG_ERROR ,
" Invalid or not supported codec type '%s' found in the input \n " ,
2016-04-10 21:58:15 +02:00
( char * ) av_x_if_null ( av_get_media_type_string ( par - > codec_type ) , " ? " ) ) ;
2014-03-04 22:17:51 +01:00
return AVERROR ( EINVAL ) ;
2001-09-25 01:26:46 +02:00
}
2014-02-28 19:58:20 +01:00
ff_end_tag ( pb , strf ) ;
2014-05-11 10:07:35 +02:00
if ( ( t = av_dict_get ( st - > metadata , " title " , NULL , 0 ) ) ) {
2014-02-28 19:58:20 +01:00
ff_riff_write_info_tag ( s - > pb , " strn " , t - > value ) ;
t = NULL ;
}
2016-04-10 21:58:15 +02:00
if ( par - > codec_id = = AV_CODEC_ID_XSUB
2014-03-04 22:17:51 +01:00
& & ( t = av_dict_get ( s - > streams [ i ] - > metadata , " language " , NULL , 0 ) ) ) {
2016-05-13 23:03:28 +02:00
const char * langstr = ff_convert_lang_to ( t - > value , AV_LANG_ISO639_1 ) ;
2014-03-04 22:17:51 +01:00
t = NULL ;
if ( langstr ) {
char * str = av_asprintf ( " Subtitle - %s-xx;02 " , langstr ) ;
2015-05-28 17:25:56 +02:00
if ( ! str )
return AVERROR ( ENOMEM ) ;
2014-03-04 22:17:51 +01:00
ff_riff_write_info_tag ( s - > pb , " strn " , str ) ;
av_free ( str ) ;
}
2013-11-09 20:26:00 +01:00
}
}
2005-12-17 19:14:38 +01:00
2016-09-27 16:26:37 +02:00
if ( pb - > seekable & AVIO_SEEKABLE_NORMAL ) {
2015-03-19 03:02:42 +01:00
write_odml_master ( s , i ) ;
2005-12-22 02:10:11 +01:00
}
2005-12-17 19:14:38 +01: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 20:42:52 +02:00
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO & &
2014-05-11 10:07:35 +02:00
st - > sample_aspect_ratio . num > 0 & &
st - > sample_aspect_ratio . den > 0 ) {
2014-02-28 19:58:20 +01:00
int vprp = ff_start_tag ( pb , " vprp " ) ;
2014-05-11 10:07:35 +02:00
AVRational dar = av_mul_q ( st - > sample_aspect_ratio ,
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 20:42:52 +02:00
( AVRational ) { par - > width ,
par - > height } ) ;
2008-03-02 20:51:31 +01:00
int num , den ;
av_reduce ( & num , & den , dar . num , dar . den , 0xFFFF ) ;
2014-02-28 19:58:20 +01:00
avio_wl32 ( pb , 0 ) ; // video format = unknown
avio_wl32 ( pb , 0 ) ; // video standard = unknown
2014-05-18 12:12:59 +02:00
// TODO: should be avg_frame_rate
2015-05-23 22:46:51 +02:00
avio_wl32 ( pb , ( 2LL * st - > time_base . den + st - > time_base . num - 1 ) / ( 2LL * st - > time_base . num ) ) ;
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 20:42:52 +02:00
avio_wl32 ( pb , par - > width ) ;
avio_wl32 ( pb , par - > height ) ;
2011-02-21 19:28:17 +01:00
avio_wl16 ( pb , den ) ;
avio_wl16 ( pb , num ) ;
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 20:42:52 +02:00
avio_wl32 ( pb , par - > width ) ;
avio_wl32 ( pb , par - > height ) ;
2014-02-28 19:58:20 +01:00
avio_wl32 ( pb , 1 ) ; // progressive FIXME
2011-02-21 19:28:17 +01: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 20:42:52 +02:00
avio_wl32 ( pb , par - > height ) ;
avio_wl32 ( pb , par - > width ) ;
avio_wl32 ( pb , par - > height ) ;
avio_wl32 ( pb , par - > width ) ;
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 0 ) ;
avio_wl32 ( pb , 0 ) ;
avio_wl32 ( pb , 0 ) ;
avio_wl32 ( pb , 0 ) ;
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , vprp ) ;
2008-03-02 20:51:31 +01:00
}
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , list2 ) ;
2001-07-22 16:18:56 +02:00
}
2005-12-17 19:14:38 +01:00
2016-09-27 16:26:37 +02:00
if ( pb - > seekable & AVIO_SEEKABLE_NORMAL ) {
2003-04-23 04:04:40 +02:00
/* AVI could become an OpenDML one, if it grows beyond 2Gb range */
2009-06-23 01:09:34 +02:00
avi - > odml_list = ff_start_tag ( pb , " JUNK " ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " odml " ) ;
ffio_wfourcc ( pb , " dmlh " ) ;
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , 248 ) ;
2014-02-28 19:58:20 +01:00
for ( i = 0 ; i < 248 ; i + = 4 )
avio_wl32 ( pb , 0 ) ;
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , avi - > odml_list ) ;
2003-04-23 04:04:40 +02:00
}
2001-07-22 16:18:56 +02:00
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , list1 ) ;
2005-12-17 19:14:38 +01:00
2011-11-25 20:29:12 +01:00
ff_riff_write_info ( s ) ;
2006-08-18 18:48:35 +02:00
2014-01-24 02:22:50 +01:00
padding = s - > metadata_header_padding ;
if ( padding < 0 )
padding = 1016 ;
2006-08-18 18:48:35 +02:00
/* some padding for easier tag editing */
2014-01-24 02:22:50 +01:00
if ( padding ) {
2014-01-24 03:13:47 +01:00
list2 = ff_start_tag ( pb , " JUNK " ) ;
for ( i = padding ; i > 0 ; i - = 4 )
avio_wl32 ( pb , 0 ) ;
ff_end_tag ( pb , list2 ) ;
2014-01-24 02:22:50 +01:00
}
2006-08-18 18:48:35 +02:00
2009-06-23 01:09:34 +02:00
avi - > movi_list = ff_start_tag ( pb , " LIST " ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " movi " ) ;
2001-07-22 16:18:56 +02:00
2011-03-14 20:39:06 +01:00
avio_flush ( pb ) ;
2001-07-22 16:18:56 +02:00
return 0 ;
}
2015-03-19 16:40:12 +01:00
static void update_odml_entry ( AVFormatContext * s , int stream_index , int64_t ix , int size )
2015-03-19 03:28:08 +01:00
{
AVIOContext * pb = s - > pb ;
AVIContext * avi = s - > priv_data ;
AVIStream * avist = s - > streams [ stream_index ] - > priv_data ;
int64_t pos ;
int au_byterate , au_ssize , au_scale ;
avio_flush ( pb ) ;
pos = avio_tell ( pb ) ;
/* Updating one entry in the AVI OpenDML master index */
avio_seek ( pb , avist - > indexes . indx_start - 8 , SEEK_SET ) ;
ffio_wfourcc ( pb , " indx " ) ; /* enabling this entry */
avio_skip ( pb , 8 ) ;
2015-03-19 16:40:12 +01:00
avio_wl32 ( pb , avi - > riff_id - avist - > indexes . master_odml_riff_id_base ) ; /* nEntriesInUse */
avio_skip ( pb , 16 * ( avi - > riff_id - avist - > indexes . master_odml_riff_id_base ) ) ;
2015-03-19 03:28:08 +01:00
avio_wl64 ( pb , ix ) ; /* qwOffset */
2015-03-19 16:40:12 +01:00
avio_wl32 ( pb , size ) ; /* dwSize */
2015-03-19 03:28:08 +01:00
ff_parse_specific_params ( s - > streams [ stream_index ] , & au_byterate , & au_ssize , & au_scale ) ;
2016-04-10 21:58:15 +02:00
if ( s - > streams [ stream_index ] - > codecpar - > codec_type = = AVMEDIA_TYPE_AUDIO & & au_ssize > 0 ) {
2015-03-19 03:28:08 +01:00
uint32_t audio_segm_size = ( avist - > audio_strm_length - avist - > indexes . audio_strm_offset ) ;
if ( ( audio_segm_size % au_ssize > 0 ) & & ! avist - > sample_requested ) {
avpriv_request_sample ( s , " OpenDML index duration for audio packets with partial frames " ) ;
avist - > sample_requested = 1 ;
}
avio_wl32 ( pb , audio_segm_size / au_ssize ) ; /* dwDuration (sample count) */
} else
avio_wl32 ( pb , avist - > indexes . entry ) ; /* dwDuration (packet count) */
avio_seek ( pb , pos , SEEK_SET ) ;
}
2003-04-23 04:04:40 +02:00
static int avi_write_ix ( AVFormatContext * s )
{
2011-02-20 11:04:12 +01:00
AVIOContext * pb = s - > pb ;
2003-04-23 04:04:40 +02:00
AVIContext * avi = s - > priv_data ;
2006-09-27 21:47:39 +02:00
char tag [ 5 ] ;
char ix_tag [ ] = " ix00 " ;
2003-04-23 04:04:40 +02:00
int i , j ;
2005-12-17 19:14:38 +01:00
2017-03-21 21:02:30 +01:00
av_assert0 ( pb - > seekable & AVIO_SEEKABLE_NORMAL ) ;
2005-11-13 04:32:12 +01:00
2015-03-19 16:40:12 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVIStream * avist = s - > streams [ i ] - > priv_data ;
2017-01-25 09:53:03 +01:00
if ( avi - > riff_id - avist - > indexes . master_odml_riff_id_base = = avi - > master_index_max_size ) {
2015-03-19 16:40:12 +01:00
int64_t pos ;
2017-01-25 09:53:03 +01:00
int size = AVI_MASTER_INDEX_PREFIX_SIZE + AVI_MASTER_INDEX_ENTRY_SIZE * avi - > master_index_max_size ;
2015-03-19 16:40:12 +01:00
pos = avio_tell ( pb ) ;
update_odml_entry ( s , i , pos , size ) ;
write_odml_master ( s , i ) ;
av_assert1 ( avio_tell ( pb ) - pos = = size ) ;
avist - > indexes . master_odml_riff_id_base = avi - > riff_id - 1 ;
}
2017-01-25 09:53:03 +01:00
av_assert0 ( avi - > riff_id - avist - > indexes . master_odml_riff_id_base < avi - > master_index_max_size ) ;
2012-11-16 12:02:22 +01:00
}
2005-12-17 19:14:38 +01:00
2014-02-28 19:58:20 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVIStream * avist = s - > streams [ i ] - > priv_data ;
2015-03-19 03:28:08 +01:00
int64_t ix ;
2014-02-28 19:58:20 +01: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 20:42:52 +02:00
avi_stream2fourcc ( tag , i , s - > streams [ i ] - > codecpar - > codec_type ) ;
2014-02-28 19:58:20 +01:00
ix_tag [ 3 ] = ' 0 ' + i ;
/* Writing AVI OpenDML leaf index chunk */
ix = avio_tell ( pb ) ;
ffio_wfourcc ( pb , ix_tag ) ; /* ix?? */
avio_wl32 ( pb , avist - > indexes . entry * 8 + 24 ) ;
/* chunk size */
avio_wl16 ( pb , 2 ) ; /* wLongsPerEntry */
avio_w8 ( pb , 0 ) ; /* bIndexSubType (0 == frame index) */
avio_w8 ( pb , 1 ) ; /* bIndexType (1 == AVI_INDEX_OF_CHUNKS) */
avio_wl32 ( pb , avist - > indexes . entry ) ;
/* nEntriesInUse */
ffio_wfourcc ( pb , tag ) ; /* dwChunkId */
avio_wl64 ( pb , avi - > movi_list ) ; /* qwBaseOffset */
avio_wl32 ( pb , 0 ) ; /* dwReserved_3 (must be 0) */
for ( j = 0 ; j < avist - > indexes . entry ; j + + ) {
AVIIentry * ie = avi_get_ientry ( & avist - > indexes , j ) ;
avio_wl32 ( pb , ie - > pos + 8 ) ;
avio_wl32 ( pb , ( ( uint32_t ) ie - > len & ~ 0x80000000 ) |
2005-12-22 02:10:11 +01:00
( ie - > flags & 0x10 ? 0 : 0x80000000 ) ) ;
2014-02-28 19:58:20 +01:00
}
2015-03-19 16:40:12 +01:00
update_odml_entry ( s , i , ix , avio_tell ( pb ) - ix ) ;
2003-04-23 04:04:40 +02:00
}
return 0 ;
}
static int avi_write_idx1 ( AVFormatContext * s )
2003-04-08 11:51:15 +02:00
{
2011-02-20 11:04:12 +01:00
AVIOContext * pb = s - > pb ;
2003-04-08 11:51:15 +02:00
AVIContext * avi = s - > priv_data ;
2008-10-03 12:16:29 +02:00
int64_t idx_chunk ;
2006-08-24 10:22:26 +02:00
int i ;
2006-09-27 21:47:39 +02:00
char tag [ 5 ] ;
2003-04-08 11:51:15 +02:00
2016-09-27 16:26:37 +02:00
if ( pb - > seekable & AVIO_SEEKABLE_NORMAL ) {
2010-01-28 04:37:22 +01:00
AVIStream * avist ;
2014-02-28 19:58:20 +01:00
AVIIentry * ie = 0 , * tie ;
2005-12-22 02:10:11 +01:00
int empty , stream_id = - 1 ;
2009-06-23 01:09:34 +02:00
idx_chunk = ff_start_tag ( pb , " idx1 " ) ;
2014-02-28 19:58:20 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
avist = s - > streams [ i ] - > priv_data ;
avist - > entry = 0 ;
2010-01-28 04:37:22 +01:00
}
2005-12-22 02:10:11 +01:00
do {
empty = 1 ;
2014-02-28 19:58:20 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
avist = s - > streams [ i ] - > priv_data ;
if ( avist - > indexes . entry < = avist - > entry )
continue ;
tie = avi_get_ientry ( & avist - > indexes , avist - > entry ) ;
if ( empty | | tie - > pos < ie - > pos ) {
ie = tie ;
stream_id = i ;
}
empty = 0 ;
2005-12-22 02:10:11 +01:00
}
if ( ! empty ) {
2014-02-28 19:58:20 +01:00
avist = s - > streams [ stream_id ] - > priv_data ;
2016-03-12 16:18:36 +01:00
if ( * ie - > tag )
ffio_wfourcc ( pb , ie - > tag ) ;
else {
avi_stream2fourcc ( tag , stream_id ,
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 20:42:52 +02:00
s - > streams [ stream_id ] - > codecpar - > codec_type ) ;
2016-03-12 16:18:36 +01:00
ffio_wfourcc ( pb , tag ) ;
}
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , ie - > flags ) ;
avio_wl32 ( pb , ie - > pos ) ;
avio_wl32 ( pb , ie - > len ) ;
2010-01-28 04:37:22 +01:00
avist - > entry + + ;
2005-12-22 02:10:11 +01:00
}
} while ( ! empty ) ;
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , idx_chunk ) ;
2003-04-08 11:51:15 +02:00
2006-08-24 10:22:26 +02:00
avi_write_counters ( s , avi - > riff_id ) ;
2003-04-08 11:51:15 +02:00
}
return 0 ;
}
2014-11-19 19:30:49 +01:00
static int write_skip_frames ( AVFormatContext * s , int stream_index , int64_t dts )
{
AVIStream * avist = s - > streams [ stream_index ] - > priv_data ;
2016-04-10 21:58:15 +02:00
AVCodecParameters * par = s - > streams [ stream_index ] - > codecpar ;
2014-11-19 19:30:49 +01:00
2015-08-18 02:45:35 +02:00
ff_dlog ( s , " dts:%s packet_count:%d stream_index:%d \n " , av_ts2str ( dts ) , avist - > packet_count , stream_index ) ;
2016-04-10 21:58:15 +02:00
while ( par - > block_align = = 0 & & dts ! = AV_NOPTS_VALUE & &
dts > avist - > packet_count & & par - > codec_id ! = AV_CODEC_ID_XSUB & & avist - > packet_count ) {
2014-11-19 19:30:49 +01:00
AVPacket empty_packet ;
if ( dts - avist - > packet_count > 60000 ) {
av_log ( s , AV_LOG_ERROR , " Too large number of skipped frames % " PRId64 " > 60000 \n " , dts - avist - > packet_count ) ;
return AVERROR ( EINVAL ) ;
}
av_init_packet ( & empty_packet ) ;
empty_packet . size = 0 ;
empty_packet . data = NULL ;
empty_packet . stream_index = stream_index ;
2016-02-17 13:37:13 +01:00
avi_write_packet_internal ( s , & empty_packet ) ;
2015-08-18 02:45:35 +02:00
ff_dlog ( s , " dup dts:%s packet_count:%d \n " , av_ts2str ( dts ) , avist - > packet_count ) ;
2014-11-19 19:30:49 +01:00
}
return 0 ;
}
2004-05-29 04:06:32 +02:00
static int avi_write_packet ( AVFormatContext * s , AVPacket * pkt )
2001-07-22 16:18:56 +02:00
{
2014-02-28 19:58:20 +01:00
const int stream_index = pkt - > stream_index ;
2016-04-10 21:58:15 +02:00
AVCodecParameters * par = s - > streams [ stream_index ] - > codecpar ;
2014-11-19 19:30:49 +01:00
int ret ;
2003-04-08 11:51:15 +02:00
2016-04-10 21:58:15 +02:00
if ( par - > codec_id = = AV_CODEC_ID_H264 & & par - > codec_tag = = MKTAG ( ' H ' , ' 2 ' , ' 6 ' , ' 4 ' ) & & pkt - > size ) {
2014-11-19 19:30:49 +01:00
ret = ff_check_h264_startcode ( s , s - > streams [ stream_index ] , pkt ) ;
2014-05-23 16:20:22 +02:00
if ( ret < 0 )
return ret ;
}
2004-06-15 15:49:12 +02:00
2014-11-19 19:30:49 +01:00
if ( ( ret = write_skip_frames ( s , stream_index , pkt - > dts ) ) < 0 )
return ret ;
2011-10-01 03:48:33 +02:00
2016-03-05 12:16:57 +01:00
if ( ! pkt - > size )
return avi_write_packet_internal ( s , pkt ) ; /* Passthrough */
2016-04-10 21:58:15 +02:00
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2016-03-08 11:26:32 +01:00
AVIStream * avist = s - > streams [ stream_index ] - > priv_data ;
AVIOContext * pb = s - > pb ;
AVPacket * opkt = pkt ;
2016-05-22 01:50:08 +02:00
int reshuffle_ret ;
2016-04-10 21:58:15 +02:00
if ( par - > codec_id = = AV_CODEC_ID_RAWVIDEO & & par - > codec_tag = = 0 ) {
int64_t bpc = par - > bits_per_coded_sample ! = 15 ? par - > bits_per_coded_sample : 16 ;
int expected_stride = ( ( par - > width * bpc + 31 ) > > 5 ) * 4 ;
2016-05-22 01:50:08 +02:00
reshuffle_ret = ff_reshuffle_raw_rgb ( s , & pkt , par , expected_stride ) ;
if ( reshuffle_ret < 0 )
return reshuffle_ret ;
2016-03-05 12:16:57 +01:00
} else
2016-05-22 01:50:08 +02:00
reshuffle_ret = 0 ;
2016-04-10 21:58:15 +02:00
if ( par - > format = = AV_PIX_FMT_PAL8 ) {
2016-05-22 01:54:50 +02:00
ret = ff_get_packet_palette ( s , opkt , reshuffle_ret , avist - > palette ) ;
if ( ret < 0 )
goto fail ;
if ( ret ) {
2016-04-10 21:58:15 +02:00
int pal_size = 1 < < par - > bits_per_coded_sample ;
2016-03-05 12:16:57 +01:00
int pc_tag , i ;
2016-03-05 18:18:07 +01:00
2016-04-10 21:58:15 +02:00
av_assert0 ( par - > bits_per_coded_sample > = 0 & & par - > bits_per_coded_sample < = 8 ) ;
2016-03-05 18:18:07 +01:00
2017-03-21 21:02:30 +01:00
if ( ( pb - > seekable & AVIO_SEEKABLE_NORMAL ) & & avist - > pal_offset ) {
2016-02-20 12:57:50 +01:00
int64_t cur_offset = avio_tell ( pb ) ;
avio_seek ( pb , avist - > pal_offset , SEEK_SET ) ;
for ( i = 0 ; i < pal_size ; i + + ) {
2016-03-05 12:16:57 +01:00
uint32_t v = avist - > palette [ i ] ;
2016-02-20 12:57:50 +01:00
avio_wl32 ( pb , v & 0xffffff ) ;
}
avio_seek ( pb , cur_offset , SEEK_SET ) ;
2016-03-05 12:16:57 +01:00
memcpy ( avist - > old_palette , avist - > palette , pal_size * 4 ) ;
avist - > pal_offset = 0 ;
2016-02-20 12:57:50 +01:00
}
2016-03-05 12:16:57 +01:00
if ( memcmp ( avist - > palette , avist - > old_palette , pal_size * 4 ) ) {
2016-03-08 11:26:32 +01:00
unsigned char tag [ 5 ] ;
2016-04-10 21:58:15 +02:00
avi_stream2fourcc ( tag , stream_index , par - > codec_type ) ;
2016-03-05 12:16:57 +01:00
tag [ 2 ] = ' p ' ; tag [ 3 ] = ' c ' ;
2017-03-21 21:02:30 +01:00
if ( s - > pb - > seekable & AVIO_SEEKABLE_NORMAL ) {
2016-03-12 16:18:36 +01:00
if ( avist - > strh_flags_offset ) {
int64_t cur_offset = avio_tell ( pb ) ;
avio_seek ( pb , avist - > strh_flags_offset , SEEK_SET ) ;
avio_wl32 ( pb , AVISF_VIDEO_PALCHANGES ) ;
avio_seek ( pb , cur_offset , SEEK_SET ) ;
avist - > strh_flags_offset = 0 ;
}
ret = avi_add_ientry ( s , stream_index , tag , AVIIF_NO_TIME ,
pal_size * 4 + 4 ) ;
if ( ret < 0 )
2016-05-22 01:54:50 +02:00
goto fail ;
2016-03-12 16:18:36 +01:00
}
2016-03-05 12:16:57 +01:00
pc_tag = ff_start_tag ( pb , tag ) ;
avio_w8 ( pb , 0 ) ;
avio_w8 ( pb , pal_size & 0xFF ) ;
avio_wl16 ( pb , 0 ) ; // reserved
for ( i = 0 ; i < pal_size ; i + + ) {
uint32_t v = avist - > palette [ i ] ;
avio_wb32 ( pb , v < < 8 ) ;
}
ff_end_tag ( pb , pc_tag ) ;
memcpy ( avist - > old_palette , avist - > palette , pal_size * 4 ) ;
2016-02-18 20:57:32 +01:00
}
}
2016-03-05 12:16:57 +01:00
}
2016-05-22 01:50:08 +02:00
if ( reshuffle_ret ) {
2016-02-17 13:37:41 +01:00
ret = avi_write_packet_internal ( s , pkt ) ;
2016-05-22 01:54:50 +02:00
fail :
if ( reshuffle_ret )
av_packet_free ( & pkt ) ;
2016-02-17 13:37:41 +01:00
return ret ;
}
}
2016-02-17 13:37:13 +01:00
return avi_write_packet_internal ( s , pkt ) ;
}
static int avi_write_packet_internal ( AVFormatContext * s , AVPacket * pkt )
{
unsigned char tag [ 5 ] ;
unsigned int flags = 0 ;
const int stream_index = pkt - > stream_index ;
int size = pkt - > size ;
AVIContext * avi = s - > priv_data ;
AVIOContext * pb = s - > pb ;
AVIStream * avist = s - > streams [ stream_index ] - > priv_data ;
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 20:42:52 +02:00
AVCodecParameters * par = s - > streams [ stream_index ] - > codecpar ;
2016-02-17 13:37:13 +01:00
2014-11-19 19:59:44 +01:00
if ( pkt - > dts ! = AV_NOPTS_VALUE )
avist - > last_dts = pkt - > dts + pkt - > duration ;
2010-01-28 03:45:17 +01:00
avist - > packet_count + + ;
2004-06-15 15:49:12 +02:00
2005-11-13 04:32:12 +01:00
// Make sure to put an OpenDML chunk when the file size exceeds the limits
2016-09-27 16:26:37 +02:00
if ( ( pb - > seekable & AVIO_SEEKABLE_NORMAL ) & &
2011-03-03 20:11:45 +01:00
( avio_tell ( pb ) - avi - > riff_start > AVI_MAX_RIFF_SIZE ) ) {
2003-04-23 04:04:40 +02:00
avi_write_ix ( s ) ;
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , avi - > movi_list ) ;
2005-12-17 19:14:38 +01:00
2005-12-22 02:10:11 +01:00
if ( avi - > riff_id = = 1 )
avi_write_idx1 ( s ) ;
2003-04-23 04:04:40 +02:00
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , avi - > riff_start ) ;
2010-01-28 03:45:17 +01:00
avi - > movi_list = avi_start_new_riff ( s , pb , " AVIX " , " movi " ) ;
2003-04-08 11:51:15 +02:00
}
2005-12-17 19:14:38 +01: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 20:42:52 +02:00
avi_stream2fourcc ( tag , stream_index , par - > codec_type ) ;
2014-02-28 19:58:20 +01:00
if ( pkt - > flags & AV_PKT_FLAG_KEY )
2004-05-29 04:06:32 +02:00
flags = 0x10 ;
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 20:42:52 +02:00
if ( par - > codec_type = = AVMEDIA_TYPE_AUDIO )
2014-02-28 19:58:20 +01:00
avist - > audio_strm_length + = size ;
2001-07-22 16:18:56 +02:00
2016-09-27 16:26:37 +02:00
if ( s - > pb - > seekable & AVIO_SEEKABLE_NORMAL ) {
2016-03-12 16:18:36 +01:00
int ret ;
ret = avi_add_ientry ( s , stream_index , NULL , flags , size ) ;
if ( ret < 0 )
return ret ;
2001-07-22 16:18:56 +02:00
}
2005-12-17 19:14:38 +01:00
2011-02-21 19:28:17 +01:00
avio_write ( pb , tag , 4 ) ;
avio_wl32 ( pb , size ) ;
avio_write ( pb , pkt - > data , size ) ;
2001-07-22 16:18:56 +02:00
if ( size & 1 )
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0 ) ;
2001-07-22 16:18:56 +02:00
return 0 ;
}
static int avi_write_trailer ( AVFormatContext * s )
{
AVIContext * avi = s - > priv_data ;
2011-02-20 11:04:12 +01:00
AVIOContext * pb = s - > pb ;
2003-04-08 11:51:15 +02:00
int res = 0 ;
2003-04-23 04:04:40 +02:00
int i , j , n , nb_frames ;
2008-10-03 12:16:29 +02:00
int64_t file_size ;
2003-04-23 04:04:40 +02:00
2014-11-19 19:59:44 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVIStream * avist = s - > streams [ i ] - > priv_data ;
write_skip_frames ( s , i , avist - > last_dts ) ;
}
2016-09-27 16:26:37 +02:00
if ( pb - > seekable & AVIO_SEEKABLE_NORMAL ) {
2007-01-21 00:09:27 +01:00
if ( avi - > riff_id = = 1 ) {
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , avi - > movi_list ) ;
2007-01-21 00:09:27 +01:00
res = avi_write_idx1 ( s ) ;
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , avi - > riff_start ) ;
2007-01-21 00:09:27 +01:00
} else {
avi_write_ix ( s ) ;
2009-06-23 01:09:34 +02:00
ff_end_tag ( pb , avi - > movi_list ) ;
ff_end_tag ( pb , avi - > riff_start ) ;
2007-01-21 00:09:27 +01:00
2011-03-03 20:11:45 +01:00
file_size = avio_tell ( pb ) ;
2011-02-28 14:57:54 +01:00
avio_seek ( pb , avi - > odml_list - 8 , SEEK_SET ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " LIST " ) ; /* Making this AVI OpenDML one */
2011-03-15 09:14:38 +01:00
avio_skip ( pb , 16 ) ;
2007-01-21 00:09:27 +01:00
2014-02-28 19:58:20 +01:00
for ( n = nb_frames = 0 ; n < s - > nb_streams ; n + + ) {
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 20:42:52 +02:00
AVCodecParameters * par = s - > streams [ n ] - > codecpar ;
2014-02-28 19:58:20 +01:00
AVIStream * avist = s - > streams [ n ] - > priv_data ;
2010-01-28 03:45:17 +01: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 20:42:52 +02:00
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2010-01-28 03:45:17 +01:00
if ( nb_frames < avist - > packet_count )
nb_frames = avist - > packet_count ;
2007-01-21 00:09:27 +01: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 20:42:52 +02:00
if ( par - > codec_id = = AV_CODEC_ID_MP2 | |
par - > codec_id = = AV_CODEC_ID_MP3 )
2010-01-28 03:45:17 +01:00
nb_frames + = avist - > packet_count ;
2002-03-01 23:28:30 +01:00
}
}
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , nb_frames ) ;
2011-02-28 14:57:54 +01:00
avio_seek ( pb , file_size , SEEK_SET ) ;
2006-08-24 10:22:26 +02:00
2007-01-21 00:09:27 +01:00
avi_write_counters ( s , avi - > riff_id ) ;
}
2005-11-13 04:32:12 +01:00
}
2003-04-23 04:04:40 +02:00
2017-01-25 09:53:03 +01:00
if ( avi - > riff_id > = avi - > master_index_max_size ) {
int index_space = AVI_MASTER_INDEX_PREFIX_SIZE +
AVI_MASTER_INDEX_ENTRY_SIZE * avi - > riff_id ;
av_log ( s , AV_LOG_WARNING , " Output file not strictly OpenDML compliant, "
" consider re-muxing with 'reserve_index_space' option value >= %d \n " ,
index_space ) ;
}
2014-02-28 19:58:20 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVIStream * avist = s - > streams [ i ] - > priv_data ;
for ( j = 0 ; j < avist - > indexes . ents_allocated / AVI_INDEX_CLUSTER_SIZE ; j + + )
2014-03-04 22:17:51 +01:00
av_freep ( & avist - > indexes . cluster [ j ] ) ;
2014-02-28 19:58:20 +01:00
av_freep ( & avist - > indexes . cluster ) ;
avist - > indexes . ents_allocated = avist - > indexes . entry = 0 ;
2017-03-21 21:02:30 +01:00
if ( pb - > seekable & AVIO_SEEKABLE_NORMAL ) {
2014-05-19 00:05:40 +02:00
avio_seek ( pb , avist - > frames_hdr_strm + 4 , SEEK_SET ) ;
avio_wl32 ( pb , avist - > max_size ) ;
}
2003-04-23 04:04:40 +02:00
}
2005-12-17 19:14:38 +01:00
2003-04-08 11:51:15 +02:00
return res ;
2001-07-22 16:18:56 +02:00
}
2015-09-10 14:04:18 +02:00
# define OFFSET(x) offsetof(AVIContext, x)
# define ENC AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options [ ] = {
2017-01-25 09:53:03 +01:00
{ " reserve_index_space " , " reserve space (in bytes) at the beginning of the file for each stream index " , OFFSET ( reserve_index_space ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , ENC } ,
2015-09-10 14:04:18 +02:00
{ " write_channel_mask " , " write channel mask into wave format header " , OFFSET ( write_channel_mask ) , AV_OPT_TYPE_BOOL , { . i64 = 1 } , 0 , 1 , ENC } ,
{ NULL } ,
} ;
static const AVClass avi_muxer_class = {
. class_name = " AVI muxer " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2011-01-25 23:03:28 +01:00
AVOutputFormat ff_avi_muxer = {
2014-02-28 19:58:20 +01:00
. name = " avi " ,
. long_name = NULL_IF_CONFIG_SMALL ( " AVI (Audio Video Interleaved) " ) ,
. mime_type = " video/x-msvideo " ,
. extensions = " avi " ,
. priv_data_size = sizeof ( AVIContext ) ,
. audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_AC3 ,
. video_codec = AV_CODEC_ID_MPEG4 ,
2017-01-25 09:53:03 +01:00
. init = avi_init ,
2014-02-28 19:58:20 +01:00
. write_header = avi_write_header ,
. write_packet = avi_write_packet ,
. write_trailer = avi_write_trailer ,
. codec_tag = ( const AVCodecTag * const [ ] ) {
2012-04-06 16:50:48 +02:00
ff_codec_bmp_tags , ff_codec_wav_tags , 0
} ,
2015-09-10 14:04:18 +02:00
. priv_class = & avi_muxer_class ,
2001-07-22 16:18:56 +02:00
} ;