int discont;
int64_t pos;
int64_t size;
+ unsigned var_stream_idx;
char key_uri[LINE_BUFFER_SIZE + 1];
char iv_string[KEYSIZE*2 + 1];
} SegmentType;
typedef struct VariantStream {
+ unsigned var_stream_idx;
unsigned number;
int64_t sequence;
AVOutputFormat *oformat;
char *fmp4_init_filename;
char *base_output_dirname;
- int fmp4_init_mode;
AVStream **streams;
char codec_attr[128];
float time; // Set by a private option.
float init_time; // Set by a private option.
int max_nb_segments; // Set by a private option.
+ int hls_delete_threshold; // Set by a private option.
#if FF_API_HLS_WRAP
int wrap; // Set by a private option.
#endif
AVIOContext *m3u8_out;
AVIOContext *sub_m3u8_out;
int64_t timeout;
+ int ignore_io_errors;
} HLSContext;
-static int mkdir_p(const char *path) {
- int ret = 0;
- char *temp = av_strdup(path);
- char *pos = temp;
- char tmp_ch = '\0';
-
- if (!path || !temp) {
- return -1;
- }
-
- if (!strncmp(temp, "/", 1) || !strncmp(temp, "\\", 1)) {
- pos++;
- } else if (!strncmp(temp, "./", 2) || !strncmp(temp, ".\\", 2)) {
- pos += 2;
- }
-
- for ( ; *pos != '\0'; ++pos) {
- if (*pos == '/' || *pos == '\\') {
- tmp_ch = *pos;
- *pos = '\0';
- ret = mkdir(temp, 0755);
- *pos = tmp_ch;
- }
- }
-
- if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
- ret = mkdir(temp, 0755);
- }
-
- av_free(temp);
- return ret;
-}
-
static int hlsenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename,
AVDictionary **options) {
HLSContext *hls = s->priv_data;
URLContext *http_url_context = ffio_geturlcontext(*pb);
av_assert0(http_url_context);
err = ff_http_do_new_request(http_url_context, filename);
+ if (err < 0)
+ ff_format_io_close(s, pb);
+
#endif
}
return err;
static void hlsenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename) {
HLSContext *hls = s->priv_data;
int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
+ if (!*pb)
+ return;
if (!http_base_proto || !hls->http_persistent || hls->key_info_file || hls->encrypt) {
ff_format_io_close(s, pb);
#if CONFIG_HTTP_PROTOCOL
HLSSegment *segment, *previous_segment = NULL;
float playlist_duration = 0.0f;
int ret = 0, path_size, sub_path_size;
+ int segment_cnt = 0;
char *dirname = NULL, *p, *sub_path;
char *path = NULL;
+ char *vtt_dirname = NULL;
AVDictionary *options = NULL;
AVIOContext *out = NULL;
const char *proto = NULL;
}
segment = vs->old_segments;
+ segment_cnt = 0;
while (segment) {
playlist_duration -= segment->duration;
previous_segment = segment;
segment = previous_segment->next;
+ segment_cnt++;
if (playlist_duration <= -previous_segment->duration) {
previous_segment->next = NULL;
break;
}
+ if (segment_cnt >= hls->hls_delete_threshold) {
+ previous_segment->next = NULL;
+ break;
+ }
}
if (segment && !hls->use_localtime_mkdir) {
}
p = (char *)av_basename(dirname);
*p = '\0';
+
}
while (segment) {
+ char * r_dirname = dirname;
+
+ /* if %v is present in the file's directory */
+ if (dirname && av_stristr(dirname, "%v")) {
+
+ if (replace_int_data_in_filename(&r_dirname, dirname, 'v', segment->var_stream_idx) < 1) {
+ ret = AVERROR(EINVAL);
+ goto fail;
+ }
+ av_free(dirname);
+ dirname = r_dirname;
+ }
+
av_log(hls, AV_LOG_DEBUG, "deleting old segment %s\n",
segment->filename);
path_size = (hls->use_localtime_mkdir ? 0 : strlen(dirname)) + strlen(segment->filename) + 1;
proto = avio_find_protocol_name(s->url);
if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
av_dict_set(&options, "method", "DELETE", 0);
- if ((ret = vs->avf->io_open(vs->avf, &out, path, AVIO_FLAG_WRITE, &options)) < 0)
+ if ((ret = vs->avf->io_open(vs->avf, &out, path, AVIO_FLAG_WRITE, &options)) < 0) {
+ if (hls->ignore_io_errors)
+ ret = 0;
goto fail;
+ }
ff_format_io_close(vs->avf, &out);
} else if (unlink(path) < 0) {
av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
}
if ((segment->sub_filename[0] != '\0')) {
- sub_path_size = strlen(segment->sub_filename) + 1 + (dirname ? strlen(dirname) : 0);
+ vtt_dirname = av_strdup(vs->vtt_avf->url);
+ if (!vtt_dirname) {
+ ret = AVERROR(ENOMEM);
+ goto fail;
+ }
+ p = (char *)av_basename(vtt_dirname);
+ *p = '\0';
+ sub_path_size = strlen(segment->sub_filename) + 1 + strlen(vtt_dirname);
sub_path = av_malloc(sub_path_size);
if (!sub_path) {
ret = AVERROR(ENOMEM);
goto fail;
}
- av_strlcpy(sub_path, dirname, sub_path_size);
+ av_strlcpy(sub_path, vtt_dirname, sub_path_size);
av_strlcat(sub_path, segment->sub_filename, sub_path_size);
if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
av_dict_set(&options, "method", "DELETE", 0);
- if ((ret = vs->avf->io_open(vs->avf, &out, sub_path, AVIO_FLAG_WRITE, &options)) < 0) {
+ if ((ret = vs->vtt_avf->io_open(vs->vtt_avf, &out, sub_path, AVIO_FLAG_WRITE, &options)) < 0) {
+ if (hls->ignore_io_errors)
+ ret = 0;
av_free(sub_path);
goto fail;
}
- ff_format_io_close(vs->avf, &out);
+ ff_format_io_close(vs->vtt_avf, &out);
} else if (unlink(sub_path) < 0) {
av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
sub_path, strerror(errno));
fail:
av_free(path);
av_free(dirname);
+ av_free(vtt_dirname);
return ret;
}
return 0;
}
-static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
-{
- int len = ff_get_line(s, buf, maxlen);
- while (len > 0 && av_isspace(buf[len - 1]))
- buf[--len] = '\0';
- return len;
-}
-
static int hls_mux_init(AVFormatContext *s, VariantStream *vs)
{
AVDictionary *options = NULL;
vs->packets_written = 1;
vs->start_pos = 0;
vs->new_start = 1;
- vs->fmp4_init_mode = 0;
if (hls->segment_type == SEGMENT_TYPE_FMP4) {
if (hls->max_seg_size > 0) {
vs->packets_written = 0;
vs->init_range_length = 0;
- vs->fmp4_init_mode = !byterange_mode;
set_http_options(s, &options, hls);
if ((ret = avio_open_dyn_buf(&oc->pb)) < 0)
return ret;
if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
av_log(hls, AV_LOG_ERROR,
- "second_level_segment_duration hls_flag requires use_localtime to be true\n");
+ "second_level_segment_duration hls_flag requires strftime to be true\n");
ret = AVERROR(EINVAL);
}
if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
av_log(hls, AV_LOG_ERROR,
- "second_level_segment_size hls_flag requires use_localtime to be true\n");
+ "second_level_segment_size hls_flag requires strfime to be true\n");
ret = AVERROR(EINVAL);
}
if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_INDEX) {
av_log(hls, AV_LOG_ERROR,
- "second_level_segment_index hls_flag requires use_localtime to be true\n");
+ "second_level_segment_index hls_flag requires strftime to be true\n");
ret = AVERROR(EINVAL);
}
if (!en)
return AVERROR(ENOMEM);
+ en->var_stream_idx = vs->var_stream_idx;
ret = sls_flags_filename_process(s, hls, vs, en, duration, pos, size);
if (ret < 0) {
return ret;
s->protocol_whitelist, s->protocol_blacklist)) < 0)
return ret;
- read_chomp_line(in, line, sizeof(line));
+ ff_get_chomp_line(in, line, sizeof(line));
if (strcmp(line, "#EXTM3U")) {
ret = AVERROR_INVALIDDATA;
goto fail;
vs->discontinuity = 0;
while (!avio_feof(in)) {
- read_chomp_line(in, line, sizeof(line));
+ ff_get_chomp_line(in, line, sizeof(line));
if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
int64_t tmp_sequence = strtoll(ptr, NULL, 10);
if (tmp_sequence < vs->sequence)
char temp_filename[1024];
int64_t sequence = FFMAX(hls->start_sequence, vs->sequence - vs->nb_entries);
const char *proto = avio_find_protocol_name(s->url);
- int use_rename = proto && !strcmp(proto, "file");
+ int use_temp_file = proto && !strcmp(proto, "file") && (s->flags & HLS_TEMP_FILE);
static unsigned warned_non_file;
char *key_uri = NULL;
char *iv_string = NULL;
hls->version = 7;
}
- if (!use_rename && !warned_non_file++)
+ if (!use_temp_file && !warned_non_file++)
av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
set_http_options(s, &options, hls);
- snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", vs->m3u8_name);
- if ((ret = hlsenc_io_open(s, &hls->m3u8_out, temp_filename, &options)) < 0)
+ snprintf(temp_filename, sizeof(temp_filename), use_temp_file ? "%s.tmp" : "%s", vs->m3u8_name);
+ if ((ret = hlsenc_io_open(s, &hls->m3u8_out, temp_filename, &options)) < 0) {
+ if (hls->ignore_io_errors)
+ ret = 0;
goto fail;
+ }
for (en = vs->segments; en; en = en->next) {
if (target_duration <= en->duration)
ff_hls_write_end_list(hls->m3u8_out);
if( vs->vtt_m3u8_name ) {
- if ((ret = hlsenc_io_open(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name, &options)) < 0)
+ if ((ret = hlsenc_io_open(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name, &options)) < 0) {
+ if (hls->ignore_io_errors)
+ ret = 0;
goto fail;
+ }
ff_hls_write_playlist_header(hls->sub_m3u8_out, hls->version, hls->allowcache,
target_duration, sequence, PLAYLIST_TYPE_NONE);
for (en = vs->segments; en; en = en->next) {
av_dict_free(&options);
hlsenc_io_close(s, &hls->m3u8_out, temp_filename);
hlsenc_io_close(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name);
- if (ret >= 0 && use_rename)
+ if (use_temp_file)
ff_rename(temp_filename, vs->m3u8_name, s);
-
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");
AVFormatContext *oc = vs->avf;
AVFormatContext *vtt_oc = vs->vtt_avf;
AVDictionary *options = NULL;
+ const char *proto = avio_find_protocol_name(s->url);
+ int use_temp_file = proto && !strcmp(proto, "file") && (s->flags & HLS_TEMP_FILE);
char *filename, iv_string[KEYSIZE*2 + 1];
int err = 0;
vs->basename, 'd', vs->sequence) < 1) {
#endif
av_free(filename);
- av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s', you can try to use -use_localtime 1 with it\n", vs->basename);
+ av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s', you can try to use -strftime 1 with it\n", vs->basename);
return AVERROR(EINVAL);
}
ff_format_set_url(oc, filename);
tm = localtime_r(&now0, &tmpbuf);
ff_format_set_url(oc, buf);
if (!strftime(oc->url, bufsize, vs->basename, tm)) {
- av_log(oc, AV_LOG_ERROR, "Could not get segment filename with use_localtime\n");
+ av_log(oc, AV_LOG_ERROR, "Could not get segment filename with strftime\n");
return AVERROR(EINVAL);
}
return AVERROR(ENOMEM);
}
dir = av_dirname(fn_copy);
- if (mkdir_p(dir) == -1 && errno != EEXIST) {
+ if (ff_mkdir_p(dir) == -1 && errno != EEXIST) {
av_log(oc, AV_LOG_ERROR, "Could not create directory %s with use_localtime_mkdir\n", dir);
av_free(fn_copy);
return AVERROR(errno);
vs->basename, 'd', vs->sequence) < 1) {
#endif
av_free(filename);
- av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s' you can try to use -use_localtime 1 with it\n", vs->basename);
+ av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s' you can try to use -strftime 1 with it\n", vs->basename);
return AVERROR(EINVAL);
}
ff_format_set_url(oc, filename);
set_http_options(s, &options, c);
- if (c->flags & HLS_TEMP_FILE) {
+ if (use_temp_file) {
char *new_name = av_asprintf("%s.tmp", oc->url);
if (!new_name)
return AVERROR(ENOMEM);
}
if (c->key_info_file || c->encrypt) {
+ if (c->segment_type == SEGMENT_TYPE_FMP4) {
+ av_log(s, AV_LOG_ERROR, "Encrypted fmp4 not yet supported\n");
+ return AVERROR_PATCHWELCOME;
+ }
+
if (c->key_info_file && c->encrypt) {
av_log(s, AV_LOG_WARNING, "Cannot use both -hls_key_info_file and -hls_enc,"
- " will use -hls_key_info_file priority\n");
+ " ignoring -hls_enc\n");
}
if (!c->encrypt_started || (c->flags & HLS_PERIODIC_REKEY)) {
if (err < 0)
return err;
} else if (c->segment_type != SEGMENT_TYPE_FMP4) {
- if ((err = hlsenc_io_open(s, &oc->pb, oc->url, &options)) < 0)
+ if ((err = hlsenc_io_open(s, &oc->pb, oc->url, &options)) < 0) {
+ if (c->ignore_io_errors)
+ err = 0;
goto fail;
+ }
}
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 ((err = hlsenc_io_open(s, &vtt_oc->pb, vtt_oc->url, &options)) < 0) {
+ if (c->ignore_io_errors)
+ err = 0;
goto fail;
+ }
}
av_dict_free(&options);
}
dir = av_dirname(mod_buf_dup);
- if (mkdir_p(dir) == -1 && errno != EEXIST) {
+ if (ff_mkdir_p(dir) == -1 && errno != EEXIST) {
ret = AVERROR(errno);
goto fail;
}
while (varstr = av_strtok(p, " \t", &saveptr1)) {
p = NULL;
- if (nb_varstreams < hls->nb_varstreams)
- vs = &(hls->var_streams[nb_varstreams++]);
- else
+ if (nb_varstreams < hls->nb_varstreams) {
+ vs = &(hls->var_streams[nb_varstreams]);
+ vs->var_stream_idx = nb_varstreams;
+ nb_varstreams++;
+ } else
return AVERROR(EINVAL);
q = varstr;
if (!hls->var_streams)
return AVERROR(ENOMEM);
+ hls->var_streams[0].var_stream_idx = 0;
hls->var_streams[0].nb_streams = s->nb_streams;
hls->var_streams[0].streams = av_mallocz(sizeof(AVStream *) *
hls->var_streams[0].nb_streams);
int ret = 0, can_split = 1, i, j;
int stream_index = 0;
int range_length = 0;
+ const char *proto = avio_find_protocol_name(s->url);
+ int use_temp_file = proto && !strcmp(proto, "file") && (s->flags & HLS_TEMP_FILE);
uint8_t *buffer = NULL;
VariantStream *vs = NULL;
+ AVDictionary *options = NULL;
+ char *old_filename = NULL;
for (i = 0; i < hls->nb_varstreams; i++) {
vs = &hls->var_streams[i];
if (vs->sequence - vs->nb_entries > hls->start_sequence && hls->init_time > 0) {
/* reset end_pts, hls->recording_time at end of the init hls list */
int init_list_dur = hls->init_time * vs->nb_entries * AV_TIME_BASE;
- int after_init_list_dur = (vs->sequence - vs->nb_entries ) * hls->time * AV_TIME_BASE;
+ int after_init_list_dur = (vs->sequence - hls->start_sequence - vs->nb_entries ) * (hls->time * AV_TIME_BASE);
hls->recording_time = hls->time * AV_TIME_BASE;
end_pts = init_list_dur + after_init_list_dur ;
}
if (vs->packets_written && can_split && av_compare_ts(pkt->pts - vs->start_pts, st->time_base,
end_pts, AV_TIME_BASE_Q) >= 0) {
int64_t new_start_pos;
- char *old_filename = NULL;
int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
av_write_frame(vs->avf, NULL); /* Flush any buffered data */
avio_flush(oc->pb);
range_length = avio_close_dyn_buf(oc->pb, &buffer);
avio_write(vs->out, buffer, range_length);
+ av_free(buffer);
vs->init_range_length = range_length;
avio_open_dyn_buf(&oc->pb);
vs->packets_written = 0;
hlsenc_io_close(s, &vs->vtt_avf->pb, vs->vtt_avf->url);
}
}
- if ((hls->flags & HLS_TEMP_FILE) && oc->url[0]) {
+
+ // look to rename the asset name
+ if (use_temp_file && oc->url[0]) {
if (!(hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size <= 0))
- if ((vs->avf->oformat->priv_class && vs->avf->priv_data) && hls->segment_type != SEGMENT_TYPE_FMP4)
+ if ((vs->avf->oformat->priv_class && vs->avf->priv_data) && hls->segment_type != SEGMENT_TYPE_FMP4) {
av_opt_set(vs->avf->priv_data, "mpegts_flags", "resend_headers", 0);
- hls_rename_temp_file(s, oc);
- }
-
- if (vs->fmp4_init_mode) {
- vs->number--;
+ }
}
if (hls->segment_type == SEGMENT_TYPE_FMP4) {
}
vs->size = range_length;
} else {
- ret = hlsenc_io_open(s, &vs->out, vs->avf->url, NULL);
+ set_http_options(s, &options, hls);
+ ret = hlsenc_io_open(s, &vs->out, vs->avf->url, &options);
if (ret < 0) {
- av_log(s, AV_LOG_ERROR, "Failed to open file '%s'\n",
- vs->avf->url);
- return ret;
+ av_log(s, hls->ignore_io_errors ? AV_LOG_WARNING : AV_LOG_ERROR,
+ "Failed to open file '%s'\n", vs->avf->url);
+ return hls->ignore_io_errors ? 0 : ret;
}
write_styp(vs->out);
ret = flush_dynbuf(vs, &range_length);
return ret;
}
ff_format_io_close(s, &vs->out);
+
+ // rename that segment from .tmp to the real one
+ if (use_temp_file && oc->url[0]) {
+ hls_rename_temp_file(s, oc);
+ av_free(old_filename);
+ old_filename = av_strdup(vs->avf->url);
+
+ if (!old_filename) {
+ return AVERROR(ENOMEM);
+ }
+ }
}
}
vs->start_pos += vs->size;
}
- vs->fmp4_init_mode = 0;
if (hls->flags & HLS_SINGLE_FILE) {
vs->number++;
} else if (hls->max_seg_size > 0) {
return ret;
}
- if (!vs->fmp4_init_mode || byterange_mode)
+ // 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) {
return ret;
}
+ }
}
vs->packets_written++;
- ret = ff_write_chained(oc, stream_index, pkt, s, 0);
+ if (oc->pb) {
+ ret = ff_write_chained(oc, stream_index, pkt, s, 0);
+ if (hls->ignore_io_errors)
+ ret = 0;
+ }
return ret;
}
AVFormatContext *oc = NULL;
AVFormatContext *vtt_oc = NULL;
char *old_filename = NULL;
+ const char *proto = avio_find_protocol_name(s->url);
+ int use_temp_file = proto && !strcmp(proto, "file") && (s->flags & HLS_TEMP_FILE);
int i;
int ret = 0;
VariantStream *vs = NULL;
}
if ( hls->segment_type == SEGMENT_TYPE_FMP4) {
int range_length = 0;
+ if (!vs->init_range_length) {
+ uint8_t *buffer = NULL;
+ int range_length, byterange_mode;
+ av_write_frame(vs->avf, NULL); /* Flush any buffered data */
+ avio_flush(oc->pb);
+
+ range_length = avio_close_dyn_buf(oc->pb, &buffer);
+ avio_write(vs->out, buffer, range_length);
+ av_free(buffer);
+ vs->init_range_length = range_length;
+ avio_open_dyn_buf(&oc->pb);
+ vs->packets_written = 0;
+ vs->start_pos = range_length;
+ byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
+ if (!byterange_mode) {
+ ff_format_io_close(s, &vs->out);
+ hlsenc_io_close(s, &vs->out, vs->base_output_dirname);
+ }
+ }
if (!(hls->flags & HLS_SINGLE_FILE)) {
ret = hlsenc_io_open(s, &vs->out, vs->avf->url, NULL);
if (ret < 0) {
if (ret < 0) {
goto failed;
}
+ vs->size = range_length;
ff_format_io_close(s, &vs->out);
}
if (oc->pb) {
if (hls->segment_type != SEGMENT_TYPE_FMP4) {
vs->size = avio_tell(vs->avf->pb) - vs->start_pos;
- } else {
- vs->size = avio_tell(vs->avf->pb);
}
if (hls->segment_type != SEGMENT_TYPE_FMP4)
ff_format_io_close(s, &oc->pb);
- if ((hls->flags & HLS_TEMP_FILE) && oc->url[0]) {
+ // rename that segment from .tmp to the real one
+ if (use_temp_file && oc->url[0] && !(hls->flags & HLS_SINGLE_FILE)) {
hls_rename_temp_file(s, oc);
av_free(old_filename);
old_filename = av_strdup(vs->avf->url);
{"hls_time", "set segment length in seconds", OFFSET(time), AV_OPT_TYPE_FLOAT, {.dbl = 2}, 0, FLT_MAX, E},
{"hls_init_time", "set segment length in seconds at init list", OFFSET(init_time), AV_OPT_TYPE_FLOAT, {.dbl = 0}, 0, FLT_MAX, E},
{"hls_list_size", "set maximum number of playlist entries", OFFSET(max_nb_segments), AV_OPT_TYPE_INT, {.i64 = 5}, 0, INT_MAX, E},
+ {"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},
{"hls_ts_options","set hls mpegts list of options for the container format used for hls", OFFSET(format_options_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
{"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},
#if FF_API_HLS_WRAP
{"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"},
{"periodic_rekey", "reload keyinfo file periodically for re-keying", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PERIODIC_REKEY }, 0, UINT_MAX, E, "flags"},
{"independent_segments", "add EXT-X-INDEPENDENT-SEGMENTS, whenever applicable", 0, AV_OPT_TYPE_CONST, { .i64 = HLS_INDEPENDENT_SEGMENTS }, 0, UINT_MAX, E, "flags"},
- {"use_localtime", "set filename expansion with strftime at segment creation", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
- {"use_localtime_mkdir", "create last directory component in strftime-generated filename", OFFSET(use_localtime_mkdir), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
+#if FF_API_HLS_USE_LOCALTIME
+ {"use_localtime", "set filename expansion with strftime at segment creation(will be deprecated )", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
+#endif
+ {"strftime", "set filename expansion with strftime at segment creation", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
+#if FF_API_HLS_USE_LOCALTIME
+ {"use_localtime_mkdir", "create last directory component in strftime-generated filename(will be deprecated)", OFFSET(use_localtime_mkdir), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
+#endif
+ {"strftime_mkdir", "create last directory component in strftime-generated filename", OFFSET(use_localtime_mkdir), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
{"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" },
{"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},
{"http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
{"timeout", "set timeout for socket I/O operations", OFFSET(timeout), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E },
+ {"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 },
{ NULL },
};
.audio_codec = AV_CODEC_ID_AAC,
.video_codec = AV_CODEC_ID_H264,
.subtitle_codec = AV_CODEC_ID_WEBVTT,
- .flags = AVFMT_NOFILE | AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
+ .flags = AVFMT_NOFILE | AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_NODIMENSIONS,
.init = hls_init,
.write_header = hls_write_header,
.write_packet = hls_write_packet,
projects / ffmpeg / blobdiff