2012-10-26 16:36:56 +02:00
/*
* Apple HTTP Live Streaming segmenter
* Copyright ( c ) 2012 , Luca Barbato
*
2012-11-14 11:22:40 +01:00
* This file is part of FFmpeg .
2012-10-26 16:36:56 +02:00
*
2012-11-14 11:22:40 +01:00
* FFmpeg is free software ; you can redistribute it and / or
2012-10-26 16:36:56 +02: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 .
*
2012-11-14 11:22:40 +01:00
* FFmpeg is distributed in the hope that it will be useful ,
2012-10-26 16:36:56 +02: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
2012-11-14 11:22:40 +01:00
* License along with FFmpeg ; if not , write to the Free Software
2012-10-26 16:36:56 +02:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
2014-12-08 17:25:05 +01:00
# include "config.h"
2012-10-26 16:36:56 +02:00
# include <float.h>
2013-11-23 21:32:55 +01:00
# include <stdint.h>
2014-12-08 17:25:05 +01:00
# if HAVE_UNISTD_H
# include <unistd.h>
# endif
2012-10-26 16:36:56 +02:00
2014-09-28 22:27:33 +02:00
# include "libavutil/avassert.h"
2012-10-26 16:36:56 +02:00
# include "libavutil/mathematics.h"
# include "libavutil/parseutils.h"
# include "libavutil/avstring.h"
# include "libavutil/opt.h"
# include "libavutil/log.h"
2015-08-31 22:10:15 +02:00
# include "libavutil/time_internal.h"
2012-10-26 16:36:56 +02:00
# include "avformat.h"
2016-01-30 02:17:51 +01:00
# include "avio_internal.h"
2012-10-26 16:36:56 +02:00
# include "internal.h"
2014-12-08 17:25:05 +01:00
# include "os_support.h"
2012-10-26 16:36:56 +02:00
2015-06-15 20:58:07 +02:00
# define KEYSIZE 16
# define LINE_BUFFER_SIZE 1024
2014-07-18 10:57:42 +02:00
typedef struct HLSSegment {
char filename [ 1024 ] ;
2015-06-04 09:55:52 +02:00
char sub_filename [ 1024 ] ;
2014-07-18 10:57:42 +02:00
double duration ; /* in seconds */
2014-09-15 15:26:57 +02:00
int64_t pos ;
int64_t size ;
2014-07-18 10:57:42 +02:00
2015-06-15 20:58:07 +02:00
char key_uri [ LINE_BUFFER_SIZE + 1 ] ;
char iv_string [ KEYSIZE * 2 + 1 ] ;
2014-07-18 10:57:42 +02:00
struct HLSSegment * next ;
} HLSSegment ;
2012-10-26 16:36:56 +02:00
2014-09-15 15:26:57 +02:00
typedef enum HLSFlags {
// Generate a single media file and use byte ranges in the playlist.
HLS_SINGLE_FILE = ( 1 < < 0 ) ,
2014-12-08 17:25:05 +01:00
HLS_DELETE_SEGMENTS = ( 1 < < 1 ) ,
2015-04-21 23:46:17 +02:00
HLS_ROUND_DURATIONS = ( 1 < < 2 ) ,
2015-04-21 23:52:03 +02:00
HLS_DISCONT_START = ( 1 < < 3 ) ,
2015-04-21 23:53:57 +02:00
HLS_OMIT_ENDLIST = ( 1 < < 4 ) ,
2014-09-15 15:26:57 +02:00
} HLSFlags ;
2015-12-17 04:16:45 +01:00
typedef enum {
PLAYLIST_TYPE_NONE ,
PLAYLIST_TYPE_EVENT ,
PLAYLIST_TYPE_VOD ,
PLAYLIST_TYPE_NB ,
} PlaylistType ;
2012-10-26 16:36:56 +02:00
typedef struct HLSContext {
const AVClass * class ; // Class for private options.
2012-12-29 12:31:01 +01:00
unsigned number ;
2012-12-29 12:09:17 +01:00
int64_t sequence ;
2014-04-29 10:13:34 +02:00
int64_t start_sequence ;
2012-10-26 16:36:56 +02:00
AVOutputFormat * oformat ;
2015-06-04 09:55:52 +02:00
AVOutputFormat * vtt_oformat ;
2014-07-18 10:57:42 +02:00
2012-10-26 16:36:56 +02:00
AVFormatContext * avf ;
2015-06-04 09:55:52 +02:00
AVFormatContext * vtt_avf ;
2014-07-18 10:57:42 +02:00
2012-10-26 16:36:56 +02:00
float time ; // Set by a private option.
2014-07-18 10:57:42 +02:00
int max_nb_segments ; // Set by a private option.
2012-10-26 16:36:56 +02:00
int wrap ; // Set by a private option.
2014-09-15 15:26:57 +02:00
uint32_t flags ; // enum HLSFlags
2015-12-17 04:16:45 +01:00
uint32_t pl_type ; // enum PlaylistType
2014-12-05 22:20:15 +01:00
char * segment_filename ;
2014-07-18 10:57:42 +02:00
2015-08-31 22:10:15 +02:00
int use_localtime ; ///< flag to expand filename with localtime
2016-02-03 22:20:07 +01:00
int use_localtime_mkdir ; ///< flag to mkdir dirname in timebased filename
2014-09-22 10:17:01 +02:00
int allowcache ;
2012-10-26 16:36:56 +02:00
int64_t recording_time ;
int has_video ;
2015-06-04 09:55:52 +02:00
int has_subtitle ;
2012-10-26 16:36:56 +02:00
int64_t start_pts ;
int64_t end_pts ;
2014-04-02 21:17:13 +02:00
double duration ; // last segment duration computed so far, in seconds
2014-09-15 15:26:57 +02:00
int64_t start_pos ; // last segment starting position
int64_t size ; // last segment size
2012-12-25 10:05:42 +01:00
int nb_entries ;
2015-04-21 23:52:03 +02:00
int discontinuity_set ;
2014-07-18 10:57:42 +02:00
2014-07-18 10:57:42 +02:00
HLSSegment * segments ;
HLSSegment * last_segment ;
2014-12-08 17:25:05 +01:00
HLSSegment * old_segments ;
2014-07-18 10:57:42 +02:00
2012-10-26 16:36:56 +02:00
char * basename ;
2015-06-04 09:55:52 +02:00
char * vtt_basename ;
char * vtt_m3u8_name ;
2014-03-18 21:19:00 +01:00
char * baseurl ;
2014-09-12 12:04:52 +02:00
char * format_options_str ;
2015-06-04 09:55:52 +02:00
char * vtt_format_options_str ;
char * subtitle_filename ;
2014-09-12 12:04:52 +02:00
AVDictionary * format_options ;
2015-06-15 20:58:07 +02:00
char * key_info_file ;
char key_file [ LINE_BUFFER_SIZE + 1 ] ;
char key_uri [ LINE_BUFFER_SIZE + 1 ] ;
char key_string [ KEYSIZE * 2 + 1 ] ;
char iv_string [ KEYSIZE * 2 + 1 ] ;
2015-06-04 09:55:52 +02:00
AVDictionary * vtt_format_options ;
2015-09-14 21:07:37 +02:00
char * method ;
2012-10-26 16:36:56 +02:00
} HLSContext ;
2014-12-08 17:25:05 +01:00
static int hls_delete_old_segments ( HLSContext * hls ) {
HLSSegment * segment , * previous_segment = NULL ;
float playlist_duration = 0.0f ;
2015-06-04 09:55:52 +02:00
int ret = 0 , path_size , sub_path_size ;
2015-09-03 11:18:10 +02:00
char * dirname = NULL , * p , * sub_path ;
char * path = NULL ;
2014-12-08 17:25:05 +01:00
segment = hls - > segments ;
while ( segment ) {
playlist_duration + = segment - > duration ;
segment = segment - > next ;
}
segment = hls - > old_segments ;
while ( segment ) {
playlist_duration - = segment - > duration ;
previous_segment = segment ;
segment = previous_segment - > next ;
if ( playlist_duration < = - previous_segment - > duration ) {
previous_segment - > next = NULL ;
break ;
}
}
if ( segment ) {
if ( hls - > segment_filename ) {
dirname = av_strdup ( hls - > segment_filename ) ;
} else {
dirname = av_strdup ( hls - > avf - > filename ) ;
}
if ( ! dirname ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
p = ( char * ) av_basename ( dirname ) ;
* p = ' \0 ' ;
}
while ( segment ) {
av_log ( hls , AV_LOG_DEBUG , " deleting old segment %s \n " ,
segment - > filename ) ;
path_size = strlen ( dirname ) + strlen ( segment - > filename ) + 1 ;
path = av_malloc ( path_size ) ;
if ( ! path ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
2015-06-04 09:55:52 +02:00
2014-12-08 17:25:05 +01:00
av_strlcpy ( path , dirname , path_size ) ;
av_strlcat ( path , segment - > filename , path_size ) ;
if ( unlink ( path ) < 0 ) {
av_log ( hls , AV_LOG_ERROR , " failed to delete old segment %s: %s \n " ,
path , strerror ( errno ) ) ;
}
2015-06-04 09:55:52 +02:00
2015-10-02 01:21:33 +02:00
if ( segment - > sub_filename [ 0 ] ! = ' \0 ' ) {
sub_path_size = strlen ( dirname ) + strlen ( segment - > sub_filename ) + 1 ;
sub_path = av_malloc ( sub_path_size ) ;
if ( ! sub_path ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
av_strlcpy ( sub_path , dirname , sub_path_size ) ;
av_strlcat ( sub_path , segment - > sub_filename , sub_path_size ) ;
if ( unlink ( sub_path ) < 0 ) {
av_log ( hls , AV_LOG_ERROR , " failed to delete old segment %s: %s \n " ,
sub_path , strerror ( errno ) ) ;
}
av_free ( sub_path ) ;
2015-06-04 09:55:52 +02:00
}
2015-09-03 11:18:10 +02:00
av_freep ( & path ) ;
2014-12-08 17:25:05 +01:00
previous_segment = segment ;
segment = previous_segment - > next ;
av_free ( previous_segment ) ;
}
fail :
2015-09-03 11:18:10 +02:00
av_free ( path ) ;
2014-12-08 17:25:05 +01:00
av_free ( dirname ) ;
return ret ;
}
2015-06-15 20:58:07 +02:00
static int hls_encryption_start ( AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
int ret ;
AVIOContext * pb ;
uint8_t key [ KEYSIZE ] ;
2016-02-10 15:40:32 +01:00
if ( ( ret = s - > io_open ( s , & pb , hls - > key_info_file , AVIO_FLAG_READ , NULL ) ) < 0 ) {
2015-06-15 20:58:07 +02:00
av_log ( hls , AV_LOG_ERROR ,
" error opening key info file %s \n " , hls - > key_info_file ) ;
return ret ;
}
ff_get_line ( pb , hls - > key_uri , sizeof ( hls - > key_uri ) ) ;
hls - > key_uri [ strcspn ( hls - > key_uri , " \r \n " ) ] = ' \0 ' ;
ff_get_line ( pb , hls - > key_file , sizeof ( hls - > key_file ) ) ;
hls - > key_file [ strcspn ( hls - > key_file , " \r \n " ) ] = ' \0 ' ;
ff_get_line ( pb , hls - > iv_string , sizeof ( hls - > iv_string ) ) ;
hls - > iv_string [ strcspn ( hls - > iv_string , " \r \n " ) ] = ' \0 ' ;
2016-02-10 15:40:32 +01:00
ff_format_io_close ( s , & pb ) ;
2015-06-15 20:58:07 +02:00
if ( ! * hls - > key_uri ) {
av_log ( hls , AV_LOG_ERROR , " no key URI specified in key info file \n " ) ;
return AVERROR ( EINVAL ) ;
}
if ( ! * hls - > key_file ) {
av_log ( hls , AV_LOG_ERROR , " no key file specified in key info file \n " ) ;
return AVERROR ( EINVAL ) ;
}
2016-02-10 15:40:32 +01:00
if ( ( ret = s - > io_open ( s , & pb , hls - > key_file , AVIO_FLAG_READ , NULL ) ) < 0 ) {
2015-06-15 20:58:07 +02:00
av_log ( hls , AV_LOG_ERROR , " error opening key file %s \n " , hls - > key_file ) ;
return ret ;
}
ret = avio_read ( pb , key , sizeof ( key ) ) ;
2016-02-10 15:40:32 +01:00
ff_format_io_close ( s , & pb ) ;
2015-06-15 20:58:07 +02:00
if ( ret ! = sizeof ( key ) ) {
av_log ( hls , AV_LOG_ERROR , " error reading key file %s \n " , hls - > key_file ) ;
if ( ret > = 0 | | ret = = AVERROR_EOF )
ret = AVERROR ( EINVAL ) ;
return ret ;
}
ff_data_to_hex ( hls - > key_string , key , sizeof ( key ) , 0 ) ;
return 0 ;
}
2012-10-26 16:36:56 +02:00
static int hls_mux_init ( AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
AVFormatContext * oc ;
2015-09-03 11:14:48 +02:00
AVFormatContext * vtt_oc = NULL ;
2014-10-17 18:28:47 +02:00
int i , ret ;
2012-10-26 16:36:56 +02:00
2014-10-17 18:28:47 +02:00
ret = avformat_alloc_output_context2 ( & hls - > avf , hls - > oformat , NULL , NULL ) ;
if ( ret < 0 )
return ret ;
oc = hls - > avf ;
2012-10-26 16:36:56 +02:00
oc - > oformat = hls - > oformat ;
oc - > interrupt_callback = s - > interrupt_callback ;
2014-10-17 18:28:47 +02:00
oc - > max_delay = s - > max_delay ;
2016-01-16 17:53:43 +01:00
oc - > opaque = s - > opaque ;
oc - > io_open = s - > io_open ;
oc - > io_close = s - > io_close ;
2013-12-12 18:41:39 +01:00
av_dict_copy ( & oc - > metadata , s - > metadata , 0 ) ;
2012-10-26 16:36:56 +02:00
2015-06-04 09:55:52 +02:00
if ( hls - > vtt_oformat ) {
ret = avformat_alloc_output_context2 ( & hls - > vtt_avf , hls - > vtt_oformat , NULL , NULL ) ;
if ( ret < 0 )
return ret ;
vtt_oc = hls - > vtt_avf ;
vtt_oc - > oformat = hls - > vtt_oformat ;
av_dict_copy ( & vtt_oc - > metadata , s - > metadata , 0 ) ;
}
2012-10-26 16:36:56 +02:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st ;
2015-06-04 09:55:52 +02:00
AVFormatContext * loc ;
2016-04-10 21:58:15 +02:00
if ( s - > streams [ i ] - > codecpar - > codec_type = = AVMEDIA_TYPE_SUBTITLE )
2015-06-04 09:55:52 +02:00
loc = vtt_oc ;
else
loc = oc ;
if ( ! ( st = avformat_new_stream ( loc , NULL ) ) )
2012-10-26 16:36:56 +02:00
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 20:42:52 +02:00
avcodec_parameters_copy ( st - > codecpar , s - > streams [ i ] - > codecpar ) ;
2012-10-26 16:36:56 +02:00
st - > sample_aspect_ratio = s - > streams [ i ] - > sample_aspect_ratio ;
2014-10-06 10:41:33 +02:00
st - > time_base = s - > streams [ i ] - > time_base ;
2012-10-26 16:36:56 +02:00
}
2014-09-15 15:26:57 +02:00
hls - > start_pos = 0 ;
2012-10-26 16:36:56 +02:00
return 0 ;
}
2014-07-18 10:57:42 +02:00
/* Create a new segment and append it to the segment list */
2016-02-03 22:20:07 +01:00
static int hls_append_segment ( struct AVFormatContext * s , HLSContext * hls , double duration ,
int64_t pos , int64_t size )
2012-10-26 16:36:56 +02:00
{
2014-07-18 10:57:42 +02:00
HLSSegment * en = av_malloc ( sizeof ( * en ) ) ;
2016-02-03 22:20:07 +01:00
char * tmp , * p ;
const char * pl_dir , * filename ;
2014-12-08 17:25:05 +01:00
int ret ;
2012-10-26 16:36:56 +02:00
if ( ! en )
return AVERROR ( ENOMEM ) ;
2016-02-03 22:20:07 +01:00
filename = av_basename ( hls - > avf - > filename ) ;
if ( hls - > use_localtime_mkdir ) {
/* Possibly prefix with mkdir'ed subdir, if playlist share same
* base path . */
tmp = av_strdup ( s - > filename ) ;
if ( ! tmp ) {
av_free ( en ) ;
return AVERROR ( ENOMEM ) ;
}
pl_dir = av_dirname ( tmp ) ;
p = hls - > avf - > filename ;
if ( strstr ( p , pl_dir ) = = p )
filename = hls - > avf - > filename + strlen ( pl_dir ) + 1 ;
av_free ( tmp ) ;
}
av_strlcpy ( en - > filename , filename , sizeof ( en - > filename ) ) ;
2012-10-26 16:36:56 +02:00
2015-06-04 09:55:52 +02:00
if ( hls - > has_subtitle )
av_strlcpy ( en - > sub_filename , av_basename ( hls - > vtt_avf - > filename ) , sizeof ( en - > sub_filename ) ) ;
2015-10-02 01:21:33 +02:00
else
en - > sub_filename [ 0 ] = ' \0 ' ;
2015-06-04 09:55:52 +02:00
2012-10-26 16:36:56 +02:00
en - > duration = duration ;
2014-09-15 15:26:57 +02:00
en - > pos = pos ;
en - > size = size ;
2012-10-26 16:36:56 +02:00
en - > next = NULL ;
2015-06-15 20:58:07 +02:00
if ( hls - > key_info_file ) {
av_strlcpy ( en - > key_uri , hls - > key_uri , sizeof ( en - > key_uri ) ) ;
av_strlcpy ( en - > iv_string , hls - > iv_string , sizeof ( en - > iv_string ) ) ;
}
2014-07-18 10:57:42 +02:00
if ( ! hls - > segments )
hls - > segments = en ;
2012-10-26 16:36:56 +02:00
else
2014-07-18 10:57:42 +02:00
hls - > last_segment - > next = en ;
2012-10-26 16:36:56 +02:00
2014-07-18 10:57:42 +02:00
hls - > last_segment = en ;
2012-10-26 16:36:56 +02:00
2015-12-17 04:16:45 +01:00
// EVENT or VOD playlists imply sliding window cannot be used
if ( hls - > pl_type ! = PLAYLIST_TYPE_NONE )
hls - > max_nb_segments = 0 ;
2014-07-18 10:57:42 +02:00
if ( hls - > max_nb_segments & & hls - > nb_entries > = hls - > max_nb_segments ) {
en = hls - > segments ;
hls - > segments = en - > next ;
2014-12-08 17:25:05 +01:00
if ( en & & hls - > flags & HLS_DELETE_SEGMENTS & &
! ( hls - > flags & HLS_SINGLE_FILE | | hls - > wrap ) ) {
en - > next = hls - > old_segments ;
hls - > old_segments = en ;
if ( ( ret = hls_delete_old_segments ( hls ) ) < 0 )
return ret ;
} else
av_free ( en ) ;
2012-12-25 10:05:42 +01:00
} else
hls - > nb_entries + + ;
2012-10-26 16:36:56 +02:00
2012-12-29 12:09:17 +01:00
hls - > sequence + + ;
2012-10-26 16:36:56 +02:00
return 0 ;
}
2014-12-08 17:25:05 +01:00
static void hls_free_segments ( HLSSegment * p )
2012-10-26 16:36:56 +02:00
{
2014-12-08 17:25:05 +01:00
HLSSegment * en ;
2012-10-26 16:36:56 +02:00
while ( p ) {
en = p ;
p = p - > next ;
av_free ( en ) ;
}
}
2015-09-14 21:07:37 +02:00
static void set_http_options ( AVDictionary * * options , HLSContext * c )
{
if ( c - > method )
av_dict_set ( options , " method " , c - > method , 0 ) ;
}
2012-10-26 16:36:56 +02:00
static int hls_window ( AVFormatContext * s , int last )
{
HLSContext * hls = s - > priv_data ;
2014-07-18 10:57:42 +02:00
HLSSegment * en ;
2012-12-21 12:05:46 +01:00
int target_duration = 0 ;
2012-10-26 16:36:56 +02:00
int ret = 0 ;
2015-02-20 12:55:13 +01:00
AVIOContext * out = NULL ;
2015-06-04 09:55:52 +02:00
AVIOContext * sub_out = NULL ;
2015-02-20 12:55:14 +01:00
char temp_filename [ 1024 ] ;
2014-04-30 21:14:56 +02:00
int64_t sequence = FFMAX ( hls - > start_sequence , hls - > sequence - hls - > nb_entries ) ;
2014-09-15 15:26:57 +02:00
int version = hls - > flags & HLS_SINGLE_FILE ? 4 : 3 ;
2015-02-21 01:21:53 +01:00
const char * proto = avio_find_protocol_name ( s - > filename ) ;
int use_rename = proto & & ! strcmp ( proto , " file " ) ;
2015-02-21 19:27:06 +01:00
static unsigned warned_non_file ;
2015-06-15 20:58:07 +02:00
char * key_uri = NULL ;
char * iv_string = NULL ;
2015-09-14 21:07:37 +02:00
AVDictionary * options = NULL ;
2015-02-21 19:27:06 +01: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 temporarly partial files \n " ) ;
2012-10-26 16:36:56 +02:00
2015-09-14 21:07:37 +02:00
set_http_options ( & options , hls ) ;
2015-02-21 01:21:53 +01:00
snprintf ( temp_filename , sizeof ( temp_filename ) , use_rename ? " %s.tmp " : " %s " , s - > filename ) ;
2016-03-11 00:29:59 +01:00
if ( ( ret = s - > io_open ( s , & out , temp_filename , AVIO_FLAG_WRITE , & options ) ) < 0 )
2012-10-26 16:36:56 +02:00
goto fail ;
2014-07-18 10:57:42 +02:00
for ( en = hls - > segments ; en ; en = en - > next ) {
2012-12-21 12:05:46 +01:00
if ( target_duration < en - > duration )
2014-07-07 13:26:12 +02:00
target_duration = ceil ( en - > duration ) ;
2012-12-21 12:05:46 +01:00
}
2015-04-21 23:52:03 +02:00
hls - > discontinuity_set = 0 ;
2015-02-20 12:55:13 +01:00
avio_printf ( out , " #EXTM3U \n " ) ;
avio_printf ( out , " #EXT-X-VERSION:%d \n " , version ) ;
2014-09-22 10:17:01 +02:00
if ( hls - > allowcache = = 0 | | hls - > allowcache = = 1 ) {
2015-02-20 12:55:13 +01:00
avio_printf ( out , " #EXT-X-ALLOW-CACHE:%s \n " , hls - > allowcache = = 0 ? " NO " : " YES " ) ;
2014-09-22 10:17:01 +02:00
}
2015-02-20 12:55:13 +01:00
avio_printf ( out , " #EXT-X-TARGETDURATION:%d \n " , target_duration ) ;
avio_printf ( out , " #EXT-X-MEDIA-SEQUENCE:% " PRId64 " \n " , sequence ) ;
2015-12-17 04:16:45 +01:00
if ( hls - > pl_type = = PLAYLIST_TYPE_EVENT ) {
avio_printf ( out , " #EXT-X-PLAYLIST-TYPE:EVENT \n " ) ;
} else if ( hls - > pl_type = = PLAYLIST_TYPE_VOD ) {
avio_printf ( out , " #EXT-X-PLAYLIST-TYPE:VOD \n " ) ;
}
2012-10-26 16:36:56 +02:00
2014-04-29 10:07:03 +02:00
av_log ( s , AV_LOG_VERBOSE , " EXT-X-MEDIA-SEQUENCE:% " PRId64 " \n " ,
2014-04-29 18:37:01 +02:00
sequence ) ;
2015-04-21 23:52:03 +02:00
if ( ( hls - > flags & HLS_DISCONT_START ) & & sequence = = hls - > start_sequence & & hls - > discontinuity_set = = 0 ) {
avio_printf ( out , " #EXT-X-DISCONTINUITY \n " ) ;
hls - > discontinuity_set = 1 ;
}
2014-07-18 10:57:42 +02:00
for ( en = hls - > segments ; en ; en = en - > next ) {
2015-06-15 20:58:07 +02:00
if ( hls - > key_info_file & & ( ! key_uri | | strcmp ( en - > key_uri , key_uri ) | |
av_strcasecmp ( en - > iv_string , iv_string ) ) ) {
avio_printf ( out , " #EXT-X-KEY:METHOD=AES-128,URI= \" %s \" " , en - > key_uri ) ;
if ( * en - > iv_string )
avio_printf ( out , " ,IV=0x%s " , en - > iv_string ) ;
avio_printf ( out , " \n " ) ;
key_uri = en - > key_uri ;
iv_string = en - > iv_string ;
}
2015-04-21 23:46:17 +02:00
if ( hls - > flags & HLS_ROUND_DURATIONS )
2015-12-16 20:40:50 +01:00
avio_printf ( out , " #EXTINF:%ld, \n " , lrint ( en - > duration ) ) ;
2015-04-21 23:46:17 +02:00
else
avio_printf ( out , " #EXTINF:%f, \n " , en - > duration ) ;
2014-09-15 15:26:57 +02:00
if ( hls - > flags & HLS_SINGLE_FILE )
2015-02-20 12:55:13 +01:00
avio_printf ( out , " #EXT-X-BYTERANGE:% " PRIi64 " @% " PRIi64 " \n " ,
2014-09-15 15:26:57 +02:00
en - > size , en - > pos ) ;
2014-03-18 21:19:00 +01:00
if ( hls - > baseurl )
2015-02-20 12:55:13 +01:00
avio_printf ( out , " %s " , hls - > baseurl ) ;
avio_printf ( out , " %s \n " , en - > filename ) ;
2012-10-26 16:36:56 +02:00
}
2015-04-21 23:53:57 +02:00
if ( last & & ( hls - > flags & HLS_OMIT_ENDLIST ) = = 0 )
2015-02-20 12:55:13 +01:00
avio_printf ( out , " #EXT-X-ENDLIST \n " ) ;
2012-10-26 16:36:56 +02:00
2015-06-04 09:55:52 +02:00
if ( hls - > vtt_m3u8_name ) {
2016-02-10 15:40:32 +01:00
if ( ( ret = s - > io_open ( s , & sub_out , hls - > vtt_m3u8_name , AVIO_FLAG_WRITE , & options ) ) < 0 )
2015-06-04 09:55:52 +02:00
goto fail ;
avio_printf ( sub_out , " #EXTM3U \n " ) ;
avio_printf ( sub_out , " #EXT-X-VERSION:%d \n " , version ) ;
if ( hls - > allowcache = = 0 | | hls - > allowcache = = 1 ) {
avio_printf ( sub_out , " #EXT-X-ALLOW-CACHE:%s \n " , hls - > allowcache = = 0 ? " NO " : " YES " ) ;
}
avio_printf ( sub_out , " #EXT-X-TARGETDURATION:%d \n " , target_duration ) ;
avio_printf ( sub_out , " #EXT-X-MEDIA-SEQUENCE:% " PRId64 " \n " , sequence ) ;
av_log ( s , AV_LOG_VERBOSE , " EXT-X-MEDIA-SEQUENCE:% " PRId64 " \n " ,
sequence ) ;
for ( en = hls - > segments ; en ; en = en - > next ) {
avio_printf ( sub_out , " #EXTINF:%f, \n " , en - > duration ) ;
if ( hls - > flags & HLS_SINGLE_FILE )
avio_printf ( sub_out , " #EXT-X-BYTERANGE:% " PRIi64 " @% " PRIi64 " \n " ,
en - > size , en - > pos ) ;
if ( hls - > baseurl )
avio_printf ( sub_out , " %s " , hls - > baseurl ) ;
avio_printf ( sub_out , " %s \n " , en - > sub_filename ) ;
}
if ( last )
avio_printf ( sub_out , " #EXT-X-ENDLIST \n " ) ;
}
2012-10-26 16:36:56 +02:00
fail :
2015-09-14 21:07:37 +02:00
av_dict_free ( & options ) ;
2016-01-16 17:53:43 +01:00
ff_format_io_close ( s , & out ) ;
2016-02-10 15:40:32 +01:00
ff_format_io_close ( s , & sub_out ) ;
2015-02-21 01:21:53 +01:00
if ( ret > = 0 & & use_rename )
2015-02-20 12:55:14 +01:00
ff_rename ( temp_filename , s - > filename , s ) ;
2012-10-26 16:36:56 +02:00
return ret ;
}
static int hls_start ( AVFormatContext * s )
{
HLSContext * c = s - > priv_data ;
AVFormatContext * oc = c - > avf ;
2015-06-04 09:55:52 +02:00
AVFormatContext * vtt_oc = c - > vtt_avf ;
2015-06-15 20:58:07 +02:00
AVDictionary * options = NULL ;
char * filename , iv_string [ KEYSIZE * 2 + 1 ] ;
2012-10-26 16:36:56 +02:00
int err = 0 ;
2015-06-04 09:55:52 +02:00
if ( c - > flags & HLS_SINGLE_FILE ) {
2014-09-15 15:26:57 +02:00
av_strlcpy ( oc - > filename , c - > basename ,
sizeof ( oc - > filename ) ) ;
2015-06-04 09:55:52 +02:00
if ( c - > vtt_basename )
av_strlcpy ( vtt_oc - > filename , c - > vtt_basename ,
sizeof ( vtt_oc - > filename ) ) ;
} else {
2015-08-31 22:10:15 +02:00
if ( c - > use_localtime ) {
time_t now0 ;
struct tm * tm , tmpbuf ;
time ( & now0 ) ;
tm = localtime_r ( & now0 , & tmpbuf ) ;
if ( ! strftime ( oc - > filename , sizeof ( oc - > filename ) , c - > basename , tm ) ) {
av_log ( oc , AV_LOG_ERROR , " Could not get segment filename with use_localtime \n " ) ;
return AVERROR ( EINVAL ) ;
}
2016-02-03 22:20:07 +01:00
if ( c - > use_localtime_mkdir ) {
const char * dir ;
char * fn_copy = av_strdup ( oc - > filename ) ;
if ( ! fn_copy ) {
return AVERROR ( ENOMEM ) ;
}
dir = av_dirname ( fn_copy ) ;
if ( mkdir ( dir , 0777 ) = = - 1 & & errno ! = EEXIST ) {
av_log ( oc , AV_LOG_ERROR , " Could not create directory %s with use_localtime_mkdir \n " , dir ) ;
av_free ( fn_copy ) ;
return AVERROR ( errno ) ;
}
av_free ( fn_copy ) ;
}
} else if ( av_get_frame_filename ( oc - > filename , sizeof ( oc - > filename ) ,
2014-09-15 15:26:57 +02:00
c - > basename , c - > wrap ? c - > sequence % c - > wrap : c - > sequence ) < 0 ) {
2015-08-31 22:10:15 +02:00
av_log ( oc , AV_LOG_ERROR , " Invalid segment filename template '%s' you can try use -use_localtime 1 with it \n " , c - > basename ) ;
2014-09-15 15:26:57 +02:00
return AVERROR ( EINVAL ) ;
}
2015-06-04 09:55:52 +02:00
if ( c - > vtt_basename ) {
if ( av_get_frame_filename ( vtt_oc - > filename , sizeof ( vtt_oc - > filename ) ,
c - > vtt_basename , c - > wrap ? c - > sequence % c - > wrap : c - > sequence ) < 0 ) {
av_log ( vtt_oc , AV_LOG_ERROR , " Invalid segment filename template '%s' \n " , c - > vtt_basename ) ;
return AVERROR ( EINVAL ) ;
}
}
}
2013-06-06 12:09:38 +02:00
c - > number + + ;
2012-10-26 16:36:56 +02:00
2015-09-14 21:07:37 +02:00
set_http_options ( & options , c ) ;
2015-06-15 20:58:07 +02:00
if ( c - > key_info_file ) {
if ( ( err = hls_encryption_start ( s ) ) < 0 )
2015-09-14 21:07:37 +02:00
goto fail ;
2015-06-15 20:58:07 +02:00
if ( ( err = av_dict_set ( & options , " encryption_key " , c - > key_string , 0 ) )
< 0 )
2015-09-14 21:07:37 +02:00
goto fail ;
2015-06-15 20:58:07 +02:00
err = av_strlcpy ( iv_string , c - > iv_string , sizeof ( iv_string ) ) ;
if ( ! err )
snprintf ( iv_string , sizeof ( iv_string ) , " %032 " PRIx64 , c - > sequence ) ;
if ( ( err = av_dict_set ( & options , " encryption_iv " , iv_string , 0 ) ) < 0 )
2015-09-14 21:07:37 +02:00
goto fail ;
2015-06-15 20:58:07 +02:00
filename = av_asprintf ( " crypto:%s " , oc - > filename ) ;
if ( ! filename ) {
2015-09-14 21:07:37 +02:00
err = AVERROR ( ENOMEM ) ;
goto fail ;
2015-06-15 20:58:07 +02:00
}
2016-02-10 19:02:48 +01:00
err = s - > io_open ( s , & oc - > pb , filename , AVIO_FLAG_WRITE , & options ) ;
2015-06-15 20:58:07 +02:00
av_free ( filename ) ;
av_dict_free ( & options ) ;
if ( err < 0 )
return err ;
} else
2016-02-10 15:40:32 +01:00
if ( ( err = s - > io_open ( s , & oc - > pb , oc - > filename , AVIO_FLAG_WRITE , & options ) ) < 0 )
2015-09-14 21:07:37 +02:00
goto fail ;
2015-06-04 09:55:52 +02:00
if ( c - > vtt_basename ) {
2015-09-14 21:07:37 +02:00
set_http_options ( & options , c ) ;
2016-02-10 15:40:32 +01:00
if ( ( err = s - > io_open ( s , & vtt_oc - > pb , vtt_oc - > filename , AVIO_FLAG_WRITE , & options ) ) < 0 )
2015-09-14 21:07:37 +02:00
goto fail ;
2015-06-04 09:55:52 +02:00
}
2015-09-14 21:07:37 +02:00
av_dict_free ( & options ) ;
2012-10-26 16:36:56 +02:00
2015-04-05 20:28:38 +02:00
/* We only require one PAT/PMT per segment. */
if ( oc - > oformat - > priv_class & & oc - > priv_data ) {
char period [ 21 ] ;
snprintf ( period , sizeof ( period ) , " %d " , ( INT_MAX / 2 ) - 1 ) ;
2012-10-26 16:36:56 +02:00
av_opt_set ( oc - > priv_data , " mpegts_flags " , " resend_headers " , 0 ) ;
2015-04-05 20:28:38 +02:00
av_opt_set ( oc - > priv_data , " sdt_period " , period , 0 ) ;
av_opt_set ( oc - > priv_data , " pat_period " , period , 0 ) ;
}
2012-10-26 16:36:56 +02:00
2015-12-13 02:28:13 +01:00
if ( c - > vtt_basename ) {
err = avformat_write_header ( vtt_oc , NULL ) ;
if ( err < 0 )
return err ;
}
2015-06-04 09:55:52 +02:00
2012-10-26 16:36:56 +02:00
return 0 ;
2015-09-14 21:07:37 +02:00
fail :
av_dict_free ( & options ) ;
return err ;
2012-10-26 16:36:56 +02:00
}
static int hls_write_header ( AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
int ret , i ;
char * p ;
const char * pattern = " %d.ts " ;
2015-08-31 22:10:15 +02:00
const char * pattern_localtime_fmt = " -%s.ts " ;
2015-06-04 09:55:52 +02:00
const char * vtt_pattern = " %d.vtt " ;
2014-09-12 12:04:52 +02:00
AVDictionary * options = NULL ;
2014-12-05 22:20:15 +01:00
int basename_size ;
2015-06-04 09:55:52 +02:00
int vtt_basename_size ;
2012-10-26 16:36:56 +02:00
2014-04-29 10:13:34 +02:00
hls - > sequence = hls - > start_sequence ;
2012-12-29 11:44:33 +01:00
hls - > recording_time = hls - > time * AV_TIME_BASE ;
2012-10-26 16:36:56 +02:00
hls - > start_pts = AV_NOPTS_VALUE ;
2014-09-12 12:04:52 +02:00
if ( hls - > format_options_str ) {
ret = av_dict_parse_string ( & hls - > format_options , hls - > format_options_str , " = " , " : " , 0 ) ;
if ( ret < 0 ) {
av_log ( s , AV_LOG_ERROR , " Could not parse format options list '%s' \n " , hls - > format_options_str ) ;
goto fail ;
}
}
2015-06-04 09:55:52 +02:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
2012-10-26 16:36:56 +02:00
hls - > has_video + =
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
s - > streams [ i ] - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO ;
2015-06-04 09:55:52 +02:00
hls - > has_subtitle + =
2016-04-10 21:58:15 +02:00
s - > streams [ i ] - > codecpar - > codec_type = = AVMEDIA_TYPE_SUBTITLE ;
2015-06-04 09:55:52 +02:00
}
2012-10-26 16:36:56 +02:00
if ( hls - > has_video > 1 )
av_log ( s , AV_LOG_WARNING ,
" More than a single video stream present, "
" expect issues decoding it. \n " ) ;
hls - > oformat = av_guess_format ( " mpegts " , NULL , NULL ) ;
if ( ! hls - > oformat ) {
ret = AVERROR_MUXER_NOT_FOUND ;
goto fail ;
}
2015-06-04 09:55:52 +02:00
if ( hls - > has_subtitle ) {
hls - > vtt_oformat = av_guess_format ( " webvtt " , NULL , NULL ) ;
if ( ! hls - > oformat ) {
ret = AVERROR_MUXER_NOT_FOUND ;
goto fail ;
}
}
2014-12-05 22:20:15 +01:00
if ( hls - > segment_filename ) {
hls - > basename = av_strdup ( hls - > segment_filename ) ;
if ( ! hls - > basename ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
} else {
if ( hls - > flags & HLS_SINGLE_FILE )
pattern = " .ts " ;
2012-10-26 16:36:56 +02:00
2015-08-31 22:10:15 +02:00
if ( hls - > use_localtime ) {
basename_size = strlen ( s - > filename ) + strlen ( pattern_localtime_fmt ) + 1 ;
} else {
basename_size = strlen ( s - > filename ) + strlen ( pattern ) + 1 ;
}
2014-12-05 22:20:15 +01:00
hls - > basename = av_malloc ( basename_size ) ;
if ( ! hls - > basename ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
2012-10-26 16:36:56 +02:00
2014-12-05 22:20:15 +01:00
av_strlcpy ( hls - > basename , s - > filename , basename_size ) ;
2012-10-26 16:36:56 +02:00
2014-12-05 22:20:15 +01:00
p = strrchr ( hls - > basename , ' . ' ) ;
if ( p )
* p = ' \0 ' ;
2015-08-31 22:10:15 +02:00
if ( hls - > use_localtime ) {
av_strlcat ( hls - > basename , pattern_localtime_fmt , basename_size ) ;
} else {
av_strlcat ( hls - > basename , pattern , basename_size ) ;
}
2014-12-05 22:20:15 +01:00
}
2012-10-26 16:36:56 +02:00
2015-06-04 09:55:52 +02:00
if ( hls - > has_subtitle ) {
if ( hls - > flags & HLS_SINGLE_FILE )
vtt_pattern = " .vtt " ;
vtt_basename_size = strlen ( s - > filename ) + strlen ( vtt_pattern ) + 1 ;
hls - > vtt_basename = av_malloc ( vtt_basename_size ) ;
if ( ! hls - > vtt_basename ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
hls - > vtt_m3u8_name = av_malloc ( vtt_basename_size ) ;
if ( ! hls - > vtt_m3u8_name ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
av_strlcpy ( hls - > vtt_basename , s - > filename , vtt_basename_size ) ;
p = strrchr ( hls - > vtt_basename , ' . ' ) ;
if ( p )
* p = ' \0 ' ;
if ( hls - > subtitle_filename ) {
strcpy ( hls - > vtt_m3u8_name , hls - > subtitle_filename ) ;
} else {
strcpy ( hls - > vtt_m3u8_name , hls - > vtt_basename ) ;
av_strlcat ( hls - > vtt_m3u8_name , " _vtt.m3u8 " , vtt_basename_size ) ;
}
av_strlcat ( hls - > vtt_basename , vtt_pattern , vtt_basename_size ) ;
}
2012-10-26 16:36:56 +02:00
if ( ( ret = hls_mux_init ( s ) ) < 0 )
goto fail ;
if ( ( ret = hls_start ( s ) ) < 0 )
goto fail ;
2014-09-12 12:04:52 +02:00
av_dict_copy ( & options , hls - > format_options , 0 ) ;
ret = avformat_write_header ( hls - > avf , & options ) ;
if ( av_dict_count ( options ) ) {
av_log ( s , AV_LOG_ERROR , " Some of provided format options in '%s' are not recognized \n " , hls - > format_options_str ) ;
ret = AVERROR ( EINVAL ) ;
2014-07-29 16:24:11 +02:00
goto fail ;
2014-09-12 12:04:52 +02:00
}
2015-06-04 09:55:52 +02:00
//av_assert0(s->nb_streams == hls->avf->nb_streams);
2014-09-28 22:27:33 +02:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
2015-06-04 09:55:52 +02:00
AVStream * inner_st ;
2014-09-29 00:19:43 +02:00
AVStream * outer_st = s - > streams [ i ] ;
2016-04-10 21:58:15 +02:00
if ( outer_st - > codecpar - > codec_type ! = AVMEDIA_TYPE_SUBTITLE )
2015-06-04 09:55:52 +02:00
inner_st = hls - > avf - > streams [ i ] ;
else if ( hls - > vtt_avf )
inner_st = hls - > vtt_avf - > streams [ 0 ] ;
else {
2015-07-26 22:06:19 +02:00
/* We have a subtitle stream, when the user does not want one */
2015-06-04 09:55:52 +02:00
inner_st = NULL ;
continue ;
}
2014-09-29 00:19:43 +02:00
avpriv_set_pts_info ( outer_st , inner_st - > pts_wrap_bits , inner_st - > time_base . num , inner_st - > time_base . den ) ;
2014-09-28 22:27:33 +02:00
}
2012-10-26 16:36:56 +02:00
fail :
2014-09-12 12:04:52 +02:00
av_dict_free ( & options ) ;
2015-01-11 04:58:29 +01:00
if ( ret < 0 ) {
2014-12-16 15:04:41 +01:00
av_freep ( & hls - > basename ) ;
2015-06-04 09:55:52 +02:00
av_freep ( & hls - > vtt_basename ) ;
2012-10-26 16:36:56 +02:00
if ( hls - > avf )
avformat_free_context ( hls - > avf ) ;
2015-06-04 09:55:52 +02:00
if ( hls - > vtt_avf )
avformat_free_context ( hls - > vtt_avf ) ;
2012-10-26 16:36:56 +02:00
}
return ret ;
}
static int hls_write_packet ( AVFormatContext * s , AVPacket * pkt )
{
HLSContext * hls = s - > priv_data ;
2015-06-04 09:55:52 +02:00
AVFormatContext * oc = NULL ;
2012-10-26 16:36:56 +02:00
AVStream * st = s - > streams [ pkt - > stream_index ] ;
int64_t end_pts = hls - > recording_time * hls - > number ;
2013-04-28 11:48:40 +02:00
int is_ref_pkt = 1 ;
2013-04-26 09:54:59 +02:00
int ret , can_split = 1 ;
2015-06-04 09:55:52 +02:00
int stream_index = 0 ;
2012-10-26 16:36:56 +02:00
2016-04-10 21:58:15 +02:00
if ( st - > codecpar - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
2015-06-04 09:55:52 +02:00
oc = hls - > vtt_avf ;
stream_index = 0 ;
} else {
oc = hls - > avf ;
stream_index = pkt - > stream_index ;
}
2012-10-26 16:36:56 +02:00
if ( hls - > start_pts = = AV_NOPTS_VALUE ) {
hls - > start_pts = pkt - > pts ;
hls - > end_pts = pkt - > pts ;
}
2013-04-26 09:54:59 +02:00
if ( hls - > has_video ) {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
can_split = st - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO & &
2013-04-26 09:54:59 +02:00
pkt - > flags & AV_PKT_FLAG_KEY ;
2016-04-10 21:58:15 +02:00
is_ref_pkt = st - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO ;
2013-01-13 17:22:59 +01:00
}
2013-04-28 11:48:40 +02:00
if ( pkt - > pts = = AV_NOPTS_VALUE )
is_ref_pkt = can_split = 0 ;
2013-01-13 17:22:59 +01:00
2013-04-28 11:48:40 +02:00
if ( is_ref_pkt )
2014-04-02 21:17:13 +02:00
hls - > duration = ( double ) ( pkt - > pts - hls - > end_pts )
* st - > time_base . num / st - > time_base . den ;
2012-10-26 16:36:56 +02:00
2013-04-26 09:54:59 +02:00
if ( can_split & & av_compare_ts ( pkt - > pts - hls - > start_pts , st - > time_base ,
end_pts , AV_TIME_BASE_Q ) > = 0 ) {
2014-09-15 15:26:57 +02:00
int64_t new_start_pos ;
av_write_frame ( oc , NULL ) ; /* Flush any buffered data */
new_start_pos = avio_tell ( hls - > avf - > pb ) ;
hls - > size = new_start_pos - hls - > start_pos ;
2016-02-03 22:20:07 +01:00
ret = hls_append_segment ( s , hls , hls - > duration , hls - > start_pos , hls - > size ) ;
2014-09-15 15:26:57 +02:00
hls - > start_pos = new_start_pos ;
2015-01-11 04:58:29 +01:00
if ( ret < 0 )
2012-12-25 08:59:38 +01:00
return ret ;
2012-10-26 16:36:56 +02:00
hls - > end_pts = pkt - > pts ;
2013-01-13 17:22:59 +01:00
hls - > duration = 0 ;
2012-10-26 16:36:56 +02:00
2014-09-15 15:26:57 +02:00
if ( hls - > flags & HLS_SINGLE_FILE ) {
if ( hls - > avf - > oformat - > priv_class & & hls - > avf - > priv_data )
av_opt_set ( hls - > avf - > priv_data , " mpegts_flags " , " resend_headers " , 0 ) ;
hls - > number + + ;
} else {
2016-02-10 15:40:32 +01:00
ff_format_io_close ( s , & oc - > pb ) ;
2015-06-04 09:55:52 +02:00
if ( hls - > vtt_avf )
2016-02-10 15:40:32 +01:00
ff_format_io_close ( s , & hls - > vtt_avf - > pb ) ;
2012-10-26 16:36:56 +02:00
2014-09-15 15:26:57 +02:00
ret = hls_start ( s ) ;
}
2012-10-26 16:36:56 +02:00
2015-01-11 04:58:29 +01:00
if ( ret < 0 )
2012-10-26 16:36:56 +02:00
return ret ;
2016-04-10 21:58:15 +02:00
if ( st - > codecpar - > codec_type = = AVMEDIA_TYPE_SUBTITLE )
2015-06-04 09:55:52 +02:00
oc = hls - > vtt_avf ;
else
2012-10-26 16:36:56 +02:00
oc = hls - > avf ;
if ( ( ret = hls_window ( s , 0 ) ) < 0 )
return ret ;
}
2015-06-04 09:55:52 +02:00
ret = ff_write_chained ( oc , stream_index , pkt , s , 0 ) ;
2012-10-26 16:36:56 +02:00
return ret ;
}
static int hls_write_trailer ( struct AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
AVFormatContext * oc = hls - > avf ;
2015-06-04 09:55:52 +02:00
AVFormatContext * vtt_oc = hls - > vtt_avf ;
2012-10-26 16:36:56 +02:00
av_write_trailer ( oc ) ;
2014-12-16 01:10:46 +01:00
if ( oc - > pb ) {
hls - > size = avio_tell ( hls - > avf - > pb ) - hls - > start_pos ;
2016-02-10 15:40:32 +01:00
ff_format_io_close ( s , & oc - > pb ) ;
2016-02-03 22:20:07 +01:00
hls_append_segment ( s , hls , hls - > duration , hls - > start_pos , hls - > size ) ;
2014-12-16 01:10:46 +01:00
}
2015-06-04 09:55:52 +02:00
if ( vtt_oc ) {
if ( vtt_oc - > pb )
av_write_trailer ( vtt_oc ) ;
hls - > size = avio_tell ( hls - > vtt_avf - > pb ) - hls - > start_pos ;
2016-02-10 15:40:32 +01:00
ff_format_io_close ( s , & vtt_oc - > pb ) ;
2015-06-04 09:55:52 +02:00
}
2014-12-16 15:04:41 +01:00
av_freep ( & hls - > basename ) ;
2014-11-16 04:02:56 +01:00
avformat_free_context ( oc ) ;
2015-06-04 09:55:52 +02:00
if ( vtt_oc ) {
av_freep ( & hls - > vtt_basename ) ;
av_freep ( & hls - > vtt_m3u8_name ) ;
avformat_free_context ( vtt_oc ) ;
}
2014-11-16 04:02:56 +01:00
hls - > avf = NULL ;
2012-10-26 16:36:56 +02:00
hls_window ( s , 1 ) ;
2014-12-08 17:25:05 +01:00
hls_free_segments ( hls - > segments ) ;
hls_free_segments ( hls - > old_segments ) ;
2012-10-26 16:36:56 +02:00
return 0 ;
}
# define OFFSET(x) offsetof(HLSContext, x)
# define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options [ ] = {
2014-04-30 20:52:58 +02:00
{ " start_number " , " set first number in the sequence " , OFFSET ( start_sequence ) , AV_OPT_TYPE_INT64 , { . i64 = 0 } , 0 , INT64_MAX , E } ,
2013-01-09 11:26:31 +01:00
{ " hls_time " , " set segment length in seconds " , OFFSET ( time ) , AV_OPT_TYPE_FLOAT , { . dbl = 2 } , 0 , FLT_MAX , E } ,
2014-07-18 10:57:42 +02:00
{ " hls_list_size " , " set maximum number of playlist entries " , OFFSET ( max_nb_segments ) , AV_OPT_TYPE_INT , { . i64 = 5 } , 0 , INT_MAX , E } ,
2014-09-12 12:04:52 +02:00
{ " hls_ts_options " , " set hls mpegts list of options for the container format used for hls " , OFFSET ( format_options_str ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2015-06-04 09:55:52 +02:00
{ " hls_vtt_options " , " set hls vtt list of options for the container format used for hls " , OFFSET ( vtt_format_options_str ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2013-01-09 11:26:31 +01:00
{ " hls_wrap " , " set number after which the index wraps " , OFFSET ( wrap ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , E } ,
2014-09-22 10:17:01 +02:00
{ " hls_allow_cache " , " explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments " , OFFSET ( allowcache ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , INT_MIN , INT_MAX , E } ,
2014-03-18 21:19:00 +01:00
{ " hls_base_url " , " url to prepend to each playlist entry " , OFFSET ( baseurl ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2014-12-05 22:20:15 +01:00
{ " hls_segment_filename " , " filename template for segment files " , OFFSET ( segment_filename ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2015-06-15 20:58:07 +02:00
{ " hls_key_info_file " , " file with key URI and key file path " , OFFSET ( key_info_file ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2015-06-04 09:55:52 +02:00
{ " hls_subtitle_path " , " set path of hls subtitles " , OFFSET ( subtitle_filename ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2014-09-15 15:26:57 +02:00
{ " hls_flags " , " set flags affecting HLS playlist and media file generation " , OFFSET ( flags ) , AV_OPT_TYPE_FLAGS , { . i64 = 0 } , 0 , UINT_MAX , E , " flags " } ,
{ " single_file " , " generate a single media file indexed with byte ranges " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_SINGLE_FILE } , 0 , UINT_MAX , E , " flags " } ,
2014-12-08 17:25:05 +01:00
{ " delete_segments " , " delete segment files that are no longer part of the playlist " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_DELETE_SEGMENTS } , 0 , UINT_MAX , E , " flags " } ,
2015-04-21 23:46:17 +02:00
{ " round_durations " , " round durations in m3u8 to whole numbers " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_ROUND_DURATIONS } , 0 , UINT_MAX , E , " flags " } ,
2015-04-21 23:52:03 +02:00
{ " discont_start " , " start the playlist with a discontinuity tag " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_DISCONT_START } , 0 , UINT_MAX , E , " flags " } ,
2015-04-21 23:53:57 +02:00
{ " omit_endlist " , " Do not append an endlist when ending stream " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_OMIT_ENDLIST } , 0 , UINT_MAX , E , " flags " } ,
2016-02-03 22:20:07 +01:00
{ " use_localtime " , " set filename expansion with strftime at segment creation " , OFFSET ( use_localtime ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
{ " use_localtime_mkdir " , " create last directory component in strftime-generated filename " , OFFSET ( use_localtime_mkdir ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
2015-12-17 04:16:45 +01:00
{ " hls_playlist_type " , " set the HLS playlist type " , OFFSET ( pl_type ) , AV_OPT_TYPE_INT , { . i64 = PLAYLIST_TYPE_NONE } , 0 , PLAYLIST_TYPE_NB - 1 , E , " pl_type " } ,
{ " event " , " EVENT playlist " , 0 , AV_OPT_TYPE_CONST , { . i64 = PLAYLIST_TYPE_EVENT } , INT_MIN , INT_MAX , E , " pl_type " } ,
{ " vod " , " VOD playlist " , 0 , AV_OPT_TYPE_CONST , { . i64 = PLAYLIST_TYPE_VOD } , INT_MIN , INT_MAX , E , " pl_type " } ,
2015-09-14 21:07:37 +02:00
{ " method " , " set the HTTP method " , OFFSET ( method ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2014-09-15 15:26:57 +02:00
2012-10-26 16:36:56 +02:00
{ NULL } ,
} ;
static const AVClass hls_class = {
. class_name = " hls muxer " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
AVOutputFormat ff_hls_muxer = {
. name = " hls " ,
2012-12-08 06:00:46 +01:00
. long_name = NULL_IF_CONFIG_SMALL ( " Apple HTTP Live Streaming " ) ,
2012-10-26 16:36:56 +02:00
. extensions = " m3u8 " ,
. priv_data_size = sizeof ( HLSContext ) ,
2014-05-15 20:43:46 +02:00
. audio_codec = AV_CODEC_ID_AAC ,
. video_codec = AV_CODEC_ID_H264 ,
2015-06-04 09:55:52 +02:00
. subtitle_codec = AV_CODEC_ID_WEBVTT ,
2012-10-26 16:36:56 +02:00
. flags = AVFMT_NOFILE | AVFMT_ALLOW_FLUSH ,
. write_header = hls_write_header ,
. write_packet = hls_write_packet ,
. write_trailer = hls_write_trailer ,
. priv_class = & hls_class ,
} ;