} CodecAttributeStatus;
#define KEYSIZE 16
-#define LINE_BUFFER_SIZE 1024
+#define LINE_BUFFER_SIZE MAX_URL_SIZE
#define HLS_MICROSECOND_UNIT 1000000
#define POSTFIX_PATTERN "_%d"
typedef struct HLSSegment {
- char filename[1024];
- char sub_filename[1024];
+ char filename[MAX_URL_SIZE];
+ char sub_filename[MAX_URL_SIZE];
double duration; /* in seconds */
int discont;
int64_t pos;
char *m3u8_name;
double initial_prog_date_time;
- char current_segment_final_filename_fmt[1024]; // when renaming segments
+ char current_segment_final_filename_fmt[MAX_URL_SIZE]; // when renaming segments
char *fmp4_init_filename;
char *base_output_dirname;
vs->new_start = 1;
if (hls->segment_type == SEGMENT_TYPE_FMP4) {
+ 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");
+ }
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;
AVIOContext *in;
int ret = 0, is_segment = 0;
int64_t new_start_pos;
- char line[1024];
+ char line[MAX_URL_SIZE];
const char *ptr;
const char *end;
AVDictionary *options = NULL;
unsigned int i, j;
int m3u8_name_size, ret, bandwidth;
- char *m3u8_rel_name, *ccgroup;
+ char *m3u8_rel_name = NULL, *ccgroup;
ClosedCaptionsStream *ccs;
+ 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);
+ char temp_filename[MAX_URL_SIZE];
input_vs->m3u8_created = 1;
if (!hls->master_m3u8_created) {
}
set_http_options(s, &options, hls);
-
- ret = hlsenc_io_open(s, &hls->m3u8_out, hls->master_m3u8_url, &options);
+ 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);
av_dict_free(&options);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to open master play list file '%s'\n",
- hls->master_m3u8_url);
+ temp_filename);
goto fail;
}
if(ret >=0)
hls->master_m3u8_created = 1;
av_freep(&m3u8_rel_name);
- hlsenc_io_close(s, &hls->m3u8_out, hls->master_m3u8_url);
+ hlsenc_io_close(s, &hls->m3u8_out, temp_filename);
+ if (use_temp_file)
+ ff_rename(temp_filename, hls->master_m3u8_url, s);
+
return ret;
}
{
HLSContext *hls = s->priv_data;
HLSSegment *en;
+ AVFormatContext *oc = vs->avf;
int target_duration = 0;
int ret = 0;
- char temp_filename[1024];
+ char temp_filename[MAX_URL_SIZE];
+ char temp_vtt_filename[MAX_URL_SIZE];
int64_t sequence = FFMAX(hls->start_sequence, vs->sequence - vs->nb_entries);
const char *proto = avio_find_protocol_name(vs->m3u8_name);
int is_file_proto = proto && !strcmp(proto, "file");
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, &hls->m3u8_out, temp_filename, &options)) < 0) {
+ if ((ret = hlsenc_io_open(s, (byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? &hls->m3u8_out : &oc->pb, temp_filename, &options)) < 0) {
if (hls->ignore_io_errors)
ret = 0;
goto fail;
}
vs->discontinuity_set = 0;
- ff_hls_write_playlist_header(hls->m3u8_out, hls->version, hls->allowcache,
+ ff_hls_write_playlist_header((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : oc->pb, 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(hls->m3u8_out, "#EXT-X-DISCONTINUITY\n");
+ avio_printf((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : oc->pb, "#EXT-X-DISCONTINUITY\n");
vs->discontinuity_set = 1;
}
if (vs->has_video && (hls->flags & HLS_INDEPENDENT_SEGMENTS)) {
- avio_printf(hls->m3u8_out, "#EXT-X-INDEPENDENT-SEGMENTS\n");
+ avio_printf((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : oc->pb, "#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(hls->m3u8_out, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
+ avio_printf((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : oc->pb, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
if (*en->iv_string)
- avio_printf(hls->m3u8_out, ",IV=0x%s", en->iv_string);
- avio_printf(hls->m3u8_out, "\n");
+ avio_printf((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : oc->pb, ",IV=0x%s", en->iv_string);
+ avio_printf((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : oc->pb, "\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(hls->m3u8_out, (hls->flags & HLS_SINGLE_FILE) ? en->filename : vs->fmp4_init_filename,
+ ff_hls_write_init_file((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : oc->pb, (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(hls->m3u8_out, en->discont, byterange_mode,
+ ret = ff_hls_write_file_entry((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : oc->pb, 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(hls->m3u8_out);
+ ff_hls_write_end_list((byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? hls->m3u8_out : oc->pb);
- if( vs->vtt_m3u8_name ) {
- if ((ret = hlsenc_io_open(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name, &options)) < 0) {
+ 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) {
if (hls->ignore_io_errors)
ret = 0;
goto fail;
fail:
av_dict_free(&options);
- hlsenc_io_close(s, &hls->m3u8_out, temp_filename);
+ hlsenc_io_close(s, (byterange_mode || hls->segment_type == SEGMENT_TYPE_FMP4) ? &hls->m3u8_out : &oc->pb, temp_filename);
hlsenc_io_close(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name);
- if (use_temp_file)
+ if (use_temp_file) {
ff_rename(temp_filename, vs->m3u8_name, s);
+ if (vs->vtt_m3u8_name)
+ ff_rename(temp_vtt_filename, vs->vtt_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");
if (c->use_localtime) {
time_t now0;
struct tm *tm, tmpbuf;
- int bufsize = strlen(vs->basename) + 1024;
+ int bufsize = strlen(vs->basename) + MAX_URL_SIZE;
char *buf = av_mallocz(bufsize);
if (!buf)
return AVERROR(ENOMEM);
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 - hls->start_sequence - vs->nb_entries ) * (hls->time * AV_TIME_BASE);
+ int64_t init_list_dur = hls->init_time * vs->nb_entries * AV_TIME_BASE;
+ int64_t 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 ;
}
} else {
vs->start_pos += vs->size;
}
+ // 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;
+ }
+ }
if (hls->flags & HLS_SINGLE_FILE) {
vs->number++;
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) {
- return ret;
- }
- }
}
vs->packets_written++;
if (oc->pb) {
if (hls->segment_type != SEGMENT_TYPE_FMP4) {
vs->size = avio_tell(vs->avf->pb) - vs->start_pos;
- ff_format_io_close(s, &oc->pb);
+ hlsenc_io_close(s, &vs->avf->pb, vs->avf->url);
}
// rename that segment from .tmp to the real one
ff_format_io_close(s, &vtt_oc->pb);
avformat_free_context(vtt_oc);
}
+ hls_window(s, 1, vs);
avformat_free_context(oc);
vs->avf = NULL;
- hls_window(s, 1, vs);
av_free(old_filename);
}
{"hls_fmp4_init_filename", "set fragment mp4 file init filename", OFFSET(fmp4_init_filename), AV_OPT_TYPE_STRING, {.str = "init.mp4"}, 0, 0, E},
{"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"},
- {"temp_file", "write segment to temporary file and rename when complete", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_TEMP_FILE }, 0, UINT_MAX, E, "flags"},
+ {"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"},
{"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"},
{"round_durations", "round durations in m3u8 to whole numbers", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_ROUND_DURATIONS }, 0, UINT_MAX, E, "flags"},
{"discont_start", "start the playlist with a discontinuity tag", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DISCONT_START }, 0, UINT_MAX, E, "flags"},
projects / ffmpeg / blobdiff