2012-10-26 17:36:56 +03:00
/*
* Apple HTTP Live Streaming segmenter
* Copyright ( c ) 2012 , Luca Barbato
*
2012-11-14 13:22:40 +03:00
* This file is part of FFmpeg .
2012-10-26 17:36:56 +03:00
*
2012-11-14 13:22:40 +03:00
* FFmpeg is free software ; you can redistribute it and / or
2012-10-26 17:36:56 +03: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 13:22:40 +03:00
* FFmpeg is distributed in the hope that it will be useful ,
2012-10-26 17:36:56 +03: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 13:22:40 +03:00
* License along with FFmpeg ; if not , write to the Free Software
2012-10-26 17:36:56 +03:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
2014-12-08 18:25:05 +02:00
# include "config.h"
2012-10-26 17:36:56 +03:00
# include <float.h>
2013-11-23 23:32:55 +03:00
# include <stdint.h>
2014-12-08 18:25:05 +02:00
# if HAVE_UNISTD_H
# include <unistd.h>
# endif
2012-10-26 17:36:56 +03:00
2014-09-28 23:27:33 +03:00
# include "libavutil/avassert.h"
2012-10-26 17:36:56 +03:00
# include "libavutil/mathematics.h"
# include "libavutil/parseutils.h"
# include "libavutil/avstring.h"
# include "libavutil/opt.h"
# include "libavutil/log.h"
# include "avformat.h"
# include "internal.h"
2014-12-08 18:25:05 +02:00
# include "os_support.h"
2012-10-26 17:36:56 +03:00
2014-07-18 11:57:42 +03:00
typedef struct HLSSegment {
char filename [ 1024 ] ;
2014-07-18 11:57:42 +03:00
double duration ; /* in seconds */
2014-09-15 16:26:57 +03:00
int64_t pos ;
int64_t size ;
2014-07-18 11:57:42 +03:00
2014-07-18 11:57:42 +03:00
struct HLSSegment * next ;
} HLSSegment ;
2012-10-26 17:36:56 +03:00
2014-09-15 16:26:57 +03:00
typedef enum HLSFlags {
// Generate a single media file and use byte ranges in the playlist.
HLS_SINGLE_FILE = ( 1 < < 0 ) ,
2014-12-08 18:25:05 +02:00
HLS_DELETE_SEGMENTS = ( 1 < < 1 ) ,
2014-09-15 16:26:57 +03:00
} HLSFlags ;
2012-10-26 17:36:56 +03:00
typedef struct HLSContext {
const AVClass * class ; // Class for private options.
2012-12-29 14:31:01 +03:00
unsigned number ;
2012-12-29 14:09:17 +03:00
int64_t sequence ;
2014-04-29 11:13:34 +03:00
int64_t start_sequence ;
2012-10-26 17:36:56 +03:00
AVOutputFormat * oformat ;
2014-07-18 11:57:42 +03:00
2012-10-26 17:36:56 +03:00
AVFormatContext * avf ;
2014-07-18 11:57:42 +03:00
2012-10-26 17:36:56 +03:00
float time ; // Set by a private option.
2014-07-18 11:57:42 +03:00
int max_nb_segments ; // Set by a private option.
2012-10-26 17:36:56 +03:00
int wrap ; // Set by a private option.
2014-09-15 16:26:57 +03:00
uint32_t flags ; // enum HLSFlags
2014-12-05 23:20:15 +02:00
char * segment_filename ;
2014-07-18 11:57:42 +03:00
2014-09-22 11:17:01 +03:00
int allowcache ;
2012-10-26 17:36:56 +03:00
int64_t recording_time ;
int has_video ;
int64_t start_pts ;
int64_t end_pts ;
2014-04-02 22:17:13 +03:00
double duration ; // last segment duration computed so far, in seconds
2014-09-15 16:26:57 +03:00
int64_t start_pos ; // last segment starting position
int64_t size ; // last segment size
2012-12-25 12:05:42 +03:00
int nb_entries ;
2014-07-18 11:57:42 +03:00
2014-07-18 11:57:42 +03:00
HLSSegment * segments ;
HLSSegment * last_segment ;
2014-12-08 18:25:05 +02:00
HLSSegment * old_segments ;
2014-07-18 11:57:42 +03:00
2012-10-26 17:36:56 +03:00
char * basename ;
2014-03-18 23:19:00 +03:00
char * baseurl ;
2014-09-12 13:04:52 +03:00
char * format_options_str ;
AVDictionary * format_options ;
2014-07-18 11:57:42 +03:00
2012-10-26 17:36:56 +03:00
AVIOContext * pb ;
} HLSContext ;
2014-12-08 18:25:05 +02:00
static int hls_delete_old_segments ( HLSContext * hls ) {
HLSSegment * segment , * previous_segment = NULL ;
float playlist_duration = 0.0f ;
int ret = 0 , path_size ;
char * dirname = NULL , * p , * path ;
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 ;
}
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 ) ) ;
}
av_free ( path ) ;
previous_segment = segment ;
segment = previous_segment - > next ;
av_free ( previous_segment ) ;
}
fail :
av_free ( dirname ) ;
return ret ;
}
2012-10-26 17:36:56 +03:00
static int hls_mux_init ( AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
AVFormatContext * oc ;
2014-10-17 19:28:47 +03:00
int i , ret ;
2012-10-26 17:36:56 +03:00
2014-10-17 19:28:47 +03:00
ret = avformat_alloc_output_context2 ( & hls - > avf , hls - > oformat , NULL , NULL ) ;
if ( ret < 0 )
return ret ;
oc = hls - > avf ;
2012-10-26 17:36:56 +03:00
oc - > oformat = hls - > oformat ;
oc - > interrupt_callback = s - > interrupt_callback ;
2014-10-17 19:28:47 +03:00
oc - > max_delay = s - > max_delay ;
2013-12-12 20:41:39 +03:00
av_dict_copy ( & oc - > metadata , s - > metadata , 0 ) ;
2012-10-26 17:36:56 +03:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st ;
if ( ! ( st = avformat_new_stream ( oc , NULL ) ) )
return AVERROR ( ENOMEM ) ;
avcodec_copy_context ( st - > codec , s - > streams [ i ] - > codec ) ;
st - > sample_aspect_ratio = s - > streams [ i ] - > sample_aspect_ratio ;
2014-10-06 11:41:33 +03:00
st - > time_base = s - > streams [ i ] - > time_base ;
2012-10-26 17:36:56 +03:00
}
2014-09-15 16:26:57 +03:00
hls - > start_pos = 0 ;
2012-10-26 17:36:56 +03:00
return 0 ;
}
2014-07-18 11:57:42 +03:00
/* Create a new segment and append it to the segment list */
2014-09-15 16:26:57 +03:00
static int hls_append_segment ( HLSContext * hls , double duration , int64_t pos ,
int64_t size )
2012-10-26 17:36:56 +03:00
{
2014-07-18 11:57:42 +03:00
HLSSegment * en = av_malloc ( sizeof ( * en ) ) ;
2014-12-08 18:25:05 +02:00
int ret ;
2012-10-26 17:36:56 +03:00
if ( ! en )
return AVERROR ( ENOMEM ) ;
2014-07-18 11:57:42 +03:00
av_strlcpy ( en - > filename , av_basename ( hls - > avf - > filename ) , sizeof ( en - > filename ) ) ;
2012-10-26 17:36:56 +03:00
en - > duration = duration ;
2014-09-15 16:26:57 +03:00
en - > pos = pos ;
en - > size = size ;
2012-10-26 17:36:56 +03:00
en - > next = NULL ;
2014-07-18 11:57:42 +03:00
if ( ! hls - > segments )
hls - > segments = en ;
2012-10-26 17:36:56 +03:00
else
2014-07-18 11:57:42 +03:00
hls - > last_segment - > next = en ;
2012-10-26 17:36:56 +03:00
2014-07-18 11:57:42 +03:00
hls - > last_segment = en ;
2012-10-26 17:36:56 +03:00
2014-07-18 11:57:42 +03:00
if ( hls - > max_nb_segments & & hls - > nb_entries > = hls - > max_nb_segments ) {
en = hls - > segments ;
hls - > segments = en - > next ;
2014-12-08 18:25:05 +02: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 12:05:42 +03:00
} else
hls - > nb_entries + + ;
2012-10-26 17:36:56 +03:00
2012-12-29 14:09:17 +03:00
hls - > sequence + + ;
2012-10-26 17:36:56 +03:00
return 0 ;
}
2014-12-08 18:25:05 +02:00
static void hls_free_segments ( HLSSegment * p )
2012-10-26 17:36:56 +03:00
{
2014-12-08 18:25:05 +02:00
HLSSegment * en ;
2012-10-26 17:36:56 +03:00
while ( p ) {
en = p ;
p = p - > next ;
av_free ( en ) ;
}
}
static int hls_window ( AVFormatContext * s , int last )
{
HLSContext * hls = s - > priv_data ;
2014-07-18 11:57:42 +03:00
HLSSegment * en ;
2012-12-21 14:05:46 +03:00
int target_duration = 0 ;
2012-10-26 17:36:56 +03:00
int ret = 0 ;
2014-04-30 22:14:56 +03:00
int64_t sequence = FFMAX ( hls - > start_sequence , hls - > sequence - hls - > nb_entries ) ;
2014-09-15 16:26:57 +03:00
int version = hls - > flags & HLS_SINGLE_FILE ? 4 : 3 ;
2012-10-26 17:36:56 +03:00
if ( ( ret = avio_open2 ( & hls - > pb , s - > filename , AVIO_FLAG_WRITE ,
& s - > interrupt_callback , NULL ) ) < 0 )
goto fail ;
2014-07-18 11:57:42 +03:00
for ( en = hls - > segments ; en ; en = en - > next ) {
2012-12-21 14:05:46 +03:00
if ( target_duration < en - > duration )
2014-07-07 14:26:12 +03:00
target_duration = ceil ( en - > duration ) ;
2012-12-21 14:05:46 +03:00
}
2012-10-26 17:36:56 +03:00
avio_printf ( hls - > pb , " #EXTM3U \n " ) ;
2014-09-15 16:26:57 +03:00
avio_printf ( hls - > pb , " #EXT-X-VERSION:%d \n " , version ) ;
2014-09-22 11:17:01 +03:00
if ( hls - > allowcache = = 0 | | hls - > allowcache = = 1 ) {
avio_printf ( hls - > pb , " #EXT-X-ALLOW-CACHE:%s \n " , hls - > allowcache = = 0 ? " NO " : " YES " ) ;
}
2012-12-21 14:05:46 +03:00
avio_printf ( hls - > pb , " #EXT-X-TARGETDURATION:%d \n " , target_duration ) ;
2014-04-29 19:37:01 +03:00
avio_printf ( hls - > pb , " #EXT-X-MEDIA-SEQUENCE:% " PRId64 " \n " , sequence ) ;
2012-10-26 17:36:56 +03:00
2014-04-29 11:07:03 +03:00
av_log ( s , AV_LOG_VERBOSE , " EXT-X-MEDIA-SEQUENCE:% " PRId64 " \n " ,
2014-04-29 19:37:01 +03:00
sequence ) ;
2014-04-29 11:07:03 +03:00
2014-07-18 11:57:42 +03:00
for ( en = hls - > segments ; en ; en = en - > next ) {
2014-04-03 01:27:53 +03:00
avio_printf ( hls - > pb , " #EXTINF:%f, \n " , en - > duration ) ;
2014-09-15 16:26:57 +03:00
if ( hls - > flags & HLS_SINGLE_FILE )
avio_printf ( hls - > pb , " #EXT-X-BYTERANGE:% " PRIi64 " @% " PRIi64 " \n " ,
en - > size , en - > pos ) ;
2014-03-18 23:19:00 +03:00
if ( hls - > baseurl )
avio_printf ( hls - > pb , " %s " , hls - > baseurl ) ;
2014-07-18 11:57:42 +03:00
avio_printf ( hls - > pb , " %s \n " , en - > filename ) ;
2012-10-26 17:36:56 +03:00
}
if ( last )
avio_printf ( hls - > pb , " #EXT-X-ENDLIST \n " ) ;
fail :
avio_closep ( & hls - > pb ) ;
return ret ;
}
static int hls_start ( AVFormatContext * s )
{
HLSContext * c = s - > priv_data ;
AVFormatContext * oc = c - > avf ;
int err = 0 ;
2014-09-15 16:26:57 +03:00
if ( c - > flags & HLS_SINGLE_FILE )
av_strlcpy ( oc - > filename , c - > basename ,
sizeof ( oc - > filename ) ) ;
else
if ( av_get_frame_filename ( oc - > filename , sizeof ( oc - > filename ) ,
c - > basename , c - > wrap ? c - > sequence % c - > wrap : c - > sequence ) < 0 ) {
av_log ( oc , AV_LOG_ERROR , " Invalid segment filename template '%s' \n " , c - > basename ) ;
return AVERROR ( EINVAL ) ;
}
2013-06-06 13:09:38 +03:00
c - > number + + ;
2012-10-26 17:36:56 +03:00
if ( ( err = avio_open2 ( & oc - > pb , oc - > filename , AVIO_FLAG_WRITE ,
& s - > interrupt_callback , NULL ) ) < 0 )
return err ;
if ( oc - > oformat - > priv_class & & oc - > priv_data )
av_opt_set ( oc - > priv_data , " mpegts_flags " , " resend_headers " , 0 ) ;
return 0 ;
}
static int hls_write_header ( AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
int ret , i ;
char * p ;
const char * pattern = " %d.ts " ;
2014-09-12 13:04:52 +03:00
AVDictionary * options = NULL ;
2014-12-05 23:20:15 +02:00
int basename_size ;
2012-10-26 17:36:56 +03:00
2014-04-29 11:13:34 +03:00
hls - > sequence = hls - > start_sequence ;
2012-12-29 13:44:33 +03:00
hls - > recording_time = hls - > time * AV_TIME_BASE ;
2012-10-26 17:36:56 +03:00
hls - > start_pts = AV_NOPTS_VALUE ;
2014-09-12 13:04:52 +03: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 ;
}
}
2012-10-26 17:36:56 +03:00
for ( i = 0 ; i < s - > nb_streams ; i + + )
hls - > has_video + =
s - > streams [ i ] - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ;
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 ;
}
2014-12-05 23:20:15 +02: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 17:36:56 +03:00
2014-12-05 23:20:15 +02:00
basename_size = strlen ( s - > filename ) + strlen ( pattern ) + 1 ;
hls - > basename = av_malloc ( basename_size ) ;
if ( ! hls - > basename ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
2012-10-26 17:36:56 +03:00
2014-12-05 23:20:15 +02:00
av_strlcpy ( hls - > basename , s - > filename , basename_size ) ;
2012-10-26 17:36:56 +03:00
2014-12-05 23:20:15 +02:00
p = strrchr ( hls - > basename , ' . ' ) ;
if ( p )
* p = ' \0 ' ;
av_strlcat ( hls - > basename , pattern , basename_size ) ;
}
2012-10-26 17:36:56 +03:00
if ( ( ret = hls_mux_init ( s ) ) < 0 )
goto fail ;
if ( ( ret = hls_start ( s ) ) < 0 )
goto fail ;
2014-09-12 13:04:52 +03: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 17:24:11 +03:00
goto fail ;
2014-09-12 13:04:52 +03:00
}
2014-09-28 23:27:33 +03:00
av_assert0 ( s - > nb_streams = = hls - > avf - > nb_streams ) ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * inner_st = hls - > avf - > streams [ i ] ;
2014-09-29 01:19:43 +03:00
AVStream * outer_st = s - > streams [ i ] ;
avpriv_set_pts_info ( outer_st , inner_st - > pts_wrap_bits , inner_st - > time_base . num , inner_st - > time_base . den ) ;
2014-09-28 23:27:33 +03:00
}
2012-10-26 17:36:56 +03:00
fail :
2014-09-12 13:04:52 +03:00
av_dict_free ( & options ) ;
2012-10-26 17:36:56 +03:00
if ( ret ) {
2014-12-16 16:04:41 +02:00
av_freep ( & hls - > basename ) ;
2012-10-26 17:36:56 +03:00
if ( hls - > avf )
avformat_free_context ( hls - > avf ) ;
}
return ret ;
}
static int hls_write_packet ( AVFormatContext * s , AVPacket * pkt )
{
HLSContext * hls = s - > priv_data ;
AVFormatContext * oc = hls - > avf ;
AVStream * st = s - > streams [ pkt - > stream_index ] ;
int64_t end_pts = hls - > recording_time * hls - > number ;
2013-04-28 12:48:40 +03:00
int is_ref_pkt = 1 ;
2013-04-26 10:54:59 +03:00
int ret , can_split = 1 ;
2012-10-26 17:36:56 +03:00
if ( hls - > start_pts = = AV_NOPTS_VALUE ) {
hls - > start_pts = pkt - > pts ;
hls - > end_pts = pkt - > pts ;
}
2013-04-26 10:54:59 +03:00
if ( hls - > has_video ) {
can_split = st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & &
pkt - > flags & AV_PKT_FLAG_KEY ;
2013-04-28 12:48:40 +03:00
is_ref_pkt = st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ;
2013-01-13 19:22:59 +03:00
}
2013-04-28 12:48:40 +03:00
if ( pkt - > pts = = AV_NOPTS_VALUE )
is_ref_pkt = can_split = 0 ;
2013-01-13 19:22:59 +03:00
2013-04-28 12:48:40 +03:00
if ( is_ref_pkt )
2014-04-02 22:17:13 +03:00
hls - > duration = ( double ) ( pkt - > pts - hls - > end_pts )
* st - > time_base . num / st - > time_base . den ;
2012-10-26 17:36:56 +03:00
2013-04-26 10:54:59 +03: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 16:26:57 +03: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 ;
ret = hls_append_segment ( hls , hls - > duration , hls - > start_pos , hls - > size ) ;
hls - > start_pos = new_start_pos ;
2012-12-25 10:59:38 +03:00
if ( ret )
return ret ;
2012-10-26 17:36:56 +03:00
hls - > end_pts = pkt - > pts ;
2013-01-13 19:22:59 +03:00
hls - > duration = 0 ;
2012-10-26 17:36:56 +03:00
2014-09-15 16:26:57 +03: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 {
2014-12-16 02:10:46 +02:00
avio_closep ( & oc - > pb ) ;
2012-10-26 17:36:56 +03:00
2014-09-15 16:26:57 +03:00
ret = hls_start ( s ) ;
}
2012-10-26 17:36:56 +03:00
if ( ret )
return ret ;
oc = hls - > avf ;
if ( ( ret = hls_window ( s , 0 ) ) < 0 )
return ret ;
}
2014-07-24 23:39:22 +03:00
ret = ff_write_chained ( oc , pkt - > stream_index , pkt , s , 0 ) ;
2012-10-26 17:36:56 +03:00
return ret ;
}
static int hls_write_trailer ( struct AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
AVFormatContext * oc = hls - > avf ;
av_write_trailer ( oc ) ;
2014-12-16 02:10:46 +02:00
if ( oc - > pb ) {
hls - > size = avio_tell ( hls - > avf - > pb ) - hls - > start_pos ;
avio_closep ( & oc - > pb ) ;
hls_append_segment ( hls , hls - > duration , hls - > start_pos , hls - > size ) ;
}
2014-12-16 16:04:41 +02:00
av_freep ( & hls - > basename ) ;
2014-11-16 05:02:56 +02:00
avformat_free_context ( oc ) ;
hls - > avf = NULL ;
2012-10-26 17:36:56 +03:00
hls_window ( s , 1 ) ;
2014-12-08 18:25:05 +02:00
hls_free_segments ( hls - > segments ) ;
hls_free_segments ( hls - > old_segments ) ;
2015-01-08 15:51:04 +02:00
avio_closep ( & hls - > pb ) ;
2012-10-26 17:36:56 +03:00
return 0 ;
}
# define OFFSET(x) offsetof(HLSContext, x)
# define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options [ ] = {
2014-04-30 21:52:58 +03: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 13:26:31 +03:00
{ " hls_time " , " set segment length in seconds " , OFFSET ( time ) , AV_OPT_TYPE_FLOAT , { . dbl = 2 } , 0 , FLT_MAX , E } ,
2014-07-18 11:57:42 +03: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 13:04:52 +03: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 } ,
2013-01-09 13:26:31 +03: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 11:17:01 +03: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 23:19:00 +03: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 23:20:15 +02:00
{ " hls_segment_filename " , " filename template for segment files " , OFFSET ( segment_filename ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2014-09-15 16:26:57 +03: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 18:25:05 +02: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 " } ,
2014-09-15 16:26:57 +03:00
2012-10-26 17:36:56 +03: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 08:00:46 +03:00
. long_name = NULL_IF_CONFIG_SMALL ( " Apple HTTP Live Streaming " ) ,
2012-10-26 17:36:56 +03:00
. extensions = " m3u8 " ,
. priv_data_size = sizeof ( HLSContext ) ,
2014-05-15 21:43:46 +03:00
. audio_codec = AV_CODEC_ID_AAC ,
. video_codec = AV_CODEC_ID_H264 ,
2012-10-26 17:36:56 +03: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 ,
} ;