AVIOContext *out;
int packets_written;
int init_range_length;
+ uint8_t *temp_buffer;
AVFormatContext *avf;
AVFormatContext *vtt_avf;
} HLSContext;
static int hlsenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename,
- AVDictionary **options) {
+ AVDictionary **options)
+{
HLSContext *hls = s->priv_data;
int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
int err = AVERROR_MUXER_NOT_FOUND;
return err;
}
-static void hlsenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename) {
+static int 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;
+ int ret = 0;
if (!*pb)
- return;
+ return ret;
if (!http_base_proto || !hls->http_persistent || hls->key_info_file || hls->encrypt) {
ff_format_io_close(s, pb);
#if CONFIG_HTTP_PROTOCOL
av_assert0(http_url_context);
avio_flush(*pb);
ffurl_shutdown(http_url_context, AVIO_FLAG_WRITE);
+ ret = ff_http_get_shutdown_status(http_url_context);
#endif
}
+ return ret;
}
static void set_http_options(AVFormatContext *s, AVDictionary **options, HLSContext *c)
if (c->method) {
av_dict_set(options, "method", c->method, 0);
} else if (http_base_proto) {
- av_log(c, AV_LOG_WARNING, "No HTTP method set, hls muxer defaulting to method PUT.\n");
av_dict_set(options, "method", "PUT", 0);
}
if (c->user_agent)
av_dict_set(options, "headers", c->headers, 0);
}
-static void write_codec_attr(AVStream *st, VariantStream *vs) {
+static void write_codec_attr(AVStream *st, VariantStream *vs)
+{
int codec_strlen = strlen(vs->codec_attr);
char attr[32];
static int flush_dynbuf(VariantStream *vs, int *range_length)
{
AVFormatContext *ctx = vs->avf;
- uint8_t *buffer;
if (!ctx->pb) {
return AVERROR(EINVAL);
avio_flush(ctx->pb);
// write out to file
- *range_length = avio_close_dyn_buf(ctx->pb, &buffer);
+ *range_length = avio_close_dyn_buf(ctx->pb, &vs->temp_buffer);
ctx->pb = NULL;
- avio_write(vs->out, buffer, *range_length);
- av_free(buffer);
+ avio_write(vs->out, vs->temp_buffer, *range_length);
+ avio_flush(vs->out);
// re-open buffer
return avio_open_dyn_buf(&ctx->pb);
}
+static void reflush_dynbuf(VariantStream *vs, int *range_length)
+{
+ // re-open buffer
+ avio_write(vs->out, vs->temp_buffer, *range_length);;
+}
+
+#if HAVE_DOS_PATHS
+#define SEPARATOR '\\'
+#else
+#define SEPARATOR '/'
+#endif
+
static int hls_delete_old_segments(AVFormatContext *s, HLSContext *hls,
- VariantStream *vs) {
+ VariantStream *vs)
+{
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 *dirname = NULL, *sub_path;
+ char *dirname_r = NULL;
+ char *dirname_repl = NULL;
char *path = NULL;
char *vtt_dirname = NULL;
+ char *vtt_dirname_r = NULL;
AVDictionary *options = NULL;
AVIOContext *out = NULL;
const char *proto = NULL;
}
if (segment && !hls->use_localtime_mkdir) {
- dirname = hls->segment_filename ? av_strdup(hls->segment_filename): av_strdup(vs->avf->url);
- if (!dirname) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
- p = (char *)av_basename(dirname);
- *p = '\0';
+ dirname_r = hls->segment_filename ? av_strdup(hls->segment_filename): av_strdup(vs->avf->url);
+ dirname = (char*)av_dirname(dirname_r);
}
/* 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")) {
- char * r_dirname = dirname;
+ char * dirname_repl = dirname;
if (!vs->varname) {
- if (replace_int_data_in_filename(&r_dirname, dirname, 'v', segment->var_stream_idx) < 1) {
+ if (replace_int_data_in_filename(&dirname_repl, dirname, 'v', segment->var_stream_idx) < 1) {
ret = AVERROR(EINVAL);
goto fail;
}
} else {
- if (replace_str_data_in_filename(&r_dirname, dirname, 'v', vs->varname) < 1) {
+ if (replace_str_data_in_filename(&dirname_repl, dirname, 'v', vs->varname) < 1) {
ret = AVERROR(EINVAL);
goto fail;
}
}
- av_free(dirname);
- dirname = r_dirname;
+ dirname = dirname_repl;
}
while (segment) {
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;
+ path_size = (hls->use_localtime_mkdir ? 0 : strlen(dirname)+1) + strlen(segment->filename) + 1;
path = av_malloc(path_size);
if (!path) {
ret = AVERROR(ENOMEM);
if (hls->use_localtime_mkdir)
av_strlcpy(path, segment->filename, path_size);
else { // segment->filename contains basename only
- av_strlcpy(path, dirname, path_size);
- av_strlcat(path, segment->filename, path_size);
+ snprintf(path, path_size, "%s%c%s", dirname, SEPARATOR, segment->filename);
}
proto = avio_find_protocol_name(s->url);
}
if ((segment->sub_filename[0] != '\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);
+ vtt_dirname_r = av_strdup(vs->vtt_avf->url);
+ vtt_dirname = (char*)av_dirname(vtt_dirname_r);
+ sub_path_size = strlen(segment->sub_filename) + 1 + strlen(vtt_dirname) + 1;
sub_path = av_malloc(sub_path_size);
if (!sub_path) {
ret = AVERROR(ENOMEM);
goto fail;
}
- av_strlcpy(sub_path, vtt_dirname, sub_path_size);
- av_strlcat(sub_path, segment->sub_filename, sub_path_size);
+ snprintf(sub_path, sub_path_size, "%s%c%s", vtt_dirname, SEPARATOR, segment->sub_filename);
+
+ av_freep(&vtt_dirname_r);
if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
av_dict_set(&options, "method", "DELETE", 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);
+ av_freep(&sub_path);
goto fail;
}
ff_format_io_close(vs->vtt_avf, &out);
av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
sub_path, strerror(errno));
}
- av_free(sub_path);
+ av_freep(&sub_path);
}
av_freep(&path);
previous_segment = segment;
segment = previous_segment->next;
- av_free(previous_segment);
+ av_freep(&previous_segment);
}
fail:
- av_free(path);
- av_free(dirname);
- av_free(vtt_dirname);
+ av_freep(&path);
+ av_freep(&dirname_r);
+ av_freep(&dirname_repl);
+ av_freep(&vtt_dirname_r);
return ret;
}
if (!oc->url)
return AVERROR(ENOMEM);
- oc->oformat = vs->oformat;
- 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;
+ oc->oformat = vs->oformat;
+ 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;
+ oc->strict_std_compliance = s->strict_std_compliance;
av_dict_copy(&oc->metadata, s->metadata, 0);
- if(vs->vtt_oformat) {
+ if (vs->vtt_oformat) {
ret = avformat_alloc_output_context2(&vs->vtt_avf, vs->vtt_oformat, NULL, NULL);
if (ret < 0)
return ret;
strlen(vs->current_segment_final_filename_fmt)) {
char * new_url = av_strdup(vs->current_segment_final_filename_fmt);
if (!new_url) {
- av_free(en);
return AVERROR(ENOMEM);
}
ff_format_set_url(vs->avf, new_url);
"Invalid second level segment filename template '%s', "
"you can try to remove second_level_segment_size flag\n",
vs->avf->url);
- av_free(filename);
- av_free(en);
+ av_freep(&filename);
return AVERROR(EINVAL);
}
ff_format_set_url(vs->avf, filename);
"Invalid second level segment filename template '%s', "
"you can try to remove second_level_segment_time flag\n",
vs->avf->url);
- av_free(filename);
- av_free(en);
+ av_freep(&filename);
return AVERROR(EINVAL);
}
ff_format_set_url(vs->avf, filename);
av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
"you can try to remove second_level_segment_index flag\n",
oc->url);
- av_free(filename);
+ av_freep(&filename);
return AVERROR(EINVAL);
}
ff_format_set_url(oc, filename);
av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
"you can try to remove second_level_segment_size flag\n",
oc->url);
- av_free(filename);
+ av_freep(&filename);
return AVERROR(EINVAL);
}
ff_format_set_url(oc, filename);
av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
"you can try to remove second_level_segment_time flag\n",
oc->url);
- av_free(filename);
+ av_freep(&filename);
return AVERROR(EINVAL);
}
ff_format_set_url(oc, filename);
en->var_stream_idx = vs->var_stream_idx;
ret = sls_flags_filename_process(s, hls, vs, en, duration, pos, size);
if (ret < 0) {
+ av_freep(&en);
return ret;
}
}
av_strlcpy(en->filename, filename, sizeof(en->filename));
- if(vs->has_subtitle)
+ if (vs->has_subtitle)
av_strlcpy(en->sub_filename, av_basename(vs->vtt_avf->url), sizeof(en->sub_filename));
else
en->sub_filename[0] = '\0';
if ((ret = hls_delete_old_segments(s, hls, vs)) < 0)
return ret;
} else
- av_free(en);
+ av_freep(&en);
} else
vs->nb_entries++;
{
HLSSegment *en;
- while(p) {
+ while (p) {
en = p;
p = p->next;
- av_free(en);
+ av_freep(&en);
}
}
return ret;
}
-static int get_relative_url(const char *master_url, const char *media_url,
- char *rel_url, int rel_url_buf_size)
+static const char* get_relative_url(const char *master_url, const char *media_url)
{
- char *p = NULL;
- int base_len = -1;
- p = strrchr(master_url, '/') ? strrchr(master_url, '/') :\
- strrchr(master_url, '\\');
+ const char *p = strrchr(master_url, '/');
+ size_t base_len = 0;
+
+ if (!p) p = strrchr(master_url, '\\');
+
if (p) {
- base_len = FFABS(p - master_url);
+ base_len = p + 1 - master_url;
if (av_strncasecmp(master_url, media_url, base_len)) {
av_log(NULL, AV_LOG_WARNING, "Unable to find relative url\n");
- return AVERROR(EINVAL);
+ return NULL;
}
}
- av_strlcpy(rel_url, &(media_url[base_len + 1]), rel_url_buf_size);
- return 0;
+
+ return media_url + base_len;
}
-static int64_t get_stream_bit_rate(AVStream *stream) {
+static int64_t get_stream_bit_rate(AVStream *stream)
+{
AVCPBProperties *props = (AVCPBProperties*)av_stream_get_side_data(
stream,
AV_PKT_DATA_CPB_PROPERTIES,
AVStream *vid_st, *aud_st;
AVDictionary *options = NULL;
unsigned int i, j;
- int m3u8_name_size, ret, bandwidth;
- char *m3u8_rel_name = NULL, *ccgroup;
+ int ret, bandwidth;
+ const char *m3u8_rel_name = NULL;
+ char *ccgroup;
ClosedCaptionsStream *ccs;
const char *proto = avio_find_protocol_name(hls->master_m3u8_url);
int is_file_proto = proto && !strcmp(proto, "file");
ret = hlsenc_io_open(s, &hls->m3u8_out, temp_filename, &options);
av_dict_free(&options);
if (ret < 0) {
- av_log(NULL, AV_LOG_ERROR, "Failed to open master play list file '%s'\n",
+ av_log(s, AV_LOG_ERROR, "Failed to open master play list file '%s'\n",
temp_filename);
goto fail;
}
if (vs->has_video || vs->has_subtitle || !vs->agroup)
continue;
- m3u8_name_size = strlen(vs->m3u8_name) + 1;
- m3u8_rel_name = av_malloc(m3u8_name_size);
+ m3u8_rel_name = get_relative_url(hls->master_m3u8_url, vs->m3u8_name);
if (!m3u8_rel_name) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
- av_strlcpy(m3u8_rel_name, vs->m3u8_name, m3u8_name_size);
- ret = get_relative_url(hls->master_m3u8_url, vs->m3u8_name,
- m3u8_rel_name, m3u8_name_size);
- if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Unable to find relative URL\n");
goto fail;
}
ff_hls_write_audio_rendition(hls->m3u8_out, vs->agroup, m3u8_rel_name, vs->language, i, hls->has_default_key ? vs->is_default : 1);
-
- av_freep(&m3u8_rel_name);
}
/* 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]);
- m3u8_name_size = strlen(vs->m3u8_name) + 1;
- m3u8_rel_name = av_malloc(m3u8_name_size);
+ m3u8_rel_name = get_relative_url(hls->master_m3u8_url, vs->m3u8_name);
if (!m3u8_rel_name) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
- av_strlcpy(m3u8_rel_name, vs->m3u8_name, m3u8_name_size);
- ret = get_relative_url(hls->master_m3u8_url, vs->m3u8_name,
- m3u8_rel_name, m3u8_name_size);
- if (ret < 0) {
- av_log(NULL, AV_LOG_ERROR, "Unable to find relative URL\n");
+ av_log(s, AV_LOG_ERROR, "Unable to find relative URL\n");
goto fail;
}
}
if (!vid_st && !aud_st) {
- av_log(NULL, AV_LOG_WARNING, "Media stream not found\n");
+ av_log(s, AV_LOG_WARNING, "Media stream not found\n");
continue;
}
}
}
if (j == hls->nb_ccstreams)
- av_log(NULL, AV_LOG_WARNING, "mapping ccgroup %s not found\n",
+ av_log(s, AV_LOG_WARNING, "mapping ccgroup %s not found\n",
vs->ccgroup);
}
aud_st ? vs->agroup : NULL, vs->codec_attr, ccgroup);
}
}
-
- av_freep(&m3u8_rel_name);
}
fail:
- if(ret >=0)
+ if (ret >=0)
hls->master_m3u8_created = 1;
- av_freep(&m3u8_rel_name);
hlsenc_io_close(s, &hls->m3u8_out, temp_filename);
if (use_temp_file)
ff_rename(temp_filename, hls->master_m3u8_url, s);
set_http_options(s, &options, hls);
snprintf(temp_filename, sizeof(temp_filename), use_temp_file ? "%s.tmp" : "%s", vs->m3u8_name);
- if ((ret = hlsenc_io_open(s, (byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? &hls->m3u8_out : &vs->out, temp_filename, &options)) < 0) {
+ if ((ret = hlsenc_io_open(s, byterange_mode ? &hls->m3u8_out : &vs->out, temp_filename, &options)) < 0) {
if (hls->ignore_io_errors)
ret = 0;
goto fail;
}
vs->discontinuity_set = 0;
- ff_hls_write_playlist_header((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : vs->out, hls->version, hls->allowcache,
+ ff_hls_write_playlist_header(byterange_mode ? hls->m3u8_out : vs->out, hls->version, hls->allowcache,
target_duration, sequence, hls->pl_type, hls->flags & HLS_I_FRAMES_ONLY);
- if((hls->flags & HLS_DISCONT_START) && sequence==hls->start_sequence && vs->discontinuity_set==0 ){
- avio_printf((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : vs->out, "#EXT-X-DISCONTINUITY\n");
+ if ((hls->flags & HLS_DISCONT_START) && sequence==hls->start_sequence && vs->discontinuity_set==0 ) {
+ avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "#EXT-X-DISCONTINUITY\n");
vs->discontinuity_set = 1;
}
if (vs->has_video && (hls->flags & HLS_INDEPENDENT_SEGMENTS)) {
- avio_printf((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : vs->out, "#EXT-X-INDEPENDENT-SEGMENTS\n");
+ avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "#EXT-X-INDEPENDENT-SEGMENTS\n");
}
for (en = vs->segments; en; en = en->next) {
if ((hls->encrypt || hls->key_info_file) && (!key_uri || strcmp(en->key_uri, key_uri) ||
av_strcasecmp(en->iv_string, iv_string))) {
- avio_printf((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : vs->out, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
+ avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
if (*en->iv_string)
- avio_printf((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : vs->out, ",IV=0x%s", en->iv_string);
- avio_printf((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : vs->out, "\n");
+ 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");
key_uri = en->key_uri;
iv_string = en->iv_string;
}
if ((hls->segment_type == SEGMENT_TYPE_FMP4) && (en == vs->segments)) {
- ff_hls_write_init_file((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : vs->out, (hls->flags & HLS_SINGLE_FILE) ? en->filename : vs->fmp4_init_filename,
+ ff_hls_write_init_file(byterange_mode ? hls->m3u8_out : vs->out, (hls->flags & HLS_SINGLE_FILE) ? en->filename : vs->fmp4_init_filename,
hls->flags & HLS_SINGLE_FILE, vs->init_range_length, 0);
}
- ret = ff_hls_write_file_entry((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : vs->out, en->discont, byterange_mode,
+ ret = ff_hls_write_file_entry(byterange_mode ? hls->m3u8_out : vs->out, en->discont, byterange_mode,
en->duration, hls->flags & HLS_ROUND_DURATIONS,
en->size, en->pos, vs->baseurl,
en->filename, prog_date_time_p, en->keyframe_size, en->keyframe_pos, hls->flags & HLS_I_FRAMES_ONLY);
}
if (last && (hls->flags & HLS_OMIT_ENDLIST)==0)
- ff_hls_write_end_list((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : vs->out);
+ ff_hls_write_end_list(byterange_mode ? hls->m3u8_out : vs->out);
if (vs->vtt_m3u8_name) {
snprintf(temp_vtt_filename, sizeof(temp_vtt_filename), use_temp_file ? "%s.tmp" : "%s", vs->vtt_m3u8_name);
fail:
av_dict_free(&options);
- hlsenc_io_close(s, (byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? &hls->m3u8_out : &vs->out, temp_filename);
+ ret = hlsenc_io_close(s, byterange_mode ? &hls->m3u8_out : &vs->out, temp_filename);
+ if (ret < 0) {
+ return ret;
+ }
hlsenc_io_close(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name);
if (use_temp_file) {
ff_rename(temp_filename, vs->m3u8_name, s);
#else
vs->basename, 'd', vs->sequence) < 1) {
#endif
- av_free(filename);
+ av_freep(&filename);
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);
}
if (c->use_localtime_mkdir) {
const char *dir;
char *fn_copy = av_strdup(oc->url);
- if (!fn_copy) {
- return AVERROR(ENOMEM);
- }
dir = av_dirname(fn_copy);
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);
+ av_freep(&fn_copy);
return AVERROR(errno);
}
- av_free(fn_copy);
+ av_freep(&fn_copy);
}
} else {
char *filename = NULL;
#else
vs->basename, 'd', vs->sequence) < 1) {
#endif
- av_free(filename);
+ av_freep(&filename);
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);
}
- if( vs->vtt_basename) {
+ if ( vs->vtt_basename) {
char *filename = NULL;
if (replace_int_data_in_filename(&filename,
#if FF_API_HLS_WRAP
#else
vs->vtt_basename, 'd', vs->sequence) < 1) {
#endif
- av_free(filename);
+ av_freep(&filename);
av_log(vtt_oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", vs->vtt_basename);
return AVERROR(EINVAL);
}
}
fn_dup = av_strdup(fn);
- if (!fn_dup) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
-
filename = av_basename(fn);
subdir_name = av_dirname(fn_dup);
/* if %v is present in the file's directory, create sub-directory */
if (av_stristr(dir, "%v") && proto && !strcmp(proto, "file")) {
mod_buf_dup = av_strdup(*s);
- if (!mod_buf_dup) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
-
dir = av_dirname(mod_buf_dup);
if (ff_mkdir_p(dir) == -1 && errno != EEXIST) {
ret = AVERROR(errno);
* agroup: is key to specify audio group. A string can be given as value.
*/
p = av_strdup(hls->var_stream_map);
+ if (!p)
+ return AVERROR(ENOMEM);
+
q = p;
- while(av_strtok(q, " \t", &saveptr1)) {
+ while (av_strtok(q, " \t", &saveptr1)) {
q = NULL;
hls->nb_varstreams++;
}
atoi(val));
if (stream_index >= 0 && nb_streams < vs->nb_streams) {
- for(i = 0; nb_streams > 0 && i < nb_streams; i++) {
+ for (i = 0; nb_streams > 0 && i < nb_streams; i++) {
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);
}
}
- for(j = 0; nb_varstreams > 1 && j < nb_varstreams - 1; j++) {
- for(i = 0; i < hls->var_streams[j].nb_streams; i++) {
+ for (j = 0; nb_varstreams > 1 && j < nb_varstreams - 1; j++) {
+ for (i = 0; i < hls->var_streams[j].nb_streams; i++) {
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",
ClosedCaptionsStream *ccs;
p = av_strdup(hls->cc_stream_map);
+ if(!p)
+ return AVERROR(ENOMEM);
+
q = p;
- while(av_strtok(q, " \t", &saveptr1)) {
+ while (av_strtok(q, " \t", &saveptr1)) {
q = NULL;
hls->nb_ccstreams++;
}
}
if (av_strstart(ccs->instreamid, "CC", &val)) {
- if(atoi(val) < 1 || atoi(val) > 4) {
+ if (atoi(val) < 1 || atoi(val) > 4) {
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)) {
- if(atoi(val) < 1 || atoi(val) > 63) {
+ if (atoi(val) < 1 || atoi(val) > 63) {
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);
return 0;
}
-static int update_variant_stream_info(AVFormatContext *s) {
+static int update_variant_stream_info(AVFormatContext *s)
+{
HLSContext *hls = s->priv_data;
unsigned int i;
int ret = 0;
hls->var_streams[0].streams = av_mallocz(sizeof(AVStream *) *
hls->var_streams[0].nb_streams);
if (!hls->var_streams[0].streams) {
- av_free(hls->var_streams);
+ av_freep(&hls->var_streams);
return AVERROR(ENOMEM);
}
if (hls->nb_ccstreams) {
hls->var_streams[0].ccgroup = av_strdup(hls->cc_streams[0].ccgroup);
if (!hls->var_streams[0].ccgroup) {
- av_free(hls->var_streams);
+ av_freep(&hls->var_streams);
return AVERROR(ENOMEM);
}
}
return 0;
}
-static int update_master_pl_info(AVFormatContext *s) {
+static int update_master_pl_info(AVFormatContext *s)
+{
HLSContext *hls = s->priv_data;
const char *dir;
char *fn1= NULL, *fn2 = NULL;
int ret = 0;
fn1 = av_strdup(s->url);
- if (!fn1) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
-
dir = av_dirname(fn1);
/**
*/
if (dir && av_stristr(av_basename(dir), "%v")) {
fn2 = av_strdup(dir);
- if (!fn2) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
dir = av_dirname(fn2);
}
vs = &hls->var_streams[i];
for (j = 0; j < vs->nb_streams; j++) {
if (vs->streams[j] == st) {
- if( st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
+ if ( st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
oc = vs->vtt_avf;
stream_index = 0;
} else {
if (!vs->init_range_length) {
range_length = avio_close_dyn_buf(oc->pb, &buffer);
avio_write(vs->out, buffer, range_length);
- av_free(buffer);
+ av_freep(&buffer);
vs->init_range_length = range_length;
avio_open_dyn_buf(&oc->pb);
vs->packets_written = 0;
if (hls->flags & HLS_SINGLE_FILE) {
ret = flush_dynbuf(vs, &range_length);
+ av_freep(&vs->temp_buffer);
if (ret < 0) {
return ret;
}
if (ret < 0) {
return ret;
}
- hlsenc_io_close(s, &vs->out, filename);
- av_free(filename);
+ 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);
+ }
+ av_freep(&vs->temp_buffer);
+ av_freep(&filename);
}
}
vs->end_pts = pkt->pts;
vs->duration = 0;
if (ret < 0) {
- av_free(old_filename);
+ av_freep(&old_filename);
return ret;
}
}
// 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) {
- av_free(old_filename);
- return ret;
+ av_log(s, AV_LOG_WARNING, "upload playlist failed, will retry with a new http session.\n");
+ ff_format_io_close(s, &vs->out);
+ vs->out = NULL;
+ if ((ret = hls_window(s, 0, vs)) < 0) {
+ av_freep(&old_filename);
+ return ret;
+ }
}
}
sls_flag_file_rename(hls, vs, old_filename);
ret = hls_start(s, vs);
}
- av_free(old_filename);
+ av_freep(&old_filename);
if (ret < 0) {
return ret;
vs = &hls->var_streams[i];
oc = vs->avf;
vtt_oc = vs->vtt_avf;
- old_filename = av_strdup(vs->avf->url);
+ old_filename = av_strdup(oc->url);
use_temp_file = 0;
if (!old_filename) {
if (hls->key_info_file || hls->encrypt) {
av_dict_set(&options, "encryption_key", hls->key_string, 0);
av_dict_set(&options, "encryption_iv", hls->iv_string, 0);
- filename = av_asprintf("crypto:%s", vs->avf->url);
+ filename = av_asprintf("crypto:%s", oc->url);
} else {
- filename = av_asprintf("%s", vs->avf->url);
+ filename = av_asprintf("%s", oc->url);
}
if (!filename) {
- av_free(old_filename);
+ av_freep(&old_filename);
return AVERROR(ENOMEM);
}
int range_length = 0;
if (!vs->init_range_length) {
uint8_t *buffer = NULL;
- av_write_frame(vs->avf, NULL); /* Flush any buffered data */
+ av_write_frame(oc, 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);
+ av_freep(&buffer);
vs->init_range_length = range_length;
avio_open_dyn_buf(&oc->pb);
vs->packets_written = 0;
set_http_options(s, &options, hls);
ret = hlsenc_io_open(s, &vs->out, filename, &options);
if (ret < 0) {
- av_log(s, AV_LOG_ERROR, "Failed to open file '%s'\n", vs->avf->url);
+ av_log(s, AV_LOG_ERROR, "Failed to open file '%s'\n", oc->url);
goto failed;
}
if (hls->segment_type == SEGMENT_TYPE_FMP4)
vs->size = range_length;
hlsenc_io_close(s, &vs->out, filename);
- av_free(filename);
+ 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) {
+ av_log(s, AV_LOG_ERROR, "Failed to open file '%s'\n", oc->url);
+ goto failed;
+ }
+ reflush_dynbuf(vs, &range_length);
+ ret = hlsenc_io_close(s, &vs->out, filename);
+ if (ret < 0)
+ av_log(s, AV_LOG_WARNING, "Failed to upload file '%s' at the end.\n", oc->url);
+ }
+ av_freep(&vs->temp_buffer);
failed:
+ av_freep(&filename);
av_write_trailer(oc);
if (oc->url[0]) {
proto = avio_find_protocol_name(oc->url);
// rename that segment from .tmp to the real one
if (use_temp_file && !(hls->flags & HLS_SINGLE_FILE)) {
hls_rename_temp_file(s, oc);
- av_free(old_filename);
- old_filename = av_strdup(vs->avf->url);
+ av_freep(&old_filename);
+ old_filename = av_strdup(oc->url);
if (!old_filename) {
return AVERROR(ENOMEM);
ff_format_io_close(s, &vtt_oc->pb);
avformat_free_context(vtt_oc);
}
- hls_window(s, 1, vs);
+ 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);
+ }
+ ffio_free_dyn_buf(&oc->pb);
avformat_free_context(oc);
vs->avf = NULL;
const char *vtt_pattern = "%d.vtt";
char *p = NULL;
int vtt_basename_size = 0;
+ int http_base_proto = ff_is_http_proto(s->url);
int fmp4_init_filename_len = strlen(hls->fmp4_init_filename) + 1;
hls->has_default_key = 0;
goto fail;
}
+ if (!hls->method && http_base_proto) {
+ av_log(hls, AV_LOG_WARNING, "No HTTP method set, hls muxer defaulting to method PUT.\n");
+ }
+
ret = validate_name(hls->nb_varstreams, s->url);
if (ret < 0)
goto fail;
ret = format_name(hls->segment_filename, &vs->basename, i, vs->varname);
if (ret < 0)
goto fail;
- basename_size = strlen(vs->basename) + 1;
} else {
if (hls->flags & HLS_SINGLE_FILE) {
if (hls->segment_type == SEGMENT_TYPE_FMP4) {
projects / ffmpeg / blobdiff