in src/media_tools/dash_client.c [1555:1980]
static GF_Err gf_dash_update_manifest(GF_DashClient *dash)
{
GF_Err e;
Bool force_timeline_setup;
u32 group_idx, rep_idx, i, j;
u64 fetch_time=0;
GF_DOMParser *mpd_parser;
u8 signature[GF_SHA1_DIGEST_SIZE];
GF_MPD_Period *period, *new_period;
const char *local_url;
char mime[128];
char * purl;
Double timeline_start_time;
GF_MPD *new_mpd;
Bool fetch_only = GF_FALSE;
if (!dash->mpd_dnload) {
local_url = purl = NULL;
if (!gf_list_count(dash->mpd->locations)) {
FILE *t = gf_fopen(dash->base_url, "rt");
if (t) {
local_url = dash->base_url;
gf_fclose(t);
}
if (!local_url) {
/*we will no longer attempt to update the MPD ...*/
dash->mpd->minimum_update_period = 0;
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: no HTTP source for MPD could be found\n"));
return GF_BAD_PARAM;
}
}
if (!local_url) {
purl = gf_strdup(gf_list_get(dash->mpd->locations, 0));
/*if no absolute URL, use <Location> to get MPD in case baseURL is relative...*/
if (!strstr(dash->base_url, "://")) {
gf_free(dash->base_url);
dash->base_url = gf_strdup(purl);
}
fetch_only = 1;
}
} else {
local_url = dash->dash_io->get_cache_name(dash->dash_io, dash->mpd_dnload);
if (local_url) {
gf_delete_file(local_url);
}
//use the redirected url
purl = gf_strdup( dash->dash_io->get_url(dash->dash_io, dash->mpd_dnload) );
}
/*if update location is specified, update - spec does not say whether location is a relative or absoute URL*/
if (gf_list_count(dash->mpd->locations)) {
char *update_loc = gf_list_get(dash->mpd->locations, 0);
char *update_url = gf_url_concatenate(purl, update_loc);
if (update_url) {
gf_free(purl);
purl = update_url;
}
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DASH] Updating Playlist %s...\n", purl ? purl : local_url));
if (purl) {
const char *mime_type;
/*use non-persistent connection for MPD*/
e = gf_dash_download_resource(dash, &(dash->mpd_dnload), purl, 0, 0, 0, NULL);
if (e!=GF_OK) {
if (!dash->in_error) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: download problem %s for MPD file\n", gf_error_to_string(e)));
dash->in_error = GF_TRUE;
}
gf_free(purl);
//try to refetch MPD every second
dash->last_update_time+=1000;
return e;
} else {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DASH] Playlist %s updated with success\n", purl));
}
mime_type = dash->dash_io->get_mime(dash->dash_io, dash->mpd_dnload) ;
strcpy(mime, mime_type ? mime_type : "");
strlwr(mime);
/*in case the session has been restarted, local_url may have been destroyed - get it back*/
local_url = dash->dash_io->get_cache_name(dash->dash_io, dash->mpd_dnload);
/* Some servers, for instance http://tv.freebox.fr, serve m3u8 as text/plain */
if (gf_dash_is_m3u8_mime(purl, mime) || strstr(purl, ".m3u8")) {
gf_m3u8_to_mpd(local_url, purl, NULL, dash->reload_count, dash->mimeTypeForM3U8Segments, 0, M3U8_TO_MPD_USE_TEMPLATE, &dash->getter);
} else if (!gf_dash_is_dash_mime(mime)) {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[DASH] mime '%s' should be m3u8 or mpd\n", mime));
}
gf_free(purl);
purl = (char *) dash->dash_io->get_url(dash->dash_io, dash->mpd_dnload) ;
/*if relocated, reassign MPD base URL*/
if (strcmp(purl, dash->base_url)) {
gf_free(dash->base_url);
dash->base_url = gf_strdup(purl);
}
purl = NULL;
}
fetch_time = dash_get_fetch_time(dash);
if (!gf_dash_check_mpd_root_type(local_url)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: MPD file type is not correct %s\n", local_url));
return GF_NON_COMPLIANT_BITSTREAM;
}
if (gf_sha1_file( local_url, signature)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] : cannot SHA1 file %s\n", local_url));
return GF_IO_ERR;
}
if (!dash->in_error && ! memcmp( signature, dash->lastMPDSignature, GF_SHA1_DIGEST_SIZE)) {
dash->reload_count++;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DASH] MPD file did not change for %d consecutive reloads\n", dash->reload_count));
/*if the MPD did not change, we should refresh "soon" but cannot wait a full refresh cycle in case of
low latencies as we could miss a segment*/
if (dash->is_m3u8) {
dash->last_update_time += dash->mpd->minimum_update_period/2;
} else {
dash->last_update_time = gf_sys_clock();
}
dash->mpd_fetch_time = fetch_time;
return GF_OK;
}
force_timeline_setup = dash->in_error;
dash->in_error = GF_FALSE;
dash->reload_count = 0;
memcpy(dash->lastMPDSignature, signature, GF_SHA1_DIGEST_SIZE);
/* It means we have to reparse the file ... */
/* parse the MPD */
mpd_parser = gf_xml_dom_new();
e = gf_xml_dom_parse(mpd_parser, local_url, NULL, NULL);
if (e != GF_OK) {
gf_xml_dom_del(mpd_parser);
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: error in XML parsing %s\n", gf_error_to_string(e)));
return GF_NON_COMPLIANT_BITSTREAM;
}
new_mpd = gf_mpd_new();
e = gf_mpd_init_from_dom(gf_xml_dom_get_root(mpd_parser), new_mpd, purl);
gf_xml_dom_del(mpd_parser);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: error in MPD creation %s\n", gf_error_to_string(e)));
gf_mpd_del(new_mpd);
return GF_NON_COMPLIANT_BITSTREAM;
}
/*TODO - check periods are the same !!*/
period = gf_list_get(dash->mpd->periods, dash->active_period_index);
if (fetch_only && !period) goto exit;
new_period = gf_list_get(new_mpd->periods, dash->active_period_index);
if (!new_period) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: missing period\n"));
gf_mpd_del(new_mpd);
return GF_NON_COMPLIANT_BITSTREAM;
}
if (gf_list_count(period->adaptation_sets) != gf_list_count(new_period->adaptation_sets)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: missing AdaptationSet\n"));
gf_mpd_del(new_mpd);
return GF_NON_COMPLIANT_BITSTREAM;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DASH] Updating playlist at UTC time "LLU" - availabilityStartTime "LLU"\n", fetch_time, new_mpd->availabilityStartTime));
timeline_start_time = 0;
/*if not infinity for timeShift, compute min media time before merge and adjust it*/
if (dash->mpd->time_shift_buffer_depth != (u32) -1) {
Double timeshift = dash->mpd->time_shift_buffer_depth;
timeshift /= 1000;
for (group_idx=0; group_idx<gf_list_count(dash->groups); group_idx++) {
GF_DASH_Group *group = gf_list_get(dash->groups, group_idx);
if (group->selection!=GF_DASH_GROUP_NOT_SELECTABLE) {
Double group_start = gf_dash_get_segment_start_time(group, NULL);
if (!group_idx || (timeline_start_time > group_start) ) timeline_start_time = group_start;
}
}
/*we can rewind our segments from timeshift*/
if (timeline_start_time > timeshift) timeline_start_time -= timeshift;
/*we can rewind all segments*/
else timeline_start_time = 0;
}
/*update segmentTimeline at Period level*/
e = gf_dash_merge_segment_timeline(NULL, dash, period->segment_list, period->segment_template, new_period->segment_list, new_period->segment_template, timeline_start_time);
if (e) {
gf_mpd_del(new_mpd);
return e;
}
for (group_idx=0; group_idx<gf_list_count(dash->groups); group_idx++) {
Double seg_dur;
Bool reset_segment_count;
GF_MPD_AdaptationSet *set, *new_set;
GF_DASH_Group *group = gf_list_get(dash->groups, group_idx);
/*update info even if the group is not selected !*/
if (group->selection==GF_DASH_GROUP_NOT_SELECTABLE)
continue;
set = group->adaptation_set;
new_set = gf_list_get(new_period->adaptation_sets, group_idx);
if (gf_list_count(new_set->representations) != gf_list_count(group->adaptation_set->representations)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: missing representation in adaptation set\n"));
gf_mpd_del(new_mpd);
return GF_NON_COMPLIANT_BITSTREAM;
}
/*get all representations in both periods*/
for (rep_idx = 0; rep_idx <gf_list_count(group->adaptation_set->representations); rep_idx++) {
GF_List *segments, *new_segments;
GF_MPD_Representation *rep = gf_list_get(group->adaptation_set->representations, rep_idx);
GF_MPD_Representation *new_rep = gf_list_get(new_set->representations, rep_idx);
if (rep->segment_base || group->adaptation_set->segment_base || period->segment_base) {
if (!new_rep->segment_base && !new_set->segment_base && !new_period->segment_base) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: representation does not use segment base as previous version\n"));
gf_mpd_del(new_mpd);
return GF_NON_COMPLIANT_BITSTREAM;
}
/*what else should we check ??*/
/*OK, this rep is fine*/
}
else if (rep->segment_template || group->adaptation_set->segment_template || period->segment_template) {
if (!new_rep->segment_template && !new_set->segment_template && !new_period->segment_template) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: representation does not use segment template as previous version\n"));
gf_mpd_del(new_mpd);
return GF_NON_COMPLIANT_BITSTREAM;
}
//if no segment timeline, adjust current idx of the group if start number changes (not needed if SegmentTimeline, otherwise, we will look for the index with the same starttime in the timeline)
if ((period->segment_template && period->segment_template->segment_timeline)
|| (set->segment_template && set->segment_template->segment_timeline)
|| (rep->segment_template && rep->segment_template->segment_timeline)
) {
} else {
s32 sn_diff = 0;
if (period->segment_template && (period->segment_template->start_number != (u32) -1) ) sn_diff = period->segment_template->start_number;
else if (set->segment_template && (set->segment_template->start_number != (u32) -1) ) sn_diff = set->segment_template->start_number;
else if (rep->segment_template && (rep->segment_template->start_number != (u32) -1) ) sn_diff = rep->segment_template->start_number;
if (new_period->segment_template && (new_period->segment_template->start_number != (u32) -1) ) sn_diff -= (s32) new_period->segment_template->start_number;
else if (new_set->segment_template && (new_set->segment_template->start_number != (u32) -1) ) sn_diff -= (s32) new_set->segment_template->start_number;
else if (new_rep->segment_template && (new_rep->segment_template->start_number != (u32) -1) ) sn_diff -= (s32) new_rep->segment_template->start_number;
if (sn_diff != 0) {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[DASH] startNumber change for SegmentTemplate without SegmentTimeline - adjusting current segment index by %d\n", sn_diff));
group->download_segment_index += sn_diff;
}
}
/*OK, this rep is fine*/
}
else {
/*we're using segment list*/
assert(rep->segment_list || group->adaptation_set->segment_list || period->segment_list);
if (!new_rep->segment_list && !new_set->segment_list && !new_period->segment_list) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[DASH] Error - cannot update playlist: representation does not use segment list as previous version\n"));
gf_mpd_del(new_mpd);
return GF_NON_COMPLIANT_BITSTREAM;
}
/*get the segment list*/
segments = new_segments = NULL;
if (period->segment_list && period->segment_list->segment_URLs) segments = period->segment_list->segment_URLs;
if (set->segment_list && set->segment_list->segment_URLs) segments = set->segment_list->segment_URLs;
if (rep->segment_list && rep->segment_list->segment_URLs) segments = rep->segment_list->segment_URLs;
if (new_period->segment_list && new_period->segment_list->segment_URLs) new_segments = new_period->segment_list->segment_URLs;
if (new_set->segment_list && new_set->segment_list->segment_URLs) new_segments = new_set->segment_list->segment_URLs;
if (new_rep->segment_list && new_rep->segment_list->segment_URLs) new_segments = new_rep->segment_list->segment_URLs;
for (i=0; i<gf_list_count(new_segments); i++) {
GF_MPD_SegmentURL *new_seg = gf_list_get(new_segments, i);
Bool found = GF_FALSE;
for (j=0; j<gf_list_count(segments); j++) {
GF_MPD_SegmentURL *seg = gf_list_get(segments, j);
if (seg->media && new_seg->media && !strcmp(seg->media, new_seg->media)) {
found=1;
break;
}
if (seg->media_range && new_seg->media_range && (seg->media_range->start_range==new_seg->media_range->start_range) && (seg->media_range->end_range==new_seg->media_range->end_range) ) {
found=1;
break;
}
}
/*this is a new segment, merge it: we remove from new list and push to old one, before doing a final swap
this ensures that indexing in the segment_list is still correct after merging*/
if (!found) {
gf_list_rem(new_segments, i);
i--;
gf_list_add(segments, new_seg);
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DASH] Representation #%d: Adding new segment %s\n", rep_idx+1, new_seg->media));
}
}
/*what else should we check ?*/
/*swap segment list content*/
gf_list_swap(new_segments, segments);
/*current representation is the active one in the group - update the number of segments*/
if (group->active_rep_index==rep_idx) {
group->nb_segments_in_rep = gf_list_count(new_segments);
}
}
e = gf_dash_merge_segment_timeline(group, NULL, rep->segment_list, rep->segment_template, new_rep->segment_list, new_rep->segment_template, timeline_start_time);
if (e) {
gf_mpd_del(new_mpd);
return e;
}
/*what else should we check ??*/
/*switch all intertnal GPAC stuff*/
memcpy(&new_rep->playback, &rep->playback, sizeof(GF_DASH_RepresentationPlayback));
if (rep->playback.cached_init_segment_url) rep->playback.cached_init_segment_url = NULL;
if (!new_rep->mime_type) {
new_rep->mime_type = rep->mime_type;
rep->mime_type = NULL;
}
}
/*update segmentTimeline at AdaptationSet level before switching the set (old setup needed to compute current timing of each group) */
e = gf_dash_merge_segment_timeline(group, NULL, set->segment_list, set->segment_template, new_set->segment_list, new_set->segment_template, timeline_start_time);
if (e) {
gf_mpd_del(new_mpd);
return e;
}
/*update group/period to new period*/
j = gf_list_find(group->period->adaptation_sets, group->adaptation_set);
group->adaptation_set = gf_list_get(new_period->adaptation_sets, j);
group->period = new_period;
j = gf_list_count(group->adaptation_set->representations);
assert(j);
/*now that all possible SegmentXXX have been updated, purge them if needed: all segments ending before timeline_start_time
will be removed from MPD*/
if (timeline_start_time) {
u32 nb_segments_removed = gf_dash_purge_segment_timeline(group, timeline_start_time);
if (nb_segments_removed) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DASH] AdaptationSet %d - removed %d segments from timeline (%d since start of the period)\n", group_idx+1, nb_segments_removed, group->nb_segments_purged));
}
}
if (force_timeline_setup) {
group->timeline_setup = 0;
group->start_number_at_last_ast = 0;
gf_dash_group_timeline_setup(new_mpd, group, fetch_time);
}
else if (new_mpd->availabilityStartTime != dash->mpd->availabilityStartTime) {
s64 diff = new_mpd->availabilityStartTime;
diff -= dash->mpd->availabilityStartTime;
if (diff < 0) diff = -diff;
if (diff>3000)
gf_dash_group_timeline_setup(new_mpd, group, fetch_time);
}
group->maybe_end_of_stream = 0;
reset_segment_count = 0;
/*compute fetchTime + minUpdatePeriod and check period end time*/
if (new_mpd->minimum_update_period && new_mpd->media_presentation_duration) {
u32 endTime = (u32) (fetch_time - new_mpd->availabilityStartTime - period->start);
if (endTime > new_mpd->media_presentation_duration) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DASH] Period EndTime is signaled to %d, less than fetch time %d ! Ignoring mediaPresentationDuration\n", new_mpd->media_presentation_duration, endTime));
new_mpd->media_presentation_duration = 0;
reset_segment_count = 1;
} else {
endTime += new_mpd->minimum_update_period;
if (endTime > new_mpd->media_presentation_duration) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DASH] Period EndTime is signaled to %d, less than fetch time + next update - maybe end of stream ?\n", new_mpd->availabilityStartTime, endTime));
group->maybe_end_of_stream = 1;
}
}
}
/*update number of segments in active rep*/
gf_dash_get_segment_duration(gf_list_get(group->adaptation_set->representations, group->active_rep_index), group->adaptation_set, group->period, new_mpd, &group->nb_segments_in_rep, &seg_dur);
if (reset_segment_count) {
u32 nb_segs_in_mpd_period = (u32) (dash->mpd->minimum_update_period / (1000*seg_dur) );
group->nb_segments_in_rep = group->download_segment_index + nb_segs_in_mpd_period;
}
/*check if number of segments are coherent ...*/
else if (!group->maybe_end_of_stream && new_mpd->minimum_update_period && new_mpd->media_presentation_duration) {
u32 nb_segs_in_mpd_period = (u32) (dash->mpd->minimum_update_period / (1000*seg_dur) );
if (group->download_segment_index + nb_segs_in_mpd_period >= group->nb_segments_in_rep) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DASH] Period has %d segments but %d are needed until next refresh. Maybe end of stream is near ?\n", group->nb_segments_in_rep, group->download_segment_index + nb_segs_in_mpd_period));
group->maybe_end_of_stream = 1;
}
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DASH] Updated AdaptationSet %d - %d segments\n", group_idx+1, group->nb_segments_in_rep));
}
exit:
/*swap representations - we don't need to update download_segment_index as it still points to the right entry in the merged list*/
if (dash->mpd)
gf_mpd_del(dash->mpd);
dash->mpd = new_mpd;
dash->last_update_time = gf_sys_clock();
dash->mpd_fetch_time = fetch_time;
return GF_OK;
}