2012-10-26 16:36:56 +02:00
/*
* Apple HTTP Live Streaming segmenter
* Copyright ( c ) 2012 , Luca Barbato
2017-11-20 03:02:11 +01:00
* Copyright ( c ) 2017 Akamai Technologies , Inc .
2012-10-26 16:36:56 +02:00
*
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
2017-04-14 17:30:29 +02:00
# if CONFIG_GCRYPT
# include <gcrypt.h>
# elif CONFIG_OPENSSL
# include <openssl/rand.h>
# endif
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"
2021-07-23 04:01:44 +02:00
# include "libavutil/bprint.h"
2017-04-14 17:30:29 +02:00
# include "libavutil/intreadwrite.h"
# include "libavutil/random_seed.h"
2012-10-26 16:36:56 +02:00
# include "libavutil/opt.h"
# include "libavutil/log.h"
2020-04-18 22:15:39 +02:00
# include "libavutil/time.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"
2020-10-13 09:05:59 +02:00
# include "avc.h"
2017-12-04 16:52:17 +01:00
# if CONFIG_HTTP_PROTOCOL
2017-11-29 07:33:07 +01:00
# include "http.h"
2017-12-04 16:52:17 +01:00
# endif
2017-11-29 12:44:15 +01:00
# include "hlsplaylist.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
2017-01-12 13:43:10 +01:00
typedef enum {
2019-08-20 03:56:38 +02:00
HLS_START_SEQUENCE_AS_START_NUMBER = 0 ,
HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH = 1 ,
HLS_START_SEQUENCE_AS_FORMATTED_DATETIME = 2 , // YYYYMMDDhhmmss
2020-04-18 22:15:39 +02:00
HLS_START_SEQUENCE_AS_MICROSECONDS_SINCE_EPOCH = 3 ,
HLS_START_SEQUENCE_LAST , // unused
2017-01-12 13:43:10 +01:00
} StartSequenceSourceType ;
2018-01-19 10:03:09 +01:00
typedef enum {
CODEC_ATTRIBUTE_WRITTEN = 0 ,
CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN ,
} CodecAttributeStatus ;
2015-06-15 20:58:07 +02:00
# define KEYSIZE 16
2019-07-01 04:24:21 +02:00
# define LINE_BUFFER_SIZE MAX_URL_SIZE
2017-01-24 05:29:01 +01:00
# define HLS_MICROSECOND_UNIT 1000000
2020-07-22 11:15:29 +02:00
# define BUFSIZE (16 * 1024)
2017-11-20 03:02:11 +01:00
# define POSTFIX_PATTERN "_%d"
2015-06-15 20:58:07 +02:00
2014-07-18 10:57:42 +02:00
typedef struct HLSSegment {
2019-07-01 04:24:21 +02:00
char filename [ MAX_URL_SIZE ] ;
char sub_filename [ MAX_URL_SIZE ] ;
2014-07-18 10:57:42 +02:00
double duration ; /* in seconds */
2016-12-05 10:55:33 +01:00
int discont ;
2014-09-15 15:26:57 +02:00
int64_t pos ;
int64_t size ;
2019-06-02 16:03:17 +02:00
int64_t keyframe_pos ;
int64_t keyframe_size ;
2018-04-11 05:15:54 +02:00
unsigned var_stream_idx ;
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 ;
2020-12-01 11:10:40 +01:00
double discont_program_date_time ;
2014-07-18 10:57:42 +02:00
} 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 ) ,
2016-07-07 00:51:20 +02:00
HLS_SPLIT_BY_TIME = ( 1 < < 5 ) ,
2016-08-21 06:55:45 +02:00
HLS_APPEND_LIST = ( 1 < < 6 ) ,
2016-09-07 21:34:44 +02:00
HLS_PROGRAM_DATE_TIME = ( 1 < < 7 ) ,
2016-12-27 03:40:35 +01:00
HLS_SECOND_LEVEL_SEGMENT_INDEX = ( 1 < < 8 ) , // include segment index in segment filenames when use_localtime e.g.: %%03d
2017-01-03 15:57:51 +01:00
HLS_SECOND_LEVEL_SEGMENT_DURATION = ( 1 < < 9 ) , // include segment duration (microsec) in segment filenames when use_localtime e.g.: %%09t
HLS_SECOND_LEVEL_SEGMENT_SIZE = ( 1 < < 10 ) , // include segment size (bytes) in segment filenames when use_localtime e.g.: %%014s
2017-02-07 04:58:43 +01:00
HLS_TEMP_FILE = ( 1 < < 11 ) ,
2017-08-06 09:10:35 +02:00
HLS_PERIODIC_REKEY = ( 1 < < 12 ) ,
2017-11-23 23:57:36 +01:00
HLS_INDEPENDENT_SEGMENTS = ( 1 < < 13 ) ,
2019-06-02 16:03:17 +02:00
HLS_I_FRAMES_ONLY = ( 1 < < 14 ) ,
2014-09-15 15:26:57 +02:00
} HLSFlags ;
2017-07-03 14:20:44 +02:00
typedef enum {
SEGMENT_TYPE_MPEGTS ,
SEGMENT_TYPE_FMP4 ,
} SegmentType ;
2017-11-20 03:02:11 +01:00
typedef struct VariantStream {
2018-04-11 05:15:54 +02:00
unsigned var_stream_idx ;
2012-12-29 12:31:01 +01:00
unsigned number ;
2012-12-29 12:09:17 +01:00
int64_t sequence ;
2021-02-25 03:11:32 +01:00
const AVOutputFormat * oformat ;
const AVOutputFormat * vtt_oformat ;
2017-11-14 03:31:26 +01:00
AVIOContext * out ;
2020-07-22 11:15:29 +02:00
AVIOContext * out_single_file ;
2017-11-14 03:31:26 +01:00
int packets_written ;
int init_range_length ;
2019-08-30 01:14:28 +02:00
uint8_t * temp_buffer ;
2020-04-07 11:30:18 +02:00
uint8_t * init_buffer ;
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
int has_video ;
2015-06-04 09:55:52 +02:00
int has_subtitle ;
2017-01-10 21:33:13 +01:00
int new_start ;
2020-03-06 04:58:22 +01:00
int start_pts_from_audio ;
2017-01-10 21:33:13 +01:00
double dpp ; // duration per packet
2012-10-26 16:36:56 +02:00
int64_t start_pts ;
int64_t end_pts ;
2019-06-02 16:03:17 +02:00
int64_t video_lastpos ;
int64_t video_keyframe_pos ;
int64_t video_keyframe_size ;
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 ;
2016-12-05 10:55:33 +01:00
int discontinuity ;
2018-03-02 03:56:36 +01:00
int reference_stream_index ;
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
2020-07-22 11:15:29 +02:00
char * basename_tmp ;
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 ;
2017-11-20 03:02:11 +01:00
char * m3u8_name ;
double initial_prog_date_time ;
2019-07-01 04:24:21 +02:00
char current_segment_final_filename_fmt [ MAX_URL_SIZE ] ; // when renaming segments
2017-11-20 03:02:11 +01:00
char * fmp4_init_filename ;
char * base_output_dirname ;
2020-04-30 15:10:53 +02:00
int encrypt_started ;
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 ] ;
2017-11-20 03:02:11 +01:00
AVStream * * streams ;
2018-01-19 10:03:09 +01:00
char codec_attr [ 128 ] ;
CodecAttributeStatus attr_status ;
2017-11-20 03:02:11 +01:00
unsigned int nb_streams ;
2017-11-20 03:04:34 +01:00
int m3u8_created ; /* status of media play-list creation */
avformat/hlsenc: add var_stream_map DEFAULT field status parameter
use a:0,agroup:aud_low,default:Yes a:1,agroup:aud_low,
a:2,agroup:aud_high,default:Yes a:3, agroup:aud_high,
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 11:52:02 +01:00
int is_default ; /* default status of audio group */
2021-05-19 17:33:40 +02:00
const char * language ; /* audio language name */
2020-05-25 19:22:19 +02:00
const char * agroup ; /* audio group name */
const char * sgroup ; /* subtitle group name */
const char * ccgroup ; /* closed caption group name */
const char * varname ; /* variant name */
2017-11-20 03:02:11 +01:00
} VariantStream ;
2018-01-24 04:42:57 +01:00
typedef struct ClosedCaptionsStream {
2020-05-25 19:22:19 +02:00
const char * ccgroup ; /* closed caption group name */
const char * instreamid ; /* closed captions INSTREAM-ID */
2021-05-19 17:33:40 +02:00
const char * language ; /* closed captions language */
2018-01-24 04:42:57 +01:00
} ClosedCaptionsStream ;
2017-11-20 03:02:11 +01:00
typedef struct HLSContext {
const AVClass * class ; // Class for private options.
int64_t start_sequence ;
uint32_t start_sequence_source_type ; // enum StartSequenceSourceType
2021-01-17 02:07:28 +01:00
int64_t time ; // Set by a private option.
int64_t init_time ; // Set by a private option.
2017-11-20 03:02:11 +01:00
int max_nb_segments ; // Set by a private option.
2018-04-13 09:39:49 +02:00
int hls_delete_threshold ; // Set by a private option.
2017-11-20 03:02:11 +01:00
uint32_t flags ; // enum HLSFlags
uint32_t pl_type ; // enum PlaylistType
char * segment_filename ;
char * fmp4_init_filename ;
int segment_type ;
2020-04-07 11:30:18 +02:00
int resend_init_file ; ///< resend init file into disk after refresh m3u8
2017-11-20 03:02:11 +01:00
int use_localtime ; ///< flag to expand filename with localtime
int use_localtime_mkdir ; ///< flag to mkdir dirname in timebased filename
int allowcache ;
int64_t recording_time ;
int64_t max_seg_size ; // every segment file max size
2014-03-18 21:19:00 +01:00
char * baseurl ;
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
2017-04-14 17:30:29 +02:00
int encrypt ;
char * key ;
char * key_url ;
char * iv ;
char * key_basename ;
2017-11-20 03:02:11 +01:00
int encrypt_started ;
2017-04-14 17:30:29 +02:00
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 ;
2017-09-05 17:30:52 +02:00
char * user_agent ;
2017-11-20 03:02:11 +01:00
VariantStream * var_streams ;
unsigned int nb_varstreams ;
2018-01-24 04:42:57 +01:00
ClosedCaptionsStream * cc_streams ;
unsigned int nb_ccstreams ;
2017-11-20 03:04:34 +01:00
int master_m3u8_created ; /* status of master play-list creation */
char * master_m3u8_url ; /* URL of the master m3u8 file */
int version ; /* HLS version */
2017-11-20 03:02:11 +01:00
char * var_stream_map ; /* user specified variant stream map string */
2018-01-24 04:42:57 +01:00
char * cc_stream_map ; /* user specified closed caption streams map string */
2017-11-20 03:04:34 +01:00
char * master_pl_name ;
unsigned int master_publish_rate ;
2017-11-29 07:33:07 +01:00
int http_persistent ;
2017-12-15 15:11:12 +01:00
AVIOContext * m3u8_out ;
AVIOContext * sub_m3u8_out ;
2018-03-14 12:59:34 +01:00
int64_t timeout ;
2018-12-10 07:19:23 +01:00
int ignore_io_errors ;
2019-06-21 15:26:20 +02:00
char * headers ;
avformat/hlsenc: add var_stream_map DEFAULT field status parameter
use a:0,agroup:aud_low,default:Yes a:1,agroup:aud_low,
a:2,agroup:aud_high,default:Yes a:3, agroup:aud_high,
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 11:52:02 +01:00
int has_default_key ; /* has DEFAULT field of var_stream_map */
int has_video_m3u8 ; /* has video stream m3u8 list */
2012-10-26 16:36:56 +02:00
} HLSContext ;
2020-10-27 12:28:59 +01:00
static int strftime_expand ( const char * fmt , char * * dest )
{
int r = 1 ;
time_t now0 ;
struct tm * tm , tmpbuf ;
char * buf ;
buf = av_mallocz ( MAX_URL_SIZE ) ;
if ( ! buf )
return AVERROR ( ENOMEM ) ;
time ( & now0 ) ;
tm = localtime_r ( & now0 , & tmpbuf ) ;
r = strftime ( buf , MAX_URL_SIZE , fmt , tm ) ;
if ( ! r ) {
av_free ( buf ) ;
return AVERROR ( EINVAL ) ;
}
* dest = buf ;
return r ;
}
2021-08-20 15:08:17 +02:00
static int hlsenc_io_open ( AVFormatContext * s , AVIOContext * * pb , const char * filename ,
2019-09-06 06:15:45 +02:00
AVDictionary * * options )
{
2017-11-29 07:33:07 +01:00
HLSContext * hls = s - > priv_data ;
2017-12-29 11:11:09 +01:00
int http_base_proto = filename ? ff_is_http_proto ( filename ) : 0 ;
2017-12-04 16:52:17 +01:00
int err = AVERROR_MUXER_NOT_FOUND ;
2017-11-29 07:33:07 +01:00
if ( ! * pb | | ! http_base_proto | | ! hls - > http_persistent ) {
err = s - > io_open ( s , pb , filename , AVIO_FLAG_WRITE , options ) ;
2017-12-04 16:52:17 +01:00
# if CONFIG_HTTP_PROTOCOL
2017-11-29 07:33:07 +01:00
} else {
URLContext * http_url_context = ffio_geturlcontext ( * pb ) ;
av_assert0 ( http_url_context ) ;
err = ff_http_do_new_request ( http_url_context , filename ) ;
2018-12-10 07:17:55 +01:00
if ( err < 0 )
ff_format_io_close ( s , pb ) ;
2017-12-04 16:52:17 +01:00
# endif
2017-11-29 07:33:07 +01:00
}
return err ;
}
2019-09-06 06:15:45 +02:00
static int hlsenc_io_close ( AVFormatContext * s , AVIOContext * * pb , char * filename )
{
2017-11-29 07:33:07 +01:00
HLSContext * hls = s - > priv_data ;
2017-12-29 11:11:09 +01:00
int http_base_proto = filename ? ff_is_http_proto ( filename ) : 0 ;
2019-08-30 01:14:28 +02:00
int ret = 0 ;
2018-12-10 07:17:55 +01:00
if ( ! * pb )
2019-08-30 01:14:28 +02:00
return ret ;
2017-11-29 07:33:07 +01:00
if ( ! http_base_proto | | ! hls - > http_persistent | | hls - > key_info_file | | hls - > encrypt ) {
ff_format_io_close ( s , pb ) ;
2017-12-25 05:08:06 +01:00
# if CONFIG_HTTP_PROTOCOL
2017-12-15 14:24:08 +01:00
} else {
2017-12-25 05:08:06 +01:00
URLContext * http_url_context = ffio_geturlcontext ( * pb ) ;
av_assert0 ( http_url_context ) ;
2017-12-15 14:24:08 +01:00
avio_flush ( * pb ) ;
2017-12-25 05:08:06 +01:00
ffurl_shutdown ( http_url_context , AVIO_FLAG_WRITE ) ;
2019-08-30 01:14:28 +02:00
ret = ff_http_get_shutdown_status ( http_url_context ) ;
2017-12-25 05:08:06 +01:00
# endif
2017-11-29 07:33:07 +01:00
}
2019-08-30 01:14:28 +02:00
return ret ;
2017-11-29 07:33:07 +01:00
}
2017-09-21 17:10:57 +02:00
static void set_http_options ( AVFormatContext * s , AVDictionary * * options , HLSContext * c )
{
2017-12-29 22:00:04 +01:00
int http_base_proto = ff_is_http_proto ( s - > url ) ;
2017-09-21 17:10:57 +02:00
if ( c - > method ) {
av_dict_set ( options , " method " , c - > method , 0 ) ;
} else if ( http_base_proto ) {
av_dict_set ( options , " method " , " PUT " , 0 ) ;
}
if ( c - > user_agent )
av_dict_set ( options , " user_agent " , c - > user_agent , 0 ) ;
2017-11-29 07:33:07 +01:00
if ( c - > http_persistent )
av_dict_set_int ( options , " multiple_requests " , 1 , 0 ) ;
2018-03-14 12:59:34 +01:00
if ( c - > timeout > = 0 )
av_dict_set_int ( options , " timeout " , c - > timeout , 0 ) ;
2019-06-21 15:26:20 +02:00
if ( c - > headers )
av_dict_set ( options , " headers " , c - > headers , 0 ) ;
2017-09-21 17:10:57 +02:00
}
2019-09-06 06:15:45 +02:00
static void write_codec_attr ( AVStream * st , VariantStream * vs )
{
2018-01-19 10:03:09 +01:00
int codec_strlen = strlen ( vs - > codec_attr ) ;
char attr [ 32 ] ;
if ( st - > codecpar - > codec_type = = AVMEDIA_TYPE_SUBTITLE )
return ;
if ( vs - > attr_status = = CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN )
return ;
if ( st - > codecpar - > codec_id = = AV_CODEC_ID_H264 ) {
uint8_t * data = st - > codecpar - > extradata ;
2018-01-21 06:16:42 +01:00
if ( data & & ( data [ 0 ] | data [ 1 ] | data [ 2 ] ) = = 0 & & data [ 3 ] = = 1 & & ( data [ 4 ] & 0x1F ) = = 7 ) {
2018-01-19 10:03:09 +01:00
snprintf ( attr , sizeof ( attr ) ,
" avc1.%02x%02x%02x " , data [ 5 ] , data [ 6 ] , data [ 7 ] ) ;
} else {
goto fail ;
}
2020-10-13 09:05:59 +02:00
} else if ( st - > codecpar - > codec_id = = AV_CODEC_ID_HEVC ) {
uint8_t * data = st - > codecpar - > extradata ;
int profile = FF_PROFILE_UNKNOWN ;
int level = FF_LEVEL_UNKNOWN ;
if ( st - > codecpar - > profile ! = FF_PROFILE_UNKNOWN )
profile = st - > codecpar - > profile ;
if ( st - > codecpar - > level ! = FF_LEVEL_UNKNOWN )
level = st - > codecpar - > level ;
/* check the boundary of data which from current position is small than extradata_size */
2020-10-20 12:16:27 +02:00
while ( data & & ( data - st - > codecpar - > extradata + 19 ) < st - > codecpar - > extradata_size ) {
2020-10-13 09:05:59 +02:00
/* get HEVC SPS NAL and seek to profile_tier_level */
2020-10-20 13:00:04 +02:00
if ( ! ( data [ 0 ] | data [ 1 ] | data [ 2 ] ) & & data [ 3 ] = = 1 & & ( ( data [ 4 ] & 0x7E ) = = 0x42 ) ) {
2020-10-20 12:55:22 +02:00
uint8_t * rbsp_buf ;
2020-10-13 09:05:59 +02:00
int remain_size = 0 ;
int rbsp_size = 0 ;
/* skip start code + nalu header */
data + = 6 ;
/* process by reference General NAL unit syntax */
remain_size = st - > codecpar - > extradata_size - ( data - st - > codecpar - > extradata ) ;
2020-10-20 12:55:22 +02:00
rbsp_buf = ff_nal_unit_extract_rbsp ( data , remain_size , & rbsp_size , 0 ) ;
2020-10-13 09:05:59 +02:00
if ( ! rbsp_buf )
return ;
if ( rbsp_size < 13 ) {
av_freep ( & rbsp_buf ) ;
break ;
}
/* skip sps_video_parameter_set_id u(4),
* sps_max_sub_layers_minus1 u ( 3 ) ,
* and sps_temporal_id_nesting_flag u ( 1 ) */
profile = rbsp_buf [ 1 ] & 0x1f ;
/* skip 8 + 8 + 32 + 4 + 43 + 1 bit */
level = rbsp_buf [ 12 ] ;
av_freep ( & rbsp_buf ) ;
break ;
}
data + + ;
}
if ( st - > codecpar - > codec_tag = = MKTAG ( ' h ' , ' v ' , ' c ' , ' 1 ' ) & &
profile ! = FF_PROFILE_UNKNOWN & &
level ! = FF_LEVEL_UNKNOWN ) {
snprintf ( attr , sizeof ( attr ) , " %s.%d.4.L%d.B01 " , av_fourcc2str ( st - > codecpar - > codec_tag ) , profile , level ) ;
2020-10-20 12:52:49 +02:00
} else
goto fail ;
2018-01-19 10:03:09 +01:00
} else if ( st - > codecpar - > codec_id = = AV_CODEC_ID_MP2 ) {
snprintf ( attr , sizeof ( attr ) , " mp4a.40.33 " ) ;
} else if ( st - > codecpar - > codec_id = = AV_CODEC_ID_MP3 ) {
snprintf ( attr , sizeof ( attr ) , " mp4a.40.34 " ) ;
} else if ( st - > codecpar - > codec_id = = AV_CODEC_ID_AAC ) {
/* TODO : For HE-AAC, HE-AACv2, the last digit needs to be set to 5 and 29 respectively */
snprintf ( attr , sizeof ( attr ) , " mp4a.40.2 " ) ;
} else if ( st - > codecpar - > codec_id = = AV_CODEC_ID_AC3 ) {
snprintf ( attr , sizeof ( attr ) , " ac-3 " ) ;
} else if ( st - > codecpar - > codec_id = = AV_CODEC_ID_EAC3 ) {
snprintf ( attr , sizeof ( attr ) , " ec-3 " ) ;
} else {
goto fail ;
}
// Don't write the same attribute multiple times
if ( ! av_stristr ( vs - > codec_attr , attr ) ) {
snprintf ( vs - > codec_attr + codec_strlen ,
sizeof ( vs - > codec_attr ) - codec_strlen ,
" %s%s " , codec_strlen ? " , " : " " , attr ) ;
}
return ;
fail :
vs - > codec_attr [ 0 ] = ' \0 ' ;
vs - > attr_status = CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN ;
return ;
}
2019-06-20 05:08:04 +02:00
static int replace_str_data_in_filename ( char * * s , const char * filename , char placeholder , const char * datastring )
{
const char * p ;
char c ;
int addchar_count ;
int found_count = 0 ;
AVBPrint buf ;
2020-06-22 15:58:47 +02:00
int ret ;
2019-06-20 05:08:04 +02:00
av_bprint_init ( & buf , 0 , AV_BPRINT_SIZE_UNLIMITED ) ;
p = filename ;
for ( ; ; ) {
c = * p ;
if ( c = = ' \0 ' )
break ;
if ( c = = ' % ' & & * ( p + 1 ) = = ' % ' ) // %%
addchar_count = 2 ;
else if ( c = = ' % ' & & * ( p + 1 ) = = placeholder ) {
av_bprintf ( & buf , " %s " , datastring ) ;
p + = 2 ;
addchar_count = 0 ;
found_count + + ;
} else
addchar_count = 1 ;
if ( addchar_count > 0 ) {
av_bprint_append_data ( & buf , p , addchar_count ) ;
p + = addchar_count ;
}
}
if ( ! av_bprint_is_complete ( & buf ) ) {
av_bprint_finalize ( & buf , NULL ) ;
2020-06-22 15:58:47 +02:00
return AVERROR ( ENOMEM ) ;
2019-06-20 05:08:04 +02:00
}
2020-06-24 18:14:55 +02:00
if ( ( ret = av_bprint_finalize ( & buf , s ) ) < 0 )
2020-06-22 15:58:47 +02:00
return ret ;
2019-06-20 05:08:04 +02:00
return found_count ;
}
2018-01-06 18:41:27 +01:00
static int replace_int_data_in_filename ( char * * s , const char * filename , char placeholder , int64_t number )
2017-01-03 15:57:51 +01:00
{
const char * p ;
2018-01-06 18:41:27 +01:00
char c ;
int nd , addchar_count ;
2017-01-03 15:57:51 +01:00
int found_count = 0 ;
2018-01-06 18:41:27 +01:00
AVBPrint buf ;
2020-06-22 15:58:47 +02:00
int ret ;
2018-01-06 18:41:27 +01:00
av_bprint_init ( & buf , 0 , AV_BPRINT_SIZE_UNLIMITED ) ;
2017-01-03 15:57:51 +01:00
p = filename ;
for ( ; ; ) {
c = * p ;
if ( c = = ' \0 ' )
break ;
if ( c = = ' % ' & & * ( p + 1 ) = = ' % ' ) // %%
addchar_count = 2 ;
else if ( c = = ' % ' & & ( av_isdigit ( * ( p + 1 ) ) | | * ( p + 1 ) = = placeholder ) ) {
nd = 0 ;
addchar_count = 1 ;
while ( av_isdigit ( * ( p + addchar_count ) ) ) {
nd = nd * 10 + * ( p + addchar_count ) - ' 0 ' ;
addchar_count + + ;
}
if ( * ( p + addchar_count ) = = placeholder ) {
2018-01-06 18:41:27 +01:00
av_bprintf ( & buf , " %0* " PRId64 , ( number < 0 ) ? nd : nd + + , number ) ;
2017-01-03 15:57:51 +01:00
p + = ( addchar_count + 1 ) ;
addchar_count = 0 ;
found_count + + ;
}
} else
addchar_count = 1 ;
2018-01-06 18:41:27 +01:00
av_bprint_append_data ( & buf , p , addchar_count ) ;
p + = addchar_count ;
2017-01-03 15:57:51 +01:00
}
2018-01-06 18:41:27 +01:00
if ( ! av_bprint_is_complete ( & buf ) ) {
av_bprint_finalize ( & buf , NULL ) ;
2020-06-22 15:58:47 +02:00
return AVERROR ( ENOMEM ) ;
2018-01-06 18:41:27 +01:00
}
2020-06-24 18:14:55 +02:00
if ( ( ret = av_bprint_finalize ( & buf , s ) ) < 0 )
2020-06-22 15:58:47 +02:00
return ret ;
2017-01-03 15:57:51 +01:00
return found_count ;
}
2017-07-03 14:20:44 +02:00
static void write_styp ( AVIOContext * pb )
{
avio_wb32 ( pb , 24 ) ;
ffio_wfourcc ( pb , " styp " ) ;
ffio_wfourcc ( pb , " msdh " ) ;
avio_wb32 ( pb , 0 ) ; /* minor */
ffio_wfourcc ( pb , " msdh " ) ;
ffio_wfourcc ( pb , " msix " ) ;
}
2017-12-21 04:14:32 +01:00
static int flush_dynbuf ( VariantStream * vs , int * range_length )
{
AVFormatContext * ctx = vs - > avf ;
if ( ! ctx - > pb ) {
return AVERROR ( EINVAL ) ;
}
// flush
av_write_frame ( ctx , NULL ) ;
// write out to file
2019-08-30 01:14:28 +02:00
* range_length = avio_close_dyn_buf ( ctx - > pb , & vs - > temp_buffer ) ;
2017-12-21 04:14:32 +01:00
ctx - > pb = NULL ;
2019-08-30 01:14:28 +02:00
avio_write ( vs - > out , vs - > temp_buffer , * range_length ) ;
2019-09-14 03:53:22 +02:00
avio_flush ( vs - > out ) ;
2017-12-21 04:14:32 +01:00
// re-open buffer
return avio_open_dyn_buf ( & ctx - > pb ) ;
}
2019-08-30 01:14:28 +02:00
static void reflush_dynbuf ( VariantStream * vs , int * range_length )
{
// re-open buffer
2019-12-08 00:20:11 +01:00
avio_write ( vs - > out , vs - > temp_buffer , * range_length ) ;
2019-08-30 01:14:28 +02:00
}
2019-10-23 17:55:15 +02:00
# if HAVE_DOS_PATHS
# define SEPARATOR '\\'
# else
# define SEPARATOR ' / '
# endif
2020-04-08 15:23:03 +02:00
static int hls_delete_file ( HLSContext * hls , AVFormatContext * avf ,
const char * path , const char * proto )
{
if ( hls - > method | | ( proto & & ! av_strcasecmp ( proto , " http " ) ) ) {
AVDictionary * opt = NULL ;
AVIOContext * out = NULL ;
int ret ;
2021-07-20 05:05:49 +02:00
set_http_options ( avf , & opt , hls ) ;
2020-04-08 15:23:03 +02:00
av_dict_set ( & opt , " method " , " DELETE " , 0 ) ;
ret = avf - > io_open ( avf , & out , path , AVIO_FLAG_WRITE , & opt ) ;
av_dict_free ( & opt ) ;
if ( ret < 0 )
return hls - > ignore_io_errors ? 1 : ret ;
ff_format_io_close ( avf , & out ) ;
} else if ( unlink ( path ) < 0 ) {
av_log ( hls , AV_LOG_ERROR , " failed to delete old segment %s: %s \n " ,
path , strerror ( errno ) ) ;
}
return 0 ;
}
2017-11-20 03:02:11 +01:00
static int hls_delete_old_segments ( AVFormatContext * s , HLSContext * hls ,
2019-09-06 06:15:45 +02:00
VariantStream * vs )
{
2014-12-08 17:25:05 +01:00
HLSSegment * segment , * previous_segment = NULL ;
float playlist_duration = 0.0f ;
2020-04-08 13:14:17 +02:00
int ret = 0 ;
2018-04-13 09:39:49 +02:00
int segment_cnt = 0 ;
2020-04-08 13:14:17 +02:00
AVBPrint path ;
2020-05-09 06:54:56 +02:00
const char * dirname = NULL ;
2019-10-23 17:55:16 +02:00
char * dirname_r = NULL ;
char * dirname_repl = NULL ;
2020-05-09 06:54:56 +02:00
const char * vtt_dirname = NULL ;
2019-10-23 17:55:16 +02:00
char * vtt_dirname_r = NULL ;
2017-02-18 02:42:51 +01:00
const char * proto = NULL ;
2014-12-08 17:25:05 +01:00
2020-04-08 13:14:17 +02:00
av_bprint_init ( & path , 0 , AV_BPRINT_SIZE_UNLIMITED ) ;
2017-11-20 03:02:11 +01:00
segment = vs - > segments ;
2014-12-08 17:25:05 +01:00
while ( segment ) {
playlist_duration + = segment - > duration ;
segment = segment - > next ;
}
2017-11-20 03:02:11 +01:00
segment = vs - > old_segments ;
2018-04-13 09:39:49 +02:00
segment_cnt = 0 ;
2014-12-08 17:25:05 +01:00
while ( segment ) {
playlist_duration - = segment - > duration ;
previous_segment = segment ;
segment = previous_segment - > next ;
2018-04-13 09:39:49 +02:00
segment_cnt + + ;
2014-12-08 17:25:05 +01:00
if ( playlist_duration < = - previous_segment - > duration ) {
previous_segment - > next = NULL ;
break ;
}
2018-04-13 09:39:49 +02:00
if ( segment_cnt > = hls - > hls_delete_threshold ) {
previous_segment - > next = NULL ;
break ;
}
2014-12-08 17:25:05 +01:00
}
2016-12-29 05:00:20 +01:00
if ( segment & & ! hls - > use_localtime_mkdir ) {
2019-10-23 17:55:16 +02:00
dirname_r = hls - > segment_filename ? av_strdup ( hls - > segment_filename ) : av_strdup ( vs - > avf - > url ) ;
2020-05-09 06:54:56 +02:00
dirname = av_dirname ( dirname_r ) ;
2014-12-08 17:25:05 +01:00
}
2019-06-20 05:08:04 +02:00
/* if %v is present in the file's directory
* all segment belongs to the same variant , so do it only once before the loop */
if ( dirname & & av_stristr ( dirname , " %v " ) ) {
if ( ! vs - > varname ) {
2019-10-23 17:55:16 +02:00
if ( replace_int_data_in_filename ( & dirname_repl , dirname , ' v ' , segment - > var_stream_idx ) < 1 ) {
2018-04-11 05:15:54 +02:00
ret = AVERROR ( EINVAL ) ;
goto fail ;
}
2019-06-20 05:08:04 +02:00
} else {
2019-10-23 17:55:16 +02:00
if ( replace_str_data_in_filename ( & dirname_repl , dirname , ' v ' , vs - > varname ) < 1 ) {
2019-06-20 05:08:04 +02:00
ret = AVERROR ( EINVAL ) ;
goto fail ;
}
2018-04-11 05:15:54 +02:00
}
2019-10-23 17:55:16 +02:00
dirname = dirname_repl ;
2019-06-20 05:08:04 +02:00
}
while ( segment ) {
2014-12-08 17:25:05 +01:00
av_log ( hls , AV_LOG_DEBUG , " deleting old segment %s \n " ,
2019-08-20 03:56:38 +02:00
segment - > filename ) ;
2020-04-08 13:14:17 +02:00
if ( ! hls - > use_localtime_mkdir ) // segment->filename contains basename only
av_bprintf ( & path , " %s%c " , dirname , SEPARATOR ) ;
av_bprintf ( & path , " %s " , segment - > filename ) ;
if ( ! av_bprint_is_complete ( & path ) ) {
2014-12-08 17:25:05 +01:00
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
2015-06-04 09:55:52 +02:00
2017-12-29 22:00:04 +01:00
proto = avio_find_protocol_name ( s - > url ) ;
2020-04-08 15:23:03 +02:00
if ( ret = hls_delete_file ( hls , vs - > avf , path . str , proto ) )
goto fail ;
2015-06-04 09:55:52 +02:00
2017-01-05 23:29:12 +01:00
if ( ( segment - > sub_filename [ 0 ] ! = ' \0 ' ) ) {
2019-10-23 17:55:16 +02:00
vtt_dirname_r = av_strdup ( vs - > vtt_avf - > url ) ;
2020-05-09 06:54:56 +02:00
vtt_dirname = av_dirname ( vtt_dirname_r ) ;
2020-04-08 13:14:17 +02:00
av_bprint_clear ( & path ) ;
av_bprintf ( & path , " %s%c%s " , vtt_dirname , SEPARATOR ,
segment - > sub_filename ) ;
av_freep ( & vtt_dirname_r ) ;
if ( ! av_bprint_is_complete ( & path ) ) {
2015-10-02 01:21:33 +02:00
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
2020-04-08 15:23:03 +02:00
if ( ret = hls_delete_file ( hls , vs - > vtt_avf , path . str , proto ) )
goto fail ;
2015-06-04 09:55:52 +02:00
}
2020-04-08 13:14:17 +02:00
av_bprint_clear ( & path ) ;
2014-12-08 17:25:05 +01:00
previous_segment = segment ;
segment = previous_segment - > next ;
2019-09-24 13:24:01 +02:00
av_freep ( & previous_segment ) ;
2014-12-08 17:25:05 +01:00
}
fail :
2020-04-08 13:14:17 +02:00
av_bprint_finalize ( & path , NULL ) ;
2019-10-23 17:55:16 +02:00
av_freep ( & dirname_r ) ;
av_freep ( & dirname_repl ) ;
2014-12-08 17:25:05 +01:00
return ret ;
}
2017-04-14 17:30:29 +02:00
static int randomize ( uint8_t * buf , int len )
{
# if CONFIG_GCRYPT
gcry_randomize ( buf , len , GCRY_VERY_STRONG_RANDOM ) ;
return 0 ;
# elif CONFIG_OPENSSL
if ( RAND_bytes ( buf , len ) )
return 0 ;
# else
return AVERROR ( ENOSYS ) ;
# endif
return AVERROR ( EINVAL ) ;
}
2017-11-20 03:02:11 +01:00
static int do_encrypt ( AVFormatContext * s , VariantStream * vs )
2017-04-14 17:30:29 +02:00
{
HLSContext * hls = s - > priv_data ;
int ret ;
int len ;
AVIOContext * pb ;
uint8_t key [ KEYSIZE ] ;
2020-01-19 23:01:32 +01:00
char * key_basename_source = ( hls - > master_m3u8_url ) ? hls - > master_m3u8_url : s - > url ;
2017-04-14 17:30:29 +02:00
2020-01-19 23:01:32 +01:00
len = strlen ( key_basename_source ) + 4 + 1 ;
2017-04-14 17:30:29 +02:00
hls - > key_basename = av_mallocz ( len ) ;
if ( ! hls - > key_basename )
return AVERROR ( ENOMEM ) ;
2020-01-19 23:01:32 +01:00
av_strlcpy ( hls - > key_basename , key_basename_source , len ) ;
2017-04-14 17:30:29 +02:00
av_strlcat ( hls - > key_basename , " .key " , len ) ;
if ( hls - > key_url ) {
2017-04-28 04:18:44 +02:00
av_strlcpy ( hls - > key_file , hls - > key_url , sizeof ( hls - > key_file ) ) ;
av_strlcpy ( hls - > key_uri , hls - > key_url , sizeof ( hls - > key_uri ) ) ;
2017-04-14 17:30:29 +02:00
} else {
2017-04-28 04:18:44 +02:00
av_strlcpy ( hls - > key_file , hls - > key_basename , sizeof ( hls - > key_file ) ) ;
av_strlcpy ( hls - > key_uri , hls - > key_basename , sizeof ( hls - > key_uri ) ) ;
2017-04-14 17:30:29 +02:00
}
if ( ! * hls - > iv_string ) {
uint8_t iv [ 16 ] = { 0 } ;
char buf [ 33 ] ;
if ( ! hls - > iv ) {
2017-11-20 03:02:11 +01:00
AV_WB64 ( iv + 8 , vs - > sequence ) ;
2017-04-14 17:30:29 +02:00
} else {
memcpy ( iv , hls - > iv , sizeof ( iv ) ) ;
}
ff_data_to_hex ( buf , iv , sizeof ( iv ) , 0 ) ;
memcpy ( hls - > iv_string , buf , sizeof ( hls - > iv_string ) ) ;
}
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 ( ! * hls - > key_string ) {
2020-03-12 07:00:45 +01:00
AVDictionary * options = NULL ;
2017-04-14 17:30:29 +02:00
if ( ! hls - > key ) {
if ( ( ret = randomize ( key , sizeof ( key ) ) ) < 0 ) {
av_log ( s , AV_LOG_ERROR , " Cannot generate a strong random key \n " ) ;
return ret ;
}
} else {
memcpy ( key , hls - > key , sizeof ( key ) ) ;
}
ff_data_to_hex ( hls - > key_string , key , sizeof ( key ) , 0 ) ;
2020-03-12 07:00:45 +01:00
set_http_options ( s , & options , hls ) ;
ret = s - > io_open ( s , & pb , hls - > key_file , AVIO_FLAG_WRITE , & options ) ;
av_dict_free ( & options ) ;
if ( ret < 0 )
2017-04-14 17:30:29 +02:00
return ret ;
avio_seek ( pb , 0 , SEEK_CUR ) ;
avio_write ( pb , key , KEYSIZE ) ;
avio_close ( pb ) ;
}
return 0 ;
}
2020-04-30 15:10:53 +02:00
static int hls_encryption_start ( AVFormatContext * s , VariantStream * vs )
2015-06-15 20:58:07 +02:00
{
HLSContext * hls = s - > priv_data ;
int ret ;
AVIOContext * pb ;
uint8_t key [ KEYSIZE ] ;
2020-03-12 07:00:45 +01:00
AVDictionary * options = NULL ;
2015-06-15 20:58:07 +02:00
2020-03-12 07:00:45 +01:00
set_http_options ( s , & options , hls ) ;
ret = s - > io_open ( s , & pb , hls - > key_info_file , AVIO_FLAG_READ , & options ) ;
av_dict_free ( & options ) ;
if ( ret < 0 ) {
2015-06-15 20:58:07 +02:00
av_log ( hls , AV_LOG_ERROR ,
2019-08-20 03:56:38 +02:00
" error opening key info file %s \n " , hls - > key_info_file ) ;
2015-06-15 20:58:07 +02:00
return ret ;
}
2020-04-30 15:10:53 +02:00
ff_get_line ( pb , vs - > key_uri , sizeof ( vs - > key_uri ) ) ;
vs - > key_uri [ strcspn ( vs - > key_uri , " \r \n " ) ] = ' \0 ' ;
2015-06-15 20:58:07 +02:00
2020-04-30 15:10:53 +02:00
ff_get_line ( pb , vs - > key_file , sizeof ( vs - > key_file ) ) ;
vs - > key_file [ strcspn ( vs - > key_file , " \r \n " ) ] = ' \0 ' ;
2015-06-15 20:58:07 +02:00
2020-04-30 15:10:53 +02:00
ff_get_line ( pb , vs - > iv_string , sizeof ( vs - > iv_string ) ) ;
vs - > iv_string [ strcspn ( vs - > iv_string , " \r \n " ) ] = ' \0 ' ;
2015-06-15 20:58:07 +02:00
2016-02-10 15:40:32 +01:00
ff_format_io_close ( s , & pb ) ;
2015-06-15 20:58:07 +02:00
2020-04-30 15:10:53 +02:00
if ( ! * vs - > key_uri ) {
2015-06-15 20:58:07 +02:00
av_log ( hls , AV_LOG_ERROR , " no key URI specified in key info file \n " ) ;
return AVERROR ( EINVAL ) ;
}
2020-04-30 15:10:53 +02:00
if ( ! * vs - > key_file ) {
2015-06-15 20:58:07 +02:00
av_log ( hls , AV_LOG_ERROR , " no key file specified in key info file \n " ) ;
return AVERROR ( EINVAL ) ;
}
2020-03-12 07:00:45 +01:00
set_http_options ( s , & options , hls ) ;
2020-04-30 15:10:53 +02:00
ret = s - > io_open ( s , & pb , vs - > key_file , AVIO_FLAG_READ , & options ) ;
2020-03-12 07:00:45 +01:00
av_dict_free ( & options ) ;
if ( ret < 0 ) {
2020-04-30 15:10:53 +02:00
av_log ( hls , AV_LOG_ERROR , " error opening key file %s \n " , vs - > key_file ) ;
2015-06-15 20:58:07 +02:00
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 ) ) {
2020-04-30 15:10:53 +02:00
av_log ( hls , AV_LOG_ERROR , " error reading key file %s \n " , vs - > key_file ) ;
2015-06-15 20:58:07 +02:00
if ( ret > = 0 | | ret = = AVERROR_EOF )
ret = AVERROR ( EINVAL ) ;
return ret ;
}
2020-04-30 15:10:53 +02:00
ff_data_to_hex ( vs - > key_string , key , sizeof ( key ) , 0 ) ;
2015-06-15 20:58:07 +02:00
return 0 ;
}
2017-11-20 03:02:11 +01:00
static int hls_mux_init ( AVFormatContext * s , VariantStream * vs )
2012-10-26 16:36:56 +02:00
{
2017-07-03 14:20:44 +02:00
AVDictionary * options = NULL ;
2012-10-26 16:36:56 +02:00
HLSContext * hls = s - > priv_data ;
AVFormatContext * oc ;
2015-09-03 11:14:48 +02:00
AVFormatContext * vtt_oc = NULL ;
2017-08-04 15:38:55 +02:00
int byterange_mode = ( hls - > flags & HLS_SINGLE_FILE ) | | ( hls - > max_seg_size > 0 ) ;
2019-12-23 01:27:38 +01:00
int remaining_options ;
2014-10-17 18:28:47 +02:00
int i , ret ;
2012-10-26 16:36:56 +02:00
2017-11-20 03:02:11 +01:00
ret = avformat_alloc_output_context2 ( & vs - > avf , vs - > oformat , NULL , NULL ) ;
2014-10-17 18:28:47 +02:00
if ( ret < 0 )
return ret ;
2017-11-20 03:02:11 +01:00
oc = vs - > avf ;
2012-10-26 16:36:56 +02:00
2017-12-29 22:00:04 +01:00
oc - > url = av_strdup ( " " ) ;
if ( ! oc - > url )
return AVERROR ( ENOMEM ) ;
2019-11-25 04:15:13 +01:00
oc - > interrupt_callback = s - > interrupt_callback ;
oc - > max_delay = s - > max_delay ;
oc - > opaque = s - > opaque ;
oc - > io_open = s - > io_open ;
oc - > io_close = s - > io_close ;
2021-11-30 00:38:30 +01:00
oc - > io_close2 = s - > io_close2 ;
2019-11-25 04:15:13 +01:00
oc - > strict_std_compliance = s - > strict_std_compliance ;
2013-12-12 18:41:39 +01:00
av_dict_copy ( & oc - > metadata , s - > metadata , 0 ) ;
2012-10-26 16:36:56 +02:00
2019-09-06 06:15:45 +02:00
if ( vs - > vtt_oformat ) {
2017-11-20 03:02:11 +01:00
ret = avformat_alloc_output_context2 ( & vs - > vtt_avf , vs - > vtt_oformat , NULL , NULL ) ;
2015-06-04 09:55:52 +02:00
if ( ret < 0 )
return ret ;
2017-11-20 03:02:11 +01:00
vtt_oc = vs - > vtt_avf ;
2015-06-04 09:55:52 +02:00
av_dict_copy ( & vtt_oc - > metadata , s - > metadata , 0 ) ;
}
2017-11-20 03:02:11 +01:00
for ( i = 0 ; i < vs - > nb_streams ; i + + ) {
2012-10-26 16:36:56 +02:00
AVStream * st ;
2015-06-04 09:55:52 +02:00
AVFormatContext * loc ;
2017-11-20 03:02:11 +01:00
if ( vs - > 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 ) ;
2017-11-20 03:02:11 +01:00
avcodec_parameters_copy ( st - > codecpar , vs - > streams [ i ] - > codecpar ) ;
2017-07-05 05:20:21 +02:00
if ( ! oc - > oformat - > codec_tag | |
2017-11-20 03:02:11 +01:00
av_codec_get_id ( oc - > oformat - > codec_tag , vs - > streams [ i ] - > codecpar - > codec_tag ) = = st - > codecpar - > codec_id | |
av_codec_get_tag ( oc - > oformat - > codec_tag , vs - > streams [ i ] - > codecpar - > codec_id ) < = 0 ) {
st - > codecpar - > codec_tag = vs - > streams [ i ] - > codecpar - > codec_tag ;
2017-07-05 05:20:21 +02:00
} else {
st - > codecpar - > codec_tag = 0 ;
}
2017-11-20 03:02:11 +01:00
st - > sample_aspect_ratio = vs - > streams [ i ] - > sample_aspect_ratio ;
st - > time_base = vs - > streams [ i ] - > time_base ;
av_dict_copy ( & st - > metadata , vs - > streams [ i ] - > metadata , 0 ) ;
2022-01-07 17:33:21 +01:00
st - > id = vs - > streams [ i ] - > id ;
2012-10-26 16:36:56 +02:00
}
2017-11-20 03:02:11 +01:00
vs - > start_pos = 0 ;
vs - > new_start = 1 ;
2012-10-26 16:36:56 +02:00
2019-08-05 04:24:37 +02:00
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 & & hls - > max_seg_size > 0 ) {
2019-07-13 13:41:07 +02:00
if ( hls - > http_persistent > 0 ) {
//TODO: Support fragment fmp4 for http persistent in HLS muxer.
av_log ( s , AV_LOG_WARNING , " http persistent mode is currently unsupported for fragment mp4 in the HLS muxer. \n " ) ;
}
2017-08-04 15:38:55 +02:00
if ( hls - > max_seg_size > 0 ) {
av_log ( s , AV_LOG_WARNING , " Multi-file byterange mode is currently unsupported in the HLS muxer. \n " ) ;
return AVERROR_PATCHWELCOME ;
}
2019-08-05 04:24:37 +02:00
}
2017-11-20 03:02:11 +01:00
2019-08-05 04:24:37 +02:00
if ( ( ret = avio_open_dyn_buf ( & oc - > pb ) ) < 0 )
return ret ;
2017-11-14 03:31:26 +01:00
2019-08-05 04:24:37 +02:00
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 ) {
2019-12-16 01:04:06 +01:00
set_http_options ( s , & options , hls ) ;
2018-03-18 07:08:57 +01:00
if ( byterange_mode ) {
ret = hlsenc_io_open ( s , & vs - > out , vs - > basename , & options ) ;
} else {
ret = hlsenc_io_open ( s , & vs - > out , vs - > base_output_dirname , & options ) ;
}
2019-12-16 01:04:06 +01:00
av_dict_free ( & options ) ;
2019-08-05 04:24:37 +02:00
}
if ( ret < 0 ) {
av_log ( s , AV_LOG_ERROR , " Failed to open segment '%s' \n " , vs - > fmp4_init_filename ) ;
return ret ;
}
2019-12-23 01:27:38 +01:00
av_dict_copy ( & options , hls - > format_options , 0 ) ;
2019-08-05 04:24:37 +02:00
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 ) {
2017-07-03 14:20:44 +02:00
av_dict_set ( & options , " fflags " , " -autobsf " , 0 ) ;
2018-12-12 08:37:01 +01:00
av_dict_set ( & options , " movflags " , " +frag_custom+dash+delay_moov " , AV_DICT_APPEND ) ;
2019-12-23 01:27:38 +01:00
} else {
/* We only require one PAT/PMT per segment. */
char period [ 21 ] ;
snprintf ( period , sizeof ( period ) , " %d " , ( INT_MAX / 2 ) - 1 ) ;
2019-12-23 01:36:41 +01:00
av_dict_set ( & options , " sdt_period " , period , AV_DICT_DONT_OVERWRITE ) ;
av_dict_set ( & options , " pat_period " , period , AV_DICT_DONT_OVERWRITE ) ;
2019-12-23 01:27:38 +01:00
}
ret = avformat_init_output ( oc , & options ) ;
remaining_options = av_dict_count ( options ) ;
av_dict_free ( & options ) ;
if ( ret < 0 )
return ret ;
if ( remaining_options ) {
av_log ( s , AV_LOG_ERROR , " Some of the provided format options are not recognized \n " ) ;
return AVERROR ( EINVAL ) ;
2017-07-03 14:20:44 +02:00
}
2019-08-05 04:24:37 +02:00
avio_flush ( oc - > pb ) ;
2012-10-26 16:36:56 +02:00
return 0 ;
}
2017-01-01 13:22:34 +01:00
static HLSSegment * find_segment_by_filename ( HLSSegment * segment , const char * filename )
{
while ( segment ) {
if ( ! av_strcasecmp ( segment - > filename , filename ) )
return segment ;
segment = segment - > next ;
}
return ( HLSSegment * ) NULL ;
}
2017-11-20 03:02:11 +01:00
static int sls_flags_filename_process ( struct AVFormatContext * s , HLSContext * hls ,
VariantStream * vs , HLSSegment * en ,
double duration , int64_t pos , int64_t size )
2012-10-26 16:36:56 +02:00
{
2017-01-03 15:57:51 +01:00
if ( ( hls - > flags & ( HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION ) ) & &
2017-11-20 03:02:11 +01:00
strlen ( vs - > current_segment_final_filename_fmt ) ) {
2017-12-29 22:00:04 +01:00
char * new_url = av_strdup ( vs - > current_segment_final_filename_fmt ) ;
if ( ! new_url ) {
return AVERROR ( ENOMEM ) ;
}
ff_format_set_url ( vs - > avf , new_url ) ;
2017-01-03 15:57:51 +01:00
if ( hls - > flags & HLS_SECOND_LEVEL_SEGMENT_SIZE ) {
2018-01-06 18:41:27 +01:00
char * filename = NULL ;
2017-12-29 22:00:04 +01:00
if ( replace_int_data_in_filename ( & filename , vs - > avf - > url , ' s ' , pos + size ) < 1 ) {
2017-01-03 15:57:51 +01:00
av_log ( hls , AV_LOG_ERROR ,
" Invalid second level segment filename template '%s', "
2019-08-20 03:56:38 +02:00
" you can try to remove second_level_segment_size flag \n " ,
2017-12-29 22:00:04 +01:00
vs - > avf - > url ) ;
2019-09-24 13:24:01 +02:00
av_freep ( & filename ) ;
2017-01-03 15:57:51 +01:00
return AVERROR ( EINVAL ) ;
}
2017-12-29 22:00:04 +01:00
ff_format_set_url ( vs - > avf , filename ) ;
2017-01-03 15:57:51 +01:00
}
if ( hls - > flags & HLS_SECOND_LEVEL_SEGMENT_DURATION ) {
2018-01-06 18:41:27 +01:00
char * filename = NULL ;
2017-12-29 22:00:04 +01:00
if ( replace_int_data_in_filename ( & filename , vs - > avf - > url ,
2019-08-20 03:56:38 +02:00
' t ' , ( int64_t ) round ( duration * HLS_MICROSECOND_UNIT ) ) < 1 ) {
2017-01-03 15:57:51 +01:00
av_log ( hls , AV_LOG_ERROR ,
" Invalid second level segment filename template '%s', "
2019-08-20 03:56:38 +02:00
" you can try to remove second_level_segment_time flag \n " ,
2017-12-29 22:00:04 +01:00
vs - > avf - > url ) ;
2019-09-24 13:24:01 +02:00
av_freep ( & filename ) ;
2017-01-03 15:57:51 +01:00
return AVERROR ( EINVAL ) ;
}
2017-12-29 22:00:04 +01:00
ff_format_set_url ( vs - > avf , filename ) ;
2017-01-03 15:57:51 +01:00
}
}
2017-03-13 04:58:34 +01:00
return 0 ;
}
static int sls_flag_check_duration_size_index ( HLSContext * hls )
{
int ret = 0 ;
if ( hls - > flags & HLS_SECOND_LEVEL_SEGMENT_DURATION ) {
2019-08-20 03:56:38 +02:00
av_log ( hls , AV_LOG_ERROR ,
" second_level_segment_duration hls_flag requires strftime to be true \n " ) ;
ret = AVERROR ( EINVAL ) ;
2017-03-13 04:58:34 +01:00
}
if ( hls - > flags & HLS_SECOND_LEVEL_SEGMENT_SIZE ) {
2019-08-20 03:56:38 +02:00
av_log ( hls , AV_LOG_ERROR ,
" second_level_segment_size hls_flag requires strfime to be true \n " ) ;
ret = AVERROR ( EINVAL ) ;
2017-03-13 04:58:34 +01:00
}
if ( hls - > flags & HLS_SECOND_LEVEL_SEGMENT_INDEX ) {
av_log ( hls , AV_LOG_ERROR ,
2018-09-03 05:10:35 +02:00
" second_level_segment_index hls_flag requires strftime to be true \n " ) ;
2017-03-13 04:58:34 +01:00
ret = AVERROR ( EINVAL ) ;
}
return ret ;
}
2017-11-20 03:02:11 +01:00
static int sls_flag_check_duration_size ( HLSContext * hls , VariantStream * vs )
2017-03-13 04:58:34 +01:00
{
2017-11-20 03:02:11 +01:00
const char * proto = avio_find_protocol_name ( vs - > basename ) ;
2017-03-13 04:58:34 +01:00
int segment_renaming_ok = proto & & ! strcmp ( proto , " file " ) ;
int ret = 0 ;
if ( ( hls - > flags & HLS_SECOND_LEVEL_SEGMENT_DURATION ) & & ! segment_renaming_ok ) {
2019-08-20 03:56:38 +02:00
av_log ( hls , AV_LOG_ERROR ,
" second_level_segment_duration hls_flag works only with file protocol segment names \n " ) ;
ret = AVERROR ( EINVAL ) ;
2017-03-13 04:58:34 +01:00
}
if ( ( hls - > flags & HLS_SECOND_LEVEL_SEGMENT_SIZE ) & & ! segment_renaming_ok ) {
2019-08-20 03:56:38 +02:00
av_log ( hls , AV_LOG_ERROR ,
" second_level_segment_size hls_flag works only with file protocol segment names \n " ) ;
ret = AVERROR ( EINVAL ) ;
2017-03-13 04:58:34 +01:00
}
return ret ;
}
2017-11-20 03:02:11 +01:00
static void sls_flag_file_rename ( HLSContext * hls , VariantStream * vs , char * old_filename ) {
2017-03-13 04:58:34 +01:00
if ( ( hls - > flags & ( HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION ) ) & &
2017-11-20 03:02:11 +01:00
strlen ( vs - > current_segment_final_filename_fmt ) ) {
2017-12-29 22:00:04 +01:00
ff_rename ( old_filename , vs - > avf - > url , hls ) ;
2017-03-13 04:58:34 +01:00
}
}
2017-11-20 03:02:11 +01:00
static int sls_flag_use_localtime_filename ( AVFormatContext * oc , HLSContext * c , VariantStream * vs )
2017-03-13 04:58:34 +01:00
{
if ( c - > flags & HLS_SECOND_LEVEL_SEGMENT_INDEX ) {
2018-01-06 18:41:27 +01:00
char * filename = NULL ;
if ( replace_int_data_in_filename ( & filename ,
2017-12-29 22:00:04 +01:00
oc - > url , ' d ' , vs - > sequence ) < 1 ) {
2017-03-13 04:58:34 +01:00
av_log ( c , AV_LOG_ERROR , " Invalid second level segment filename template '%s', "
" you can try to remove second_level_segment_index flag \n " ,
2017-12-29 22:00:04 +01:00
oc - > url ) ;
2019-09-24 13:24:01 +02:00
av_freep ( & filename ) ;
2017-03-13 04:58:34 +01:00
return AVERROR ( EINVAL ) ;
}
2017-12-29 22:00:04 +01:00
ff_format_set_url ( oc , filename ) ;
2017-03-13 04:58:34 +01:00
}
if ( c - > flags & ( HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION ) ) {
2017-12-29 22:00:04 +01:00
av_strlcpy ( vs - > current_segment_final_filename_fmt , oc - > url ,
2017-11-20 03:02:11 +01:00
sizeof ( vs - > current_segment_final_filename_fmt ) ) ;
2017-03-13 04:58:34 +01:00
if ( c - > flags & HLS_SECOND_LEVEL_SEGMENT_SIZE ) {
2018-01-06 18:41:27 +01:00
char * filename = NULL ;
2017-12-29 22:00:04 +01:00
if ( replace_int_data_in_filename ( & filename , oc - > url , ' s ' , 0 ) < 1 ) {
2017-03-13 04:58:34 +01:00
av_log ( c , AV_LOG_ERROR , " Invalid second level segment filename template '%s', "
" you can try to remove second_level_segment_size flag \n " ,
2017-12-29 22:00:04 +01:00
oc - > url ) ;
2019-09-24 13:24:01 +02:00
av_freep ( & filename ) ;
2017-03-13 04:58:34 +01:00
return AVERROR ( EINVAL ) ;
}
2017-12-29 22:00:04 +01:00
ff_format_set_url ( oc , filename ) ;
2017-03-13 04:58:34 +01:00
}
if ( c - > flags & HLS_SECOND_LEVEL_SEGMENT_DURATION ) {
2018-01-06 18:41:27 +01:00
char * filename = NULL ;
2017-12-29 22:00:04 +01:00
if ( replace_int_data_in_filename ( & filename , oc - > url , ' t ' , 0 ) < 1 ) {
2017-03-13 04:58:34 +01:00
av_log ( c , AV_LOG_ERROR , " Invalid second level segment filename template '%s', "
" you can try to remove second_level_segment_time flag \n " ,
2017-12-29 22:00:04 +01:00
oc - > url ) ;
2019-09-24 13:24:01 +02:00
av_freep ( & filename ) ;
2017-03-13 04:58:34 +01:00
return AVERROR ( EINVAL ) ;
}
2017-12-29 22:00:04 +01:00
ff_format_set_url ( oc , filename ) ;
2017-03-13 04:58:34 +01:00
}
}
return 0 ;
}
/* Create a new segment and append it to the segment list */
2017-11-20 03:02:11 +01:00
static int hls_append_segment ( struct AVFormatContext * s , HLSContext * hls ,
VariantStream * vs , double duration , int64_t pos ,
int64_t size )
2017-03-13 04:58:34 +01:00
{
HLSSegment * en = av_malloc ( sizeof ( * en ) ) ;
const char * filename ;
2017-06-19 04:35:41 +02:00
int byterange_mode = ( hls - > flags & HLS_SINGLE_FILE ) | | ( hls - > max_seg_size > 0 ) ;
2017-03-13 04:58:34 +01:00
int ret ;
2017-01-03 15:57:51 +01:00
2017-03-13 04:58:34 +01:00
if ( ! en )
return AVERROR ( ENOMEM ) ;
2018-04-11 05:15:54 +02:00
en - > var_stream_idx = vs - > var_stream_idx ;
2017-11-20 03:02:11 +01:00
ret = sls_flags_filename_process ( s , hls , vs , en , duration , pos , size ) ;
2017-03-13 04:58:34 +01:00
if ( ret < 0 ) {
2019-10-10 04:07:49 +02:00
av_freep ( & en ) ;
2017-03-13 04:58:34 +01:00
return ret ;
}
2017-01-03 15:57:51 +01:00
2017-12-29 22:00:04 +01:00
filename = av_basename ( vs - > avf - > url ) ;
2016-02-03 22:20:07 +01:00
if ( hls - > use_localtime_mkdir ) {
2017-12-29 22:00:04 +01:00
filename = vs - > avf - > url ;
2016-02-03 22:20:07 +01:00
}
2017-11-20 03:02:11 +01:00
if ( ( find_segment_by_filename ( vs - > segments , filename ) | | find_segment_by_filename ( vs - > old_segments , filename ) )
2017-06-19 04:35:41 +02:00
& & ! byterange_mode ) {
2017-01-01 13:22:34 +01:00
av_log ( hls , AV_LOG_WARNING , " Duplicated segment filename detected: %s \n " , filename ) ;
}
2016-02-03 22:20:07 +01:00
av_strlcpy ( en - > filename , filename , sizeof ( en - > filename ) ) ;
2012-10-26 16:36:56 +02:00
2019-09-06 06:15:45 +02:00
if ( vs - > has_subtitle )
2017-12-29 22:00:04 +01:00
av_strlcpy ( en - > sub_filename , av_basename ( vs - > vtt_avf - > url ) , 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 ;
2019-06-02 16:03:17 +02:00
en - > keyframe_pos = vs - > video_keyframe_pos ;
en - > keyframe_size = vs - > video_keyframe_size ;
2012-10-26 16:36:56 +02:00
en - > next = NULL ;
2016-12-05 10:55:33 +01:00
en - > discont = 0 ;
2020-12-01 11:10:40 +01:00
en - > discont_program_date_time = 0 ;
2016-12-05 10:55:33 +01:00
2017-11-20 03:02:11 +01:00
if ( vs - > discontinuity ) {
2016-12-05 10:55:33 +01:00
en - > discont = 1 ;
2017-11-20 03:02:11 +01:00
vs - > discontinuity = 0 ;
2016-12-05 10:55:33 +01:00
}
2012-10-26 16:36:56 +02:00
2017-04-14 17:30:29 +02:00
if ( hls - > key_info_file | | hls - > encrypt ) {
2020-04-30 15:10:53 +02:00
av_strlcpy ( en - > key_uri , vs - > key_uri , sizeof ( en - > key_uri ) ) ;
av_strlcpy ( en - > iv_string , vs - > iv_string , sizeof ( en - > iv_string ) ) ;
2015-06-15 20:58:07 +02:00
}
2017-11-20 03:02:11 +01:00
if ( ! vs - > segments )
vs - > segments = en ;
2012-10-26 16:36:56 +02:00
else
2017-11-20 03:02:11 +01:00
vs - > last_segment - > next = en ;
2012-10-26 16:36:56 +02:00
2017-11-20 03:02:11 +01:00
vs - > 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 ;
2017-11-20 03:02:11 +01:00
if ( hls - > max_nb_segments & & vs - > nb_entries > = hls - > max_nb_segments ) {
en = vs - > segments ;
2020-12-01 11:10:40 +01:00
if ( ! en - > next - > discont_program_date_time & & ! en - > discont_program_date_time )
vs - > initial_prog_date_time + = en - > duration ;
2017-11-20 03:02:11 +01:00
vs - > segments = en - > next ;
2014-12-08 17:25:05 +01:00
if ( en & & hls - > flags & HLS_DELETE_SEGMENTS & &
2017-02-11 05:32:31 +01:00
! ( hls - > flags & HLS_SINGLE_FILE ) ) {
2017-11-20 03:02:11 +01:00
en - > next = vs - > old_segments ;
vs - > old_segments = en ;
if ( ( ret = hls_delete_old_segments ( s , hls , vs ) ) < 0 )
2014-12-08 17:25:05 +01:00
return ret ;
} else
2019-09-24 13:24:01 +02:00
av_freep ( & en ) ;
2012-12-25 10:05:42 +01:00
} else
2017-11-20 03:02:11 +01:00
vs - > nb_entries + + ;
2012-10-26 16:36:56 +02:00
2016-09-19 01:00:42 +02:00
if ( hls - > max_seg_size > 0 ) {
return 0 ;
}
2017-11-20 03:02:11 +01:00
vs - > sequence + + ;
2012-12-29 12:09:17 +01:00
2012-10-26 16:36:56 +02:00
return 0 ;
}
2017-11-20 03:02:11 +01:00
static int parse_playlist ( AVFormatContext * s , const char * url , VariantStream * vs )
2016-08-21 06:55:45 +02:00
{
HLSContext * hls = s - > priv_data ;
AVIOContext * in ;
int ret = 0 , is_segment = 0 ;
int64_t new_start_pos ;
2019-07-01 04:24:21 +02:00
char line [ MAX_URL_SIZE ] ;
2016-08-21 06:55:45 +02:00
const char * ptr ;
2017-04-28 04:17:40 +02:00
const char * end ;
2020-12-01 11:10:40 +01:00
double discont_program_date_time = 0 ;
2016-08-21 06:55:45 +02:00
if ( ( ret = ffio_open_whitelist ( & in , url , AVIO_FLAG_READ ,
& s - > interrupt_callback , NULL ,
s - > protocol_whitelist , s - > protocol_blacklist ) ) < 0 )
return ret ;
2018-04-09 17:12:16 +02:00
ff_get_chomp_line ( in , line , sizeof ( line ) ) ;
2016-08-21 06:55:45 +02:00
if ( strcmp ( line , " #EXTM3U " ) ) {
ret = AVERROR_INVALIDDATA ;
goto fail ;
}
2017-11-20 03:02:11 +01:00
vs - > discontinuity = 0 ;
2016-08-21 06:55:45 +02:00
while ( ! avio_feof ( in ) ) {
2018-04-09 17:12:16 +02:00
ff_get_chomp_line ( in , line , sizeof ( line ) ) ;
2016-08-21 06:55:45 +02:00
if ( av_strstart ( line , " #EXT-X-MEDIA-SEQUENCE: " , & ptr ) ) {
2017-01-12 13:43:10 +01:00
int64_t tmp_sequence = strtoll ( ptr , NULL , 10 ) ;
2017-11-20 03:02:11 +01:00
if ( tmp_sequence < vs - > sequence )
2017-01-12 13:43:10 +01:00
av_log ( hls , AV_LOG_VERBOSE ,
" Found playlist sequence number was smaller " " "
" than specified start sequence number: % " PRId64 " < % " PRId64 " , "
" omitting \n " , tmp_sequence , hls - > start_sequence ) ;
else {
av_log ( hls , AV_LOG_DEBUG , " Found playlist sequence number: % " PRId64 " \n " , tmp_sequence ) ;
2017-11-20 03:02:11 +01:00
vs - > sequence = tmp_sequence ;
2017-01-12 13:43:10 +01:00
}
2016-12-07 00:43:36 +01:00
} else if ( av_strstart ( line , " #EXT-X-DISCONTINUITY " , & ptr ) ) {
is_segment = 1 ;
2017-11-20 03:02:11 +01:00
vs - > discontinuity = 1 ;
2016-08-21 06:55:45 +02:00
} else if ( av_strstart ( line , " #EXTINF: " , & ptr ) ) {
is_segment = 1 ;
2017-11-20 03:02:11 +01:00
vs - > duration = atof ( ptr ) ;
2017-04-28 04:17:40 +02:00
} else if ( av_stristart ( line , " #EXT-X-KEY: " , & ptr ) ) {
ptr = av_stristr ( line , " URI= \" " ) ;
if ( ptr ) {
ptr + = strlen ( " URI= \" " ) ;
end = av_stristr ( ptr , " , " ) ;
if ( end ) {
2020-04-30 15:10:53 +02:00
av_strlcpy ( vs - > key_uri , ptr , end - ptr ) ;
2017-04-28 04:17:40 +02:00
} else {
2020-04-30 15:10:53 +02:00
av_strlcpy ( vs - > key_uri , ptr , sizeof ( vs - > key_uri ) ) ;
2017-04-28 04:17:40 +02:00
}
}
ptr = av_stristr ( line , " IV=0x " ) ;
if ( ptr ) {
ptr + = strlen ( " IV=0x " ) ;
end = av_stristr ( ptr , " , " ) ;
if ( end ) {
2020-04-30 15:10:53 +02:00
av_strlcpy ( vs - > iv_string , ptr , end - ptr ) ;
2017-04-28 04:17:40 +02:00
} else {
2020-04-30 15:10:53 +02:00
av_strlcpy ( vs - > iv_string , ptr , sizeof ( vs - > iv_string ) ) ;
2017-04-28 04:17:40 +02:00
}
}
2020-12-01 11:10:40 +01:00
} else if ( av_strstart ( line , " #EXT-X-PROGRAM-DATE-TIME: " , & ptr ) ) {
struct tm program_date_time ;
int y , M , d , h , m , s ;
double ms ;
if ( sscanf ( ptr , " %d-%d-%dT%d:%d:%d.%lf " , & y , & M , & d , & h , & m , & s , & ms ) ! = 7 ) {
ret = AVERROR_INVALIDDATA ;
goto fail ;
}
program_date_time . tm_year = y - 1900 ;
program_date_time . tm_mon = M - 1 ;
program_date_time . tm_mday = d ;
program_date_time . tm_hour = h ;
program_date_time . tm_min = m ;
program_date_time . tm_sec = s ;
program_date_time . tm_isdst = - 1 ;
2017-04-28 04:17:40 +02:00
2020-12-01 11:10:40 +01:00
discont_program_date_time = mktime ( & program_date_time ) ;
discont_program_date_time + = ( double ) ( ms / 1000 ) ;
2016-08-21 06:55:45 +02:00
} else if ( av_strstart ( line , " # " , NULL ) ) {
continue ;
} else if ( line [ 0 ] ) {
if ( is_segment ) {
2017-12-29 22:00:04 +01:00
char * new_file = av_strdup ( line ) ;
if ( ! new_file ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
ff_format_set_url ( vs - > avf , new_file ) ;
2016-08-21 06:55:45 +02:00
is_segment = 0 ;
2017-11-20 03:02:11 +01:00
new_start_pos = avio_tell ( vs - > avf - > pb ) ;
vs - > size = new_start_pos - vs - > start_pos ;
ret = hls_append_segment ( s , hls , vs , vs - > duration , vs - > start_pos , vs - > size ) ;
2020-12-01 11:10:40 +01:00
vs - > last_segment - > discont_program_date_time = discont_program_date_time ;
discont_program_date_time + = vs - > duration ;
2016-08-21 06:55:45 +02:00
if ( ret < 0 )
goto fail ;
2017-11-20 03:02:11 +01:00
vs - > start_pos = new_start_pos ;
2016-08-21 06:55:45 +02:00
}
}
}
fail :
avio_close ( in ) ;
return ret ;
}
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
2019-09-06 06:15:45 +02:00
while ( p ) {
2012-10-26 16:36:56 +02:00
en = p ;
p = p - > next ;
2019-09-24 13:24:01 +02:00
av_freep ( & en ) ;
2012-10-26 16:36:56 +02:00
}
}
2017-12-29 22:00:04 +01:00
static int hls_rename_temp_file ( AVFormatContext * s , AVFormatContext * oc )
2017-02-25 03:59:05 +01:00
{
2017-12-29 22:00:04 +01:00
size_t len = strlen ( oc - > url ) ;
char * final_filename = av_strdup ( oc - > url ) ;
int ret ;
2017-02-25 03:59:05 +01:00
2017-12-29 22:00:04 +01:00
if ( ! final_filename )
return AVERROR ( ENOMEM ) ;
2017-02-25 03:59:05 +01:00
final_filename [ len - 4 ] = ' \0 ' ;
2017-12-29 22:00:04 +01:00
ret = ff_rename ( oc - > url , final_filename , s ) ;
oc - > url [ len - 4 ] = ' \0 ' ;
av_freep ( & final_filename ) ;
return ret ;
2017-02-25 03:59:05 +01:00
}
2019-08-30 05:45:39 +02:00
static const char * get_relative_url ( const char * master_url , const char * media_url )
2017-11-20 03:04:34 +01:00
{
2019-08-30 05:45:39 +02:00
const char * p = strrchr ( master_url , ' / ' ) ;
size_t base_len = 0 ;
if ( ! p ) p = strrchr ( master_url , ' \\ ' ) ;
2017-11-20 03:04:34 +01:00
if ( p ) {
2020-01-10 15:51:22 +01:00
base_len = p - master_url ;
2017-11-20 03:04:34 +01:00
if ( av_strncasecmp ( master_url , media_url , base_len ) ) {
av_log ( NULL , AV_LOG_WARNING , " Unable to find relative url \n " ) ;
2019-08-30 05:45:39 +02:00
return NULL ;
2017-11-20 03:04:34 +01:00
}
2020-04-09 03:50:46 +02:00
} else {
return media_url ;
2017-11-20 03:04:34 +01:00
}
2019-08-30 05:45:39 +02:00
2020-03-26 14:56:57 +01:00
return media_url + base_len + 1 ;
2017-11-20 03:04:34 +01:00
}
2019-09-06 06:15:45 +02:00
static int64_t get_stream_bit_rate ( AVStream * stream )
{
2018-03-23 13:41:28 +01:00
AVCPBProperties * props = ( AVCPBProperties * ) av_stream_get_side_data (
stream ,
AV_PKT_DATA_CPB_PROPERTIES ,
NULL
) ;
if ( stream - > codecpar - > bit_rate )
return stream - > codecpar - > bit_rate ;
else if ( props )
return props - > max_bitrate ;
return 0 ;
}
2017-11-20 03:04:34 +01:00
static int create_master_playlist ( AVFormatContext * s ,
VariantStream * const input_vs )
{
HLSContext * hls = s - > priv_data ;
2017-12-23 06:42:00 +01:00
VariantStream * vs , * temp_vs ;
2017-11-20 03:04:34 +01:00
AVStream * vid_st , * aud_st ;
AVDictionary * options = NULL ;
unsigned int i , j ;
2019-08-30 05:45:39 +02:00
int ret , bandwidth ;
const char * m3u8_rel_name = NULL ;
avformat: add subtitle support in master playlist m3u8
Test with the following command for the webvtt subtitle:
$ ./ffmpeg -y -i input_with_subtitle.mkv \
-b:v:0 5250k -c:v h264 -pix_fmt yuv420p -profile:v main -level 4.1 \
-b:a:0 256k \
-c:s webvtt -c:a mp2 -ar 48000 -ac 2 -map 0:v -map 0:a:0 -map 0:s:0 \
-f hls -var_stream_map "v:0,a:0,s:0,sgroup:subtitle" \
-master_pl_name master.m3u8 -t 300 -hls_time 10 -hls_init_time 4 -hls_list_size \
10 -master_pl_publish_rate 10 -hls_flags \
delete_segments+discont_start+split_by_time ./tmp/video.m3u8
Check the master m3u8:
$ cat tmp/master.m3u8
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="subtitle",NAME="subtitle_0",DEFAULT=YES,URI="video_vtt.m3u8"
#EXT-X-STREAM-INF:BANDWIDTH=6056600,RESOLUTION=1280x720,CODECS="avc1.4d4829,mp4a.40.33",SUBTITLES="subtitle"
video.m3u8
Check the result by convert to mkv:
$ ./ffmpeg -strict experimental -i ./tmp/master.m3u8 -c:v copy -c:a mp2 -c:s srt ./test.mkv
Signed-off-by: Limin Wang <lance.lmwang@gmail.com>
2020-03-29 13:13:44 +02:00
const char * vtt_m3u8_rel_name = NULL ;
2020-05-25 19:22:19 +02:00
const char * ccgroup ;
const char * sgroup = NULL ;
2018-01-24 04:42:57 +01:00
ClosedCaptionsStream * ccs ;
2019-06-28 07:54:27 +02:00
const char * proto = avio_find_protocol_name ( hls - > master_m3u8_url ) ;
int is_file_proto = proto & & ! strcmp ( proto , " file " ) ;
int use_temp_file = is_file_proto & & ( ( hls - > flags & HLS_TEMP_FILE ) | | hls - > master_publish_rate ) ;
2019-07-01 04:24:21 +02:00
char temp_filename [ MAX_URL_SIZE ] ;
2017-11-20 03:04:34 +01:00
input_vs - > m3u8_created = 1 ;
if ( ! hls - > master_m3u8_created ) {
/* For the first time, wait until all the media playlists are created */
for ( i = 0 ; i < hls - > nb_varstreams ; i + + )
if ( ! hls - > var_streams [ i ] . m3u8_created )
return 0 ;
} else {
/* Keep publishing the master playlist at the configured rate */
if ( & hls - > var_streams [ 0 ] ! = input_vs | | ! hls - > master_publish_rate | |
input_vs - > number % hls - > master_publish_rate )
return 0 ;
}
2017-11-23 23:41:25 +01:00
set_http_options ( s , & options , hls ) ;
2019-06-28 07:54:27 +02:00
snprintf ( temp_filename , sizeof ( temp_filename ) , use_temp_file ? " %s.tmp " : " %s " , hls - > master_m3u8_url ) ;
ret = hlsenc_io_open ( s , & hls - > m3u8_out , temp_filename , & options ) ;
2017-11-20 03:04:34 +01:00
av_dict_free ( & options ) ;
if ( ret < 0 ) {
2019-09-30 08:31:36 +02:00
av_log ( s , AV_LOG_ERROR , " Failed to open master play list file '%s' \n " ,
2019-06-28 07:54:27 +02:00
temp_filename ) ;
2017-11-20 03:04:34 +01:00
goto fail ;
}
2017-12-15 15:11:12 +01:00
ff_hls_write_playlist_version ( hls - > m3u8_out , hls - > version ) ;
2017-11-20 03:04:34 +01:00
2018-01-24 04:42:57 +01:00
for ( i = 0 ; i < hls - > nb_ccstreams ; i + + ) {
ccs = & ( hls - > cc_streams [ i ] ) ;
avio_printf ( hls - > m3u8_out , " #EXT-X-MEDIA:TYPE=CLOSED-CAPTIONS " ) ;
avio_printf ( hls - > m3u8_out , " ,GROUP-ID= \" %s \" " , ccs - > ccgroup ) ;
avio_printf ( hls - > m3u8_out , " ,NAME= \" %s \" " , ccs - > instreamid ) ;
if ( ccs - > language )
avio_printf ( hls - > m3u8_out , " ,LANGUAGE= \" %s \" " , ccs - > language ) ;
avio_printf ( hls - > m3u8_out , " ,INSTREAM-ID= \" %s \" \n " , ccs - > instreamid ) ;
}
2017-12-23 06:42:00 +01:00
/* For audio only variant streams add #EXT-X-MEDIA tag with attributes*/
for ( i = 0 ; i < hls - > nb_varstreams ; i + + ) {
vs = & ( hls - > var_streams [ i ] ) ;
if ( vs - > has_video | | vs - > has_subtitle | | ! vs - > agroup )
continue ;
2019-08-30 05:45:39 +02:00
m3u8_rel_name = get_relative_url ( hls - > master_m3u8_url , vs - > m3u8_name ) ;
2017-12-23 06:42:00 +01:00
if ( ! m3u8_rel_name ) {
av_log ( s , AV_LOG_ERROR , " Unable to find relative URL \n " ) ;
goto fail ;
}
avformat/hlsenc: add var_stream_map LANGUAGE field string parameter
use a:0,agroup:aud_low,default:Yes,language:CHN a:1,agroup:aud_low,language:ENG
a:2,agroup:aud_high,default:YesYes,language:CHN a:3,agroup:aud_high,language:ENG
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,LANGUAGE="CHN",URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,LANGUAGE="ENG",URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,LANGUAGE="CHN",URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,LANGUAGE="ENG",URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 12:19:49 +01:00
ff_hls_write_audio_rendition ( hls - > m3u8_out , vs - > agroup , m3u8_rel_name , vs - > language , i , hls - > has_default_key ? vs - > is_default : 1 ) ;
2017-12-23 06:42:00 +01:00
}
2017-11-20 03:04:34 +01:00
/* For variant streams with video add #EXT-X-STREAM-INF tag with attributes*/
for ( i = 0 ; i < hls - > nb_varstreams ; i + + ) {
vs = & ( hls - > var_streams [ i ] ) ;
2019-08-30 05:45:39 +02:00
m3u8_rel_name = get_relative_url ( hls - > master_m3u8_url , vs - > m3u8_name ) ;
2017-11-23 23:42:35 +01:00
if ( ! m3u8_rel_name ) {
2019-09-30 08:31:36 +02:00
av_log ( s , AV_LOG_ERROR , " Unable to find relative URL \n " ) ;
2017-11-20 03:04:34 +01:00
goto fail ;
}
vid_st = NULL ;
aud_st = NULL ;
for ( j = 0 ; j < vs - > nb_streams ; j + + ) {
if ( vs - > streams [ j ] - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO )
vid_st = vs - > streams [ j ] ;
else if ( vs - > streams [ j ] - > codecpar - > codec_type = = AVMEDIA_TYPE_AUDIO )
aud_st = vs - > streams [ j ] ;
}
if ( ! vid_st & & ! aud_st ) {
2019-09-30 08:31:36 +02:00
av_log ( s , AV_LOG_WARNING , " Media stream not found \n " ) ;
2017-11-20 03:04:34 +01:00
continue ;
}
2017-12-23 06:42:00 +01:00
/**
* Traverse through the list of audio only rendition streams and find
* the rendition which has highest bitrate in the same audio group
*/
if ( vs - > agroup ) {
for ( j = 0 ; j < hls - > nb_varstreams ; j + + ) {
temp_vs = & ( hls - > var_streams [ j ] ) ;
if ( ! temp_vs - > has_video & & ! temp_vs - > has_subtitle & &
temp_vs - > agroup & &
! av_strcasecmp ( temp_vs - > agroup , vs - > agroup ) ) {
if ( ! aud_st )
aud_st = temp_vs - > streams [ 0 ] ;
if ( temp_vs - > streams [ 0 ] - > codecpar - > bit_rate >
aud_st - > codecpar - > bit_rate )
aud_st = temp_vs - > streams [ 0 ] ;
}
}
}
2017-11-20 03:04:34 +01:00
bandwidth = 0 ;
if ( vid_st )
2018-03-23 13:41:28 +01:00
bandwidth + = get_stream_bit_rate ( vid_st ) ;
2017-11-20 03:04:34 +01:00
if ( aud_st )
2018-03-23 13:41:28 +01:00
bandwidth + = get_stream_bit_rate ( aud_st ) ;
2017-11-20 03:04:34 +01:00
bandwidth + = bandwidth / 10 ;
2018-01-24 04:42:57 +01:00
ccgroup = NULL ;
if ( vid_st & & vs - > ccgroup ) {
/* check if this group name is available in the cc map string */
for ( j = 0 ; j < hls - > nb_ccstreams ; j + + ) {
ccs = & ( hls - > cc_streams [ j ] ) ;
if ( ! av_strcasecmp ( ccs - > ccgroup , vs - > ccgroup ) ) {
ccgroup = vs - > ccgroup ;
break ;
}
}
if ( j = = hls - > nb_ccstreams )
2019-09-30 08:31:36 +02:00
av_log ( s , AV_LOG_WARNING , " mapping ccgroup %s not found \n " ,
2018-01-24 04:42:57 +01:00
vs - > ccgroup ) ;
}
avformat: add subtitle support in master playlist m3u8
Test with the following command for the webvtt subtitle:
$ ./ffmpeg -y -i input_with_subtitle.mkv \
-b:v:0 5250k -c:v h264 -pix_fmt yuv420p -profile:v main -level 4.1 \
-b:a:0 256k \
-c:s webvtt -c:a mp2 -ar 48000 -ac 2 -map 0:v -map 0:a:0 -map 0:s:0 \
-f hls -var_stream_map "v:0,a:0,s:0,sgroup:subtitle" \
-master_pl_name master.m3u8 -t 300 -hls_time 10 -hls_init_time 4 -hls_list_size \
10 -master_pl_publish_rate 10 -hls_flags \
delete_segments+discont_start+split_by_time ./tmp/video.m3u8
Check the master m3u8:
$ cat tmp/master.m3u8
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="subtitle",NAME="subtitle_0",DEFAULT=YES,URI="video_vtt.m3u8"
#EXT-X-STREAM-INF:BANDWIDTH=6056600,RESOLUTION=1280x720,CODECS="avc1.4d4829,mp4a.40.33",SUBTITLES="subtitle"
video.m3u8
Check the result by convert to mkv:
$ ./ffmpeg -strict experimental -i ./tmp/master.m3u8 -c:v copy -c:a mp2 -c:s srt ./test.mkv
Signed-off-by: Limin Wang <lance.lmwang@gmail.com>
2020-03-29 13:13:44 +02:00
if ( vid_st & & vs - > sgroup ) {
sgroup = vs - > sgroup ;
vtt_m3u8_rel_name = get_relative_url ( hls - > master_m3u8_url , vs - > vtt_m3u8_name ) ;
if ( ! vtt_m3u8_rel_name ) {
av_log ( s , AV_LOG_WARNING , " Unable to find relative subtitle URL \n " ) ;
break ;
}
ff_hls_write_subtitle_rendition ( hls - > m3u8_out , sgroup , vtt_m3u8_rel_name , vs - > language , i , hls - > has_default_key ? vs - > is_default : 1 ) ;
}
avformat/hlsenc: add var_stream_map DEFAULT field status parameter
use a:0,agroup:aud_low,default:Yes a:1,agroup:aud_low,
a:2,agroup:aud_high,default:Yes a:3, agroup:aud_high,
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 11:52:02 +01:00
if ( ! hls - > has_default_key | | ! hls - > has_video_m3u8 ) {
ff_hls_write_stream_info ( vid_st , hls - > m3u8_out , bandwidth , m3u8_rel_name ,
avformat: add subtitle support in master playlist m3u8
Test with the following command for the webvtt subtitle:
$ ./ffmpeg -y -i input_with_subtitle.mkv \
-b:v:0 5250k -c:v h264 -pix_fmt yuv420p -profile:v main -level 4.1 \
-b:a:0 256k \
-c:s webvtt -c:a mp2 -ar 48000 -ac 2 -map 0:v -map 0:a:0 -map 0:s:0 \
-f hls -var_stream_map "v:0,a:0,s:0,sgroup:subtitle" \
-master_pl_name master.m3u8 -t 300 -hls_time 10 -hls_init_time 4 -hls_list_size \
10 -master_pl_publish_rate 10 -hls_flags \
delete_segments+discont_start+split_by_time ./tmp/video.m3u8
Check the master m3u8:
$ cat tmp/master.m3u8
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="subtitle",NAME="subtitle_0",DEFAULT=YES,URI="video_vtt.m3u8"
#EXT-X-STREAM-INF:BANDWIDTH=6056600,RESOLUTION=1280x720,CODECS="avc1.4d4829,mp4a.40.33",SUBTITLES="subtitle"
video.m3u8
Check the result by convert to mkv:
$ ./ffmpeg -strict experimental -i ./tmp/master.m3u8 -c:v copy -c:a mp2 -c:s srt ./test.mkv
Signed-off-by: Limin Wang <lance.lmwang@gmail.com>
2020-03-29 13:13:44 +02:00
aud_st ? vs - > agroup : NULL , vs - > codec_attr , ccgroup , sgroup ) ;
avformat/hlsenc: add var_stream_map DEFAULT field status parameter
use a:0,agroup:aud_low,default:Yes a:1,agroup:aud_low,
a:2,agroup:aud_high,default:Yes a:3, agroup:aud_high,
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 11:52:02 +01:00
} else {
if ( vid_st ) {
ff_hls_write_stream_info ( vid_st , hls - > m3u8_out , bandwidth , m3u8_rel_name ,
avformat: add subtitle support in master playlist m3u8
Test with the following command for the webvtt subtitle:
$ ./ffmpeg -y -i input_with_subtitle.mkv \
-b:v:0 5250k -c:v h264 -pix_fmt yuv420p -profile:v main -level 4.1 \
-b:a:0 256k \
-c:s webvtt -c:a mp2 -ar 48000 -ac 2 -map 0:v -map 0:a:0 -map 0:s:0 \
-f hls -var_stream_map "v:0,a:0,s:0,sgroup:subtitle" \
-master_pl_name master.m3u8 -t 300 -hls_time 10 -hls_init_time 4 -hls_list_size \
10 -master_pl_publish_rate 10 -hls_flags \
delete_segments+discont_start+split_by_time ./tmp/video.m3u8
Check the master m3u8:
$ cat tmp/master.m3u8
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="subtitle",NAME="subtitle_0",DEFAULT=YES,URI="video_vtt.m3u8"
#EXT-X-STREAM-INF:BANDWIDTH=6056600,RESOLUTION=1280x720,CODECS="avc1.4d4829,mp4a.40.33",SUBTITLES="subtitle"
video.m3u8
Check the result by convert to mkv:
$ ./ffmpeg -strict experimental -i ./tmp/master.m3u8 -c:v copy -c:a mp2 -c:s srt ./test.mkv
Signed-off-by: Limin Wang <lance.lmwang@gmail.com>
2020-03-29 13:13:44 +02:00
aud_st ? vs - > agroup : NULL , vs - > codec_attr , ccgroup , sgroup ) ;
avformat/hlsenc: add var_stream_map DEFAULT field status parameter
use a:0,agroup:aud_low,default:Yes a:1,agroup:aud_low,
a:2,agroup:aud_high,default:Yes a:3, agroup:aud_high,
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 11:52:02 +01:00
}
}
2017-11-20 03:04:34 +01:00
}
fail :
2019-09-06 06:15:45 +02:00
if ( ret > = 0 )
2017-11-20 03:04:34 +01:00
hls - > master_m3u8_created = 1 ;
2019-06-28 07:54:27 +02:00
hlsenc_io_close ( s , & hls - > m3u8_out , temp_filename ) ;
if ( use_temp_file )
ff_rename ( temp_filename , hls - > master_m3u8_url , s ) ;
2017-11-20 03:04:34 +01:00
return ret ;
}
2017-11-20 03:02:11 +01:00
static int hls_window ( AVFormatContext * s , int last , VariantStream * vs )
2012-10-26 16:36:56 +02:00
{
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 ;
2019-07-01 04:24:21 +02:00
char temp_filename [ MAX_URL_SIZE ] ;
char temp_vtt_filename [ MAX_URL_SIZE ] ;
2017-11-20 03:02:11 +01:00
int64_t sequence = FFMAX ( hls - > start_sequence , vs - > sequence - vs - > nb_entries ) ;
2018-12-17 23:14:53 +01:00
const char * proto = avio_find_protocol_name ( vs - > m3u8_name ) ;
int is_file_proto = proto & & ! strcmp ( proto , " file " ) ;
int use_temp_file = is_file_proto & & ( ( hls - > flags & HLS_TEMP_FILE ) | | ! ( hls - > pl_type = = PLAYLIST_TYPE_VOD ) ) ;
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 ;
2017-11-20 03:02:11 +01:00
double prog_date_time = vs - > initial_prog_date_time ;
2017-11-29 12:44:15 +01:00
double * prog_date_time_p = ( hls - > flags & HLS_PROGRAM_DATE_TIME ) ? & prog_date_time : NULL ;
2016-09-19 01:00:42 +02:00
int byterange_mode = ( hls - > flags & HLS_SINGLE_FILE ) | | ( hls - > max_seg_size > 0 ) ;
2017-11-20 03:04:34 +01:00
hls - > version = 3 ;
2016-09-19 01:00:42 +02:00
if ( byterange_mode ) {
2017-11-20 03:04:34 +01:00
hls - > version = 4 ;
2016-09-19 01:00:42 +02:00
sequence = 0 ;
}
2015-02-21 19:27:06 +01:00
2021-01-15 17:47:41 +01:00
if ( hls - > flags & HLS_I_FRAMES_ONLY ) {
hls - > version = 4 ;
}
2017-11-23 23:57:36 +01:00
if ( hls - > flags & HLS_INDEPENDENT_SEGMENTS ) {
hls - > version = 6 ;
}
2017-07-03 14:20:44 +02:00
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 ) {
2017-11-20 03:04:34 +01:00
hls - > version = 7 ;
2017-07-03 14:20:44 +02:00
}
2018-12-17 23:14:53 +01:00
if ( ! is_file_proto & & ( hls - > flags & HLS_TEMP_FILE ) & & ! warned_non_file + + )
2016-10-09 12:57:01 +02:00
av_log ( s , AV_LOG_ERROR , " Cannot use rename on non file protocol, this may lead to races and temporary partial files \n " ) ;
2012-10-26 16:36:56 +02:00
2017-02-18 02:42:51 +01:00
set_http_options ( s , & options , hls ) ;
2018-08-19 03:57:44 +02:00
snprintf ( temp_filename , sizeof ( temp_filename ) , use_temp_file ? " %s.tmp " : " %s " , vs - > m3u8_name ) ;
2019-09-06 09:39:02 +02:00
if ( ( ret = hlsenc_io_open ( s , byterange_mode ? & hls - > m3u8_out : & vs - > out , temp_filename , & options ) ) < 0 ) {
2018-12-10 07:19:23 +01:00
if ( hls - > ignore_io_errors )
ret = 0 ;
2012-10-26 16:36:56 +02:00
goto fail ;
2018-12-10 07:19:23 +01:00
}
2012-10-26 16:36:56 +02:00
2017-11-20 03:02:11 +01:00
for ( en = vs - > segments ; en ; en = en - > next ) {
2017-01-10 21:38:34 +01:00
if ( target_duration < = en - > duration )
2017-12-22 00:43:54 +01:00
target_duration = lrint ( en - > duration ) ;
2012-12-21 12:05:46 +01:00
}
2017-11-20 03:02:11 +01:00
vs - > discontinuity_set = 0 ;
2019-09-06 09:39:02 +02:00
ff_hls_write_playlist_header ( byterange_mode ? hls - > m3u8_out : vs - > out , hls - > version , hls - > allowcache ,
2019-06-02 16:03:17 +02:00
target_duration , sequence , hls - > pl_type , hls - > flags & HLS_I_FRAMES_ONLY ) ;
2012-10-26 16:36:56 +02:00
2020-02-28 07:59:34 +01:00
if ( ( hls - > flags & HLS_DISCONT_START ) & & sequence = = hls - > start_sequence & & vs - > discontinuity_set = = 0 ) {
2019-09-06 09:39:02 +02:00
avio_printf ( byterange_mode ? hls - > m3u8_out : vs - > out , " #EXT-X-DISCONTINUITY \n " ) ;
2017-11-20 03:02:11 +01:00
vs - > discontinuity_set = 1 ;
2015-04-21 23:52:03 +02:00
}
2017-11-23 23:57:36 +01:00
if ( vs - > has_video & & ( hls - > flags & HLS_INDEPENDENT_SEGMENTS ) ) {
2019-09-06 09:39:02 +02:00
avio_printf ( byterange_mode ? hls - > m3u8_out : vs - > out , " #EXT-X-INDEPENDENT-SEGMENTS \n " ) ;
2017-11-23 23:57:36 +01:00
}
2017-11-20 03:02:11 +01:00
for ( en = vs - > segments ; en ; en = en - > next ) {
2017-04-14 17:30:29 +02:00
if ( ( hls - > encrypt | | hls - > key_info_file ) & & ( ! key_uri | | strcmp ( en - > key_uri , key_uri ) | |
2015-06-15 20:58:07 +02:00
av_strcasecmp ( en - > iv_string , iv_string ) ) ) {
2019-09-06 09:39:02 +02:00
avio_printf ( byterange_mode ? hls - > m3u8_out : vs - > out , " #EXT-X-KEY:METHOD=AES-128,URI= \" %s \" " , en - > key_uri ) ;
2015-06-15 20:58:07 +02:00
if ( * en - > iv_string )
2019-09-06 09:39:02 +02:00
avio_printf ( byterange_mode ? hls - > m3u8_out : vs - > out , " ,IV=0x%s " , en - > iv_string ) ;
avio_printf ( byterange_mode ? hls - > m3u8_out : vs - > out , " \n " ) ;
2015-06-15 20:58:07 +02:00
key_uri = en - > key_uri ;
iv_string = en - > iv_string ;
}
2017-11-20 03:02:11 +01:00
if ( ( hls - > segment_type = = SEGMENT_TYPE_FMP4 ) & & ( en = = vs - > segments ) ) {
2019-09-06 09:39:02 +02:00
ff_hls_write_init_file ( byterange_mode ? hls - > m3u8_out : vs - > out , ( hls - > flags & HLS_SINGLE_FILE ) ? en - > filename : vs - > fmp4_init_filename ,
2018-03-18 07:08:57 +01:00
hls - > flags & HLS_SINGLE_FILE , vs - > init_range_length , 0 ) ;
2017-10-29 05:31:49 +01:00
}
2017-11-29 12:44:15 +01:00
2019-09-06 09:39:02 +02:00
ret = ff_hls_write_file_entry ( byterange_mode ? hls - > m3u8_out : vs - > out , en - > discont , byterange_mode ,
2017-12-15 15:11:12 +01:00
en - > duration , hls - > flags & HLS_ROUND_DURATIONS ,
2020-05-25 18:52:57 +02:00
en - > size , en - > pos , hls - > baseurl ,
2020-12-01 11:10:40 +01:00
en - > filename ,
en - > discont_program_date_time ? & en - > discont_program_date_time : prog_date_time_p ,
en - > keyframe_size , en - > keyframe_pos , hls - > flags & HLS_I_FRAMES_ONLY ) ;
if ( en - > discont_program_date_time )
en - > discont_program_date_time - = en - > duration ;
2017-12-04 05:03:37 +01:00
if ( ret < 0 ) {
av_log ( s , AV_LOG_WARNING , " ff_hls_write_file_entry get error \n " ) ;
}
2012-10-26 16:36:56 +02:00
}
2015-04-21 23:53:57 +02:00
if ( last & & ( hls - > flags & HLS_OMIT_ENDLIST ) = = 0 )
2019-09-06 09:39:02 +02:00
ff_hls_write_end_list ( byterange_mode ? hls - > m3u8_out : vs - > out ) ;
2012-10-26 16:36:56 +02:00
2019-06-28 07:54:27 +02:00
if ( vs - > vtt_m3u8_name ) {
snprintf ( temp_vtt_filename , sizeof ( temp_vtt_filename ) , use_temp_file ? " %s.tmp " : " %s " , vs - > vtt_m3u8_name ) ;
if ( ( ret = hlsenc_io_open ( s , & hls - > sub_m3u8_out , temp_vtt_filename , & options ) ) < 0 ) {
2018-12-10 07:19:23 +01:00
if ( hls - > ignore_io_errors )
ret = 0 ;
2015-06-04 09:55:52 +02:00
goto fail ;
2018-12-10 07:19:23 +01:00
}
2017-12-15 15:11:12 +01:00
ff_hls_write_playlist_header ( hls - > sub_m3u8_out , hls - > version , hls - > allowcache ,
2019-06-02 16:03:17 +02:00
target_duration , sequence , PLAYLIST_TYPE_NONE , 0 ) ;
2017-11-20 03:02:11 +01:00
for ( en = vs - > segments ; en ; en = en - > next ) {
2017-12-15 15:11:12 +01:00
ret = ff_hls_write_file_entry ( hls - > sub_m3u8_out , 0 , byterange_mode ,
en - > duration , 0 , en - > size , en - > pos ,
2020-05-25 18:52:57 +02:00
hls - > baseurl , en - > sub_filename , NULL , 0 , 0 , 0 ) ;
2017-12-04 05:03:37 +01:00
if ( ret < 0 ) {
av_log ( s , AV_LOG_WARNING , " ff_hls_write_file_entry get error \n " ) ;
}
2015-06-04 09:55:52 +02:00
}
if ( last )
2017-12-15 15:11:12 +01:00
ff_hls_write_end_list ( hls - > sub_m3u8_out ) ;
2015-06-04 09:55:52 +02:00
}
2012-10-26 16:36:56 +02:00
fail :
2015-09-14 21:07:37 +02:00
av_dict_free ( & options ) ;
2019-09-06 09:39:02 +02:00
ret = hlsenc_io_close ( s , byterange_mode ? & hls - > m3u8_out : & vs - > out , temp_filename ) ;
2019-08-30 01:14:28 +02:00
if ( ret < 0 ) {
return ret ;
}
2017-12-15 15:11:12 +01:00
hlsenc_io_close ( s , & hls - > sub_m3u8_out , vs - > vtt_m3u8_name ) ;
2019-06-28 07:54:27 +02:00
if ( use_temp_file ) {
2017-11-20 03:02:11 +01:00
ff_rename ( temp_filename , vs - > m3u8_name , s ) ;
2019-06-28 07:54:27 +02:00
if ( vs - > vtt_m3u8_name )
ff_rename ( temp_vtt_filename , vs - > vtt_m3u8_name , s ) ;
}
2017-11-20 03:04:34 +01:00
if ( ret > = 0 & & hls - > master_pl_name )
if ( create_master_playlist ( s , vs ) < 0 )
av_log ( s , AV_LOG_WARNING , " Master playlist creation failed \n " ) ;
2012-10-26 16:36:56 +02:00
return ret ;
}
2017-11-20 03:02:11 +01:00
static int hls_start ( AVFormatContext * s , VariantStream * vs )
2012-10-26 16:36:56 +02:00
{
HLSContext * c = s - > priv_data ;
2017-11-20 03:02:11 +01:00
AVFormatContext * oc = vs - > avf ;
AVFormatContext * vtt_oc = vs - > vtt_avf ;
2015-06-15 20:58:07 +02:00
AVDictionary * options = NULL ;
2018-12-17 23:14:53 +01:00
const char * proto = NULL ;
int use_temp_file = 0 ;
2019-08-19 03:42:29 +02:00
char 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 ) {
2017-12-29 22:00:04 +01:00
char * new_name = av_strdup ( vs - > basename ) ;
if ( ! new_name )
return AVERROR ( ENOMEM ) ;
ff_format_set_url ( oc , new_name ) ;
if ( vs - > vtt_basename ) {
new_name = av_strdup ( vs - > vtt_basename ) ;
if ( ! new_name )
return AVERROR ( ENOMEM ) ;
ff_format_set_url ( vtt_oc , new_name ) ;
}
2016-09-19 01:00:42 +02:00
} else if ( c - > max_seg_size > 0 ) {
2018-01-06 18:41:27 +01:00
char * filename = NULL ;
if ( replace_int_data_in_filename ( & filename ,
2017-11-20 03:02:11 +01:00
vs - > basename , ' d ' , vs - > sequence ) < 1 ) {
2019-09-24 13:24:01 +02:00
av_freep ( & filename ) ;
2018-09-03 05:10:35 +02:00
av_log ( oc , AV_LOG_ERROR , " Invalid segment filename template '%s', you can try to use -strftime 1 with it \n " , vs - > basename ) ;
2016-09-19 01:00:42 +02:00
return AVERROR ( EINVAL ) ;
}
2017-12-29 22:00:04 +01:00
ff_format_set_url ( oc , filename ) ;
2015-06-04 09:55:52 +02:00
} else {
2015-08-31 22:10:15 +02:00
if ( c - > use_localtime ) {
2020-10-27 12:28:59 +01:00
int r ;
char * expanded = NULL ;
r = strftime_expand ( vs - > basename , & expanded ) ;
if ( r < 0 ) {
2018-09-03 05:10:35 +02:00
av_log ( oc , AV_LOG_ERROR , " Could not get segment filename with strftime \n " ) ;
2020-10-27 12:28:59 +01:00
return r ;
2015-08-31 22:10:15 +02:00
}
2020-10-27 12:28:59 +01:00
ff_format_set_url ( oc , expanded ) ;
2017-03-13 04:58:34 +01:00
2017-11-20 03:02:11 +01:00
err = sls_flag_use_localtime_filename ( oc , c , vs ) ;
2017-03-13 04:58:34 +01:00
if ( err < 0 ) {
return AVERROR ( ENOMEM ) ;
2017-01-03 15:57:51 +01:00
}
2017-03-13 04:58:34 +01:00
2016-02-03 22:20:07 +01:00
if ( c - > use_localtime_mkdir ) {
const char * dir ;
2017-12-29 22:00:04 +01:00
char * fn_copy = av_strdup ( oc - > url ) ;
2019-12-15 11:24:32 +01:00
if ( ! fn_copy )
return AVERROR ( ENOMEM ) ;
2016-02-03 22:20:07 +01:00
dir = av_dirname ( fn_copy ) ;
2018-09-22 16:10:09 +02:00
if ( ff_mkdir_p ( dir ) = = - 1 & & errno ! = EEXIST ) {
2016-02-03 22:20:07 +01:00
av_log ( oc , AV_LOG_ERROR , " Could not create directory %s with use_localtime_mkdir \n " , dir ) ;
2019-09-24 13:23:59 +02:00
av_freep ( & fn_copy ) ;
2016-02-03 22:20:07 +01:00
return AVERROR ( errno ) ;
}
2019-09-24 13:23:59 +02:00
av_freep ( & fn_copy ) ;
2016-02-03 22:20:07 +01:00
}
2018-01-06 18:41:27 +01:00
} else {
char * filename = NULL ;
if ( replace_int_data_in_filename ( & filename ,
2017-11-20 03:02:11 +01:00
vs - > basename , ' d ' , vs - > sequence ) < 1 ) {
2019-09-24 13:24:01 +02:00
av_freep ( & filename ) ;
2018-09-03 05:10:35 +02:00
av_log ( oc , AV_LOG_ERROR , " Invalid segment filename template '%s' you can try to use -strftime 1 with it \n " , vs - > basename ) ;
2018-01-06 18:41:27 +01:00
return AVERROR ( EINVAL ) ;
}
2017-12-29 22:00:04 +01:00
ff_format_set_url ( oc , filename ) ;
2014-09-15 15:26:57 +02:00
}
2020-02-28 07:59:34 +01:00
if ( vs - > vtt_basename ) {
2018-01-06 18:41:27 +01:00
char * filename = NULL ;
if ( replace_int_data_in_filename ( & filename ,
2017-11-20 03:02:11 +01:00
vs - > vtt_basename , ' d ' , vs - > sequence ) < 1 ) {
2019-09-24 13:24:01 +02:00
av_freep ( & filename ) ;
2017-11-20 03:02:11 +01:00
av_log ( vtt_oc , AV_LOG_ERROR , " Invalid segment filename template '%s' \n " , vs - > vtt_basename ) ;
2015-06-04 09:55:52 +02:00
return AVERROR ( EINVAL ) ;
}
2017-12-29 22:00:04 +01:00
ff_format_set_url ( vtt_oc , filename ) ;
2015-06-04 09:55:52 +02:00
}
}
2012-10-26 16:36:56 +02:00
2018-12-17 23:14:53 +01:00
proto = avio_find_protocol_name ( oc - > url ) ;
use_temp_file = proto & & ! strcmp ( proto , " file " ) & & ( c - > flags & HLS_TEMP_FILE ) ;
2018-08-19 03:57:44 +02:00
if ( use_temp_file ) {
2017-12-29 22:00:04 +01:00
char * new_name = av_asprintf ( " %s.tmp " , oc - > url ) ;
if ( ! new_name )
return AVERROR ( ENOMEM ) ;
ff_format_set_url ( oc , new_name ) ;
2017-02-07 04:58:43 +01:00
}
2017-04-14 17:30:29 +02:00
if ( c - > key_info_file | | c - > encrypt ) {
2018-04-16 08:35:14 +02:00
if ( c - > segment_type = = SEGMENT_TYPE_FMP4 ) {
av_log ( s , AV_LOG_ERROR , " Encrypted fmp4 not yet supported \n " ) ;
return AVERROR_PATCHWELCOME ;
}
2017-04-14 17:30:29 +02:00
if ( c - > key_info_file & & c - > encrypt ) {
av_log ( s , AV_LOG_WARNING , " Cannot use both -hls_key_info_file and -hls_enc, "
2018-04-16 08:35:14 +02:00
" ignoring -hls_enc \n " ) ;
2017-04-14 17:30:29 +02:00
}
2017-07-25 04:31:29 +02:00
2020-04-30 15:10:53 +02:00
if ( ! vs - > encrypt_started | | ( c - > flags & HLS_PERIODIC_REKEY ) ) {
2017-07-25 04:31:29 +02:00
if ( c - > key_info_file ) {
2020-04-30 15:10:53 +02:00
if ( ( err = hls_encryption_start ( s , vs ) ) < 0 )
2017-07-25 04:31:29 +02:00
goto fail ;
} else {
2020-04-30 15:10:53 +02:00
if ( ! c - > encrypt_started ) {
if ( ( err = do_encrypt ( s , vs ) ) < 0 )
goto fail ;
c - > encrypt_started = 1 ;
}
av_strlcpy ( vs - > key_uri , c - > key_uri , sizeof ( vs - > key_uri ) ) ;
av_strlcpy ( vs - > key_string , c - > key_string , sizeof ( vs - > key_string ) ) ;
av_strlcpy ( vs - > iv_string , c - > iv_string , sizeof ( vs - > iv_string ) ) ;
2017-07-25 04:31:29 +02:00
}
2020-04-30 15:10:53 +02:00
vs - > encrypt_started = 1 ;
2017-04-14 17:30:29 +02:00
}
2020-04-30 15:10:53 +02:00
err = av_strlcpy ( iv_string , vs - > iv_string , sizeof ( iv_string ) ) ;
2019-08-05 04:24:37 +02:00
if ( ! err ) {
2017-11-20 03:02:11 +01:00
snprintf ( iv_string , sizeof ( iv_string ) , " %032 " PRIx64 , vs - > sequence ) ;
2020-04-30 15:10:53 +02:00
memset ( vs - > iv_string , 0 , sizeof ( vs - > iv_string ) ) ;
memcpy ( vs - > iv_string , iv_string , sizeof ( iv_string ) ) ;
2018-12-10 07:19:23 +01:00
}
2017-12-21 04:14:32 +01:00
}
if ( c - > segment_type ! = SEGMENT_TYPE_FMP4 ) {
2017-07-03 14:20:44 +02:00
if ( oc - > oformat - > priv_class & & oc - > priv_data ) {
av_opt_set ( oc - > priv_data , " mpegts_flags " , " resend_headers " , 0 ) ;
}
2019-08-05 04:24:37 +02:00
if ( c - > flags & HLS_SINGLE_FILE ) {
2020-07-22 11:15:29 +02:00
if ( c - > key_info_file | | c - > encrypt ) {
av_dict_set ( & options , " encryption_key " , vs - > key_string , 0 ) ;
av_dict_set ( & options , " encryption_iv " , vs - > iv_string , 0 ) ;
/* Write temp file with cryption content */
av_freep ( & vs - > basename_tmp ) ;
vs - > basename_tmp = av_asprintf ( " crypto:%s.tmp " , oc - > url ) ;
/* append temp file content into single file */
av_freep ( & vs - > basename ) ;
vs - > basename = av_asprintf ( " %s " , oc - > url ) ;
} else {
vs - > basename_tmp = vs - > basename ;
}
2019-12-16 01:04:06 +01:00
set_http_options ( s , & options , c ) ;
2020-07-22 11:15:29 +02:00
if ( ! vs - > out_single_file )
if ( ( err = hlsenc_io_open ( s , & vs - > out_single_file , vs - > basename , & options ) ) < 0 ) {
if ( c - > ignore_io_errors )
err = 0 ;
goto fail ;
}
if ( ( err = hlsenc_io_open ( s , & vs - > out , vs - > basename_tmp , & options ) ) < 0 ) {
2019-08-05 04:24:37 +02:00
if ( c - > ignore_io_errors )
err = 0 ;
goto fail ;
}
2020-07-22 11:15:29 +02:00
2019-08-05 04:24:37 +02:00
}
}
if ( vs - > vtt_basename ) {
set_http_options ( s , & options , c ) ;
if ( ( err = hlsenc_io_open ( s , & vtt_oc - > pb , vtt_oc - > url , & options ) ) < 0 ) {
if ( c - > ignore_io_errors )
err = 0 ;
goto fail ;
}
2015-04-05 20:28:38 +02:00
}
2019-08-05 04:24:37 +02:00
av_dict_free ( & options ) ;
2012-10-26 16:36:56 +02:00
2017-11-20 03:02:11 +01:00
if ( vs - > vtt_basename ) {
2015-12-13 02:28:13 +01:00
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
}
2017-07-24 13:55:19 +02:00
static const char * get_default_pattern_localtime_fmt ( AVFormatContext * s )
2017-01-01 04:00:45 +01:00
{
char b [ 21 ] ;
time_t t = time ( NULL ) ;
struct tm * p , tmbuf ;
2017-07-24 13:55:19 +02:00
HLSContext * hls = s - > priv_data ;
2017-01-01 04:00:45 +01:00
p = localtime_r ( & t , & tmbuf ) ;
// no %s support when strftime returned error or left format string unchanged
2017-02-25 04:23:50 +01:00
// also no %s support on MSVC, which invokes the invalid parameter handler on unsupported format strings, instead of returning an error
2017-07-24 13:55:19 +02:00
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 ) {
return ( HAVE_LIBC_MSVCRT | | ! strftime ( b , sizeof ( b ) , " %s " , p ) | | ! strcmp ( b , " %s " ) ) ? " -%Y%m%d%H%M%S.m4s " : " -%s.m4s " ;
}
2017-02-25 04:23:50 +01:00
return ( HAVE_LIBC_MSVCRT | | ! strftime ( b , sizeof ( b ) , " %s " , p ) | | ! strcmp ( b , " %s " ) ) ? " -%Y%m%d%H%M%S.ts " : " -%s.ts " ;
2017-01-01 04:00:45 +01:00
}
2018-01-02 03:46:17 +01:00
static int append_postfix ( char * name , int name_buf_len , int i )
2017-11-20 03:02:11 +01:00
{
char * p ;
char extension [ 10 ] = { ' \0 ' } ;
p = strrchr ( name , ' . ' ) ;
if ( p ) {
av_strlcpy ( extension , p , sizeof ( extension ) ) ;
* p = ' \0 ' ;
}
snprintf ( name + strlen ( name ) , name_buf_len - strlen ( name ) , POSTFIX_PATTERN , i ) ;
if ( strlen ( extension ) )
av_strlcat ( name , extension , name_buf_len ) ;
return 0 ;
}
2018-01-02 03:46:17 +01:00
static int validate_name ( int nb_vs , const char * fn )
{
2018-01-02 03:46:48 +01:00
const char * filename , * subdir_name ;
char * fn_dup = NULL ;
2018-01-02 03:46:17 +01:00
int ret = 0 ;
2020-02-28 07:59:34 +01:00
if ( ! fn )
return AVERROR ( EINVAL ) ;
2018-01-02 03:46:17 +01:00
2018-01-02 03:46:48 +01:00
fn_dup = av_strdup ( fn ) ;
2019-12-15 11:24:32 +01:00
if ( ! fn_dup )
return AVERROR ( ENOMEM ) ;
2018-01-02 03:46:17 +01:00
filename = av_basename ( fn ) ;
2018-01-02 03:46:48 +01:00
subdir_name = av_dirname ( fn_dup ) ;
2018-01-02 03:46:17 +01:00
2018-01-02 03:46:48 +01:00
if ( nb_vs > 1 & & ! av_stristr ( filename , " %v " ) & & ! av_stristr ( subdir_name , " %v " ) ) {
2019-06-22 15:55:54 +02:00
av_log ( NULL , AV_LOG_ERROR , " More than 1 variant streams are present, %%v is expected "
" either in the filename or in the sub-directory name of file %s \n " , fn ) ;
2018-01-02 03:46:17 +01:00
ret = AVERROR ( EINVAL ) ;
goto fail ;
}
2018-01-02 03:46:48 +01:00
if ( av_stristr ( filename , " %v " ) & & av_stristr ( subdir_name , " %v " ) ) {
2019-06-22 15:55:54 +02:00
av_log ( NULL , AV_LOG_ERROR , " %%v is expected either in the filename or "
" in the sub-directory name of file %s, but only in one of them \n " , fn ) ;
2018-01-02 03:46:48 +01:00
ret = AVERROR ( EINVAL ) ;
goto fail ;
}
2018-01-02 03:46:17 +01:00
fail :
2018-01-02 03:46:48 +01:00
av_freep ( & fn_dup ) ;
2018-01-02 03:46:17 +01:00
return ret ;
}
2019-06-20 05:08:04 +02:00
static int format_name ( const char * buf , char * * s , int index , const char * varname )
2018-01-02 03:46:17 +01:00
{
2018-01-02 03:46:48 +01:00
const char * proto , * dir ;
av_format/hlsenc: fix %v handling by format_name function
Hi All,
When multiple variant streams are specified by var_stream_map option, %v
placeholder in various names ensures that each variant has its unique
names. Most of %v handlng is done in format_name function. Currently
in this function the result buffer is the same as the
input pattern buffer, so you must allocate it before calling format_name
function. It also means, that it is silently assumed that the result
string will NOT be
longer that the pattern string. It is true most of the time, because %v
may appear only once in the pattern string and number of variant streams
is less than 100 in practical cases. But theoretically it will fail if
specified number of variant streams is greater than 100 (i.e. longer
than 2 digits).
This patch fixes this behaviour by altering format_name function to
allocate the
result buffer and return it to the caller.
Please, review this patch.
best,
Bela
>From 6377ebee8a106a9684d41b270c7d6c8e57cd3e7b Mon Sep 17 00:00:00 2001
From: Bela Bodecs <bodecsb@vivanet.hu>
Date: Mon, 17 Jun 2019 14:31:36 +0200
Subject: [PATCH] av_format/hlsenc: fix %v handling by format_name function
When multiple variant streams are specified by var_stream_map option, %v
placeholder in various names ensures that each variant has its unique
names. Most of %v handlng is done in format_name function. Currently
in this function the result buffer is the same as the input pattern
buffer, so you must allocate it before calling format_name function. It
also means, that it is silently assumed that the result string will NOT
be longer that the pattern string. It is true most of the time, because
%v may appear only once in the pattern string and number of variant
streams is less than 100 in practical cases. But theoretically it will
fail if specified number of variant streams is greater than 100. This
patch fixes this behaviour by altering format_name function to allocate
the result buffer and return it to the caller.
Signed-off-by: Bela Bodecs <bodecsb@vivanet.hu>
2019-06-17 23:05:21 +02:00
char * orig_buf_dup = NULL , * mod_buf_dup = NULL ;
2018-01-02 03:46:17 +01:00
int ret = 0 ;
orig_buf_dup = av_strdup ( buf ) ;
2020-02-28 07:59:34 +01:00
if ( ! orig_buf_dup )
return AVERROR ( ENOMEM ) ;
2018-01-02 03:46:17 +01:00
av_format/hlsenc: fix %v handling by format_name function
Hi All,
When multiple variant streams are specified by var_stream_map option, %v
placeholder in various names ensures that each variant has its unique
names. Most of %v handlng is done in format_name function. Currently
in this function the result buffer is the same as the
input pattern buffer, so you must allocate it before calling format_name
function. It also means, that it is silently assumed that the result
string will NOT be
longer that the pattern string. It is true most of the time, because %v
may appear only once in the pattern string and number of variant streams
is less than 100 in practical cases. But theoretically it will fail if
specified number of variant streams is greater than 100 (i.e. longer
than 2 digits).
This patch fixes this behaviour by altering format_name function to
allocate the
result buffer and return it to the caller.
Please, review this patch.
best,
Bela
>From 6377ebee8a106a9684d41b270c7d6c8e57cd3e7b Mon Sep 17 00:00:00 2001
From: Bela Bodecs <bodecsb@vivanet.hu>
Date: Mon, 17 Jun 2019 14:31:36 +0200
Subject: [PATCH] av_format/hlsenc: fix %v handling by format_name function
When multiple variant streams are specified by var_stream_map option, %v
placeholder in various names ensures that each variant has its unique
names. Most of %v handlng is done in format_name function. Currently
in this function the result buffer is the same as the input pattern
buffer, so you must allocate it before calling format_name function. It
also means, that it is silently assumed that the result string will NOT
be longer that the pattern string. It is true most of the time, because
%v may appear only once in the pattern string and number of variant
streams is less than 100 in practical cases. But theoretically it will
fail if specified number of variant streams is greater than 100. This
patch fixes this behaviour by altering format_name function to allocate
the result buffer and return it to the caller.
Signed-off-by: Bela Bodecs <bodecsb@vivanet.hu>
2019-06-17 23:05:21 +02:00
if ( ! av_stristr ( buf , " %v " ) ) {
* s = orig_buf_dup ;
2020-02-28 07:59:34 +01:00
return 0 ;
av_format/hlsenc: fix %v handling by format_name function
Hi All,
When multiple variant streams are specified by var_stream_map option, %v
placeholder in various names ensures that each variant has its unique
names. Most of %v handlng is done in format_name function. Currently
in this function the result buffer is the same as the
input pattern buffer, so you must allocate it before calling format_name
function. It also means, that it is silently assumed that the result
string will NOT be
longer that the pattern string. It is true most of the time, because %v
may appear only once in the pattern string and number of variant streams
is less than 100 in practical cases. But theoretically it will fail if
specified number of variant streams is greater than 100 (i.e. longer
than 2 digits).
This patch fixes this behaviour by altering format_name function to
allocate the
result buffer and return it to the caller.
Please, review this patch.
best,
Bela
>From 6377ebee8a106a9684d41b270c7d6c8e57cd3e7b Mon Sep 17 00:00:00 2001
From: Bela Bodecs <bodecsb@vivanet.hu>
Date: Mon, 17 Jun 2019 14:31:36 +0200
Subject: [PATCH] av_format/hlsenc: fix %v handling by format_name function
When multiple variant streams are specified by var_stream_map option, %v
placeholder in various names ensures that each variant has its unique
names. Most of %v handlng is done in format_name function. Currently
in this function the result buffer is the same as the input pattern
buffer, so you must allocate it before calling format_name function. It
also means, that it is silently assumed that the result string will NOT
be longer that the pattern string. It is true most of the time, because
%v may appear only once in the pattern string and number of variant
streams is less than 100 in practical cases. But theoretically it will
fail if specified number of variant streams is greater than 100. This
patch fixes this behaviour by altering format_name function to allocate
the result buffer and return it to the caller.
Signed-off-by: Bela Bodecs <bodecsb@vivanet.hu>
2019-06-17 23:05:21 +02:00
}
2019-06-20 05:08:04 +02:00
if ( ! varname ) {
if ( replace_int_data_in_filename ( s , orig_buf_dup , ' v ' , index ) < 1 ) {
ret = AVERROR ( EINVAL ) ;
goto fail ;
}
} else {
if ( replace_str_data_in_filename ( s , orig_buf_dup , ' v ' , varname ) < 1 ) {
ret = AVERROR ( EINVAL ) ;
goto fail ;
}
2018-01-02 03:46:17 +01:00
}
2018-01-02 03:46:48 +01:00
proto = avio_find_protocol_name ( orig_buf_dup ) ;
dir = av_dirname ( orig_buf_dup ) ;
/* if %v is present in the file's directory, create sub-directory */
if ( av_stristr ( dir , " %v " ) & & proto & & ! strcmp ( proto , " file " ) ) {
av_format/hlsenc: fix %v handling by format_name function
Hi All,
When multiple variant streams are specified by var_stream_map option, %v
placeholder in various names ensures that each variant has its unique
names. Most of %v handlng is done in format_name function. Currently
in this function the result buffer is the same as the
input pattern buffer, so you must allocate it before calling format_name
function. It also means, that it is silently assumed that the result
string will NOT be
longer that the pattern string. It is true most of the time, because %v
may appear only once in the pattern string and number of variant streams
is less than 100 in practical cases. But theoretically it will fail if
specified number of variant streams is greater than 100 (i.e. longer
than 2 digits).
This patch fixes this behaviour by altering format_name function to
allocate the
result buffer and return it to the caller.
Please, review this patch.
best,
Bela
>From 6377ebee8a106a9684d41b270c7d6c8e57cd3e7b Mon Sep 17 00:00:00 2001
From: Bela Bodecs <bodecsb@vivanet.hu>
Date: Mon, 17 Jun 2019 14:31:36 +0200
Subject: [PATCH] av_format/hlsenc: fix %v handling by format_name function
When multiple variant streams are specified by var_stream_map option, %v
placeholder in various names ensures that each variant has its unique
names. Most of %v handlng is done in format_name function. Currently
in this function the result buffer is the same as the input pattern
buffer, so you must allocate it before calling format_name function. It
also means, that it is silently assumed that the result string will NOT
be longer that the pattern string. It is true most of the time, because
%v may appear only once in the pattern string and number of variant
streams is less than 100 in practical cases. But theoretically it will
fail if specified number of variant streams is greater than 100. This
patch fixes this behaviour by altering format_name function to allocate
the result buffer and return it to the caller.
Signed-off-by: Bela Bodecs <bodecsb@vivanet.hu>
2019-06-17 23:05:21 +02:00
mod_buf_dup = av_strdup ( * s ) ;
2018-01-02 03:46:48 +01:00
dir = av_dirname ( mod_buf_dup ) ;
2018-09-22 16:10:09 +02:00
if ( ff_mkdir_p ( dir ) = = - 1 & & errno ! = EEXIST ) {
2018-01-02 03:46:48 +01:00
ret = AVERROR ( errno ) ;
goto fail ;
}
}
2018-01-02 03:46:17 +01:00
fail :
av_freep ( & orig_buf_dup ) ;
2018-01-02 03:46:48 +01:00
av_freep ( & mod_buf_dup ) ;
2018-01-02 03:46:17 +01:00
return ret ;
}
2017-11-20 03:02:11 +01:00
static int get_nth_codec_stream_index ( AVFormatContext * s ,
enum AVMediaType codec_type ,
2020-05-05 00:40:44 +02:00
int64_t stream_id )
2017-11-20 03:02:11 +01:00
{
unsigned int stream_index , cnt ;
if ( stream_id < 0 | | stream_id > s - > nb_streams - 1 )
return - 1 ;
cnt = 0 ;
for ( stream_index = 0 ; stream_index < s - > nb_streams ; stream_index + + ) {
if ( s - > streams [ stream_index ] - > codecpar - > codec_type ! = codec_type )
continue ;
if ( cnt = = stream_id )
return stream_index ;
cnt + + ;
}
return - 1 ;
}
static int parse_variant_stream_mapstring ( AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
VariantStream * vs ;
2019-06-19 10:25:36 +02:00
int stream_index , i , j ;
2017-11-20 03:02:11 +01:00
enum AVMediaType codec_type ;
2019-12-16 01:04:09 +01:00
int nb_varstreams = 0 , nb_streams ;
2017-11-20 03:02:11 +01:00
char * p , * q , * saveptr1 , * saveptr2 , * varstr , * keyval ;
const char * val ;
/**
* Expected format for var_stream_map string is as below :
* " a:0,v:0 a:1,v:1 "
2019-06-02 15:53:11 +02:00
* " a:0,agroup:a0,default:1,language:ENG a:1,agroup:a1,default:0 v:0,agroup:a0 v:1,agroup:a1 "
2017-11-20 03:02:11 +01:00
* This string specifies how to group the audio , video and subtitle streams
* into different variant streams . The variant stream groups are separated
* by space .
*
* a : , v : , s : are keys to specify audio , video and subtitle streams
* respectively . Allowed values are 0 to 9 digits ( limited just based on
* practical usage )
*
2017-12-23 06:42:00 +01:00
* agroup : is key to specify audio group . A string can be given as value .
avformat: add subtitle support in master playlist m3u8
Test with the following command for the webvtt subtitle:
$ ./ffmpeg -y -i input_with_subtitle.mkv \
-b:v:0 5250k -c:v h264 -pix_fmt yuv420p -profile:v main -level 4.1 \
-b:a:0 256k \
-c:s webvtt -c:a mp2 -ar 48000 -ac 2 -map 0:v -map 0:a:0 -map 0:s:0 \
-f hls -var_stream_map "v:0,a:0,s:0,sgroup:subtitle" \
-master_pl_name master.m3u8 -t 300 -hls_time 10 -hls_init_time 4 -hls_list_size \
10 -master_pl_publish_rate 10 -hls_flags \
delete_segments+discont_start+split_by_time ./tmp/video.m3u8
Check the master m3u8:
$ cat tmp/master.m3u8
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="subtitle",NAME="subtitle_0",DEFAULT=YES,URI="video_vtt.m3u8"
#EXT-X-STREAM-INF:BANDWIDTH=6056600,RESOLUTION=1280x720,CODECS="avc1.4d4829,mp4a.40.33",SUBTITLES="subtitle"
video.m3u8
Check the result by convert to mkv:
$ ./ffmpeg -strict experimental -i ./tmp/master.m3u8 -c:v copy -c:a mp2 -c:s srt ./test.mkv
Signed-off-by: Limin Wang <lance.lmwang@gmail.com>
2020-03-29 13:13:44 +02:00
* sgroup : is key to specify subtitle group . A string can be given as value .
2017-11-20 03:02:11 +01:00
*/
p = av_strdup ( hls - > var_stream_map ) ;
2019-10-19 06:48:49 +02:00
if ( ! p )
return AVERROR ( ENOMEM ) ;
2017-11-20 03:02:11 +01:00
q = p ;
2019-09-06 06:15:45 +02:00
while ( av_strtok ( q , " \t " , & saveptr1 ) ) {
2017-11-20 03:02:11 +01:00
q = NULL ;
2019-12-16 01:04:09 +01:00
nb_varstreams + + ;
2017-11-20 03:02:11 +01:00
}
av_freep ( & p ) ;
2019-12-16 01:04:09 +01:00
hls - > var_streams = av_mallocz ( sizeof ( * hls - > var_streams ) * nb_varstreams ) ;
2017-11-20 03:02:11 +01:00
if ( ! hls - > var_streams )
return AVERROR ( ENOMEM ) ;
2019-12-16 01:04:09 +01:00
hls - > nb_varstreams = nb_varstreams ;
2017-11-20 03:02:11 +01:00
p = hls - > var_stream_map ;
nb_varstreams = 0 ;
while ( varstr = av_strtok ( p , " \t " , & saveptr1 ) ) {
p = NULL ;
2018-04-11 05:15:54 +02:00
if ( nb_varstreams < hls - > nb_varstreams ) {
vs = & ( hls - > var_streams [ nb_varstreams ] ) ;
vs - > var_stream_idx = nb_varstreams ;
avformat/hlsenc: add var_stream_map DEFAULT field status parameter
use a:0,agroup:aud_low,default:Yes a:1,agroup:aud_low,
a:2,agroup:aud_high,default:Yes a:3, agroup:aud_high,
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 11:52:02 +01:00
vs - > is_default = 0 ;
2018-04-11 05:15:54 +02:00
nb_varstreams + + ;
} else
2017-11-20 03:02:11 +01:00
return AVERROR ( EINVAL ) ;
q = varstr ;
2020-05-06 08:16:06 +02:00
while ( 1 ) {
2017-11-20 03:02:11 +01:00
if ( ! av_strncasecmp ( q , " a: " , 2 ) | | ! av_strncasecmp ( q , " v: " , 2 ) | |
! av_strncasecmp ( q , " s: " , 2 ) )
vs - > nb_streams + + ;
2020-05-06 08:16:06 +02:00
q = strchr ( q , ' , ' ) ;
if ( ! q )
break ;
2017-11-20 03:02:11 +01:00
q + + ;
}
vs - > streams = av_mallocz ( sizeof ( AVStream * ) * vs - > nb_streams ) ;
if ( ! vs - > streams )
return AVERROR ( ENOMEM ) ;
nb_streams = 0 ;
while ( keyval = av_strtok ( varstr , " , " , & saveptr2 ) ) {
2020-05-05 00:40:44 +02:00
int64_t num ;
char * end ;
2017-11-20 03:02:11 +01:00
varstr = NULL ;
avformat/hlsenc: add var_stream_map LANGUAGE field string parameter
use a:0,agroup:aud_low,default:Yes,language:CHN a:1,agroup:aud_low,language:ENG
a:2,agroup:aud_high,default:YesYes,language:CHN a:3,agroup:aud_high,language:ENG
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,LANGUAGE="CHN",URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,LANGUAGE="ENG",URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,LANGUAGE="CHN",URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,LANGUAGE="ENG",URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 12:19:49 +01:00
if ( av_strstart ( keyval , " language: " , & val ) ) {
2020-05-25 19:22:19 +02:00
vs - > language = val ;
avformat/hlsenc: add var_stream_map LANGUAGE field string parameter
use a:0,agroup:aud_low,default:Yes,language:CHN a:1,agroup:aud_low,language:ENG
a:2,agroup:aud_high,default:YesYes,language:CHN a:3,agroup:aud_high,language:ENG
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,LANGUAGE="CHN",URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,LANGUAGE="ENG",URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,LANGUAGE="CHN",URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,LANGUAGE="ENG",URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 12:19:49 +01:00
continue ;
} else if ( av_strstart ( keyval , " default: " , & val ) ) {
avformat/hlsenc: add var_stream_map DEFAULT field status parameter
use a:0,agroup:aud_low,default:Yes a:1,agroup:aud_low,
a:2,agroup:aud_high,default:Yes a:3, agroup:aud_high,
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 11:52:02 +01:00
vs - > is_default = ( ! av_strncasecmp ( val , " YES " , strlen ( " YES " ) ) | |
( ! av_strncasecmp ( val , " 1 " , strlen ( " 1 " ) ) ) ) ;
hls - > has_default_key = 1 ;
continue ;
2019-06-20 05:08:04 +02:00
} else if ( av_strstart ( keyval , " name: " , & val ) ) {
2020-05-25 19:22:19 +02:00
vs - > varname = val ;
2019-06-20 05:08:04 +02:00
continue ;
avformat/hlsenc: add var_stream_map DEFAULT field status parameter
use a:0,agroup:aud_low,default:Yes a:1,agroup:aud_low,
a:2,agroup:aud_high,default:Yes a:3, agroup:aud_high,
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 11:52:02 +01:00
} else if ( av_strstart ( keyval , " agroup: " , & val ) ) {
2020-05-25 19:22:19 +02:00
vs - > agroup = val ;
2017-12-23 06:42:00 +01:00
continue ;
avformat: add subtitle support in master playlist m3u8
Test with the following command for the webvtt subtitle:
$ ./ffmpeg -y -i input_with_subtitle.mkv \
-b:v:0 5250k -c:v h264 -pix_fmt yuv420p -profile:v main -level 4.1 \
-b:a:0 256k \
-c:s webvtt -c:a mp2 -ar 48000 -ac 2 -map 0:v -map 0:a:0 -map 0:s:0 \
-f hls -var_stream_map "v:0,a:0,s:0,sgroup:subtitle" \
-master_pl_name master.m3u8 -t 300 -hls_time 10 -hls_init_time 4 -hls_list_size \
10 -master_pl_publish_rate 10 -hls_flags \
delete_segments+discont_start+split_by_time ./tmp/video.m3u8
Check the master m3u8:
$ cat tmp/master.m3u8
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="subtitle",NAME="subtitle_0",DEFAULT=YES,URI="video_vtt.m3u8"
#EXT-X-STREAM-INF:BANDWIDTH=6056600,RESOLUTION=1280x720,CODECS="avc1.4d4829,mp4a.40.33",SUBTITLES="subtitle"
video.m3u8
Check the result by convert to mkv:
$ ./ffmpeg -strict experimental -i ./tmp/master.m3u8 -c:v copy -c:a mp2 -c:s srt ./test.mkv
Signed-off-by: Limin Wang <lance.lmwang@gmail.com>
2020-03-29 13:13:44 +02:00
} else if ( av_strstart ( keyval , " sgroup: " , & val ) ) {
2020-05-25 19:22:19 +02:00
vs - > sgroup = val ;
avformat: add subtitle support in master playlist m3u8
Test with the following command for the webvtt subtitle:
$ ./ffmpeg -y -i input_with_subtitle.mkv \
-b:v:0 5250k -c:v h264 -pix_fmt yuv420p -profile:v main -level 4.1 \
-b:a:0 256k \
-c:s webvtt -c:a mp2 -ar 48000 -ac 2 -map 0:v -map 0:a:0 -map 0:s:0 \
-f hls -var_stream_map "v:0,a:0,s:0,sgroup:subtitle" \
-master_pl_name master.m3u8 -t 300 -hls_time 10 -hls_init_time 4 -hls_list_size \
10 -master_pl_publish_rate 10 -hls_flags \
delete_segments+discont_start+split_by_time ./tmp/video.m3u8
Check the master m3u8:
$ cat tmp/master.m3u8
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="subtitle",NAME="subtitle_0",DEFAULT=YES,URI="video_vtt.m3u8"
#EXT-X-STREAM-INF:BANDWIDTH=6056600,RESOLUTION=1280x720,CODECS="avc1.4d4829,mp4a.40.33",SUBTITLES="subtitle"
video.m3u8
Check the result by convert to mkv:
$ ./ffmpeg -strict experimental -i ./tmp/master.m3u8 -c:v copy -c:a mp2 -c:s srt ./test.mkv
Signed-off-by: Limin Wang <lance.lmwang@gmail.com>
2020-03-29 13:13:44 +02:00
continue ;
2018-01-24 04:42:57 +01:00
} else if ( av_strstart ( keyval , " ccgroup: " , & val ) ) {
2020-05-25 19:22:19 +02:00
vs - > ccgroup = val ;
2018-01-24 04:42:57 +01:00
continue ;
2017-12-23 06:42:00 +01:00
} else if ( av_strstart ( keyval , " v: " , & val ) ) {
2017-11-20 03:02:11 +01:00
codec_type = AVMEDIA_TYPE_VIDEO ;
avformat/hlsenc: add var_stream_map DEFAULT field status parameter
use a:0,agroup:aud_low,default:Yes a:1,agroup:aud_low,
a:2,agroup:aud_high,default:Yes a:3, agroup:aud_high,
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 11:52:02 +01:00
hls - > has_video_m3u8 = 1 ;
2017-11-20 03:02:11 +01:00
} else if ( av_strstart ( keyval , " a: " , & val ) ) {
codec_type = AVMEDIA_TYPE_AUDIO ;
} else if ( av_strstart ( keyval , " s: " , & val ) ) {
codec_type = AVMEDIA_TYPE_SUBTITLE ;
} else {
av_log ( s , AV_LOG_ERROR , " Invalid keyval %s \n " , keyval ) ;
return AVERROR ( EINVAL ) ;
}
2020-06-15 05:09:07 +02:00
num = strtoll ( val , & end , 10 ) ;
2020-05-05 00:40:44 +02:00
if ( ! av_isdigit ( * val ) | | * end ! = ' \0 ' ) {
av_log ( s , AV_LOG_ERROR , " Invalid stream number: '%s' \n " , val ) ;
return AVERROR ( EINVAL ) ;
}
stream_index = get_nth_codec_stream_index ( s , codec_type , num ) ;
2017-11-20 03:02:11 +01:00
if ( stream_index > = 0 & & nb_streams < vs - > nb_streams ) {
2019-09-06 06:15:45 +02:00
for ( i = 0 ; nb_streams > 0 & & i < nb_streams ; i + + ) {
2019-06-19 10:25:36 +02:00
if ( vs - > streams [ i ] = = s - > streams [ stream_index ] ) {
av_log ( s , AV_LOG_ERROR , " Same elementary stream found more than once inside "
" variant definition #%d \n " , nb_varstreams - 1 ) ;
return AVERROR ( EINVAL ) ;
}
}
2019-09-06 06:15:45 +02:00
for ( j = 0 ; nb_varstreams > 1 & & j < nb_varstreams - 1 ; j + + ) {
for ( i = 0 ; i < hls - > var_streams [ j ] . nb_streams ; i + + ) {
2019-06-19 10:25:36 +02:00
if ( hls - > var_streams [ j ] . streams [ i ] = = s - > streams [ stream_index ] ) {
av_log ( s , AV_LOG_ERROR , " Same elementary stream found more than once "
" in two different variant definitions #%d and #%d \n " ,
j , nb_varstreams - 1 ) ;
return AVERROR ( EINVAL ) ;
}
}
}
2017-11-20 03:02:11 +01:00
vs - > streams [ nb_streams + + ] = s - > streams [ stream_index ] ;
} else {
av_log ( s , AV_LOG_ERROR , " Unable to map stream at %s \n " , keyval ) ;
return AVERROR ( EINVAL ) ;
}
}
}
av_log ( s , AV_LOG_DEBUG , " Number of variant streams %d \n " ,
hls - > nb_varstreams ) ;
return 0 ;
}
2018-01-24 04:42:57 +01:00
static int parse_cc_stream_mapstring ( AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
2019-12-16 01:04:09 +01:00
int nb_ccstreams = 0 ;
2018-03-26 14:32:00 +02:00
char * p , * q , * ccstr , * keyval ;
char * saveptr1 = NULL , * saveptr2 = NULL ;
2018-01-24 04:42:57 +01:00
const char * val ;
ClosedCaptionsStream * ccs ;
p = av_strdup ( hls - > cc_stream_map ) ;
2019-10-19 06:48:49 +02:00
if ( ! p )
return AVERROR ( ENOMEM ) ;
2018-01-24 04:42:57 +01:00
q = p ;
2019-09-06 06:15:45 +02:00
while ( av_strtok ( q , " \t " , & saveptr1 ) ) {
2018-01-24 04:42:57 +01:00
q = NULL ;
2019-12-16 01:04:09 +01:00
nb_ccstreams + + ;
2018-01-24 04:42:57 +01:00
}
av_freep ( & p ) ;
2019-12-16 01:04:09 +01:00
hls - > cc_streams = av_mallocz ( sizeof ( * hls - > cc_streams ) * nb_ccstreams ) ;
2018-01-24 04:42:57 +01:00
if ( ! hls - > cc_streams )
return AVERROR ( ENOMEM ) ;
2019-12-16 01:04:09 +01:00
hls - > nb_ccstreams = nb_ccstreams ;
2018-01-24 04:42:57 +01:00
p = hls - > cc_stream_map ;
nb_ccstreams = 0 ;
while ( ccstr = av_strtok ( p , " \t " , & saveptr1 ) ) {
p = NULL ;
if ( nb_ccstreams < hls - > nb_ccstreams )
ccs = & ( hls - > cc_streams [ nb_ccstreams + + ] ) ;
else
return AVERROR ( EINVAL ) ;
while ( keyval = av_strtok ( ccstr , " , " , & saveptr2 ) ) {
ccstr = NULL ;
if ( av_strstart ( keyval , " ccgroup: " , & val ) ) {
2020-05-25 19:22:19 +02:00
ccs - > ccgroup = val ;
2018-01-24 04:42:57 +01:00
} else if ( av_strstart ( keyval , " instreamid: " , & val ) ) {
2020-05-25 19:22:19 +02:00
ccs - > instreamid = val ;
2018-01-24 04:42:57 +01:00
} else if ( av_strstart ( keyval , " language: " , & val ) ) {
2020-05-25 19:22:19 +02:00
ccs - > language = val ;
2018-01-24 04:42:57 +01:00
} else {
av_log ( s , AV_LOG_ERROR , " Invalid keyval %s \n " , keyval ) ;
return AVERROR ( EINVAL ) ;
}
}
if ( ! ccs - > ccgroup | | ! ccs - > instreamid ) {
av_log ( s , AV_LOG_ERROR , " Insufficient parameters in cc stream map string \n " ) ;
return AVERROR ( EINVAL ) ;
}
if ( av_strstart ( ccs - > instreamid , " CC " , & val ) ) {
2019-09-06 06:15:45 +02:00
if ( atoi ( val ) < 1 | | atoi ( val ) > 4 ) {
2018-01-24 04:42:57 +01:00
av_log ( s , AV_LOG_ERROR , " Invalid instream ID CC index %d in %s, range 1-4 \n " ,
atoi ( val ) , ccs - > instreamid ) ;
return AVERROR ( EINVAL ) ;
}
} else if ( av_strstart ( ccs - > instreamid , " SERVICE " , & val ) ) {
2019-09-06 06:15:45 +02:00
if ( atoi ( val ) < 1 | | atoi ( val ) > 63 ) {
2018-01-24 04:42:57 +01:00
av_log ( s , AV_LOG_ERROR , " Invalid instream ID SERVICE index %d in %s, range 1-63 \n " ,
atoi ( val ) , ccs - > instreamid ) ;
return AVERROR ( EINVAL ) ;
}
} else {
2019-12-16 01:04:04 +01:00
av_log ( s , AV_LOG_ERROR , " Invalid instream ID %s, supported are CCn or SERVICEn \n " ,
2018-01-24 04:42:57 +01:00
ccs - > instreamid ) ;
return AVERROR ( EINVAL ) ;
}
}
return 0 ;
}
2019-09-06 06:15:45 +02:00
static int update_variant_stream_info ( AVFormatContext * s )
{
2017-11-20 03:02:11 +01:00
HLSContext * hls = s - > priv_data ;
unsigned int i ;
2018-01-24 04:42:57 +01:00
int ret = 0 ;
if ( hls - > cc_stream_map ) {
ret = parse_cc_stream_mapstring ( s ) ;
if ( ret < 0 )
return ret ;
}
2017-11-20 03:02:11 +01:00
if ( hls - > var_stream_map ) {
return parse_variant_stream_mapstring ( s ) ;
} else {
//By default, a single variant stream with all the codec streams is created
2019-12-16 01:04:09 +01:00
hls - > var_streams = av_mallocz ( sizeof ( * hls - > var_streams ) ) ;
2017-11-20 03:02:11 +01:00
if ( ! hls - > var_streams )
return AVERROR ( ENOMEM ) ;
2019-12-16 01:04:09 +01:00
hls - > nb_varstreams = 1 ;
2017-11-20 03:02:11 +01:00
2018-04-11 05:15:54 +02:00
hls - > var_streams [ 0 ] . var_stream_idx = 0 ;
2017-11-20 03:02:11 +01:00
hls - > var_streams [ 0 ] . nb_streams = s - > nb_streams ;
hls - > var_streams [ 0 ] . streams = av_mallocz ( sizeof ( AVStream * ) *
hls - > var_streams [ 0 ] . nb_streams ) ;
2020-02-28 07:59:34 +01:00
if ( ! hls - > var_streams [ 0 ] . streams )
2017-11-20 03:02:11 +01:00
return AVERROR ( ENOMEM ) ;
2018-01-24 04:42:57 +01:00
//by default, the first available ccgroup is mapped to the variant stream
2020-05-25 20:33:40 +02:00
if ( hls - > nb_ccstreams )
2020-05-25 19:22:19 +02:00
hls - > var_streams [ 0 ] . ccgroup = hls - > cc_streams [ 0 ] . ccgroup ;
2018-01-24 04:42:57 +01:00
2017-11-20 03:02:11 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + )
hls - > var_streams [ 0 ] . streams [ i ] = s - > streams [ i ] ;
}
return 0 ;
}
2019-09-06 06:15:45 +02:00
static int update_master_pl_info ( AVFormatContext * s )
{
2017-11-20 03:04:34 +01:00
HLSContext * hls = s - > priv_data ;
2018-01-02 03:45:28 +01:00
const char * dir ;
2018-01-02 03:46:48 +01:00
char * fn1 = NULL , * fn2 = NULL ;
2018-01-02 03:45:28 +01:00
int ret = 0 ;
2017-11-20 03:04:34 +01:00
2017-12-29 22:00:04 +01:00
fn1 = av_strdup ( s - > url ) ;
2019-12-15 11:24:32 +01:00
if ( ! fn1 )
return AVERROR ( ENOMEM ) ;
2018-01-02 03:46:48 +01:00
dir = av_dirname ( fn1 ) ;
/**
* if output file ' s directory has % v , variants are created in sub - directories
* then master is created at the sub - directories level
*/
if ( dir & & av_stristr ( av_basename ( dir ) , " %v " ) ) {
fn2 = av_strdup ( dir ) ;
2019-12-15 11:24:32 +01:00
if ( ! fn2 ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
2018-01-02 03:46:48 +01:00
dir = av_dirname ( fn2 ) ;
}
2018-01-02 03:45:28 +01:00
if ( dir & & strcmp ( dir , " . " ) )
hls - > master_m3u8_url = av_append_path_component ( dir , hls - > master_pl_name ) ;
else
hls - > master_m3u8_url = av_strdup ( hls - > master_pl_name ) ;
if ( ! hls - > master_m3u8_url ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
2017-11-20 03:04:34 +01:00
}
2018-01-02 03:45:28 +01:00
fail :
2018-01-02 03:46:48 +01:00
av_freep ( & fn1 ) ;
av_freep ( & fn2 ) ;
2018-01-02 03:45:28 +01:00
return ret ;
2017-11-20 03:04:34 +01:00
}
2012-10-26 16:36:56 +02:00
static int hls_write_header ( AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
2017-11-20 03:02:11 +01:00
int ret , i , j ;
VariantStream * vs = NULL ;
2017-01-12 13:43:10 +01:00
2017-11-20 03:02:11 +01:00
for ( i = 0 ; i < hls - > nb_varstreams ; i + + ) {
2021-07-20 14:07:36 +02:00
int subtitle_streams = 0 ;
2017-11-20 03:02:11 +01:00
vs = & hls - > var_streams [ i ] ;
2018-12-12 08:37:01 +01:00
ret = avformat_write_header ( vs - > avf , NULL ) ;
if ( ret < 0 )
return ret ;
2017-12-12 04:50:23 +01:00
//av_assert0(s->nb_streams == hls->avf->nb_streams);
for ( j = 0 ; j < vs - > nb_streams ; j + + ) {
AVStream * inner_st ;
AVStream * outer_st = vs - > streams [ j ] ;
if ( hls - > max_seg_size > 0 ) {
if ( ( outer_st - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO ) & &
( outer_st - > codecpar - > bit_rate > hls - > max_seg_size ) ) {
av_log ( s , AV_LOG_WARNING , " Your video bitrate is bigger than hls_segment_size, "
" (% " PRId64 " > % " PRId64 " ), the result maybe not be what you want. " ,
outer_st - > codecpar - > bit_rate , hls - > max_seg_size ) ;
}
2016-09-19 01:00:42 +02:00
}
2017-12-12 04:50:23 +01:00
if ( outer_st - > codecpar - > codec_type ! = AVMEDIA_TYPE_SUBTITLE )
2021-07-20 14:07:36 +02:00
inner_st = vs - > avf - > streams [ j - subtitle_streams ] ;
else if ( vs - > vtt_avf ) {
2017-12-12 04:50:23 +01:00
inner_st = vs - > vtt_avf - > streams [ 0 ] ;
2021-07-20 14:07:36 +02:00
subtitle_streams + + ;
} else {
2017-12-12 04:50:23 +01:00
/* We have a subtitle stream, when the user does not want one */
inner_st = NULL ;
continue ;
}
avpriv_set_pts_info ( outer_st , inner_st - > pts_wrap_bits , inner_st - > time_base . num , inner_st - > time_base . den ) ;
2020-10-13 09:05:59 +02:00
if ( outer_st - > codecpar - > codec_id = = AV_CODEC_ID_HEVC & &
outer_st - > codecpar - > codec_tag ! = MKTAG ( ' h ' , ' v ' , ' c ' , ' 1 ' ) ) {
av_log ( s , AV_LOG_WARNING , " Stream HEVC is not hvc1, you should use tag:v hvc1 to set it. \n " ) ;
}
2018-01-19 10:03:09 +01:00
write_codec_attr ( outer_st , vs ) ;
}
/* Update the Codec Attr string for the mapped audio groups */
if ( vs - > has_video & & vs - > agroup ) {
for ( j = 0 ; j < hls - > nb_varstreams ; j + + ) {
VariantStream * vs_agroup = & ( hls - > var_streams [ j ] ) ;
if ( ! vs_agroup - > has_video & & ! vs_agroup - > has_subtitle & &
vs_agroup - > agroup & &
! av_strcasecmp ( vs_agroup - > agroup , vs - > agroup ) ) {
write_codec_attr ( vs_agroup - > streams [ 0 ] , vs ) ;
}
}
2015-06-04 09:55:52 +02:00
}
2017-11-20 03:02:11 +01:00
}
2014-09-12 12:04:52 +02:00
2012-10-26 16:36:56 +02:00
return ret ;
}
2020-04-07 11:30:18 +02:00
static int hls_init_file_resend ( AVFormatContext * s , VariantStream * vs )
{
HLSContext * hls = s - > priv_data ;
AVDictionary * options = NULL ;
int ret = 0 ;
set_http_options ( s , & options , hls ) ;
2020-05-04 06:00:41 +02:00
ret = hlsenc_io_open ( s , & vs - > out , vs - > base_output_dirname , & options ) ;
2020-04-07 11:30:18 +02:00
av_dict_free ( & options ) ;
if ( ret < 0 )
return ret ;
avio_write ( vs - > out , vs - > init_buffer , vs - > init_range_length ) ;
hlsenc_io_close ( s , & vs - > out , hls - > fmp4_init_filename ) ;
return ret ;
}
2020-07-22 11:15:29 +02:00
static int64_t append_single_file ( AVFormatContext * s , VariantStream * vs )
{
int ret = 0 ;
int64_t read_byte = 0 ;
int64_t total_size = 0 ;
char * filename = NULL ;
char buf [ BUFSIZE ] ;
AVFormatContext * oc = vs - > avf ;
hlsenc_io_close ( s , & vs - > out , vs - > basename_tmp ) ;
filename = av_asprintf ( " %s.tmp " , oc - > url ) ;
ret = s - > io_open ( s , & vs - > out , filename , AVIO_FLAG_READ , NULL ) ;
if ( ret < 0 ) {
av_free ( filename ) ;
return ret ;
}
do {
read_byte = avio_read ( vs - > out , buf , BUFSIZE ) ;
if ( read_byte > 0 ) {
2021-11-09 22:21:37 +01:00
avio_write ( vs - > out_single_file , buf , read_byte ) ;
2020-07-22 11:15:29 +02:00
total_size + = read_byte ;
ret = total_size ;
}
} while ( read_byte > 0 ) ;
hlsenc_io_close ( s , & vs - > out , filename ) ;
av_free ( filename ) ;
return ret ;
}
2012-10-26 16:36:56 +02:00
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 ] ;
2017-11-20 03:02:11 +01:00
int64_t end_pts = 0 ;
2013-04-28 11:48:40 +02:00
int is_ref_pkt = 1 ;
2017-11-20 03:02:11 +01:00
int ret = 0 , can_split = 1 , i , j ;
2015-06-04 09:55:52 +02:00
int stream_index = 0 ;
2021-07-20 14:07:36 +02:00
int subtitle_streams = 0 ;
2017-11-14 03:31:26 +01:00
int range_length = 0 ;
2018-12-17 23:14:53 +01:00
const char * proto = NULL ;
int use_temp_file = 0 ;
2017-11-20 03:02:11 +01:00
VariantStream * vs = NULL ;
2018-08-20 08:36:20 +02:00
char * old_filename = NULL ;
2017-11-20 03:02:11 +01:00
for ( i = 0 ; i < hls - > nb_varstreams ; i + + ) {
vs = & hls - > var_streams [ i ] ;
for ( j = 0 ; j < vs - > nb_streams ; j + + ) {
2021-07-20 14:07:36 +02:00
if ( vs - > streams [ j ] - > codecpar - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
subtitle_streams + + ;
}
2017-11-20 03:02:11 +01:00
if ( vs - > streams [ j ] = = st ) {
2020-02-28 07:59:34 +01:00
if ( st - > codecpar - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
2017-11-20 03:02:11 +01:00
oc = vs - > vtt_avf ;
stream_index = 0 ;
} else {
oc = vs - > avf ;
2021-07-20 14:07:36 +02:00
stream_index = j - subtitle_streams ;
2017-11-20 03:02:11 +01:00
}
break ;
}
}
if ( oc )
break ;
}
if ( ! oc ) {
av_log ( s , AV_LOG_ERROR , " Unable to find mapping variant stream \n " ) ;
return AVERROR ( ENOMEM ) ;
}
end_pts = hls - > recording_time * vs - > number ;
2012-10-26 16:36:56 +02:00
2017-11-20 03:02:11 +01:00
if ( vs - > sequence - vs - > nb_entries > hls - > start_sequence & & hls - > init_time > 0 ) {
2016-08-27 13:11:14 +02:00
/* reset end_pts, hls->recording_time at end of the init hls list */
2021-01-17 02:07:28 +01:00
int64_t init_list_dur = hls - > init_time * vs - > nb_entries ;
int64_t after_init_list_dur = ( vs - > sequence - hls - > start_sequence - vs - > nb_entries ) * hls - > time ;
hls - > recording_time = hls - > time ;
2016-08-27 13:11:14 +02:00
end_pts = init_list_dur + after_init_list_dur ;
}
2017-11-20 03:02:11 +01:00
if ( vs - > start_pts = = AV_NOPTS_VALUE ) {
vs - > start_pts = pkt - > pts ;
2020-03-06 04:58:22 +01:00
if ( st - > codecpar - > codec_type = = AVMEDIA_TYPE_AUDIO )
vs - > start_pts_from_audio = 1 ;
}
if ( vs - > start_pts_from_audio & & st - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO & & vs - > start_pts > pkt - > pts ) {
vs - > start_pts = pkt - > pts ;
vs - > start_pts_from_audio = 0 ;
2012-10-26 16:36:56 +02:00
}
2020-05-25 20:33:40 +02:00
if ( vs - > 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 & &
2016-07-07 00:51:20 +02:00
( ( pkt - > flags & AV_PKT_FLAG_KEY ) | | ( hls - > flags & HLS_SPLIT_BY_TIME ) ) ;
2018-03-02 03:56:36 +01:00
is_ref_pkt = ( st - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO ) & & ( pkt - > stream_index = = vs - > reference_stream_index ) ;
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
2017-01-10 21:33:13 +01:00
if ( is_ref_pkt ) {
2017-11-28 13:03:15 +01:00
if ( vs - > end_pts = = AV_NOPTS_VALUE )
vs - > end_pts = pkt - > pts ;
2017-11-20 03:02:11 +01:00
if ( vs - > new_start ) {
vs - > new_start = 0 ;
vs - > duration = ( double ) ( pkt - > pts - vs - > end_pts )
2017-01-10 21:33:13 +01:00
* st - > time_base . num / st - > time_base . den ;
2017-11-20 03:02:11 +01:00
vs - > dpp = ( double ) ( pkt - > duration ) * st - > time_base . num / st - > time_base . den ;
2017-01-10 21:33:13 +01:00
} else {
2017-03-15 00:37:11 +01:00
if ( pkt - > duration ) {
2017-11-20 03:02:11 +01:00
vs - > duration + = ( double ) ( pkt - > duration ) * st - > time_base . num / st - > time_base . den ;
2017-03-15 00:37:11 +01:00
} else {
2021-05-05 16:55:13 +02:00
av_log ( s , AV_LOG_WARNING , " Stream %d packet with pts % " PRId64 " has duration 0. The segment duration may not be precise. \n " ,
pkt - > stream_index , pkt - > pts ) ;
2017-11-20 03:02:11 +01:00
vs - > duration = ( double ) ( pkt - > pts - vs - > end_pts ) * st - > time_base . num / st - > time_base . den ;
2017-03-15 00:37:11 +01:00
}
2017-01-10 21:33:13 +01:00
}
}
2017-11-20 03:02:11 +01:00
2020-08-18 04:44:11 +02:00
can_split = can_split & & ( pkt - > pts - vs - > end_pts > 0 ) ;
2017-11-20 03:02:11 +01:00
if ( vs - > packets_written & & can_split & & av_compare_ts ( pkt - > pts - vs - > start_pts , st - > time_base ,
2018-03-18 07:09:44 +01:00
end_pts , AV_TIME_BASE_Q ) > = 0 ) {
2014-09-15 15:26:57 +02:00
int64_t new_start_pos ;
2017-03-14 03:16:00 +01:00
int byterange_mode = ( hls - > flags & HLS_SINGLE_FILE ) | | ( hls - > max_seg_size > 0 ) ;
2017-01-13 00:57:22 +01:00
2019-08-05 04:24:37 +02:00
av_write_frame ( oc , NULL ) ; /* Flush any buffered data */
new_start_pos = avio_tell ( oc - > pb ) ;
vs - > size = new_start_pos - vs - > start_pos ;
avio_flush ( oc - > pb ) ;
2018-03-18 07:09:44 +01:00
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 ) {
if ( ! vs - > init_range_length ) {
2020-04-07 11:30:18 +02:00
range_length = avio_close_dyn_buf ( oc - > pb , & vs - > init_buffer ) ;
if ( range_length < = 0 )
return AVERROR ( EINVAL ) ;
avio_write ( vs - > out , vs - > init_buffer , range_length ) ;
if ( ! hls - > resend_init_file )
av_freep ( & vs - > init_buffer ) ;
2018-03-18 07:09:44 +01:00
vs - > init_range_length = range_length ;
avio_open_dyn_buf ( & oc - > pb ) ;
vs - > packets_written = 0 ;
vs - > start_pos = range_length ;
2018-03-18 07:08:57 +01:00
if ( ! byterange_mode ) {
2018-03-18 07:09:44 +01:00
hlsenc_io_close ( s , & vs - > out , vs - > base_output_dirname ) ;
2018-03-18 07:08:57 +01:00
}
2017-11-14 03:31:26 +01:00
}
2018-03-18 07:09:44 +01:00
}
if ( ! byterange_mode ) {
2017-11-20 03:02:11 +01:00
if ( vs - > vtt_avf ) {
2017-12-29 22:00:04 +01:00
hlsenc_io_close ( s , & vs - > vtt_avf - > pb , vs - > vtt_avf - > url ) ;
2017-03-14 03:16:00 +01:00
}
2018-03-18 07:09:44 +01:00
}
2018-08-19 03:57:44 +02:00
2019-08-05 04:24:37 +02:00
if ( hls - > flags & HLS_SINGLE_FILE ) {
ret = flush_dynbuf ( vs , & range_length ) ;
2019-09-11 14:36:36 +02:00
av_freep ( & vs - > temp_buffer ) ;
2019-08-05 04:24:37 +02:00
if ( ret < 0 ) {
return ret ;
}
vs - > size = range_length ;
2020-07-22 11:15:29 +02:00
if ( hls - > key_info_file | | hls - > encrypt )
vs - > size = append_single_file ( s , vs ) ;
2019-08-05 04:24:37 +02:00
} else {
2019-12-15 07:42:01 +01:00
if ( oc - > url [ 0 ] ) {
proto = avio_find_protocol_name ( oc - > url ) ;
use_temp_file = proto & & ! strcmp ( proto , " file " )
& & ( hls - > flags & HLS_TEMP_FILE ) ;
}
2020-06-15 14:37:40 +02:00
if ( ( hls - > max_seg_size > 0 & & ( vs - > size + vs - > start_pos > = hls - > max_seg_size ) ) | | ! byterange_mode ) {
2019-12-16 01:04:07 +01:00
AVDictionary * options = NULL ;
2019-08-05 04:24:37 +02:00
char * filename = NULL ;
if ( hls - > key_info_file | | hls - > encrypt ) {
2020-04-30 15:10:53 +02:00
av_dict_set ( & options , " encryption_key " , vs - > key_string , 0 ) ;
av_dict_set ( & options , " encryption_iv " , vs - > iv_string , 0 ) ;
2019-08-05 04:24:37 +02:00
filename = av_asprintf ( " crypto:%s " , oc - > url ) ;
} else {
filename = av_asprintf ( " %s " , oc - > url ) ;
2018-03-18 07:08:57 +01:00
}
2019-08-05 04:24:37 +02:00
if ( ! filename ) {
2019-12-16 01:04:07 +01:00
av_dict_free ( & options ) ;
2019-08-05 04:24:37 +02:00
return AVERROR ( ENOMEM ) ;
}
2019-12-16 01:04:07 +01:00
// look to rename the asset name
if ( use_temp_file )
av_dict_set ( & options , " mpegts_flags " , " resend_headers " , 0 ) ;
set_http_options ( s , & options , hls ) ;
2019-08-05 04:24:37 +02:00
ret = hlsenc_io_open ( s , & vs - > out , filename , & options ) ;
2018-03-18 07:09:44 +01:00
if ( ret < 0 ) {
2018-12-10 07:19:23 +01:00
av_log ( s , hls - > ignore_io_errors ? AV_LOG_WARNING : AV_LOG_ERROR ,
2019-08-05 04:24:37 +02:00
" Failed to open file '%s' \n " , filename ) ;
2020-05-12 12:02:26 +02:00
av_freep ( & filename ) ;
2019-12-16 01:04:07 +01:00
av_dict_free ( & options ) ;
2018-12-10 07:19:23 +01:00
return hls - > ignore_io_errors ? 0 : ret ;
2018-03-18 07:09:44 +01:00
}
2019-08-05 04:24:37 +02:00
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 ) {
write_styp ( vs - > out ) ;
}
2018-03-18 07:09:44 +01:00
ret = flush_dynbuf ( vs , & range_length ) ;
if ( ret < 0 ) {
2020-05-12 12:02:26 +02:00
av_freep ( & filename ) ;
2019-12-16 01:04:07 +01:00
av_dict_free ( & options ) ;
2018-03-18 07:09:44 +01:00
return ret ;
}
2019-08-30 01:14:28 +02:00
ret = hlsenc_io_close ( s , & vs - > out , filename ) ;
if ( ret < 0 ) {
av_log ( s , AV_LOG_WARNING , " upload segment failed, "
" will retry with a new http session. \n " ) ;
ff_format_io_close ( s , & vs - > out ) ;
ret = hlsenc_io_open ( s , & vs - > out , filename , & options ) ;
reflush_dynbuf ( vs , & range_length ) ;
ret = hlsenc_io_close ( s , & vs - > out , filename ) ;
}
2019-12-16 01:04:07 +01:00
av_dict_free ( & options ) ;
2019-09-24 13:24:01 +02:00
av_freep ( & vs - > temp_buffer ) ;
av_freep ( & filename ) ;
2018-03-18 07:08:57 +01:00
}
2018-02-19 21:36:25 +01:00
2019-12-15 07:42:01 +01:00
if ( use_temp_file )
hls_rename_temp_file ( s , oc ) ;
2018-12-17 23:14:53 +01:00
}
2019-08-05 04:24:37 +02:00
old_filename = av_strdup ( oc - > url ) ;
2018-02-19 21:36:25 +01:00
if ( ! old_filename ) {
return AVERROR ( ENOMEM ) ;
}
2018-03-18 07:08:57 +01:00
if ( vs - > start_pos | | hls - > segment_type ! = SEGMENT_TYPE_FMP4 ) {
2020-04-29 14:39:22 +02:00
double cur_duration = ( double ) ( pkt - > pts - vs - > end_pts ) * st - > time_base . num / st - > time_base . den ;
ret = hls_append_segment ( s , hls , vs , cur_duration , vs - > start_pos , vs - > size ) ;
2018-03-18 07:08:57 +01:00
vs - > end_pts = pkt - > pts ;
vs - > duration = 0 ;
if ( ret < 0 ) {
2019-09-24 13:24:01 +02:00
av_freep ( & old_filename ) ;
2018-03-18 07:08:57 +01:00
return ret ;
}
2017-01-13 00:57:22 +01:00
}
2012-12-25 08:59:38 +01:00
2019-07-11 03:38:39 +02:00
// if we're building a VOD playlist, skip writing the manifest multiple times, and just wait until the end
if ( hls - > pl_type ! = PLAYLIST_TYPE_VOD ) {
if ( ( ret = hls_window ( s , 0 , vs ) ) < 0 ) {
2019-08-30 01:14:28 +02:00
av_log ( s , AV_LOG_WARNING , " upload playlist failed, will retry with a new http session. \n " ) ;
ff_format_io_close ( s , & vs - > out ) ;
if ( ( ret = hls_window ( s , 0 , vs ) ) < 0 ) {
2019-09-24 13:24:01 +02:00
av_freep ( & old_filename ) ;
2019-08-30 01:14:28 +02:00
return ret ;
}
2019-07-11 03:38:39 +02:00
}
}
2012-10-26 16:36:56 +02:00
2020-04-07 11:30:18 +02:00
if ( hls - > resend_init_file & & hls - > segment_type = = SEGMENT_TYPE_FMP4 ) {
ret = hls_init_file_resend ( s , vs ) ;
if ( ret < 0 ) {
av_freep ( & old_filename ) ;
return ret ;
}
}
2014-09-15 15:26:57 +02:00
if ( hls - > flags & HLS_SINGLE_FILE ) {
2019-08-05 04:24:37 +02:00
vs - > start_pos + = vs - > size ;
2020-07-22 11:15:29 +02:00
if ( hls - > key_info_file | | hls - > encrypt )
ret = hls_start ( s , vs ) ;
2016-09-19 01:00:42 +02:00
} else if ( hls - > max_seg_size > 0 ) {
2020-06-15 14:37:40 +02:00
if ( vs - > size + vs - > start_pos > = hls - > max_seg_size ) {
2017-11-20 03:02:11 +01:00
vs - > sequence + + ;
sls_flag_file_rename ( hls , vs , old_filename ) ;
ret = hls_start ( s , vs ) ;
vs - > start_pos = 0 ;
2016-09-19 01:00:42 +02:00
/* When split segment by byte, the duration is short than hls_time,
* so it is not enough one segment duration as hls_time , */
2020-06-15 14:37:40 +02:00
} else {
vs - > start_pos = new_start_pos ;
2016-09-19 01:00:42 +02:00
}
2014-09-15 15:26:57 +02:00
} else {
2019-08-05 04:24:37 +02:00
vs - > start_pos = new_start_pos ;
2017-11-20 03:02:11 +01:00
sls_flag_file_rename ( hls , vs , old_filename ) ;
ret = hls_start ( s , vs ) ;
2014-09-15 15:26:57 +02:00
}
2020-05-12 11:59:23 +02:00
vs - > number + + ;
2019-09-24 13:24:01 +02:00
av_freep ( & old_filename ) ;
2012-10-26 16:36:56 +02:00
2017-01-13 00:57:22 +01:00
if ( ret < 0 ) {
2012-10-26 16:36:56 +02:00
return ret ;
2017-01-13 00:57:22 +01:00
}
2012-10-26 16:36:56 +02:00
}
2017-11-20 03:02:11 +01:00
vs - > packets_written + + ;
2018-12-10 07:19:23 +01:00
if ( oc - > pb ) {
2018-12-10 07:17:55 +01:00
ret = ff_write_chained ( oc , stream_index , pkt , s , 0 ) ;
2021-05-01 09:07:53 +02:00
vs - > video_keyframe_size + = pkt - > size ;
if ( ( st - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO ) & & ( pkt - > flags & AV_PKT_FLAG_KEY ) ) {
vs - > video_keyframe_size = avio_tell ( oc - > pb ) ;
} else {
vs - > video_keyframe_pos = avio_tell ( vs - > out ) ;
2019-06-02 16:03:17 +02:00
}
2018-12-10 07:19:23 +01:00
if ( hls - > ignore_io_errors )
ret = 0 ;
}
2012-10-26 16:36:56 +02:00
return ret ;
}
2019-12-15 11:00:02 +01:00
static void hls_deinit ( AVFormatContext * s )
2018-12-22 16:43:47 +01:00
{
2019-12-15 11:00:02 +01:00
HLSContext * hls = s - > priv_data ;
2018-12-22 16:43:47 +01:00
int i = 0 ;
VariantStream * vs = NULL ;
for ( i = 0 ; i < hls - > nb_varstreams ; i + + ) {
vs = & hls - > var_streams [ i ] ;
av_freep ( & vs - > basename ) ;
av_freep ( & vs - > base_output_dirname ) ;
av_freep ( & vs - > fmp4_init_filename ) ;
2019-12-15 18:48:28 +01:00
av_freep ( & vs - > vtt_basename ) ;
av_freep ( & vs - > vtt_m3u8_name ) ;
2018-12-22 16:43:47 +01:00
2020-02-28 07:59:34 +01:00
avformat_free_context ( vs - > vtt_avf ) ;
2019-11-29 06:07:02 +01:00
avformat_free_context ( vs - > avf ) ;
2020-04-07 11:30:18 +02:00
if ( hls - > resend_init_file )
av_freep ( & vs - > init_buffer ) ;
2018-12-22 16:43:47 +01:00
hls_free_segments ( vs - > segments ) ;
hls_free_segments ( vs - > old_segments ) ;
av_freep ( & vs - > m3u8_name ) ;
av_freep ( & vs - > streams ) ;
2019-12-15 11:00:02 +01:00
}
ff_format_io_close ( s , & hls - > m3u8_out ) ;
ff_format_io_close ( s , & hls - > sub_m3u8_out ) ;
av_freep ( & hls - > key_basename ) ;
av_freep ( & hls - > var_streams ) ;
av_freep ( & hls - > cc_streams ) ;
av_freep ( & hls - > master_m3u8_url ) ;
2018-12-22 16:43:47 +01:00
}
2012-10-26 16:36:56 +02:00
static int hls_write_trailer ( struct AVFormatContext * s )
{
HLSContext * hls = s - > priv_data ;
2017-11-20 03:02:11 +01:00
AVFormatContext * oc = NULL ;
AVFormatContext * vtt_oc = NULL ;
char * old_filename = NULL ;
2018-12-17 23:14:53 +01:00
const char * proto = NULL ;
int use_temp_file = 0 ;
2017-11-20 03:02:11 +01:00
int i ;
2017-12-21 04:14:32 +01:00
int ret = 0 ;
2017-11-20 03:02:11 +01:00
VariantStream * vs = NULL ;
2019-08-05 04:24:37 +02:00
AVDictionary * options = NULL ;
int range_length , byterange_mode ;
2017-11-20 03:02:11 +01:00
for ( i = 0 ; i < hls - > nb_varstreams ; i + + ) {
2019-08-05 04:24:37 +02:00
char * filename = NULL ;
2017-11-20 03:02:11 +01:00
vs = & hls - > var_streams [ i ] ;
2018-03-18 07:09:44 +01:00
oc = vs - > avf ;
vtt_oc = vs - > vtt_avf ;
2019-09-14 07:09:16 +02:00
old_filename = av_strdup ( oc - > url ) ;
2018-12-17 23:14:53 +01:00
use_temp_file = 0 ;
2017-01-13 00:57:22 +01:00
2018-03-18 07:09:44 +01:00
if ( ! old_filename ) {
return AVERROR ( ENOMEM ) ;
2018-03-18 07:08:57 +01:00
}
2019-08-05 04:24:37 +02:00
if ( hls - > key_info_file | | hls - > encrypt ) {
2020-04-30 15:10:53 +02:00
av_dict_set ( & options , " encryption_key " , vs - > key_string , 0 ) ;
av_dict_set ( & options , " encryption_iv " , vs - > iv_string , 0 ) ;
2019-09-14 07:09:16 +02:00
filename = av_asprintf ( " crypto:%s " , oc - > url ) ;
2019-08-05 04:24:37 +02:00
} else {
2019-09-14 07:09:16 +02:00
filename = av_asprintf ( " %s " , oc - > url ) ;
2019-08-05 04:24:37 +02:00
}
if ( ! filename ) {
2019-09-24 13:24:01 +02:00
av_freep ( & old_filename ) ;
2019-08-05 04:24:37 +02:00
return AVERROR ( ENOMEM ) ;
}
2020-02-28 07:59:34 +01:00
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 ) {
2018-11-16 22:03:37 +01:00
int range_length = 0 ;
2018-10-30 04:10:27 +01:00
if ( ! vs - > init_range_length ) {
2018-11-16 22:03:37 +01:00
uint8_t * buffer = NULL ;
2019-09-14 07:09:16 +02:00
av_write_frame ( oc , NULL ) ; /* Flush any buffered data */
2018-10-30 04:10:27 +01:00
2018-11-16 22:03:37 +01:00
range_length = avio_close_dyn_buf ( oc - > pb , & buffer ) ;
2018-10-30 04:10:27 +01:00
avio_write ( vs - > out , buffer , range_length ) ;
2019-09-24 13:24:01 +02:00
av_freep ( & buffer ) ;
2018-10-30 04:10:27 +01:00
vs - > init_range_length = range_length ;
avio_open_dyn_buf ( & oc - > pb ) ;
vs - > packets_written = 0 ;
vs - > start_pos = range_length ;
2018-11-16 22:03:37 +01:00
byterange_mode = ( hls - > flags & HLS_SINGLE_FILE ) | | ( hls - > max_seg_size > 0 ) ;
2018-10-30 04:10:27 +01:00
if ( ! byterange_mode ) {
ff_format_io_close ( s , & vs - > out ) ;
hlsenc_io_close ( s , & vs - > out , vs - > base_output_dirname ) ;
}
}
2019-08-05 04:24:37 +02:00
}
if ( ! ( hls - > flags & HLS_SINGLE_FILE ) ) {
set_http_options ( s , & options , hls ) ;
ret = hlsenc_io_open ( s , & vs - > out , filename , & options ) ;
2018-03-18 07:09:44 +01:00
if ( ret < 0 ) {
2019-09-14 07:09:16 +02:00
av_log ( s , AV_LOG_ERROR , " Failed to open file '%s' \n " , oc - > url ) ;
2018-03-18 07:09:44 +01:00
goto failed ;
}
2019-08-05 04:24:37 +02:00
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 )
write_styp ( vs - > out ) ;
2017-12-21 04:14:32 +01:00
}
2019-08-05 04:24:37 +02:00
ret = flush_dynbuf ( vs , & range_length ) ;
if ( ret < 0 )
goto failed ;
vs - > size = range_length ;
2019-08-30 01:14:28 +02:00
ret = hlsenc_io_close ( s , & vs - > out , filename ) ;
if ( ret < 0 ) {
av_log ( s , AV_LOG_WARNING , " upload segment failed, will retry with a new http session. \n " ) ;
ff_format_io_close ( s , & vs - > out ) ;
ret = hlsenc_io_open ( s , & vs - > out , filename , & options ) ;
if ( ret < 0 ) {
2019-09-14 07:09:16 +02:00
av_log ( s , AV_LOG_ERROR , " Failed to open file '%s' \n " , oc - > url ) ;
2019-08-30 01:14:28 +02:00
goto failed ;
}
reflush_dynbuf ( vs , & range_length ) ;
ret = hlsenc_io_close ( s , & vs - > out , filename ) ;
2019-09-07 14:39:28 +02:00
if ( ret < 0 )
2019-09-14 07:09:16 +02:00
av_log ( s , AV_LOG_WARNING , " Failed to upload file '%s' at the end. \n " , oc - > url ) ;
2019-08-30 01:14:28 +02:00
}
2020-07-22 11:15:29 +02:00
if ( hls - > flags & HLS_SINGLE_FILE ) {
if ( hls - > key_info_file | | hls - > encrypt ) {
vs - > size = append_single_file ( s , vs ) ;
}
hlsenc_io_close ( s , & vs - > out_single_file , vs - > basename ) ;
}
2017-12-25 16:51:25 +01:00
failed :
2020-05-12 12:04:20 +02:00
av_freep ( & vs - > temp_buffer ) ;
av_dict_free ( & options ) ;
2019-09-24 13:24:01 +02:00
av_freep ( & filename ) ;
2018-03-18 07:09:44 +01:00
av_write_trailer ( oc ) ;
2018-12-17 23:14:53 +01:00
if ( oc - > url [ 0 ] ) {
proto = avio_find_protocol_name ( oc - > url ) ;
use_temp_file = proto & & ! strcmp ( proto , " file " ) & & ( hls - > flags & HLS_TEMP_FILE ) ;
}
2019-08-20 03:56:38 +02:00
// rename that segment from .tmp to the real one
if ( use_temp_file & & ! ( hls - > flags & HLS_SINGLE_FILE ) ) {
hls_rename_temp_file ( s , oc ) ;
2019-09-24 13:24:01 +02:00
av_freep ( & old_filename ) ;
2019-09-14 07:09:16 +02:00
old_filename = av_strdup ( oc - > url ) ;
2018-02-19 21:36:25 +01:00
2019-08-20 03:56:38 +02:00
if ( ! old_filename ) {
return AVERROR ( ENOMEM ) ;
2018-02-19 21:36:25 +01:00
}
2019-08-20 03:56:38 +02:00
}
2017-02-25 03:59:05 +01:00
2019-08-20 03:56:38 +02:00
/* after av_write_trailer, then duration + 1 duration per packet */
hls_append_segment ( s , hls , vs , vs - > duration + vs - > dpp , vs - > start_pos , vs - > size ) ;
2015-06-04 09:55:52 +02:00
2018-03-18 07:09:44 +01:00
sls_flag_file_rename ( hls , vs , old_filename ) ;
2017-02-07 04:58:43 +01:00
2018-03-18 07:09:44 +01:00
if ( vtt_oc ) {
if ( vtt_oc - > pb )
av_write_trailer ( vtt_oc ) ;
vs - > size = avio_tell ( vs - > vtt_avf - > pb ) - vs - > start_pos ;
ff_format_io_close ( s , & vtt_oc - > pb ) ;
}
2019-08-30 01:14:28 +02:00
ret = hls_window ( s , 1 , vs ) ;
if ( ret < 0 ) {
av_log ( s , AV_LOG_WARNING , " upload playlist failed, will retry with a new http session. \n " ) ;
ff_format_io_close ( s , & vs - > out ) ;
hls_window ( s , 1 , vs ) ;
}
2019-09-09 08:15:21 +02:00
ffio_free_dyn_buf ( & oc - > pb ) ;
2015-06-04 09:55:52 +02:00
2018-03-18 07:09:44 +01:00
av_free ( old_filename ) ;
2017-11-20 03:02:11 +01:00
}
2012-10-26 16:36:56 +02:00
return 0 ;
}
2017-12-11 04:03:25 +01:00
static int hls_init ( AVFormatContext * s )
{
int ret = 0 ;
int i = 0 ;
int j = 0 ;
HLSContext * hls = s - > priv_data ;
2020-04-08 23:41:17 +02:00
const char * pattern ;
2017-12-11 04:03:25 +01:00
VariantStream * vs = NULL ;
2020-04-08 22:57:50 +02:00
const char * vtt_pattern = hls - > flags & HLS_SINGLE_FILE ? " .vtt " : " %d.vtt " ;
2017-12-11 04:03:25 +01:00
char * p = NULL ;
2019-09-06 06:10:15 +02:00
int http_base_proto = ff_is_http_proto ( s - > url ) ;
2017-12-11 04:03:25 +01:00
int fmp4_init_filename_len = strlen ( hls - > fmp4_init_filename ) + 1 ;
2020-07-18 23:57:42 +02:00
double initial_program_date_time = av_gettime ( ) / 1000000.0 ;
2017-12-11 04:03:25 +01:00
2020-04-08 23:41:17 +02:00
if ( hls - > use_localtime ) {
pattern = get_default_pattern_localtime_fmt ( s ) ;
} else {
pattern = hls - > segment_type = = SEGMENT_TYPE_FMP4 ? " %d.m4s " : " %d.ts " ;
if ( hls - > flags & HLS_SINGLE_FILE )
pattern + = 2 ;
}
avformat/hlsenc: add var_stream_map DEFAULT field status parameter
use a:0,agroup:aud_low,default:Yes a:1,agroup:aud_low,
a:2,agroup:aud_high,default:Yes a:3, agroup:aud_high,
v:0,agroup:aud_low v:1,agroup:aud_high
create master m3u8 list.
result:
EXTM3U
EXT-X-VERSION:3
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_0",DEFAULT=YES,URI="out_0.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_low",NAME="audio_1",DEFAULT=NO,URI="out_1.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_2",DEFAULT=YES,URI="out_2.m3u8"
EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="group_aud_high",NAME="audio_3",DEFAULT=NO,URI="out_3.m3u8"
EXT-X-STREAM-INF:BANDWIDTH=1170400,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_low"
out_4.m3u8
EXT-X-STREAM-INF:BANDWIDTH=3440800,RESOLUTION=640x480,CODECS="avc1.64001e,mp4a.40.2",AUDIO="group_aud_high"
out_5.m3u8
Signed-off-by: Steven Liu <lq@chinaffmpeg.org>
2019-01-23 11:52:02 +01:00
hls - > has_default_key = 0 ;
hls - > has_video_m3u8 = 0 ;
2017-12-11 04:03:25 +01:00
ret = update_variant_stream_info ( s ) ;
if ( ret < 0 ) {
av_log ( s , AV_LOG_ERROR , " Variant stream info update failed with status %x \n " ,
2018-03-18 07:09:44 +01:00
ret ) ;
2020-02-28 07:59:34 +01:00
return ret ;
2017-12-11 04:03:25 +01:00
}
2019-09-06 06:10:15 +02:00
if ( ! hls - > method & & http_base_proto ) {
2019-09-06 06:47:15 +02:00
av_log ( hls , AV_LOG_WARNING , " No HTTP method set, hls muxer defaulting to method PUT. \n " ) ;
2019-09-06 06:10:15 +02:00
}
2017-12-29 22:00:04 +01:00
ret = validate_name ( hls - > nb_varstreams , s - > url ) ;
2018-01-02 03:46:17 +01:00
if ( ret < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2018-01-02 03:46:17 +01:00
if ( hls - > segment_filename ) {
ret = validate_name ( hls - > nb_varstreams , hls - > segment_filename ) ;
if ( ret < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2018-01-02 03:46:17 +01:00
}
if ( av_strcasecmp ( hls - > fmp4_init_filename , " init.mp4 " ) ) {
ret = validate_name ( hls - > nb_varstreams , hls - > fmp4_init_filename ) ;
if ( ret < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2018-01-02 03:46:17 +01:00
}
if ( hls - > subtitle_filename ) {
ret = validate_name ( hls - > nb_varstreams , hls - > subtitle_filename ) ;
if ( ret < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2018-01-02 03:46:17 +01:00
}
2017-12-11 04:03:25 +01:00
if ( hls - > master_pl_name ) {
ret = update_master_pl_info ( s ) ;
if ( ret < 0 ) {
av_log ( s , AV_LOG_ERROR , " Master stream info update failed with status %x \n " ,
2018-03-18 07:09:44 +01:00
ret ) ;
2020-02-28 07:59:34 +01:00
return ret ;
2017-12-11 04:03:25 +01:00
}
}
if ( ( hls - > start_sequence_source_type = = HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH ) | |
2020-04-18 22:15:39 +02:00
( hls - > start_sequence_source_type = = HLS_START_SEQUENCE_AS_MICROSECONDS_SINCE_EPOCH ) | |
2017-12-11 04:03:25 +01:00
( hls - > start_sequence_source_type = = HLS_START_SEQUENCE_AS_FORMATTED_DATETIME ) ) {
2020-04-18 22:15:39 +02:00
time_t t = time ( NULL ) ;
if ( hls - > start_sequence_source_type = = HLS_START_SEQUENCE_AS_MICROSECONDS_SINCE_EPOCH ) {
hls - > start_sequence = av_gettime ( ) ;
} else if ( hls - > start_sequence_source_type = = HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH ) {
2017-12-11 04:03:25 +01:00
hls - > start_sequence = ( int64_t ) t ;
} else if ( hls - > start_sequence_source_type = = HLS_START_SEQUENCE_AS_FORMATTED_DATETIME ) {
char b [ 15 ] ;
struct tm * p , tmbuf ;
if ( ! ( p = localtime_r ( & t , & tmbuf ) ) )
2019-12-16 01:04:12 +01:00
return AVERROR ( errno ) ;
2017-12-11 04:03:25 +01:00
if ( ! strftime ( b , sizeof ( b ) , " %Y%m%d%H%M%S " , p ) )
return AVERROR ( ENOMEM ) ;
hls - > start_sequence = strtoll ( b , NULL , 10 ) ;
}
av_log ( hls , AV_LOG_DEBUG , " start_number evaluated to % " PRId64 " \n " , hls - > start_sequence ) ;
}
2021-01-17 02:07:28 +01:00
hls - > recording_time = hls - > init_time ? hls - > init_time : hls - > time ;
2019-12-15 19:39:16 +01:00
2020-02-28 07:59:34 +01:00
if ( hls - > flags & HLS_SPLIT_BY_TIME & & hls - > flags & HLS_INDEPENDENT_SEGMENTS ) {
// Independent segments cannot be guaranteed when splitting by time
hls - > flags & = ~ HLS_INDEPENDENT_SEGMENTS ;
av_log ( s , AV_LOG_WARNING ,
" 'split_by_time' and 'independent_segments' cannot be "
" enabled together. Disabling 'independent_segments' flag \n " ) ;
}
2019-12-15 19:39:16 +01:00
2017-12-11 04:03:25 +01:00
for ( i = 0 ; i < hls - > nb_varstreams ; i + + ) {
vs = & hls - > var_streams [ i ] ;
2018-01-02 03:46:17 +01:00
2019-06-20 05:08:04 +02:00
ret = format_name ( s - > url , & vs - > m3u8_name , i , vs - > varname ) ;
2018-01-02 03:46:17 +01:00
if ( ret < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2018-01-02 03:46:17 +01:00
2020-02-28 07:59:34 +01:00
vs - > sequence = hls - > start_sequence ;
vs - > start_pts = AV_NOPTS_VALUE ;
vs - > end_pts = AV_NOPTS_VALUE ;
2017-12-11 04:03:25 +01:00
vs - > current_segment_final_filename_fmt [ 0 ] = ' \0 ' ;
2020-07-18 23:57:42 +02:00
vs - > initial_prog_date_time = initial_program_date_time ;
2017-12-11 04:03:25 +01:00
for ( j = 0 ; j < vs - > nb_streams ; j + + ) {
vs - > has_video + = vs - > streams [ j ] - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO ;
2018-03-02 03:56:36 +01:00
/* Get one video stream to reference for split segments
* so use the first video stream index . */
if ( ( vs - > has_video = = 1 ) & & ( vs - > streams [ j ] - > codecpar - > codec_type = = AVMEDIA_TYPE_VIDEO ) ) {
2018-03-12 16:17:58 +01:00
vs - > reference_stream_index = vs - > streams [ j ] - > index ;
2018-03-02 03:56:36 +01:00
}
2017-12-11 04:03:25 +01:00
vs - > has_subtitle + = vs - > streams [ j ] - > codecpar - > codec_type = = AVMEDIA_TYPE_SUBTITLE ;
}
if ( vs - > has_video > 1 )
av_log ( s , AV_LOG_WARNING , " More than a single video stream present, expect issues decoding it. \n " ) ;
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 ) {
vs - > oformat = av_guess_format ( " mp4 " , NULL , NULL ) ;
} else {
vs - > oformat = av_guess_format ( " mpegts " , NULL , NULL ) ;
}
2020-02-28 07:59:34 +01:00
if ( ! vs - > oformat )
return AVERROR_MUXER_NOT_FOUND ;
2017-12-11 04:03:25 +01:00
if ( hls - > segment_filename ) {
2019-06-20 05:08:04 +02:00
ret = format_name ( hls - > segment_filename , & vs - > basename , i , vs - > varname ) ;
2018-01-02 03:46:17 +01:00
if ( ret < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2017-12-11 04:03:25 +01:00
} else {
2020-04-08 23:41:17 +02:00
p = strrchr ( vs - > m3u8_name , ' . ' ) ;
if ( p )
* p = ' \0 ' ;
2017-12-11 04:03:25 +01:00
2020-04-08 23:41:17 +02:00
vs - > basename = av_asprintf ( " %s%s " , vs - > m3u8_name , pattern ) ;
2020-02-28 07:59:34 +01:00
if ( ! vs - > basename )
return AVERROR ( ENOMEM ) ;
2017-12-11 04:03:25 +01:00
if ( p )
2020-04-08 23:41:17 +02:00
* p = ' . ' ;
2017-12-11 04:03:25 +01:00
}
if ( hls - > segment_type = = SEGMENT_TYPE_FMP4 ) {
if ( hls - > nb_varstreams > 1 )
fmp4_init_filename_len + = strlen ( POSTFIX_PATTERN ) ;
2018-03-18 07:08:14 +01:00
if ( hls - > flags & HLS_SINGLE_FILE ) {
vs - > fmp4_init_filename = av_strdup ( vs - > basename ) ;
2020-02-28 07:59:34 +01:00
if ( ! vs - > fmp4_init_filename )
return AVERROR ( ENOMEM ) ;
2018-03-18 07:08:14 +01:00
} else {
2018-03-18 07:09:44 +01:00
vs - > fmp4_init_filename = av_malloc ( fmp4_init_filename_len ) ;
2020-02-28 07:59:34 +01:00
if ( ! vs - > fmp4_init_filename )
return AVERROR ( ENOMEM ) ;
2018-03-18 07:09:44 +01:00
av_strlcpy ( vs - > fmp4_init_filename , hls - > fmp4_init_filename ,
fmp4_init_filename_len ) ;
if ( hls - > nb_varstreams > 1 ) {
2019-01-19 07:59:44 +01:00
if ( av_stristr ( vs - > fmp4_init_filename , " %v " ) ) {
2019-06-20 05:08:04 +02:00
av_freep ( & vs - > fmp4_init_filename ) ;
2019-12-15 11:24:32 +01:00
ret = format_name ( hls - > fmp4_init_filename ,
& vs - > fmp4_init_filename , i , vs - > varname ) ;
2019-01-19 07:59:44 +01:00
} else {
ret = append_postfix ( vs - > fmp4_init_filename , fmp4_init_filename_len , i ) ;
}
2018-03-18 07:09:44 +01:00
if ( ret < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2018-03-18 07:09:44 +01:00
}
2018-01-02 03:46:17 +01:00
2020-10-27 12:28:59 +01:00
if ( hls - > use_localtime ) {
int r ;
char * expanded = NULL ;
r = strftime_expand ( vs - > fmp4_init_filename , & expanded ) ;
if ( r < 0 ) {
2020-12-24 15:05:24 +01:00
av_log ( s , AV_LOG_ERROR , " Could not get segment filename with strftime \n " ) ;
return r ;
2020-10-27 12:28:59 +01:00
}
av_free ( vs - > fmp4_init_filename ) ;
vs - > fmp4_init_filename = expanded ;
}
2020-05-08 21:40:29 +02:00
p = strrchr ( vs - > m3u8_name , ' / ' ) ;
2018-03-18 07:09:44 +01:00
if ( p ) {
2020-05-08 21:40:29 +02:00
char tmp = * ( + + p ) ;
* p = ' \0 ' ;
vs - > base_output_dirname = av_asprintf ( " %s%s " , vs - > m3u8_name ,
vs - > fmp4_init_filename ) ;
* p = tmp ;
2018-03-18 07:09:44 +01:00
} else {
2020-05-08 21:40:29 +02:00
vs - > base_output_dirname = av_strdup ( vs - > fmp4_init_filename ) ;
2018-03-18 07:09:44 +01:00
}
2020-05-08 21:40:29 +02:00
if ( ! vs - > base_output_dirname )
return AVERROR ( ENOMEM ) ;
2018-03-18 07:08:14 +01:00
}
2017-12-11 04:03:25 +01:00
}
2019-08-20 04:31:01 +02:00
ret = hls - > use_localtime ? sls_flag_check_duration_size ( hls , vs ) : sls_flag_check_duration_size_index ( hls ) ;
if ( ret < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2019-08-20 04:31:01 +02:00
2017-12-11 04:03:25 +01:00
if ( vs - > has_subtitle ) {
2019-12-15 22:12:53 +01:00
vs - > vtt_oformat = av_guess_format ( " webvtt " , NULL , NULL ) ;
if ( ! vs - > vtt_oformat )
return AVERROR_MUXER_NOT_FOUND ;
2017-12-11 04:03:25 +01:00
2020-04-08 22:57:50 +02:00
p = strrchr ( vs - > m3u8_name , ' . ' ) ;
if ( p )
* p = ' \0 ' ;
2017-12-11 04:03:25 +01:00
2020-04-08 22:57:50 +02:00
vs - > vtt_basename = av_asprintf ( " %s%s " , vs - > m3u8_name , vtt_pattern ) ;
2020-02-28 07:59:34 +01:00
if ( ! vs - > vtt_basename )
return AVERROR ( ENOMEM ) ;
2017-12-11 04:03:25 +01:00
2020-02-28 07:59:34 +01:00
if ( hls - > subtitle_filename ) {
2019-06-20 05:08:04 +02:00
ret = format_name ( hls - > subtitle_filename , & vs - > vtt_m3u8_name , i , vs - > varname ) ;
2018-01-02 03:46:17 +01:00
if ( ret < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2017-12-11 04:03:25 +01:00
} else {
2020-04-08 22:57:50 +02:00
vs - > vtt_m3u8_name = av_asprintf ( " %s_vtt.m3u8 " , vs - > m3u8_name ) ;
2020-02-28 07:59:34 +01:00
if ( ! vs - > vtt_m3u8_name )
return AVERROR ( ENOMEM ) ;
2017-12-11 04:03:25 +01:00
}
2020-04-08 22:57:50 +02:00
if ( p )
* p = ' . ' ;
2017-12-11 04:03:25 +01:00
}
if ( ( ret = hls_mux_init ( s , vs ) ) < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2017-12-11 04:03:25 +01:00
if ( hls - > flags & HLS_APPEND_LIST ) {
parse_playlist ( s , vs - > m3u8_name , vs ) ;
vs - > discontinuity = 1 ;
if ( hls - > init_time > 0 ) {
av_log ( s , AV_LOG_WARNING , " append_list mode does not support hls_init_time, "
" hls_init_time value will have no effect \n " ) ;
hls - > init_time = 0 ;
2021-01-17 02:07:28 +01:00
hls - > recording_time = hls - > time ;
2017-12-11 04:03:25 +01:00
}
}
2017-12-21 04:17:08 +01:00
if ( ( ret = hls_start ( s , vs ) ) < 0 )
2020-02-28 07:59:34 +01:00
return ret ;
2020-05-12 11:59:23 +02:00
vs - > number + + ;
2017-12-11 04:03:25 +01:00
}
return ret ;
}
2012-10-26 16:36:56 +02:00
# 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 } ,
2021-01-17 02:07:28 +01:00
{ " hls_time " , " set segment length " , OFFSET ( time ) , AV_OPT_TYPE_DURATION , { . i64 = 2000000 } , 0 , INT64_MAX , E } ,
{ " hls_init_time " , " set segment length at init list " , OFFSET ( init_time ) , AV_OPT_TYPE_DURATION , { . i64 = 0 } , 0 , INT64_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 } ,
2018-04-13 09:39:49 +02:00
{ " hls_delete_threshold " , " set number of unreferenced segments to keep before deleting " , OFFSET ( hls_delete_threshold ) , AV_OPT_TYPE_INT , { . i64 = 1 } , 1 , INT_MAX , E } ,
2021-11-18 07:58:55 +01:00
# if FF_HLS_TS_OPTIONS
{ " hls_ts_options " , " set hls mpegts list of options for the container format used for hls (deprecated, use hls_segment_options instead of it.) " , OFFSET ( format_options ) , AV_OPT_TYPE_DICT , { . str = NULL } , 0 , 0 , E | AV_OPT_FLAG_DEPRECATED } ,
# endif
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 } ,
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 } ,
2021-11-18 07:58:54 +01:00
{ " hls_segment_options " , " set segments files format options of hls " , OFFSET ( format_options ) , AV_OPT_TYPE_DICT , { . str = NULL } , 0 , 0 , E } ,
2016-09-19 01:00:42 +02:00
{ " hls_segment_size " , " maximum size per segment file, (in bytes) " , OFFSET ( max_seg_size ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , 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 } ,
2017-04-14 17:30:29 +02:00
{ " hls_enc " , " enable AES128 encryption support " , OFFSET ( encrypt ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
{ " hls_enc_key " , " hex-coded 16 byte key to encrypt the segments " , OFFSET ( key ) , AV_OPT_TYPE_STRING , . flags = E } ,
{ " hls_enc_key_url " , " url to access the key to decrypt the segments " , OFFSET ( key_url ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
{ " hls_enc_iv " , " hex-coded 16 byte initialization vector " , OFFSET ( iv ) , AV_OPT_TYPE_STRING , . flags = 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 } ,
2017-07-05 05:15:20 +02:00
{ " hls_segment_type " , " set hls segment files type " , OFFSET ( segment_type ) , AV_OPT_TYPE_INT , { . i64 = SEGMENT_TYPE_MPEGTS } , 0 , SEGMENT_TYPE_FMP4 , E , " segment_type " } ,
2017-07-03 14:20:44 +02:00
{ " mpegts " , " make segment file to mpegts files in m3u8 " , 0 , AV_OPT_TYPE_CONST , { . i64 = SEGMENT_TYPE_MPEGTS } , 0 , UINT_MAX , E , " segment_type " } ,
2017-07-05 05:15:20 +02:00
{ " fmp4 " , " make segment file to fragment mp4 files in m3u8 " , 0 , AV_OPT_TYPE_CONST , { . i64 = SEGMENT_TYPE_FMP4 } , 0 , UINT_MAX , E , " segment_type " } ,
2017-07-03 14:20:44 +02:00
{ " hls_fmp4_init_filename " , " set fragment mp4 file init filename " , OFFSET ( fmp4_init_filename ) , AV_OPT_TYPE_STRING , { . str = " init.mp4 " } , 0 , 0 , E } ,
2020-04-07 11:30:18 +02:00
{ " hls_fmp4_init_resend " , " resend fragment mp4 init file after refresh m3u8 every time " , OFFSET ( resend_init_file ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , 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 " } ,
2019-06-28 07:54:27 +02:00
{ " temp_file " , " write segment and playlist to temporary file and rename when complete " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_TEMP_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-07-07 00:51:20 +02:00
{ " split_by_time " , " split the hls segment by time which user set by hls_time " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_SPLIT_BY_TIME } , 0 , UINT_MAX , E , " flags " } ,
2016-08-21 06:55:45 +02:00
{ " append_list " , " append the new segments into old hls segment list " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_APPEND_LIST } , 0 , UINT_MAX , E , " flags " } ,
2016-09-07 21:34:44 +02:00
{ " program_date_time " , " add EXT-X-PROGRAM-DATE-TIME " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_PROGRAM_DATE_TIME } , 0 , UINT_MAX , E , " flags " } ,
2016-12-27 03:40:35 +01:00
{ " second_level_segment_index " , " include segment index in segment filenames when use_localtime " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_SECOND_LEVEL_SEGMENT_INDEX } , 0 , UINT_MAX , E , " flags " } ,
2017-01-03 15:57:51 +01:00
{ " second_level_segment_duration " , " include segment duration in segment filenames when use_localtime " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_SECOND_LEVEL_SEGMENT_DURATION } , 0 , UINT_MAX , E , " flags " } ,
{ " second_level_segment_size " , " include segment size in segment filenames when use_localtime " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_SECOND_LEVEL_SEGMENT_SIZE } , 0 , UINT_MAX , E , " flags " } ,
2017-08-06 09:10:35 +02:00
{ " periodic_rekey " , " reload keyinfo file periodically for re-keying " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_PERIODIC_REKEY } , 0 , UINT_MAX , E , " flags " } ,
2017-11-23 23:57:36 +01:00
{ " independent_segments " , " add EXT-X-INDEPENDENT-SEGMENTS, whenever applicable " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_INDEPENDENT_SEGMENTS } , 0 , UINT_MAX , E , " flags " } ,
2019-06-02 16:03:17 +02:00
{ " iframes_only " , " add EXT-X-I-FRAMES-ONLY, whenever applicable " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_I_FRAMES_ONLY } , 0 , UINT_MAX , E , " flags " } ,
2018-09-03 05:10:35 +02:00
{ " strftime " , " set filename expansion with strftime at segment creation " , OFFSET ( use_localtime ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
{ " strftime_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 " } ,
2017-02-18 02:42:51 +01:00
{ " method " , " set the HTTP method(default: PUT) " , OFFSET ( method ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2020-04-18 22:15:39 +02:00
{ " hls_start_number_source " , " set source of first number in sequence " , OFFSET ( start_sequence_source_type ) , AV_OPT_TYPE_INT , { . i64 = HLS_START_SEQUENCE_AS_START_NUMBER } , 0 , HLS_START_SEQUENCE_LAST - 1 , E , " start_sequence_source_type " } ,
2017-01-12 14:01:22 +01:00
{ " generic " , " start_number value (default) " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_START_SEQUENCE_AS_START_NUMBER } , INT_MIN , INT_MAX , E , " start_sequence_source_type " } ,
{ " epoch " , " seconds since epoch " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH } , INT_MIN , INT_MAX , E , " start_sequence_source_type " } ,
2020-04-18 22:15:39 +02:00
{ " epoch_us " , " microseconds since epoch " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_START_SEQUENCE_AS_MICROSECONDS_SINCE_EPOCH } , INT_MIN , INT_MAX , E , " start_sequence_source_type " } ,
2017-01-12 14:01:22 +01:00
{ " datetime " , " current datetime as YYYYMMDDhhmmss " , 0 , AV_OPT_TYPE_CONST , { . i64 = HLS_START_SEQUENCE_AS_FORMATTED_DATETIME } , INT_MIN , INT_MAX , E , " start_sequence_source_type " } ,
2017-09-05 17:30:52 +02:00
{ " http_user_agent " , " override User-Agent field in HTTP header " , OFFSET ( user_agent ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2017-11-20 03:02:11 +01:00
{ " var_stream_map " , " Variant stream map string " , OFFSET ( var_stream_map ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2018-01-24 04:42:57 +01:00
{ " cc_stream_map " , " Closed captions stream map string " , OFFSET ( cc_stream_map ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
2017-11-20 03:04:34 +01:00
{ " master_pl_name " , " Create HLS master playlist with this name " , OFFSET ( master_pl_name ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
{ " master_pl_publish_rate " , " Publish master play list every after this many segment intervals " , OFFSET ( master_publish_rate ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , UINT_MAX , E } ,
2017-11-29 07:33:07 +01:00
{ " http_persistent " , " Use persistent HTTP connections " , OFFSET ( http_persistent ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
2018-03-14 12:59:34 +01:00
{ " timeout " , " set timeout for socket I/O operations " , OFFSET ( timeout ) , AV_OPT_TYPE_DURATION , { . i64 = - 1 } , - 1 , INT_MAX , . flags = E } ,
2018-12-10 07:19:23 +01:00
{ " ignore_io_errors " , " Ignore IO errors for stable long-duration runs with network output " , OFFSET ( ignore_io_errors ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , E } ,
2019-06-21 15:26:20 +02:00
{ " headers " , " set custom HTTP headers, can override built in default headers " , OFFSET ( headers ) , AV_OPT_TYPE_STRING , { . str = NULL } , 0 , 0 , E } ,
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 ,
} ;
2021-04-19 19:45:24 +02:00
const AVOutputFormat ff_hls_muxer = {
2012-10-26 16:36:56 +02:00
. 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 ,
2018-05-10 04:22:33 +02:00
. flags = AVFMT_NOFILE | AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_NODIMENSIONS ,
2017-12-11 04:03:25 +01:00
. init = hls_init ,
2012-10-26 16:36:56 +02:00
. write_header = hls_write_header ,
. write_packet = hls_write_packet ,
. write_trailer = hls_write_trailer ,
2019-12-15 11:00:02 +01:00
. deinit = hls_deinit ,
2012-10-26 16:36:56 +02:00
. priv_class = & hls_class ,
} ;