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"
# 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 ;
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
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
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 ] ;
if ( ( ret = avio_open2 ( & pb , hls - > key_info_file , AVIO_FLAG_READ ,
& s - > interrupt_callback , NULL ) ) < 0 ) {
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 ' ;
avio_close ( pb ) ;
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 ) ;
}
if ( ( ret = avio_open2 ( & pb , hls - > key_file , AVIO_FLAG_READ ,
& s - > interrupt_callback , NULL ) ) < 0 ) {
av_log ( hls , AV_LOG_ERROR , " error opening key file %s \n " , hls - > key_file ) ;
return ret ;
}
ret = avio_read ( pb , key , sizeof ( key ) ) ;
avio_close ( pb ) ;
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 ;
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 ;
if ( s - > streams [ i ] - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE )
loc = vtt_oc ;
else
loc = oc ;
if ( ! ( st = avformat_new_stream ( loc , NULL ) ) )
2012-10-26 16:36:56 +02:00
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 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 */
2014-09-15 15:26:57 +02:00
static int hls_append_segment ( 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 ) ) ;
2014-12-08 17:25:05 +01:00
int ret ;
2012-10-26 16:36:56 +02:00
if ( ! en )
return AVERROR ( ENOMEM ) ;
2014-07-18 10:57:42 +02:00
av_strlcpy ( en - > filename , av_basename ( hls - > avf - > 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
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 ) ;
2015-02-20 12:55:14 +01:00
if ( ( ret = avio_open2 ( & out , temp_filename , AVIO_FLAG_WRITE ,
2015-09-14 21:07:37 +02:00
& s - > interrupt_callback , & 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 ) ;
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 )
avio_printf ( out , " #EXTINF:%d, \n " , ( int ) round ( en - > duration ) ) ;
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 ) {
if ( ( ret = avio_open2 ( & sub_out , hls - > vtt_m3u8_name , AVIO_FLAG_WRITE ,
2015-09-14 21:07:37 +02:00
& s - > interrupt_callback , & 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 ) ;
2015-02-20 12:55:13 +01:00
avio_closep ( & out ) ;
2015-06-04 09:55:52 +02:00
avio_closep ( & 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 ) ;
}
} 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
}
err = avio_open2 ( & oc - > pb , filename , AVIO_FLAG_WRITE ,
& s - > interrupt_callback , & options ) ;
av_free ( filename ) ;
av_dict_free ( & options ) ;
if ( err < 0 )
return err ;
} else
if ( ( err = avio_open2 ( & oc - > pb , oc - > filename , AVIO_FLAG_WRITE ,
2015-09-14 21:07:37 +02:00
& s - > interrupt_callback , & options ) ) < 0 )
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 ) ;
2015-06-04 09:55:52 +02:00
if ( ( err = avio_open2 ( & vtt_oc - > pb , vtt_oc - > filename , AVIO_FLAG_WRITE ,
2015-09-14 21:07:37 +02:00
& s - > interrupt_callback , & options ) ) < 0 )
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
if ( oc - > oformat - > priv_class & & oc - > priv_data )
av_opt_set ( oc - > priv_data , " mpegts_flags " , " resend_headers " , 0 ) ;
2015-06-04 09:55:52 +02:00
if ( c - > vtt_basename )
avformat_write_header ( vtt_oc , NULL ) ;
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 + =
s - > streams [ i ] - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ;
2015-06-04 09:55:52 +02:00
hls - > has_subtitle + =
s - > streams [ i ] - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE ;
}
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 ] ;
2015-06-04 09:55:52 +02:00
if ( outer_st - > codec - > codec_type ! = AVMEDIA_TYPE_SUBTITLE )
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
2015-06-04 09:55:52 +02:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
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 ) {
can_split = st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & &
pkt - > flags & AV_PKT_FLAG_KEY ;
2013-04-28 11:48:40 +02:00
is_ref_pkt = st - > codec - > 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 ;
ret = hls_append_segment ( hls , hls - > duration , hls - > start_pos , hls - > size ) ;
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 {
2014-12-16 01:10:46 +01:00
avio_closep ( & oc - > pb ) ;
2015-06-04 09:55:52 +02:00
if ( hls - > vtt_avf )
avio_close ( 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 ;
2015-06-04 09:55:52 +02:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE )
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 ;
avio_closep ( & oc - > pb ) ;
hls_append_segment ( hls , hls - > duration , hls - > start_pos , hls - > size ) ;
}
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 ;
avio_closep ( & vtt_oc - > pb ) ;
}
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 " } ,
2015-08-31 22:10:15 +02:00
{ " use_localtime " , " set filename expansion with strftime at segment creation " , OFFSET ( use_localtime ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , 1 , E } ,
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 ,
} ;