2014-10-06 08:36:17 +00:00
/*
* MPEG - DASH ISO BMFF segmenter
* Copyright ( c ) 2014 Martin Storsjo
2018-01-02 08:19:56 +00:00
* Copyright ( c ) 2018 Akamai Technologies , Inc .
2014-10-06 08:36:17 +00:00
*
2014-11-17 21:07:11 +00:00
* This file is part of FFmpeg .
2014-10-06 08:36:17 +00:00
*
2014-11-17 21:07:11 +00:00
* FFmpeg is free software ; you can redistribute it and / or
2014-10-06 08:36:17 +00:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
2014-11-17 21:07:11 +00:00
* FFmpeg is distributed in the hope that it will be useful ,
2014-10-06 08:36:17 +00:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
2014-11-17 21:07:11 +00:00
* License along with FFmpeg ; if not , write to the Free Software
2014-10-06 08:36:17 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
# include "config.h"
# if HAVE_UNISTD_H
# include <unistd.h>
# endif
2015-11-18 09:13:14 +00:00
# include "libavutil/avassert.h"
2017-01-29 14:26:27 +00:00
# include "libavutil/avutil.h"
2014-10-06 08:36:17 +00:00
# include "libavutil/avstring.h"
# include "libavutil/intreadwrite.h"
# include "libavutil/mathematics.h"
# include "libavutil/opt.h"
2015-11-18 09:13:14 +00:00
# include "libavutil/rational.h"
2014-10-06 08:36:17 +00:00
# include "libavutil/time_internal.h"
# include "avc.h"
# include "avformat.h"
# include "avio_internal.h"
2017-11-30 02:55:51 +00:00
# include "hlsplaylist.h"
2017-12-29 10:12:32 +00:00
# if CONFIG_HTTP_PROTOCOL
# include "http.h"
# endif
2014-10-06 08:36:17 +00:00
# include "internal.h"
# include "isom.h"
# include "os_support.h"
# include "url.h"
2018-04-23 06:10:32 +00:00
# include "vpcc.h"
2017-09-01 02:20:56 +00:00
# include "dash.h"
2014-11-27 09:46:02 +00:00
2018-05-04 05:15:58 +00:00
typedef enum {
SEGMENT_TYPE_MP4 = 0 ,
SEGMENT_TYPE_WEBM ,
SEGMENT_TYPE_NB
} SegmentType ;
2014-10-06 08:36:17 +00:00
typedef struct Segment {
char file [ 1024 ] ;
int64_t start_pos ;
int range_length , index_length ;
int64_t time ;
int duration ;
int n ;
} Segment ;
2017-01-29 14:26:27 +00:00
typedef struct AdaptationSet {
char id [ 10 ] ;
enum AVMediaType media_type ;
2017-01-29 14:26:30 +00:00
AVDictionary * metadata ;
2017-10-26 16:17:31 +00:00
AVRational min_frame_rate , max_frame_rate ;
int ambiguous_frame_rate ;
2017-01-29 14:26:27 +00:00
} AdaptationSet ;
2014-10-06 08:36:17 +00:00
typedef struct OutputStream {
AVFormatContext * ctx ;
2017-01-29 14:26:27 +00:00
int ctx_inited , as_idx ;
2016-02-15 12:46:38 +00:00
AVIOContext * out ;
2014-10-06 08:36:17 +00:00
int packets_written ;
char initfile [ 1024 ] ;
2017-01-29 14:26:31 +00:00
int64_t init_start_pos , pos ;
2014-10-06 08:36:17 +00:00
int init_range_length ;
int nb_segments , segments_size , segment_index ;
Segment * * segments ;
2014-11-17 12:34:46 +00:00
int64_t first_pts , start_pts , max_pts ;
2018-04-11 07:02:25 +00:00
int64_t last_dts , last_pts ;
2014-11-27 09:46:02 +00:00
int bit_rate ;
2014-10-06 08:36:17 +00:00
char codec_str [ 100 ] ;
2018-02-19 05:55:36 +00:00
int written_len ;
2018-02-19 05:55:25 +00:00
char filename [ 1024 ] ;
char full_path [ 1024 ] ;
char temp_path [ 1024 ] ;
2018-04-11 07:01:47 +00:00
double availability_time_offset ;
2018-04-11 07:01:55 +00:00
int total_pkt_size ;
int muxer_overhead ;
2014-10-06 08:36:17 +00:00
} OutputStream ;
typedef struct DASHContext {
const AVClass * class ; /* Class for private options. */
2017-01-29 14:26:27 +00:00
char * adaptation_sets ;
AdaptationSet * as ;
int nb_as ;
2014-10-06 08:36:17 +00:00
int window_size ;
int extra_window_size ;
2018-04-16 05:25:45 +00:00
# if FF_API_DASH_MIN_SEG_DURATION
2014-10-06 08:36:17 +00:00
int min_seg_duration ;
2018-04-16 05:25:45 +00:00
# endif
int64_t seg_duration ;
2014-10-06 08:36:17 +00:00
int remove_at_exit ;
int use_template ;
int use_timeline ;
int single_file ;
OutputStream * streams ;
2017-01-29 14:26:27 +00:00
int has_video ;
2014-12-06 16:46:02 +00:00
int64_t last_duration ;
int64_t total_duration ;
2014-10-06 08:36:17 +00:00
char availability_start_time [ 100 ] ;
char dirname [ 1024 ] ;
2014-11-27 09:46:02 +00:00
const char * single_file_name ;
const char * init_seg_name ;
const char * media_seg_name ;
2017-01-29 19:41:22 +00:00
const char * utc_timing_url ;
2018-02-23 09:35:40 +00:00
const char * method ;
2017-11-08 09:22:54 +00:00
const char * user_agent ;
2017-11-30 02:55:51 +00:00
int hls_playlist ;
2017-12-29 10:12:32 +00:00
int http_persistent ;
2017-11-30 02:55:51 +00:00
int master_playlist_created ;
2017-12-29 10:12:32 +00:00
AVIOContext * mpd_out ;
AVIOContext * m3u8_out ;
2018-02-19 05:55:36 +00:00
int streaming ;
2018-03-05 09:37:26 +00:00
int64_t timeout ;
2018-04-11 07:02:25 +00:00
int index_correction ;
2018-05-07 09:58:02 +00:00
char * format_options_str ;
2018-05-04 05:15:58 +00:00
SegmentType segment_type ;
const char * format_name ;
2014-10-06 08:36:17 +00:00
} DASHContext ;
2017-01-29 14:26:32 +00:00
static struct codec_string {
int id ;
const char * str ;
} codecs [ ] = {
{ AV_CODEC_ID_VP8 , " vp8 " } ,
{ AV_CODEC_ID_VP9 , " vp9 " } ,
{ AV_CODEC_ID_VORBIS , " vorbis " } ,
{ AV_CODEC_ID_OPUS , " opus " } ,
{ 0 , NULL }
} ;
2018-05-04 05:15:58 +00:00
static struct format_string {
SegmentType segment_type ;
const char * str ;
} formats [ ] = {
{ SEGMENT_TYPE_MP4 , " mp4 " } ,
{ SEGMENT_TYPE_WEBM , " webm " } ,
{ 0 , NULL }
} ;
2017-12-29 10:12:32 +00:00
static int dashenc_io_open ( AVFormatContext * s , AVIOContext * * pb , char * filename ,
AVDictionary * * options ) {
DASHContext * c = s - > priv_data ;
int http_base_proto = filename ? ff_is_http_proto ( filename ) : 0 ;
int err = AVERROR_MUXER_NOT_FOUND ;
if ( ! * pb | | ! http_base_proto | | ! c - > http_persistent ) {
err = s - > io_open ( s , pb , filename , AVIO_FLAG_WRITE , options ) ;
# if CONFIG_HTTP_PROTOCOL
} else {
URLContext * http_url_context = ffio_geturlcontext ( * pb ) ;
av_assert0 ( http_url_context ) ;
err = ff_http_do_new_request ( http_url_context , filename ) ;
# endif
}
return err ;
}
static void dashenc_io_close ( AVFormatContext * s , AVIOContext * * pb , char * filename ) {
DASHContext * c = s - > priv_data ;
int http_base_proto = filename ? ff_is_http_proto ( filename ) : 0 ;
if ( ! http_base_proto | | ! c - > http_persistent ) {
ff_format_io_close ( s , pb ) ;
# if CONFIG_HTTP_PROTOCOL
} else {
2018-01-02 08:19:57 +00:00
URLContext * http_url_context = ffio_geturlcontext ( * pb ) ;
av_assert0 ( http_url_context ) ;
2017-12-29 10:12:32 +00:00
avio_flush ( * pb ) ;
2018-01-02 08:19:57 +00:00
ffurl_shutdown ( http_url_context , AVIO_FLAG_WRITE ) ;
2017-12-29 10:12:32 +00:00
# endif
}
}
2018-05-04 05:15:58 +00:00
static const char * get_format_str ( SegmentType segment_type ) {
int i ;
for ( i = 0 ; i < SEGMENT_TYPE_NB ; i + + )
if ( formats [ i ] . segment_type = = segment_type )
return formats [ i ] . str ;
return NULL ;
}
2018-05-14 05:51:46 +00:00
static int check_file_extension ( const char * filename , const char * extension ) {
char * dot ;
if ( ! filename | | ! extension )
return - 1 ;
dot = strrchr ( filename , ' . ' ) ;
if ( dot & & ! strcmp ( dot + 1 , extension ) )
return 0 ;
return - 1 ;
}
2018-04-23 06:10:32 +00:00
static void set_vp9_codec_str ( AVFormatContext * s , AVCodecParameters * par ,
AVRational * frame_rate , char * str , int size ) {
VPCC vpcc ;
int ret = ff_isom_get_vpcc_features ( s , par , frame_rate , & vpcc ) ;
if ( ret = = 0 ) {
av_strlcatf ( str , size , " vp09.%02x.%02x.%02x " ,
vpcc . profile , vpcc . level , vpcc . bitdepth ) ;
} else {
// Default to just vp9 in case of error while finding out profile or level
av_log ( s , AV_LOG_WARNING , " Could not find VP9 profile and/or level \n " ) ;
av_strlcpy ( str , " vp9 " , size ) ;
}
return ;
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
static void set_codec_str ( AVFormatContext * s , AVCodecParameters * par ,
2018-04-23 06:10:32 +00:00
AVRational * frame_rate , char * str , int size )
2014-10-06 08:36:17 +00:00
{
const AVCodecTag * tags [ 2 ] = { NULL , NULL } ;
uint32_t tag ;
2017-01-29 14:26:32 +00:00
int i ;
// common Webm codecs are not part of RFC 6381
for ( i = 0 ; codecs [ i ] . id ; i + + )
if ( codecs [ i ] . id = = par - > codec_id ) {
2018-04-23 06:10:32 +00:00
if ( codecs [ i ] . id = = AV_CODEC_ID_VP9 ) {
set_vp9_codec_str ( s , par , frame_rate , str , size ) ;
} else {
av_strlcpy ( str , codecs [ i ] . str , size ) ;
}
2017-01-29 14:26:32 +00:00
return ;
}
// for codecs part of RFC 6381
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO )
2014-10-06 08:36:17 +00:00
tags [ 0 ] = ff_codec_movvideo_tags ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
else if ( par - > codec_type = = AVMEDIA_TYPE_AUDIO )
2014-10-06 08:36:17 +00:00
tags [ 0 ] = ff_codec_movaudio_tags ;
else
return ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
tag = av_codec_get_tag ( tags , par - > codec_id ) ;
2014-10-06 08:36:17 +00:00
if ( ! tag )
return ;
if ( size < 5 )
return ;
AV_WL32 ( str , tag ) ;
str [ 4 ] = ' \0 ' ;
if ( ! strcmp ( str , " mp4a " ) | | ! strcmp ( str , " mp4v " ) ) {
uint32_t oti ;
tags [ 0 ] = ff_mp4_obj_type ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
oti = av_codec_get_tag ( tags , par - > codec_id ) ;
2014-10-06 08:36:17 +00:00
if ( oti )
2017-03-27 19:31:46 +00:00
av_strlcatf ( str , size , " .%02 " PRIx32 , oti ) ;
2014-10-06 08:36:17 +00:00
else
return ;
if ( tag = = MKTAG ( ' m ' , ' p ' , ' 4 ' , ' a ' ) ) {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > extradata_size > = 2 ) {
int aot = par - > extradata [ 0 ] > > 3 ;
2014-10-06 08:36:17 +00:00
if ( aot = = 31 )
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
aot = ( ( AV_RB16 ( par - > extradata ) > > 5 ) & 0x3f ) + 32 ;
2014-10-06 08:36:17 +00:00
av_strlcatf ( str , size , " .%d " , aot ) ;
}
} else if ( tag = = MKTAG ( ' m ' , ' p ' , ' 4 ' , ' v ' ) ) {
// Unimplemented, should output ProfileLevelIndication as a decimal number
av_log ( s , AV_LOG_WARNING , " Incomplete RFC 6381 codec string for mp4v \n " ) ;
}
} else if ( ! strcmp ( str , " avc1 " ) ) {
uint8_t * tmpbuf = NULL ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
uint8_t * extradata = par - > extradata ;
int extradata_size = par - > extradata_size ;
2014-10-06 08:36:17 +00:00
if ( ! extradata_size )
return ;
if ( extradata [ 0 ] ! = 1 ) {
AVIOContext * pb ;
if ( avio_open_dyn_buf ( & pb ) < 0 )
return ;
if ( ff_isom_write_avcc ( pb , extradata , extradata_size ) < 0 ) {
2015-02-24 12:07:54 +00:00
ffio_free_dyn_buf ( & pb ) ;
2014-10-06 08:36:17 +00:00
return ;
}
extradata_size = avio_close_dyn_buf ( pb , & extradata ) ;
tmpbuf = extradata ;
}
if ( extradata_size > = 4 )
av_strlcatf ( str , size , " .%02x%02x%02x " ,
extradata [ 1 ] , extradata [ 2 ] , extradata [ 3 ] ) ;
av_free ( tmpbuf ) ;
}
}
2017-01-29 14:26:31 +00:00
static int flush_dynbuf ( OutputStream * os , int * range_length )
{
uint8_t * buffer ;
if ( ! os - > ctx - > pb ) {
return AVERROR ( EINVAL ) ;
}
// flush
av_write_frame ( os - > ctx , NULL ) ;
avio_flush ( os - > ctx - > pb ) ;
// write out to file
* range_length = avio_close_dyn_buf ( os - > ctx - > pb , & buffer ) ;
os - > ctx - > pb = NULL ;
2018-02-19 05:55:36 +00:00
avio_write ( os - > out , buffer + os - > written_len , * range_length - os - > written_len ) ;
os - > written_len = 0 ;
2017-01-29 14:26:31 +00:00
av_free ( buffer ) ;
// re-open buffer
return avio_open_dyn_buf ( & os - > ctx - > pb ) ;
}
2017-11-08 09:22:54 +00:00
static void set_http_options ( AVDictionary * * options , DASHContext * c )
{
2018-02-23 09:35:40 +00:00
if ( c - > method )
av_dict_set ( options , " method " , c - > method , 0 ) ;
2017-11-08 09:22:54 +00:00
if ( c - > user_agent )
av_dict_set ( options , " user_agent " , c - > user_agent , 0 ) ;
2017-12-29 10:12:32 +00:00
if ( c - > http_persistent )
av_dict_set_int ( options , " multiple_requests " , 1 , 0 ) ;
2018-03-05 09:37:26 +00:00
if ( c - > timeout > = 0 )
av_dict_set_int ( options , " timeout " , c - > timeout , 0 ) ;
2017-11-08 09:22:54 +00:00
}
2017-11-30 02:55:51 +00:00
static void get_hls_playlist_name ( char * playlist_name , int string_size ,
const char * base_url , int id ) {
if ( base_url )
snprintf ( playlist_name , string_size , " %smedia_%d.m3u8 " , base_url , id ) ;
else
snprintf ( playlist_name , string_size , " media_%d.m3u8 " , id ) ;
}
2017-01-29 14:26:32 +00:00
static int flush_init_segment ( AVFormatContext * s , OutputStream * os )
{
DASHContext * c = s - > priv_data ;
int ret , range_length ;
ret = flush_dynbuf ( os , & range_length ) ;
if ( ret < 0 )
return ret ;
os - > pos = os - > init_range_length = range_length ;
if ( ! c - > single_file )
ff_format_io_close ( s , & os - > out ) ;
return 0 ;
}
2014-10-06 08:36:17 +00:00
static void dash_free ( AVFormatContext * s )
{
DASHContext * c = s - > priv_data ;
int i , j ;
2017-01-29 14:26:27 +00:00
if ( c - > as ) {
2017-01-29 14:26:30 +00:00
for ( i = 0 ; i < c - > nb_as ; i + + )
av_dict_free ( & c - > as [ i ] . metadata ) ;
2017-01-29 14:26:27 +00:00
av_freep ( & c - > as ) ;
c - > nb_as = 0 ;
}
2014-10-06 08:36:17 +00:00
if ( ! c - > streams )
return ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
OutputStream * os = & c - > streams [ i ] ;
if ( os - > ctx & & os - > ctx_inited )
av_write_trailer ( os - > ctx ) ;
if ( os - > ctx & & os - > ctx - > pb )
2017-01-29 14:26:31 +00:00
ffio_free_dyn_buf ( & os - > ctx - > pb ) ;
2016-02-15 12:46:38 +00:00
ff_format_io_close ( s , & os - > out ) ;
2014-10-06 08:36:17 +00:00
if ( os - > ctx )
avformat_free_context ( os - > ctx ) ;
for ( j = 0 ; j < os - > nb_segments ; j + + )
av_free ( os - > segments [ j ] ) ;
av_free ( os - > segments ) ;
}
av_freep ( & c - > streams ) ;
2018-01-02 08:19:56 +00:00
ff_format_io_close ( s , & c - > mpd_out ) ;
ff_format_io_close ( s , & c - > m3u8_out ) ;
2014-10-06 08:36:17 +00:00
}
2017-12-29 10:12:32 +00:00
static void output_segment_list ( OutputStream * os , AVIOContext * out , AVFormatContext * s ,
2017-11-30 02:55:51 +00:00
int representation_id , int final )
2014-10-06 08:36:17 +00:00
{
2017-12-29 10:12:32 +00:00
DASHContext * c = s - > priv_data ;
2014-10-06 08:36:17 +00:00
int i , start_index = 0 , start_number = 1 ;
if ( c - > window_size ) {
start_index = FFMAX ( os - > nb_segments - c - > window_size , 0 ) ;
start_number = FFMAX ( os - > segment_index - c - > window_size , 1 ) ;
}
if ( c - > use_template ) {
int timescale = c - > use_timeline ? os - > ctx - > streams [ 0 ] - > time_base . den : AV_TIME_BASE ;
avio_printf ( out , " \t \t \t \t <SegmentTemplate timescale= \" %d \" " , timescale ) ;
2018-04-11 07:01:47 +00:00
if ( ! c - > use_timeline ) {
2018-04-11 07:00:29 +00:00
avio_printf ( out , " duration= \" % " PRId64 " \" " , c - > seg_duration ) ;
2018-04-11 07:01:47 +00:00
if ( c - > streaming & & os - > availability_time_offset )
avio_printf ( out , " availabilityTimeOffset= \" %.3f \" " ,
os - > availability_time_offset ) ;
}
2014-11-27 09:46:02 +00:00
avio_printf ( out , " initialization= \" %s \" media= \" %s \" startNumber= \" %d \" > \n " , c - > init_seg_name , c - > media_seg_name , c - > use_timeline ? start_number : 1 ) ;
2014-10-06 08:36:17 +00:00
if ( c - > use_timeline ) {
2014-11-28 08:40:05 +00:00
int64_t cur_time = 0 ;
2014-10-06 08:36:17 +00:00
avio_printf ( out , " \t \t \t \t \t <SegmentTimeline> \n " ) ;
for ( i = start_index ; i < os - > nb_segments ; ) {
Segment * seg = os - > segments [ i ] ;
int repeat = 0 ;
avio_printf ( out , " \t \t \t \t \t \t <S " ) ;
2014-12-29 13:39:23 +00:00
if ( i = = start_index | | seg - > time ! = cur_time ) {
cur_time = seg - > time ;
2014-10-06 08:36:17 +00:00
avio_printf ( out , " t= \" % " PRId64 " \" " , seg - > time ) ;
2014-12-29 13:39:23 +00:00
}
2014-10-06 08:36:17 +00:00
avio_printf ( out , " d= \" %d \" " , seg - > duration ) ;
2014-11-28 08:40:05 +00:00
while ( i + repeat + 1 < os - > nb_segments & &
os - > segments [ i + repeat + 1 ] - > duration = = seg - > duration & &
os - > segments [ i + repeat + 1 ] - > time = = os - > segments [ i + repeat ] - > time + os - > segments [ i + repeat ] - > duration )
2014-10-06 08:36:17 +00:00
repeat + + ;
if ( repeat > 0 )
avio_printf ( out , " r= \" %d \" " , repeat ) ;
avio_printf ( out , " /> \n " ) ;
i + = 1 + repeat ;
2014-11-28 08:40:05 +00:00
cur_time + = ( 1 + repeat ) * seg - > duration ;
2014-10-06 08:36:17 +00:00
}
avio_printf ( out , " \t \t \t \t \t </SegmentTimeline> \n " ) ;
}
avio_printf ( out , " \t \t \t \t </SegmentTemplate> \n " ) ;
} else if ( c - > single_file ) {
avio_printf ( out , " \t \t \t \t <BaseURL>%s</BaseURL> \n " , os - > initfile ) ;
2014-12-06 16:46:02 +00:00
avio_printf ( out , " \t \t \t \t <SegmentList timescale= \" %d \" duration= \" % " PRId64 " \" startNumber= \" %d \" > \n " , AV_TIME_BASE , c - > last_duration , start_number ) ;
2014-10-06 08:36:17 +00:00
avio_printf ( out , " \t \t \t \t \t <Initialization range= \" % " PRId64 " -% " PRId64 " \" /> \n " , os - > init_start_pos , os - > init_start_pos + os - > init_range_length - 1 ) ;
for ( i = start_index ; i < os - > nb_segments ; i + + ) {
Segment * seg = os - > segments [ i ] ;
avio_printf ( out , " \t \t \t \t \t <SegmentURL mediaRange= \" % " PRId64 " -% " PRId64 " \" " , seg - > start_pos , seg - > start_pos + seg - > range_length - 1 ) ;
if ( seg - > index_length )
avio_printf ( out , " indexRange= \" % " PRId64 " -% " PRId64 " \" " , seg - > start_pos , seg - > start_pos + seg - > index_length - 1 ) ;
avio_printf ( out , " /> \n " ) ;
}
avio_printf ( out , " \t \t \t \t </SegmentList> \n " ) ;
} else {
2014-12-06 16:46:02 +00:00
avio_printf ( out , " \t \t \t \t <SegmentList timescale= \" %d \" duration= \" % " PRId64 " \" startNumber= \" %d \" > \n " , AV_TIME_BASE , c - > last_duration , start_number ) ;
2014-10-06 08:36:17 +00:00
avio_printf ( out , " \t \t \t \t \t <Initialization sourceURL= \" %s \" /> \n " , os - > initfile ) ;
for ( i = start_index ; i < os - > nb_segments ; i + + ) {
Segment * seg = os - > segments [ i ] ;
avio_printf ( out , " \t \t \t \t \t <SegmentURL media= \" %s \" /> \n " , seg - > file ) ;
}
avio_printf ( out , " \t \t \t \t </SegmentList> \n " ) ;
}
2017-11-30 02:55:51 +00:00
if ( c - > hls_playlist & & start_index < os - > nb_segments )
{
int timescale = os - > ctx - > streams [ 0 ] - > time_base . den ;
char temp_filename_hls [ 1024 ] ;
char filename_hls [ 1024 ] ;
AVDictionary * http_opts = NULL ;
int target_duration = 0 ;
2017-12-04 04:03:37 +00:00
int ret = 0 ;
2017-11-30 02:55:51 +00:00
const char * proto = avio_find_protocol_name ( c - > dirname ) ;
int use_rename = proto & & ! strcmp ( proto , " file " ) ;
get_hls_playlist_name ( filename_hls , sizeof ( filename_hls ) ,
c - > dirname , representation_id ) ;
snprintf ( temp_filename_hls , sizeof ( temp_filename_hls ) , use_rename ? " %s.tmp " : " %s " , filename_hls ) ;
set_http_options ( & http_opts , c ) ;
2017-12-29 10:12:32 +00:00
dashenc_io_open ( s , & c - > m3u8_out , temp_filename_hls , & http_opts ) ;
2017-11-30 02:55:51 +00:00
av_dict_free ( & http_opts ) ;
for ( i = start_index ; i < os - > nb_segments ; i + + ) {
Segment * seg = os - > segments [ i ] ;
double duration = ( double ) seg - > duration / timescale ;
if ( target_duration < = duration )
2017-12-21 23:44:51 +00:00
target_duration = lrint ( duration ) ;
2017-11-30 02:55:51 +00:00
}
2017-12-29 10:12:32 +00:00
ff_hls_write_playlist_header ( c - > m3u8_out , 6 , - 1 , target_duration ,
2017-11-30 02:55:51 +00:00
start_number , PLAYLIST_TYPE_NONE ) ;
2017-12-29 10:12:32 +00:00
ff_hls_write_init_file ( c - > m3u8_out , os - > initfile , c - > single_file ,
2017-11-30 02:55:51 +00:00
os - > init_range_length , os - > init_start_pos ) ;
for ( i = start_index ; i < os - > nb_segments ; i + + ) {
Segment * seg = os - > segments [ i ] ;
2017-12-29 10:12:32 +00:00
ret = ff_hls_write_file_entry ( c - > m3u8_out , 0 , c - > single_file ,
2017-11-30 02:55:51 +00:00
( double ) seg - > duration / timescale , 0 ,
seg - > range_length , seg - > start_pos , NULL ,
c - > single_file ? os - > initfile : seg - > file ,
NULL ) ;
2017-12-04 04:03:37 +00:00
if ( ret < 0 ) {
av_log ( os - > ctx , AV_LOG_WARNING , " ff_hls_write_file_entry get error \n " ) ;
}
2017-11-30 02:55:51 +00:00
}
if ( final )
2017-12-29 10:12:32 +00:00
ff_hls_write_end_list ( c - > m3u8_out ) ;
dashenc_io_close ( s , & c - > m3u8_out , temp_filename_hls ) ;
2017-11-30 02:55:51 +00:00
if ( use_rename )
2017-12-04 04:06:26 +00:00
if ( avpriv_io_move ( temp_filename_hls , filename_hls ) < 0 ) {
av_log ( os - > ctx , AV_LOG_WARNING , " renaming file %s to %s failed \n \n " , temp_filename_hls , filename_hls ) ;
}
2017-11-30 02:55:51 +00:00
}
2014-10-06 08:36:17 +00:00
}
static char * xmlescape ( const char * str ) {
int outlen = strlen ( str ) * 3 / 2 + 6 ;
char * out = av_realloc ( NULL , outlen + 1 ) ;
int pos = 0 ;
if ( ! out )
return NULL ;
for ( ; * str ; str + + ) {
if ( pos + 6 > outlen ) {
char * tmp ;
outlen = 2 * outlen + 6 ;
tmp = av_realloc ( out , outlen + 1 ) ;
if ( ! tmp ) {
av_free ( out ) ;
return NULL ;
}
out = tmp ;
}
if ( * str = = ' & ' ) {
memcpy ( & out [ pos ] , " & " , 5 ) ;
pos + = 5 ;
} else if ( * str = = ' < ' ) {
memcpy ( & out [ pos ] , " < " , 4 ) ;
pos + = 4 ;
} else if ( * str = = ' > ' ) {
memcpy ( & out [ pos ] , " > " , 4 ) ;
pos + = 4 ;
} else if ( * str = = ' \' ' ) {
memcpy ( & out [ pos ] , " ' " , 6 ) ;
pos + = 6 ;
} else if ( * str = = ' \" ' ) {
memcpy ( & out [ pos ] , " " " , 6 ) ;
pos + = 6 ;
} else {
out [ pos + + ] = * str ;
}
}
out [ pos ] = ' \0 ' ;
return out ;
}
static void write_time ( AVIOContext * out , int64_t time )
{
int seconds = time / AV_TIME_BASE ;
int fractions = time % AV_TIME_BASE ;
int minutes = seconds / 60 ;
int hours = minutes / 60 ;
seconds % = 60 ;
minutes % = 60 ;
avio_printf ( out , " PT " ) ;
if ( hours )
avio_printf ( out , " %dH " , hours ) ;
if ( hours | | minutes )
avio_printf ( out , " %dM " , minutes ) ;
avio_printf ( out , " %d.%dS " , seconds , fractions / ( AV_TIME_BASE / 10 ) ) ;
}
2015-04-17 21:01:02 +00:00
static void format_date_now ( char * buf , int size )
{
time_t t = time ( NULL ) ;
struct tm * ptm , tmbuf ;
ptm = gmtime_r ( & t , & tmbuf ) ;
if ( ptm ) {
2017-01-26 23:25:07 +00:00
if ( ! strftime ( buf , size , " %Y-%m-%dT%H:%M:%SZ " , ptm ) )
2015-04-17 21:01:02 +00:00
buf [ 0 ] = ' \0 ' ;
}
}
2017-11-30 02:55:51 +00:00
static int write_adaptation_set ( AVFormatContext * s , AVIOContext * out , int as_index ,
int final )
2017-01-29 14:26:27 +00:00
{
DASHContext * c = s - > priv_data ;
AdaptationSet * as = & c - > as [ as_index ] ;
2017-01-29 14:26:30 +00:00
AVDictionaryEntry * lang , * role ;
2017-01-29 14:26:27 +00:00
int i ;
2017-09-26 17:10:30 +00:00
avio_printf ( out , " \t \t <AdaptationSet id= \" %s \" contentType= \" %s \" segmentAlignment= \" true \" bitstreamSwitching= \" true \" " ,
2017-01-29 14:26:27 +00:00
as - > id , as - > media_type = = AVMEDIA_TYPE_VIDEO ? " video " : " audio " ) ;
2017-10-29 15:10:35 +00:00
if ( as - > media_type = = AVMEDIA_TYPE_VIDEO & & as - > max_frame_rate . num & & ! as - > ambiguous_frame_rate & & av_cmp_q ( as - > min_frame_rate , as - > max_frame_rate ) < 0 )
avio_printf ( out , " maxFrameRate= \" %d/%d \" " , as - > max_frame_rate . num , as - > max_frame_rate . den ) ;
2017-01-29 14:26:30 +00:00
lang = av_dict_get ( as - > metadata , " language " , NULL , 0 ) ;
if ( lang )
avio_printf ( out , " lang= \" %s \" " , lang - > value ) ;
2017-09-26 17:10:30 +00:00
avio_printf ( out , " > \n " ) ;
2017-01-29 14:26:27 +00:00
2017-01-29 14:26:30 +00:00
role = av_dict_get ( as - > metadata , " role " , NULL , 0 ) ;
if ( role )
avio_printf ( out , " \t \t \t <Role schemeIdUri= \" urn:mpeg:dash:role:2011 \" value= \" %s \" /> \n " , role - > value ) ;
2017-01-29 14:26:27 +00:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
OutputStream * os = & c - > streams [ i ] ;
2018-04-11 07:02:11 +00:00
char bandwidth_str [ 64 ] = { ' \0 ' } ;
2017-01-29 14:26:27 +00:00
if ( os - > as_idx - 1 ! = as_index )
continue ;
2018-04-11 07:02:11 +00:00
if ( os - > bit_rate > 0 )
snprintf ( bandwidth_str , sizeof ( bandwidth_str ) , " bandwidth= \" %d \" " ,
2018-09-04 08:15:48 +00:00
os - > bit_rate ) ;
2018-04-11 07:02:11 +00:00
2017-01-29 14:26:27 +00:00
if ( as - > media_type = = AVMEDIA_TYPE_VIDEO ) {
2017-09-26 17:10:30 +00:00
AVStream * st = s - > streams [ i ] ;
2017-09-26 17:13:09 +00:00
avio_printf ( out , " \t \t \t <Representation id= \" %d \" mimeType= \" video/%s \" codecs= \" %s \" %s width= \" %d \" height= \" %d \" " ,
2018-05-04 05:15:58 +00:00
i , c - > format_name , os - > codec_str , bandwidth_str , s - > streams [ i ] - > codecpar - > width , s - > streams [ i ] - > codecpar - > height ) ;
2017-09-26 17:10:30 +00:00
if ( st - > avg_frame_rate . num )
avio_printf ( out , " frameRate= \" %d/%d \" " , st - > avg_frame_rate . num , st - > avg_frame_rate . den ) ;
avio_printf ( out , " > \n " ) ;
2017-01-29 14:26:27 +00:00
} else {
2017-01-29 14:26:32 +00:00
avio_printf ( out , " \t \t \t <Representation id= \" %d \" mimeType= \" audio/%s \" codecs= \" %s \" %s audioSamplingRate= \" %d \" > \n " ,
2018-05-04 05:15:58 +00:00
i , c - > format_name , os - > codec_str , bandwidth_str , s - > streams [ i ] - > codecpar - > sample_rate ) ;
2017-01-29 14:26:27 +00:00
avio_printf ( out , " \t \t \t \t <AudioChannelConfiguration schemeIdUri= \" urn:mpeg:dash:23003:3:audio_channel_configuration:2011 \" value= \" %d \" /> \n " ,
s - > streams [ i ] - > codecpar - > channels ) ;
}
2017-12-29 10:12:32 +00:00
output_segment_list ( os , out , s , i , final ) ;
2017-01-29 14:26:27 +00:00
avio_printf ( out , " \t \t \t </Representation> \n " ) ;
}
avio_printf ( out , " \t \t </AdaptationSet> \n " ) ;
return 0 ;
}
static int add_adaptation_set ( AVFormatContext * s , AdaptationSet * * as , enum AVMediaType type )
{
DASHContext * c = s - > priv_data ;
void * mem = av_realloc ( c - > as , sizeof ( * c - > as ) * ( c - > nb_as + 1 ) ) ;
if ( ! mem )
return AVERROR ( ENOMEM ) ;
c - > as = mem ;
+ + c - > nb_as ;
* as = & c - > as [ c - > nb_as - 1 ] ;
memset ( * as , 0 , sizeof ( * * as ) ) ;
( * as ) - > media_type = type ;
return 0 ;
}
2017-01-29 14:26:28 +00:00
static int adaptation_set_add_stream ( AVFormatContext * s , int as_idx , int i )
{
DASHContext * c = s - > priv_data ;
AdaptationSet * as = & c - > as [ as_idx - 1 ] ;
OutputStream * os = & c - > streams [ i ] ;
if ( as - > media_type ! = s - > streams [ i ] - > codecpar - > codec_type ) {
av_log ( s , AV_LOG_ERROR , " Codec type of stream %d doesn't match AdaptationSet's media type \n " , i ) ;
return AVERROR ( EINVAL ) ;
} else if ( os - > as_idx ) {
av_log ( s , AV_LOG_ERROR , " Stream %d is already assigned to an AdaptationSet \n " , i ) ;
return AVERROR ( EINVAL ) ;
}
os - > as_idx = as_idx ;
return 0 ;
}
2017-01-29 14:26:27 +00:00
static int parse_adaptation_sets ( AVFormatContext * s )
{
DASHContext * c = s - > priv_data ;
const char * p = c - > adaptation_sets ;
enum { new_set , parse_id , parsing_streams } state ;
AdaptationSet * as ;
int i , n , ret ;
2017-01-29 14:26:29 +00:00
// default: one AdaptationSet for each stream
2017-01-29 14:26:27 +00:00
if ( ! p ) {
2017-01-29 14:26:29 +00:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
if ( ( ret = add_adaptation_set ( s , & as , s - > streams [ i ] - > codecpar - > codec_type ) ) < 0 )
return ret ;
snprintf ( as - > id , sizeof ( as - > id ) , " %d " , i ) ;
2017-01-29 14:26:27 +00:00
2017-01-29 14:26:29 +00:00
c - > streams [ i ] . as_idx = c - > nb_as ;
2017-01-29 14:26:27 +00:00
}
goto end ;
}
// syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on
state = new_set ;
while ( * p ) {
if ( * p = = ' ' ) {
p + + ;
continue ;
} else if ( state = = new_set & & av_strstart ( p , " id= " , & p ) ) {
if ( ( ret = add_adaptation_set ( s , & as , AVMEDIA_TYPE_UNKNOWN ) ) < 0 )
return ret ;
n = strcspn ( p , " , " ) ;
snprintf ( as - > id , sizeof ( as - > id ) , " %.*s " , n , p ) ;
p + = n ;
if ( * p )
p + + ;
state = parse_id ;
} else if ( state = = parse_id & & av_strstart ( p , " streams= " , & p ) ) {
state = parsing_streams ;
} else if ( state = = parsing_streams ) {
AdaptationSet * as = & c - > as [ c - > nb_as - 1 ] ;
char idx_str [ 8 ] , * end_str ;
n = strcspn ( p , " , " ) ;
snprintf ( idx_str , sizeof ( idx_str ) , " %.*s " , n , p ) ;
p + = n ;
2017-01-29 14:26:28 +00:00
// if value is "a" or "v", map all streams of that type
if ( as - > media_type = = AVMEDIA_TYPE_UNKNOWN & & ( idx_str [ 0 ] = = ' v ' | | idx_str [ 0 ] = = ' a ' ) ) {
enum AVMediaType type = ( idx_str [ 0 ] = = ' v ' ) ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO ;
av_log ( s , AV_LOG_DEBUG , " Map all streams of type %s \n " , idx_str ) ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
if ( s - > streams [ i ] - > codecpar - > codec_type ! = type )
continue ;
as - > media_type = s - > streams [ i ] - > codecpar - > codec_type ;
if ( ( ret = adaptation_set_add_stream ( s , c - > nb_as , i ) ) < 0 )
return ret ;
}
} else { // select single stream
i = strtol ( idx_str , & end_str , 10 ) ;
if ( idx_str = = end_str | | i < 0 | | i > = s - > nb_streams ) {
av_log ( s , AV_LOG_ERROR , " Selected stream \" %s \" not found! \n " , idx_str ) ;
return AVERROR ( EINVAL ) ;
}
av_log ( s , AV_LOG_DEBUG , " Map stream %d \n " , i ) ;
if ( as - > media_type = = AVMEDIA_TYPE_UNKNOWN ) {
as - > media_type = s - > streams [ i ] - > codecpar - > codec_type ;
}
2017-01-29 14:26:27 +00:00
2017-01-29 14:26:28 +00:00
if ( ( ret = adaptation_set_add_stream ( s , c - > nb_as , i ) ) < 0 )
return ret ;
2017-01-29 14:26:27 +00:00
}
if ( * p = = ' ' )
state = new_set ;
if ( * p )
p + + ;
} else {
return AVERROR ( EINVAL ) ;
}
}
end :
// check for unassigned streams
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
OutputStream * os = & c - > streams [ i ] ;
if ( ! os - > as_idx ) {
av_log ( s , AV_LOG_ERROR , " Stream %d is not mapped to an AdaptationSet \n " , i ) ;
return AVERROR ( EINVAL ) ;
}
}
return 0 ;
}
2014-10-06 08:36:17 +00:00
static int write_manifest ( AVFormatContext * s , int final )
{
DASHContext * c = s - > priv_data ;
AVIOContext * out ;
char temp_filename [ 1024 ] ;
2017-01-29 14:26:27 +00:00
int ret , i ;
2017-12-29 22:30:14 +00:00
const char * proto = avio_find_protocol_name ( s - > url ) ;
2017-02-07 20:20:32 +00:00
int use_rename = proto & & ! strcmp ( proto , " file " ) ;
static unsigned int warned_non_file = 0 ;
2014-10-06 08:36:17 +00:00
AVDictionaryEntry * title = av_dict_get ( s - > metadata , " title " , NULL , 0 ) ;
2017-11-08 09:22:54 +00:00
AVDictionary * opts = NULL ;
2014-10-06 08:36:17 +00:00
2017-02-07 20:20:32 +00:00
if ( ! use_rename & & ! warned_non_file + + )
av_log ( s , AV_LOG_ERROR , " Cannot use rename on non file protocol, this may lead to races and temporary partial files \n " ) ;
2017-12-29 22:30:14 +00:00
snprintf ( temp_filename , sizeof ( temp_filename ) , use_rename ? " %s.tmp " : " %s " , s - > url ) ;
2017-11-08 09:22:54 +00:00
set_http_options ( & opts , c ) ;
2017-12-29 10:12:32 +00:00
ret = dashenc_io_open ( s , & c - > mpd_out , temp_filename , & opts ) ;
2014-10-06 08:36:17 +00:00
if ( ret < 0 ) {
2014-11-25 08:51:23 +00:00
av_log ( s , AV_LOG_ERROR , " Unable to open %s for writing \n " , temp_filename ) ;
2014-10-06 08:36:17 +00:00
return ret ;
}
2017-12-29 10:12:32 +00:00
out = c - > mpd_out ;
2017-11-08 09:22:54 +00:00
av_dict_free ( & opts ) ;
2014-10-06 08:36:17 +00:00
avio_printf ( out , " <?xml version= \" 1.0 \" encoding= \" utf-8 \" ?> \n " ) ;
avio_printf ( out , " <MPD xmlns:xsi= \" http://www.w3.org/2001/XMLSchema-instance \" \n "
" \t xmlns= \" urn:mpeg:dash:schema:mpd:2011 \" \n "
" \t xmlns:xlink= \" http://www.w3.org/1999/xlink \" \n "
" \t xsi:schemaLocation= \" urn:mpeg:DASH:schema:MPD:2011 http://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd \" \n "
" \t profiles= \" urn:mpeg:dash:profile:isoff-live:2011 \" \n "
" \t type= \" %s \" \n " , final ? " static " : " dynamic " ) ;
if ( final ) {
avio_printf ( out , " \t mediaPresentationDuration= \" " ) ;
write_time ( out , c - > total_duration ) ;
avio_printf ( out , " \" \n " ) ;
} else {
2014-12-10 06:08:59 +00:00
int64_t update_period = c - > last_duration / AV_TIME_BASE ;
2015-04-17 21:01:02 +00:00
char now_str [ 100 ] ;
2014-10-06 08:36:17 +00:00
if ( c - > use_template & & ! c - > use_timeline )
update_period = 500 ;
2014-12-10 06:08:59 +00:00
avio_printf ( out , " \t minimumUpdatePeriod= \" PT% " PRId64 " S \" \n " , update_period ) ;
2014-12-06 16:46:02 +00:00
avio_printf ( out , " \t suggestedPresentationDelay= \" PT% " PRId64 " S \" \n " , c - > last_duration / AV_TIME_BASE ) ;
2014-10-06 08:36:17 +00:00
if ( c - > availability_start_time [ 0 ] )
avio_printf ( out , " \t availabilityStartTime= \" %s \" \n " , c - > availability_start_time ) ;
2015-04-17 21:01:02 +00:00
format_date_now ( now_str , sizeof ( now_str ) ) ;
if ( now_str [ 0 ] )
avio_printf ( out , " \t publishTime= \" %s \" \n " , now_str ) ;
2014-10-06 08:36:17 +00:00
if ( c - > window_size & & c - > use_template ) {
avio_printf ( out , " \t timeShiftBufferDepth= \" " ) ;
write_time ( out , c - > last_duration * c - > window_size ) ;
avio_printf ( out , " \" \n " ) ;
}
}
avio_printf ( out , " \t minBufferTime= \" " ) ;
2017-01-26 23:25:09 +00:00
write_time ( out , c - > last_duration * 2 ) ;
2014-10-06 08:36:17 +00:00
avio_printf ( out , " \" > \n " ) ;
avio_printf ( out , " \t <ProgramInformation> \n " ) ;
if ( title ) {
char * escaped = xmlescape ( title - > value ) ;
avio_printf ( out , " \t \t <Title>%s</Title> \n " , escaped ) ;
av_free ( escaped ) ;
}
avio_printf ( out , " \t </ProgramInformation> \n " ) ;
2017-01-29 19:41:22 +00:00
2014-10-06 08:36:17 +00:00
if ( c - > window_size & & s - > nb_streams > 0 & & c - > streams [ 0 ] . nb_segments > 0 & & ! c - > use_template ) {
OutputStream * os = & c - > streams [ 0 ] ;
int start_index = FFMAX ( os - > nb_segments - c - > window_size , 0 ) ;
int64_t start_time = av_rescale_q ( os - > segments [ start_index ] - > time , s - > streams [ 0 ] - > time_base , AV_TIME_BASE_Q ) ;
2017-01-26 23:25:08 +00:00
avio_printf ( out , " \t <Period id= \" 0 \" start= \" " ) ;
2014-10-06 08:36:17 +00:00
write_time ( out , start_time ) ;
avio_printf ( out , " \" > \n " ) ;
} else {
2017-01-26 23:25:08 +00:00
avio_printf ( out , " \t <Period id= \" 0 \" start= \" PT0.0S \" > \n " ) ;
2014-10-06 08:36:17 +00:00
}
2017-01-29 14:26:27 +00:00
for ( i = 0 ; i < c - > nb_as ; i + + ) {
2017-11-30 02:55:51 +00:00
if ( ( ret = write_adaptation_set ( s , out , i , final ) ) < 0 )
2017-01-29 14:26:27 +00:00
return ret ;
2014-10-06 08:36:17 +00:00
}
avio_printf ( out , " \t </Period> \n " ) ;
2017-10-27 19:18:47 +00:00
if ( c - > utc_timing_url )
avio_printf ( out , " \t <UTCTiming schemeIdUri= \" urn:mpeg:dash:utc:http-xsdate:2014 \" value= \" %s \" /> \n " , c - > utc_timing_url ) ;
2014-10-06 08:36:17 +00:00
avio_printf ( out , " </MPD> \n " ) ;
avio_flush ( out ) ;
2017-12-29 10:12:32 +00:00
dashenc_io_close ( s , & c - > mpd_out , temp_filename ) ;
2017-02-07 20:20:32 +00:00
2017-11-30 02:55:51 +00:00
if ( use_rename ) {
2017-12-29 22:30:14 +00:00
if ( ( ret = avpriv_io_move ( temp_filename , s - > url ) ) < 0 )
2017-11-30 02:55:51 +00:00
return ret ;
}
if ( c - > hls_playlist & & ! c - > master_playlist_created ) {
char filename_hls [ 1024 ] ;
2017-12-29 05:47:53 +00:00
const char * audio_group = " A1 " ;
2018-09-04 08:15:47 +00:00
char audio_codec_str [ 128 ] = " \0 " ;
2017-12-29 05:47:53 +00:00
int is_default = 1 ;
int max_audio_bitrate = 0 ;
2017-11-30 02:55:51 +00:00
if ( * c - > dirname )
2018-07-26 13:22:21 +00:00
snprintf ( filename_hls , sizeof ( filename_hls ) , " %smaster.m3u8 " , c - > dirname ) ;
2017-11-30 02:55:51 +00:00
else
snprintf ( filename_hls , sizeof ( filename_hls ) , " master.m3u8 " ) ;
snprintf ( temp_filename , sizeof ( temp_filename ) , use_rename ? " %s.tmp " : " %s " , filename_hls ) ;
set_http_options ( & opts , c ) ;
ret = avio_open2 ( & out , temp_filename , AVIO_FLAG_WRITE , NULL , & opts ) ;
if ( ret < 0 ) {
av_log ( s , AV_LOG_ERROR , " Unable to open %s for writing \n " , temp_filename ) ;
return ret ;
}
av_dict_free ( & opts ) ;
2018-04-20 03:29:35 +00:00
ff_hls_write_playlist_version ( out , 7 ) ;
2017-11-30 02:55:51 +00:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
char playlist_file [ 64 ] ;
AVStream * st = s - > streams [ i ] ;
2018-04-11 07:02:03 +00:00
OutputStream * os = & c - > streams [ i ] ;
2017-12-29 05:47:53 +00:00
if ( st - > codecpar - > codec_type ! = AVMEDIA_TYPE_AUDIO )
continue ;
2017-11-30 02:55:51 +00:00
get_hls_playlist_name ( playlist_file , sizeof ( playlist_file ) , NULL , i ) ;
2017-12-29 05:47:53 +00:00
ff_hls_write_audio_rendition ( out , ( char * ) audio_group ,
playlist_file , i , is_default ) ;
2018-04-11 07:02:03 +00:00
max_audio_bitrate = FFMAX ( st - > codecpar - > bit_rate +
os - > muxer_overhead , max_audio_bitrate ) ;
2018-09-04 08:15:47 +00:00
if ( ! av_strnstr ( audio_codec_str , os - > codec_str , sizeof ( audio_codec_str ) ) ) {
if ( strlen ( audio_codec_str ) )
av_strlcat ( audio_codec_str , " , " , sizeof ( audio_codec_str ) ) ;
av_strlcat ( audio_codec_str , os - > codec_str , sizeof ( audio_codec_str ) ) ;
}
2017-12-29 05:47:53 +00:00
is_default = 0 ;
}
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
char playlist_file [ 64 ] ;
2018-09-04 08:15:47 +00:00
char codec_str [ 128 ] ;
2017-12-29 05:47:53 +00:00
AVStream * st = s - > streams [ i ] ;
2018-04-11 07:02:03 +00:00
OutputStream * os = & c - > streams [ i ] ;
2017-12-29 05:47:53 +00:00
char * agroup = NULL ;
2018-04-11 07:02:03 +00:00
int stream_bitrate = st - > codecpar - > bit_rate + os - > muxer_overhead ;
2018-09-04 08:15:47 +00:00
av_strlcpy ( codec_str , os - > codec_str , sizeof ( codec_str ) ) ;
2017-12-29 05:47:53 +00:00
if ( ( st - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO ) & & max_audio_bitrate ) {
agroup = ( char * ) audio_group ;
stream_bitrate + = max_audio_bitrate ;
2018-09-04 08:15:47 +00:00
av_strlcat ( codec_str , " , " , sizeof ( codec_str ) ) ;
av_strlcat ( codec_str , audio_codec_str , sizeof ( codec_str ) ) ;
2017-12-29 05:47:53 +00:00
}
get_hls_playlist_name ( playlist_file , sizeof ( playlist_file ) , NULL , i ) ;
2018-09-04 08:15:47 +00:00
ff_hls_write_stream_info ( st , out , stream_bitrate , playlist_file , agroup ,
codec_str , NULL ) ;
2017-11-30 02:55:51 +00:00
}
avio_close ( out ) ;
if ( use_rename )
if ( ( ret = avpriv_io_move ( temp_filename , filename_hls ) ) < 0 )
return ret ;
c - > master_playlist_created = 1 ;
}
2017-02-07 20:20:32 +00:00
return 0 ;
2014-10-06 08:36:17 +00:00
}
2017-01-29 14:26:30 +00:00
static int dict_copy_entry ( AVDictionary * * dst , const AVDictionary * src , const char * key )
{
AVDictionaryEntry * entry = av_dict_get ( src , key , NULL , 0 ) ;
if ( entry )
av_dict_set ( dst , key , entry - > value , AV_DICT_DONT_OVERWRITE ) ;
return 0 ;
}
2016-04-08 00:36:39 +00:00
static int dash_init ( AVFormatContext * s )
2014-10-06 08:36:17 +00:00
{
DASHContext * c = s - > priv_data ;
int ret = 0 , i ;
char * ptr ;
char basename [ 1024 ] ;
2014-11-27 09:46:02 +00:00
if ( c - > single_file_name )
c - > single_file = 1 ;
2014-10-06 08:36:17 +00:00
if ( c - > single_file )
c - > use_template = 0 ;
2018-04-16 05:25:45 +00:00
# if FF_API_DASH_MIN_SEG_DURATION
if ( c - > min_seg_duration ! = 5000000 ) {
av_log ( s , AV_LOG_WARNING , " The min_seg_duration option is deprecated and will be removed. Please use the -seg_duration \n " ) ;
c - > seg_duration = c - > min_seg_duration ;
}
# endif
2017-12-29 22:30:14 +00:00
av_strlcpy ( c - > dirname , s - > url , sizeof ( c - > dirname ) ) ;
2014-10-06 08:36:17 +00:00
ptr = strrchr ( c - > dirname , ' / ' ) ;
if ( ptr ) {
av_strlcpy ( basename , & ptr [ 1 ] , sizeof ( basename ) ) ;
ptr [ 1 ] = ' \0 ' ;
} else {
c - > dirname [ 0 ] = ' \0 ' ;
2017-12-29 22:30:14 +00:00
av_strlcpy ( basename , s - > url , sizeof ( basename ) ) ;
2014-10-06 08:36:17 +00:00
}
ptr = strrchr ( basename , ' . ' ) ;
if ( ptr )
* ptr = ' \0 ' ;
c - > streams = av_mallocz ( sizeof ( * c - > streams ) * s - > nb_streams ) ;
2016-04-08 00:36:15 +00:00
if ( ! c - > streams )
return AVERROR ( ENOMEM ) ;
2014-10-06 08:36:17 +00:00
2017-01-29 14:26:27 +00:00
if ( ( ret = parse_adaptation_sets ( s ) ) < 0 )
2017-09-26 17:10:30 +00:00
return ret ;
2017-01-29 14:26:27 +00:00
2014-10-06 08:36:17 +00:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
OutputStream * os = & c - > streams [ i ] ;
2017-01-29 14:26:30 +00:00
AdaptationSet * as = & c - > as [ os - > as_idx - 1 ] ;
2014-10-06 08:36:17 +00:00
AVFormatContext * ctx ;
AVStream * st ;
AVDictionary * opts = NULL ;
char filename [ 1024 ] ;
2017-09-26 16:59:56 +00:00
os - > bit_rate = s - > streams [ i ] - > codecpar - > bit_rate ;
2018-04-11 07:02:11 +00:00
if ( ! os - > bit_rate ) {
2017-09-26 16:59:56 +00:00
int level = s - > strict_std_compliance > = FF_COMPLIANCE_STRICT ?
AV_LOG_ERROR : AV_LOG_WARNING ;
av_log ( s , level , " No bit rate set for stream %d \n " , i ) ;
if ( s - > strict_std_compliance > = FF_COMPLIANCE_STRICT )
return AVERROR ( EINVAL ) ;
}
2017-01-29 14:26:30 +00:00
// copy AdaptationSet language and role from stream metadata
dict_copy_entry ( & as - > metadata , s - > streams [ i ] - > metadata , " language " ) ;
dict_copy_entry ( & as - > metadata , s - > streams [ i ] - > metadata , " role " ) ;
2014-10-06 08:36:17 +00:00
ctx = avformat_alloc_context ( ) ;
2016-04-08 00:36:15 +00:00
if ( ! ctx )
return AVERROR ( ENOMEM ) ;
2017-01-29 14:26:32 +00:00
2018-05-04 05:15:58 +00:00
c - > format_name = get_format_str ( c - > segment_type ) ;
if ( ! c - > format_name )
return AVERROR_MUXER_NOT_FOUND ;
2018-05-14 05:51:46 +00:00
if ( c - > segment_type = = SEGMENT_TYPE_WEBM ) {
if ( ( ! c - > single_file & & check_file_extension ( c - > init_seg_name , c - > format_name ) ! = 0 ) | |
( ! c - > single_file & & check_file_extension ( c - > media_seg_name , c - > format_name ) ! = 0 ) | |
( c - > single_file & & check_file_extension ( c - > single_file_name , c - > format_name ) ! = 0 ) ) {
av_log ( s , AV_LOG_WARNING ,
" One or many segment file names doesn't end with .webm. "
" Override -init_seg_name and/or -media_seg_name and/or "
" -single_file_name to end with the extension .webm \n " ) ;
}
}
2018-05-04 05:15:58 +00:00
ctx - > oformat = av_guess_format ( c - > format_name , NULL , NULL ) ;
2017-09-26 17:13:09 +00:00
if ( ! ctx - > oformat )
return AVERROR_MUXER_NOT_FOUND ;
2014-10-06 08:36:17 +00:00
os - > ctx = ctx ;
2018-04-27 00:51:37 +00:00
ctx - > interrupt_callback = s - > interrupt_callback ;
ctx - > opaque = s - > opaque ;
ctx - > io_close = s - > io_close ;
ctx - > io_open = s - > io_open ;
ctx - > strict_std_compliance = s - > strict_std_compliance ;
2014-10-06 08:36:17 +00:00
2016-04-08 00:36:15 +00:00
if ( ! ( st = avformat_new_stream ( ctx , NULL ) ) )
return AVERROR ( ENOMEM ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
avcodec_parameters_copy ( st - > codecpar , s - > streams [ i ] - > codecpar ) ;
2014-10-06 08:36:17 +00:00
st - > sample_aspect_ratio = s - > streams [ i ] - > sample_aspect_ratio ;
st - > time_base = s - > streams [ i ] - > time_base ;
2017-10-26 15:58:40 +00:00
st - > avg_frame_rate = s - > streams [ i ] - > avg_frame_rate ;
2014-10-06 08:36:17 +00:00
ctx - > avoid_negative_ts = s - > avoid_negative_ts ;
2016-04-11 01:59:12 +00:00
ctx - > flags = s - > flags ;
2014-10-06 08:36:17 +00:00
2017-01-29 14:26:31 +00:00
if ( ( ret = avio_open_dyn_buf ( & ctx - > pb ) ) < 0 )
2017-09-26 17:12:19 +00:00
return ret ;
2014-10-06 08:36:17 +00:00
2014-11-27 09:46:02 +00:00
if ( c - > single_file ) {
if ( c - > single_file_name )
2017-09-01 02:20:56 +00:00
ff_dash_fill_tmpl_params ( os - > initfile , sizeof ( os - > initfile ) , c - > single_file_name , i , 0 , os - > bit_rate , 0 ) ;
2014-11-27 09:46:02 +00:00
else
snprintf ( os - > initfile , sizeof ( os - > initfile ) , " %s-stream%d.m4s " , basename , i ) ;
} else {
2017-09-01 02:20:56 +00:00
ff_dash_fill_tmpl_params ( os - > initfile , sizeof ( os - > initfile ) , c - > init_seg_name , i , 0 , os - > bit_rate , 0 ) ;
2014-11-27 09:46:02 +00:00
}
2014-10-06 08:36:17 +00:00
snprintf ( filename , sizeof ( filename ) , " %s%s " , c - > dirname , os - > initfile ) ;
2017-11-08 09:22:54 +00:00
set_http_options ( & opts , c ) ;
ret = s - > io_open ( s , & os - > out , filename , AVIO_FLAG_WRITE , & opts ) ;
2014-10-06 08:36:17 +00:00
if ( ret < 0 )
2016-04-08 00:36:15 +00:00
return ret ;
2017-11-08 09:22:54 +00:00
av_dict_free ( & opts ) ;
2014-10-06 08:36:17 +00:00
os - > init_start_pos = 0 ;
2018-05-07 09:58:02 +00:00
if ( c - > format_options_str ) {
ret = av_dict_parse_string ( & opts , c - > format_options_str , " = " , " : " , 0 ) ;
if ( ret < 0 )
return ret ;
}
2018-05-04 05:15:58 +00:00
if ( c - > segment_type = = SEGMENT_TYPE_MP4 ) {
2018-02-19 05:55:36 +00:00
if ( c - > streaming )
av_dict_set ( & opts , " movflags " , " frag_every_frame+dash+delay_moov " , 0 ) ;
else
av_dict_set ( & opts , " movflags " , " frag_custom+dash+delay_moov " , 0 ) ;
2017-01-29 14:26:32 +00:00
} else {
2018-04-16 05:25:45 +00:00
av_dict_set_int ( & opts , " cluster_time_limit " , c - > seg_duration / 1000 , 0 ) ;
2017-10-26 15:58:35 +00:00
av_dict_set_int ( & opts , " cluster_size_limit " , 5 * 1024 * 1024 , 0 ) ; // set a large cluster size limit
2017-10-29 15:10:36 +00:00
av_dict_set_int ( & opts , " dash " , 1 , 0 ) ;
av_dict_set_int ( & opts , " dash_track_number " , i + 1 , 0 ) ;
av_dict_set_int ( & opts , " live " , 1 , 0 ) ;
2017-01-29 14:26:32 +00:00
}
2017-10-26 15:58:37 +00:00
if ( ( ret = avformat_init_output ( ctx , & opts ) ) < 0 )
2016-04-08 00:36:15 +00:00
return ret ;
2014-10-06 08:36:17 +00:00
os - > ctx_inited = 1 ;
avio_flush ( ctx - > pb ) ;
av_dict_free ( & opts ) ;
2014-11-03 19:42:09 +00:00
av_log ( s , AV_LOG_VERBOSE , " Representation %d init segment will be written to: %s \n " , i , filename ) ;
2014-10-06 08:36:17 +00:00
s - > streams [ i ] - > time_base = st - > time_base ;
// If the muxer wants to shift timestamps, request to have them shifted
// already before being handed to this muxer, so we don't have mismatches
// between the MPD and the actual segments.
s - > avoid_negative_ts = ctx - > avoid_negative_ts ;
2016-04-10 19:58:15 +00:00
if ( st - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2015-11-18 09:13:14 +00:00
AVRational avg_frame_rate = s - > streams [ i ] - > avg_frame_rate ;
if ( avg_frame_rate . num > 0 ) {
2017-10-26 16:17:31 +00:00
if ( av_cmp_q ( avg_frame_rate , as - > min_frame_rate ) < 0 )
as - > min_frame_rate = avg_frame_rate ;
if ( av_cmp_q ( as - > max_frame_rate , avg_frame_rate ) < 0 )
as - > max_frame_rate = avg_frame_rate ;
2015-11-18 09:13:14 +00:00
} else {
2017-10-26 16:17:31 +00:00
as - > ambiguous_frame_rate = 1 ;
2015-11-18 09:13:14 +00:00
}
2014-10-06 08:36:17 +00:00
c - > has_video = 1 ;
2015-11-18 09:13:14 +00:00
}
2014-10-06 08:36:17 +00:00
2018-04-23 06:10:32 +00:00
set_codec_str ( s , st - > codecpar , & st - > avg_frame_rate , os - > codec_str ,
sizeof ( os - > codec_str ) ) ;
2014-11-17 12:34:46 +00:00
os - > first_pts = AV_NOPTS_VALUE ;
os - > max_pts = AV_NOPTS_VALUE ;
2015-03-06 20:30:31 +00:00
os - > last_dts = AV_NOPTS_VALUE ;
2014-10-06 08:36:17 +00:00
os - > segment_index = 1 ;
}
2018-04-16 05:25:45 +00:00
if ( ! c - > has_video & & c - > seg_duration < = 0 ) {
av_log ( s , AV_LOG_WARNING , " no video stream and no seg duration set \n " ) ;
2016-04-08 00:36:15 +00:00
return AVERROR ( EINVAL ) ;
2014-10-06 08:36:17 +00:00
}
2016-04-08 00:36:39 +00:00
return 0 ;
}
static int dash_write_header ( AVFormatContext * s )
{
DASHContext * c = s - > priv_data ;
int i , ret ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
OutputStream * os = & c - > streams [ i ] ;
2018-03-14 06:24:39 +00:00
if ( ( ret = avformat_write_header ( os - > ctx , NULL ) ) < 0 )
2016-04-08 00:36:39 +00:00
return ret ;
2018-04-27 00:51:35 +00:00
// Flush init segment
// Only for WebM segment, since for mp4 delay_moov is set and
// the init segment is thus flushed after the first packets.
2018-05-04 05:15:58 +00:00
if ( c - > segment_type = = SEGMENT_TYPE_WEBM & &
2018-04-27 00:51:35 +00:00
( ret = flush_init_segment ( s , os ) ) < 0 )
return ret ;
2016-04-08 00:36:39 +00:00
}
2014-10-06 08:36:17 +00:00
return ret ;
}
static int add_segment ( OutputStream * os , const char * file ,
int64_t time , int duration ,
int64_t start_pos , int64_t range_length ,
2018-04-11 07:02:25 +00:00
int64_t index_length , int next_exp_index )
2014-10-06 08:36:17 +00:00
{
int err ;
Segment * seg ;
if ( os - > nb_segments > = os - > segments_size ) {
os - > segments_size = ( os - > segments_size + 1 ) * 2 ;
if ( ( err = av_reallocp ( & os - > segments , sizeof ( * os - > segments ) *
os - > segments_size ) ) < 0 ) {
os - > segments_size = 0 ;
os - > nb_segments = 0 ;
return err ;
}
}
seg = av_mallocz ( sizeof ( * seg ) ) ;
if ( ! seg )
return AVERROR ( ENOMEM ) ;
av_strlcpy ( seg - > file , file , sizeof ( seg - > file ) ) ;
seg - > time = time ;
seg - > duration = duration ;
2015-05-10 07:05:37 +00:00
if ( seg - > time < 0 ) { // If pts<0, it is expected to be cut away with an edit list
seg - > duration + = seg - > time ;
seg - > time = 0 ;
}
2014-10-06 08:36:17 +00:00
seg - > start_pos = start_pos ;
seg - > range_length = range_length ;
seg - > index_length = index_length ;
os - > segments [ os - > nb_segments + + ] = seg ;
os - > segment_index + + ;
2018-04-11 07:02:25 +00:00
//correcting the segment index if it has fallen behind the expected value
if ( os - > segment_index < next_exp_index ) {
av_log ( NULL , AV_LOG_WARNING , " Correcting the segment index after file %s: current=%d corrected=%d \n " ,
file , os - > segment_index , next_exp_index ) ;
os - > segment_index = next_exp_index ;
}
2014-10-06 08:36:17 +00:00
return 0 ;
}
static void write_styp ( AVIOContext * pb )
{
avio_wb32 ( pb , 24 ) ;
ffio_wfourcc ( pb , " styp " ) ;
ffio_wfourcc ( pb , " msdh " ) ;
avio_wb32 ( pb , 0 ) ; /* minor */
ffio_wfourcc ( pb , " msdh " ) ;
ffio_wfourcc ( pb , " msix " ) ;
}
2014-12-09 08:11:23 +00:00
static void find_index_range ( AVFormatContext * s , const char * full_path ,
int64_t pos , int * index_length )
2014-10-06 08:36:17 +00:00
{
uint8_t buf [ 8 ] ;
2016-02-15 12:46:38 +00:00
AVIOContext * pb ;
2014-10-06 08:36:17 +00:00
int ret ;
2016-02-15 12:46:38 +00:00
ret = s - > io_open ( s , & pb , full_path , AVIO_FLAG_READ , NULL ) ;
2014-10-06 08:36:17 +00:00
if ( ret < 0 )
return ;
2016-02-15 12:46:38 +00:00
if ( avio_seek ( pb , pos , SEEK_SET ) ! = pos ) {
ff_format_io_close ( s , & pb ) ;
2014-10-06 08:36:17 +00:00
return ;
}
2016-02-15 12:46:38 +00:00
ret = avio_read ( pb , buf , 8 ) ;
ff_format_io_close ( s , & pb ) ;
2014-10-06 08:36:17 +00:00
if ( ret < 8 )
return ;
if ( AV_RL32 ( & buf [ 4 ] ) ! = MKTAG ( ' s ' , ' i ' , ' d ' , ' x ' ) )
return ;
* index_length = AV_RB32 ( & buf [ 0 ] ) ;
}
2015-03-04 21:48:43 +00:00
static int update_stream_extradata ( AVFormatContext * s , OutputStream * os ,
2018-04-23 06:10:32 +00:00
AVCodecParameters * par ,
AVRational * frame_rate )
2015-03-04 21:48:43 +00:00
{
uint8_t * extradata ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( os - > ctx - > streams [ 0 ] - > codecpar - > extradata_size | | ! par - > extradata_size )
2015-03-04 21:48:43 +00:00
return 0 ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
extradata = av_malloc ( par - > extradata_size ) ;
2015-03-04 21:48:43 +00:00
if ( ! extradata )
return AVERROR ( ENOMEM ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
memcpy ( extradata , par - > extradata , par - > extradata_size ) ;
2015-03-04 21:48:43 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
os - > ctx - > streams [ 0 ] - > codecpar - > extradata = extradata ;
os - > ctx - > streams [ 0 ] - > codecpar - > extradata_size = par - > extradata_size ;
2015-03-04 21:48:43 +00:00
2018-04-23 06:10:32 +00:00
set_codec_str ( s , par , frame_rate , os - > codec_str , sizeof ( os - > codec_str ) ) ;
2015-03-04 21:48:43 +00:00
return 0 ;
}
2018-02-27 09:18:10 +00:00
static void dashenc_delete_file ( AVFormatContext * s , char * filename ) {
DASHContext * c = s - > priv_data ;
int http_base_proto = ff_is_http_proto ( filename ) ;
if ( http_base_proto ) {
AVIOContext * out = NULL ;
AVDictionary * http_opts = NULL ;
set_http_options ( & http_opts , c ) ;
av_dict_set ( & http_opts , " method " , " DELETE " , 0 ) ;
if ( dashenc_io_open ( s , & out , filename , & http_opts ) < 0 ) {
av_log ( s , AV_LOG_ERROR , " failed to delete %s \n " , filename ) ;
}
av_dict_free ( & http_opts ) ;
dashenc_io_close ( s , & out , filename ) ;
} else if ( unlink ( filename ) < 0 ) {
av_log ( s , AV_LOG_ERROR , " failed to delete %s: %s \n " , filename , strerror ( errno ) ) ;
}
}
2014-11-17 13:26:17 +00:00
static int dash_flush ( AVFormatContext * s , int final , int stream )
2014-10-06 08:36:17 +00:00
{
DASHContext * c = s - > priv_data ;
int i , ret = 0 ;
2017-02-07 20:20:32 +00:00
2017-12-29 22:30:14 +00:00
const char * proto = avio_find_protocol_name ( s - > url ) ;
2017-02-07 20:20:32 +00:00
int use_rename = proto & & ! strcmp ( proto , " file " ) ;
2018-04-11 07:02:25 +00:00
int cur_flush_segment_index = 0 , next_exp_index = - 1 ;
if ( stream > = 0 ) {
2014-11-17 13:26:17 +00:00
cur_flush_segment_index = c - > streams [ stream ] . segment_index ;
2014-10-06 08:36:17 +00:00
2018-04-11 07:02:25 +00:00
//finding the next segment's expected index, based on the current pts value
if ( c - > use_template & & ! c - > use_timeline & & c - > index_correction & &
c - > streams [ stream ] . last_pts ! = AV_NOPTS_VALUE & &
c - > streams [ stream ] . first_pts ! = AV_NOPTS_VALUE ) {
int64_t pts_diff = av_rescale_q ( c - > streams [ stream ] . last_pts -
c - > streams [ stream ] . first_pts ,
s - > streams [ stream ] - > time_base ,
AV_TIME_BASE_Q ) ;
next_exp_index = ( pts_diff / c - > seg_duration ) + 1 ;
}
}
2014-10-06 08:36:17 +00:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
OutputStream * os = & c - > streams [ i ] ;
2017-10-29 15:10:34 +00:00
AVStream * st = s - > streams [ i ] ;
2014-10-06 08:36:17 +00:00
int range_length , index_length = 0 ;
if ( ! os - > packets_written )
continue ;
2014-11-17 13:26:17 +00:00
// Flush the single stream that got a keyframe right now.
// Flush all audio streams as well, in sync with video keyframes,
// but not the other video streams.
if ( stream > = 0 & & i ! = stream ) {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( s - > streams [ i ] - > codecpar - > codec_type ! = AVMEDIA_TYPE_AUDIO )
2014-11-17 13:26:17 +00:00
continue ;
// Make sure we don't flush audio streams multiple times, when
// all video streams are flushed one at a time.
if ( c - > has_video & & os - > segment_index > cur_flush_segment_index )
continue ;
}
2014-10-06 08:36:17 +00:00
if ( ! c - > single_file ) {
2018-05-04 05:15:58 +00:00
if ( c - > segment_type = = SEGMENT_TYPE_MP4 & & ! os - > written_len )
2017-01-29 14:26:32 +00:00
write_styp ( os - > ctx - > pb ) ;
2014-12-09 08:11:23 +00:00
} else {
2018-02-19 05:55:25 +00:00
snprintf ( os - > full_path , sizeof ( os - > full_path ) , " %s%s " , c - > dirname , os - > initfile ) ;
2014-10-06 08:36:17 +00:00
}
2014-12-09 08:11:23 +00:00
2017-01-29 14:26:31 +00:00
ret = flush_dynbuf ( os , & range_length ) ;
if ( ret < 0 )
break ;
2014-10-06 08:36:17 +00:00
os - > packets_written = 0 ;
if ( c - > single_file ) {
2018-02-19 05:55:25 +00:00
find_index_range ( s , os - > full_path , os - > pos , & index_length ) ;
2014-10-06 08:36:17 +00:00
} else {
2018-02-19 05:55:25 +00:00
dashenc_io_close ( s , & os - > out , os - > temp_path ) ;
2017-02-07 20:20:32 +00:00
if ( use_rename ) {
2018-02-19 05:55:25 +00:00
ret = avpriv_io_move ( os - > temp_path , os - > full_path ) ;
2017-02-07 20:20:32 +00:00
if ( ret < 0 )
break ;
}
2014-10-06 08:36:17 +00:00
}
2017-01-30 12:49:44 +00:00
2018-04-11 07:01:55 +00:00
if ( ! os - > muxer_overhead )
os - > muxer_overhead = ( ( int64_t ) ( range_length - os - > total_pkt_size ) *
8 * AV_TIME_BASE ) /
av_rescale_q ( os - > max_pts - os - > start_pts ,
st - > time_base , AV_TIME_BASE_Q ) ;
os - > total_pkt_size = 0 ;
2017-01-30 12:49:44 +00:00
if ( ! os - > bit_rate ) {
// calculate average bitrate of first segment
2017-10-26 16:02:04 +00:00
int64_t bitrate = ( int64_t ) range_length * 8 * AV_TIME_BASE / av_rescale_q ( os - > max_pts - os - > start_pts ,
st - > time_base ,
AV_TIME_BASE_Q ) ;
2018-04-11 07:02:11 +00:00
if ( bitrate > = 0 )
2017-01-30 12:49:44 +00:00
os - > bit_rate = bitrate ;
}
2018-04-11 07:02:25 +00:00
add_segment ( os , os - > filename , os - > start_pts , os - > max_pts - os - > start_pts , os - > pos , range_length , index_length , next_exp_index ) ;
2018-02-19 05:55:25 +00:00
av_log ( s , AV_LOG_VERBOSE , " Representation %d media segment %d written to: %s \n " , i , os - > segment_index , os - > full_path ) ;
2017-01-29 14:26:31 +00:00
os - > pos + = range_length ;
2014-10-06 08:36:17 +00:00
}
if ( c - > window_size | | ( final & & c - > remove_at_exit ) ) {
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
OutputStream * os = & c - > streams [ i ] ;
int j ;
int remove = os - > nb_segments - c - > window_size - c - > extra_window_size ;
if ( final & & c - > remove_at_exit )
remove = os - > nb_segments ;
if ( remove > 0 ) {
for ( j = 0 ; j < remove ; j + + ) {
char filename [ 1024 ] ;
snprintf ( filename , sizeof ( filename ) , " %s%s " , c - > dirname , os - > segments [ j ] - > file ) ;
2018-02-27 09:18:10 +00:00
dashenc_delete_file ( s , filename ) ;
2014-10-06 08:36:17 +00:00
av_free ( os - > segments [ j ] ) ;
}
os - > nb_segments - = remove ;
memmove ( os - > segments , os - > segments + remove , os - > nb_segments * sizeof ( * os - > segments ) ) ;
}
}
}
if ( ret > = 0 )
ret = write_manifest ( s , final ) ;
return ret ;
}
static int dash_write_packet ( AVFormatContext * s , AVPacket * pkt )
{
DASHContext * c = s - > priv_data ;
AVStream * st = s - > streams [ pkt - > stream_index ] ;
OutputStream * os = & c - > streams [ pkt - > stream_index ] ;
2018-04-11 07:00:18 +00:00
int64_t seg_end_duration , elapsed_duration ;
2014-10-06 08:36:17 +00:00
int ret ;
2018-04-23 06:10:32 +00:00
ret = update_stream_extradata ( s , os , st - > codecpar , & st - > avg_frame_rate ) ;
2015-03-04 21:48:43 +00:00
if ( ret < 0 )
return ret ;
2015-03-06 20:30:31 +00:00
// Fill in a heuristic guess of the packet duration, if none is available.
// The mp4 muxer will do something similar (for the last packet in a fragment)
// if nothing is set (setting it for the other packets doesn't hurt).
// By setting a nonzero duration here, we can be sure that the mp4 muxer won't
// invoke its heuristic (this doesn't have to be identical to that algorithm),
// so that we know the exact timestamps of fragments.
if ( ! pkt - > duration & & os - > last_dts ! = AV_NOPTS_VALUE )
pkt - > duration = pkt - > dts - os - > last_dts ;
os - > last_dts = pkt - > dts ;
2014-10-06 08:36:17 +00:00
// If forcing the stream to start at 0, the mp4 muxer will set the start
// timestamps to 0. Do the same here, to avoid mismatches in duration/timestamps.
2014-11-17 12:34:46 +00:00
if ( os - > first_pts = = AV_NOPTS_VALUE & &
2014-10-06 08:36:17 +00:00
s - > avoid_negative_ts = = AVFMT_AVOID_NEG_TS_MAKE_ZERO ) {
pkt - > pts - = pkt - > dts ;
pkt - > dts = 0 ;
}
2014-11-17 12:34:46 +00:00
if ( os - > first_pts = = AV_NOPTS_VALUE )
os - > first_pts = pkt - > pts ;
2018-04-11 07:02:25 +00:00
os - > last_pts = pkt - > pts ;
2014-10-06 08:36:17 +00:00
2018-04-11 07:01:36 +00:00
if ( ! c - > availability_start_time [ 0 ] )
format_date_now ( c - > availability_start_time ,
sizeof ( c - > availability_start_time ) ) ;
2018-04-11 07:01:47 +00:00
if ( ! os - > availability_time_offset & & pkt - > duration ) {
int64_t frame_duration = av_rescale_q ( pkt - > duration , st - > time_base ,
AV_TIME_BASE_Q ) ;
os - > availability_time_offset = ( ( double ) c - > seg_duration -
frame_duration ) / AV_TIME_BASE ;
}
2018-04-11 07:00:18 +00:00
if ( c - > use_template & & ! c - > use_timeline ) {
elapsed_duration = pkt - > pts - os - > first_pts ;
seg_end_duration = ( int64_t ) os - > segment_index * c - > seg_duration ;
} else {
elapsed_duration = pkt - > pts - os - > start_pts ;
seg_end_duration = c - > seg_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 18:42:52 +00:00
if ( ( ! c - > has_video | | st - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO ) & &
2014-10-06 08:36:17 +00:00
pkt - > flags & AV_PKT_FLAG_KEY & & os - > packets_written & &
2018-04-11 07:00:18 +00:00
av_compare_ts ( elapsed_duration , st - > time_base ,
seg_end_duration , AV_TIME_BASE_Q ) > = 0 ) {
2014-10-06 08:36:17 +00:00
int64_t prev_duration = c - > last_duration ;
2014-11-17 12:34:46 +00:00
c - > last_duration = av_rescale_q ( pkt - > pts - os - > start_pts ,
2014-10-06 08:36:17 +00:00
st - > time_base ,
AV_TIME_BASE_Q ) ;
2014-11-17 12:34:46 +00:00
c - > total_duration = av_rescale_q ( pkt - > pts - os - > first_pts ,
2014-10-06 08:36:17 +00:00
st - > time_base ,
AV_TIME_BASE_Q ) ;
if ( ( ! c - > use_timeline | | ! c - > use_template ) & & prev_duration ) {
if ( c - > last_duration < prev_duration * 9 / 10 | |
c - > last_duration > prev_duration * 11 / 10 ) {
av_log ( s , AV_LOG_WARNING ,
" Segment durations differ too much, enable use_timeline "
" and use_template, or keep a stricter keyframe interval \n " ) ;
}
}
2014-11-17 13:26:17 +00:00
if ( ( ret = dash_flush ( s , 0 , pkt - > stream_index ) ) < 0 )
2014-10-06 08:36:17 +00:00
return ret ;
}
2014-11-28 08:43:53 +00:00
if ( ! os - > packets_written ) {
// If we wrote a previous segment, adjust the start time of the segment
// to the end of the previous one (which is the same as the mp4 muxer
// does). This avoids gaps in the timeline.
2014-11-17 12:34:46 +00:00
if ( os - > max_pts ! = AV_NOPTS_VALUE )
os - > start_pts = os - > max_pts ;
2014-11-28 08:43:53 +00:00
else
2014-11-17 12:34:46 +00:00
os - > start_pts = pkt - > pts ;
2014-11-28 08:43:53 +00:00
}
2014-11-17 12:34:46 +00:00
if ( os - > max_pts = = AV_NOPTS_VALUE )
os - > max_pts = pkt - > pts + pkt - > duration ;
else
os - > max_pts = FFMAX ( os - > max_pts , pkt - > pts + pkt - > duration ) ;
2014-10-06 08:36:17 +00:00
os - > packets_written + + ;
2018-04-11 07:01:55 +00:00
os - > total_pkt_size + = pkt - > size ;
2018-02-19 05:55:25 +00:00
if ( ( ret = ff_write_chained ( os - > ctx , 0 , pkt , s , 0 ) ) < 0 )
return ret ;
if ( ! os - > init_range_length )
flush_init_segment ( s , os ) ;
//open the output context when the first frame of a segment is ready
2018-03-02 06:22:37 +00:00
if ( ! c - > single_file & & os - > packets_written = = 1 ) {
2018-02-19 05:55:25 +00:00
AVDictionary * opts = NULL ;
2018-02-24 07:17:18 +00:00
const char * proto = avio_find_protocol_name ( s - > url ) ;
2018-02-19 05:55:25 +00:00
int use_rename = proto & & ! strcmp ( proto , " file " ) ;
os - > filename [ 0 ] = os - > full_path [ 0 ] = os - > temp_path [ 0 ] = ' \0 ' ;
ff_dash_fill_tmpl_params ( os - > filename , sizeof ( os - > filename ) ,
c - > media_seg_name , pkt - > stream_index ,
os - > segment_index , os - > bit_rate , os - > start_pts ) ;
snprintf ( os - > full_path , sizeof ( os - > full_path ) , " %s%s " , c - > dirname ,
os - > filename ) ;
snprintf ( os - > temp_path , sizeof ( os - > temp_path ) ,
use_rename ? " %s.tmp " : " %s " , os - > full_path ) ;
set_http_options ( & opts , c ) ;
ret = dashenc_io_open ( s , & os - > out , os - > temp_path , & opts ) ;
if ( ret < 0 )
return ret ;
av_dict_free ( & opts ) ;
}
2018-02-19 05:55:36 +00:00
//write out the data immediately in streaming mode
2018-05-04 05:15:58 +00:00
if ( c - > streaming & & c - > segment_type = = SEGMENT_TYPE_MP4 ) {
2018-02-19 05:55:36 +00:00
int len = 0 ;
uint8_t * buf = NULL ;
if ( ! os - > written_len )
write_styp ( os - > ctx - > pb ) ;
avio_flush ( os - > ctx - > pb ) ;
len = avio_get_dyn_buf ( os - > ctx - > pb , & buf ) ;
avio_write ( os - > out , buf + os - > written_len , len - os - > written_len ) ;
os - > written_len = len ;
avio_flush ( os - > out ) ;
}
2018-02-19 05:55:25 +00:00
return ret ;
2014-10-06 08:36:17 +00:00
}
static int dash_write_trailer ( AVFormatContext * s )
{
DASHContext * c = s - > priv_data ;
if ( s - > nb_streams > 0 ) {
OutputStream * os = & c - > streams [ 0 ] ;
// If no segments have been written so far, try to do a crude
// guess of the segment duration
if ( ! c - > last_duration )
2014-11-17 12:34:46 +00:00
c - > last_duration = av_rescale_q ( os - > max_pts - os - > start_pts ,
2014-10-06 08:36:17 +00:00
s - > streams [ 0 ] - > time_base ,
AV_TIME_BASE_Q ) ;
2014-11-17 12:34:46 +00:00
c - > total_duration = av_rescale_q ( os - > max_pts - os - > first_pts ,
2014-10-06 08:36:17 +00:00
s - > streams [ 0 ] - > time_base ,
AV_TIME_BASE_Q ) ;
}
2014-11-17 13:26:17 +00:00
dash_flush ( s , 1 , - 1 ) ;
2014-10-06 08:36:17 +00:00
if ( c - > remove_at_exit ) {
char filename [ 1024 ] ;
int i ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
OutputStream * os = & c - > streams [ i ] ;
snprintf ( filename , sizeof ( filename ) , " %s%s " , c - > dirname , os - > initfile ) ;
2018-02-27 09:18:10 +00:00
dashenc_delete_file ( s , filename ) ;
2014-10-06 08:36:17 +00:00
}
2018-02-27 09:18:10 +00:00
dashenc_delete_file ( s , s - > url ) ;
2014-10-06 08:36:17 +00:00
}
return 0 ;
}
2016-04-08 00:36:39 +00:00
static int dash_check_bitstream ( struct AVFormatContext * s , const AVPacket * avpkt )
{
DASHContext * c = s - > priv_data ;
OutputStream * os = & c - > streams [ avpkt - > stream_index ] ;
AVFormatContext * oc = os - > ctx ;
if ( oc - > oformat - > check_bitstream ) {
int ret ;
AVPacket pkt = * avpkt ;
pkt . stream_index = 0 ;
ret = oc - > oformat - > check_bitstream ( oc , & pkt ) ;
if ( ret = = 1 ) {
AVStream * st = s - > streams [ avpkt - > stream_index ] ;
AVStream * ost = oc - > streams [ 0 ] ;
st - > internal - > bsfcs = ost - > internal - > bsfcs ;
st - > internal - > nb_bsfcs = ost - > internal - > nb_bsfcs ;
ost - > internal - > bsfcs = NULL ;
ost - > internal - > nb_bsfcs = 0 ;
}
return ret ;
}
return 1 ;
}
2014-10-06 08:36:17 +00:00
# define OFFSET(x) offsetof(DASHContext, x)
# define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options [ ] = {
2017-01-29 14:26:27 +00:00
{ " adaptation_sets " , " Adaptation sets. Syntax: id=0,streams=0,1,2 id=1,streams=3,4 and so on " , OFFSET ( adaptation_sets ) , AV_OPT_TYPE_STRING , { 0 } , 0 , 0 , AV_OPT_FLAG_ENCODING_PARAM } ,
2014-10-06 08:36:17 +00:00
{ " window_size " , " number of segments kept in the manifest " , OFFSET ( window_size ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , E } ,
{ " extra_window_size " , " number of segments kept outside of the manifest before removing from disk " , OFFSET ( extra_window_size ) , AV_OPT_TYPE_INT , { . i64 = 5 } , 0 , INT_MAX , E } ,
2018-04-16 05:25:45 +00:00
# if FF_API_DASH_MIN_SEG_DURATION
{ " min_seg_duration " , " minimum segment duration (in microseconds) (will be deprecated) " , OFFSET ( min_seg_duration ) , AV_OPT_TYPE_INT , { . i64 = 5000000 } , 0 , INT_MAX , E } ,
# endif
{ " seg_duration " , " segment duration (in seconds, fractional value can be set) " , OFFSET ( seg_duration ) , AV_OPT_TYPE_DURATION , { . i64 = 5000000 } , 0 , INT_MAX , E } ,
2015-11-21 21:05:07 +00:00
{ " remove_at_exit " , " remove all segments when finished " , OFFSET ( remove_at_exit ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
{ " use_template " , " Use SegmentTemplate instead of SegmentList " , OFFSET ( use_template ) , AV_OPT_TYPE_BOOL , { . i64 = 1 } , 0 , 1 , E } ,
{ " use_timeline " , " Use SegmentTimeline in SegmentTemplate " , OFFSET ( use_timeline ) , AV_OPT_TYPE_BOOL , { . i64 = 1 } , 0 , 1 , E } ,
{ " single_file " , " Store all segments in one file, accessed using byte ranges " , OFFSET ( single_file ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
2014-11-27 09:46:02 +00:00
{ " single_file_name " , " DASH-templated name to be used for baseURL. Implies storing all segments in one file, accessed using byte ranges " , OFFSET ( single_file_name ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2014-12-29 12:57:05 +00:00
{ " init_seg_name " , " DASH-templated name to used for the initialization segment " , OFFSET ( init_seg_name ) , AV_OPT_TYPE_STRING , { . str = " init-stream$RepresentationID$.m4s " } , 0 , 0 , E } ,
{ " media_seg_name " , " DASH-templated name to used for the media segments " , OFFSET ( media_seg_name ) , AV_OPT_TYPE_STRING , { . str = " chunk-stream$RepresentationID$-$Number%05d$.m4s " } , 0 , 0 , E } ,
2017-05-20 14:52:10 +00:00
{ " utc_timing_url " , " URL of the page that will return the UTC timestamp in ISO format " , OFFSET ( utc_timing_url ) , AV_OPT_TYPE_STRING , { 0 } , 0 , 0 , E } ,
2018-02-23 09:35:40 +00:00
{ " method " , " set the HTTP method " , OFFSET ( method ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2017-11-08 09:22:54 +00:00
{ " http_user_agent " , " override User-Agent field in HTTP header " , OFFSET ( user_agent ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2017-12-29 10:12:32 +00:00
{ " http_persistent " , " Use persistent HTTP connections " , OFFSET ( http_persistent ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
2017-11-30 02:55:51 +00:00
{ " hls_playlist " , " Generate HLS playlist files(master.m3u8, media_%d.m3u8) " , OFFSET ( hls_playlist ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
2018-02-19 05:55:36 +00:00
{ " streaming " , " Enable/Disable streaming mode of output. Each frame will be moof fragment " , OFFSET ( streaming ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
2018-03-05 09:37:26 +00:00
{ " timeout " , " set timeout for socket I/O operations " , OFFSET ( timeout ) , AV_OPT_TYPE_DURATION , { . i64 = - 1 } , - 1 , INT_MAX , . flags = E } ,
2018-04-11 07:02:25 +00:00
{ " index_correction " , " Enable/Disable segment index correction logic " , OFFSET ( index_correction ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
2018-05-07 09:58:02 +00:00
{ " format_options " , " set list of options for the container format (mp4/webm) used for dash " , OFFSET ( format_options_str ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2018-05-04 05:15:58 +00:00
{ " dash_segment_type " , " set dash segment files type " , OFFSET ( segment_type ) , AV_OPT_TYPE_INT , { . i64 = SEGMENT_TYPE_MP4 } , 0 , SEGMENT_TYPE_NB - 1 , E , " segment_type " } ,
{ " mp4 " , " make segment file in ISOBMFF format " , 0 , AV_OPT_TYPE_CONST , { . i64 = SEGMENT_TYPE_MP4 } , 0 , UINT_MAX , E , " segment_type " } ,
{ " webm " , " make segment file in WebM format " , 0 , AV_OPT_TYPE_CONST , { . i64 = SEGMENT_TYPE_WEBM } , 0 , UINT_MAX , E , " segment_type " } ,
2014-10-06 08:36:17 +00:00
{ NULL } ,
} ;
static const AVClass dash_class = {
. class_name = " dash muxer " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
AVOutputFormat ff_dash_muxer = {
. name = " dash " ,
. long_name = NULL_IF_CONFIG_SMALL ( " DASH Muxer " ) ,
2017-11-22 08:20:03 +00:00
. extensions = " mpd " ,
2014-10-06 08:36:17 +00:00
. priv_data_size = sizeof ( DASHContext ) ,
. audio_codec = AV_CODEC_ID_AAC ,
. video_codec = AV_CODEC_ID_H264 ,
. flags = AVFMT_GLOBALHEADER | AVFMT_NOFILE | AVFMT_TS_NEGATIVE ,
2016-04-08 00:36:39 +00:00
. init = dash_init ,
2014-10-06 08:36:17 +00:00
. write_header = dash_write_header ,
. write_packet = dash_write_packet ,
. write_trailer = dash_write_trailer ,
2016-04-08 00:36:15 +00:00
. deinit = dash_free ,
2016-04-08 00:36:39 +00:00
. check_bitstream = dash_check_bitstream ,
2014-10-06 08:36:17 +00:00
. priv_class = & dash_class ,
} ;