Bool MPD_CanHandleURLInService(GF_InputService *plug, const char *url)
{
/**
* May arrive when using pid:// URLs into a TS stream
*/
GF_MPD_In *mpdin = (GF_MPD_In*) plug->priv;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Received Can Handle URL In Service (%p) request from terminal for %s\n", mpdin->service, url));
if (!plug || !plug->priv) return GF_SERVICE_ERROR;
if (gf_dash_get_url(mpdin->dash) && !strcmp(gf_dash_get_url(mpdin->dash) , url)) {
return 1;
} else {
GF_MPDGroup *mudta;
GF_InputService *segment_ifce = NULL;
u32 i;
for (i=0;i<gf_dash_get_group_count(mpdin->dash); i++) {
if (!gf_dash_is_group_selected(mpdin->dash, i)) continue;
mudta = gf_dash_get_group_udta(mpdin->dash, i);
segment_ifce = mudta->segment_ifce;
if (mudta && mudta->segment_ifce && mudta->segment_ifce->CanHandleURLInService) {
return mudta->segment_ifce->CanHandleURLInService(plug, url);
}
}
return 0;
}
}
GF_Err mpdin_dash_io_setup_from_url(GF_DASHFileIO *dashio, GF_DASHFileIOSession session, const char *url, s32 group_idx)
{
if (group_idx>=0) {
GF_MPD_In *mpdin = (GF_MPD_In *)dashio->udta;
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, group_idx);
if (group && !group->netio_assigned) {
group->netio_assigned = GF_TRUE;
group->sess = (GF_DownloadSession *)session;
gf_dm_sess_reassign((GF_DownloadSession *)session, 0xFFFFFFFF, mpdin_dash_segment_netio, group);
}
}
return gf_dm_sess_setup_from_url((GF_DownloadSession *)session, url);
}
s32 MPD_GetGroupIndexForChannel(GF_MPD_In *mpdin, LPNETCHANNEL channel)
{
u32 i;
GF_InputService *ifce = MPD_GetInputServiceForChannel(mpdin, channel);
if (!ifce) return -1;
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, i);
if (!group) continue;
if (group->segment_ifce == ifce) return i;
}
return -1;
}
static s32 gf_dash_get_group_idx_from_service(GF_MPD_In *mpdin, GF_InputService *ifce)
{
s32 i;
for (i=0; (u32) i < gf_dash_get_group_count(mpdin->dash); i++) {
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, i);
if (!group) continue;
if (group->segment_ifce == ifce) {
return i;
}
}
return -1;
}
GF_InputService *MPD_GetInputServiceForChannel(GF_MPD_In *mpdin, LPNETCHANNEL channel)
{
GF_Channel *ch;
if (!channel) {
if (gf_dash_is_group_selected(mpdin->dash, 0)) {
GF_MPDGroup *mudta = gf_dash_get_group_udta(mpdin->dash, 0);
return mudta ? mudta->segment_ifce : NULL;
}
return NULL;
}
ch = (GF_Channel *) channel;
assert(ch->odm && ch->odm->OD);
return (GF_InputService *) ch->odm->OD->service_ifce;
}
GF_InputService *MPD_GetInputServiceForChannel(GF_MPD_In *mpdin, LPNETCHANNEL channel)
{
GF_Channel *ch;
if (!channel) {
u32 i;
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
if (gf_dash_is_group_selectable(mpdin->dash, i)) {
GF_MPDGroup *mudta = gf_dash_get_group_udta(mpdin->dash, i);
if (mudta && mudta->segment_ifce) return mudta->segment_ifce;
}
}
return NULL;
}
ch = (GF_Channel *) channel;
assert(ch->odm && ch->odm->OD);
return (GF_InputService *) ch->odm->OD->service_ifce;
}
static GF_Descriptor *MPD_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
u32 i;
GF_MPD_In *mpdin = (GF_MPD_In*) plug->priv;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Received Service Description request from terminal for %s\n", sub_url));
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
GF_Descriptor *desc;
GF_MPDGroup *mudta;
if (!gf_dash_is_group_selected(mpdin->dash, i))
continue;
mudta = gf_dash_get_group_udta(mpdin->dash, i);
if (!mudta) continue;
if (mudta->service_descriptor_fetched) continue;
desc = mudta->segment_ifce->GetServiceDescriptor(mudta->segment_ifce, expect_type, sub_url);
if (desc) mudta->service_descriptor_fetched = 1;
return desc;
}
return NULL;
}
GF_DASHFileIOSession mpdin_dash_io_create(GF_DASHFileIO *dashio, Bool persistent, const char *url, s32 group_idx)
{
GF_MPDGroup *group = NULL;
GF_DownloadSession *sess;
u32 flags = GF_NETIO_SESSION_NOT_THREADED;
GF_MPD_In *mpdin = (GF_MPD_In *)dashio->udta;
if (mpdin->memory_storage)
flags |= GF_NETIO_SESSION_MEMORY_CACHE;
if (persistent) flags |= GF_NETIO_SESSION_PERSISTENT;
if (group_idx>=0) {
group = gf_dash_get_group_udta(mpdin->dash, group_idx);
}
if (group) {
group->netio_assigned = GF_TRUE;
group->sess = sess = gf_service_download_new(mpdin->service, url, flags, mpdin_dash_segment_netio, group);
} else {
sess = gf_service_download_new(mpdin->service, url, flags, NULL, NULL);
}
return (GF_DASHFileIOSession ) sess;
}
static GF_Err MPD_ClientQuery(GF_InputService *ifce, GF_NetworkCommand *param)
{
u32 i;
GF_MPD_In *mpdin = (GF_MPD_In *) ifce->proxy_udta;
if (!param || !ifce || !ifce->proxy_udta) return GF_BAD_PARAM;
/*gets byte range of init segment (for local validation)*/
if (param->command_type==GF_NET_SERVICE_QUERY_INIT_RANGE) {
param->url_query.next_url = NULL;
param->url_query.start_range = 0;
param->url_query.end_range = 0;
mpdin->in_seek = 0;
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
GF_MPDGroup *group;
if (!gf_dash_is_group_selected(mpdin->dash, i)) continue;
group = gf_dash_get_group_udta(mpdin->dash, i);
if (group->segment_ifce == ifce) {
gf_dash_group_get_segment_init_url(mpdin->dash, i, ¶m->url_query.start_range, ¶m->url_query.end_range);
return GF_OK;
}
}
return GF_SERVICE_ERROR;
}
/*gets URL and byte range of next segment - if needed, adds butstream switching segment info*/
if (param->command_type==GF_NET_SERVICE_QUERY_NEXT) {
Bool group_done;
u32 nb_segments_cached;
u32 group_idx=0;
GF_MPDGroup *group=NULL;
const char *src_url;
Bool discard_first_cache_entry = 1;
u32 timer = gf_sys_clock();
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Received Service Query Next request from input service %s\n", ifce->module_name));
param->url_query.discontinuity_type = 0;
if (mpdin->in_seek) {
mpdin->in_seek = 0;
param->url_query.discontinuity_type = 2;
discard_first_cache_entry = 0;
}
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
if (!gf_dash_is_group_selected(mpdin->dash, i)) continue;
group = gf_dash_get_group_udta(mpdin->dash, i);
if (group->segment_ifce == ifce) {
group_idx = i;
break;
}
group=NULL;
}
if (!group) {
return GF_SERVICE_ERROR;
}
while (gf_dash_is_running(mpdin->dash) ) {
group_done=0;
nb_segments_cached = gf_dash_group_get_num_segments_ready(mpdin->dash, group_idx, &group_done);
if (nb_segments_cached>=2)
break;
if (group_done) {
if (!gf_dash_get_period_switch_status(mpdin->dash) && !gf_dash_in_last_period(mpdin->dash) ) {
GF_NetworkCommand com;
memset(&com, 0, sizeof(GF_NetworkCommand));
com.command_type = GF_NET_BUFFER_QUERY;
while (gf_dash_get_period_switch_status(mpdin->dash) != 1) {
gf_term_on_command(mpdin->service, &com, GF_OK);
if (!com.buffer.occupancy) {
gf_dash_request_period_switch(mpdin->dash);
break;
}
gf_sleep(20);
}
}
return GF_EOS;
}
gf_sleep(16);
}
nb_segments_cached = gf_dash_group_get_num_segments_ready(mpdin->dash, group_idx, &group_done);
if (nb_segments_cached < 2) {
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[MPD_IN] No more file in cache, EOS\n"));
return GF_EOS;
} else {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Had to wait for %u ms for the only cache file to be downloaded\n", (gf_sys_clock() - timer)));
}
if (discard_first_cache_entry) {
gf_dash_group_discard_segment(mpdin->dash, group_idx);
}
gf_dash_group_get_next_segment_location(mpdin->dash, group_idx, ¶m->url_query.next_url, ¶m->url_query.start_range, ¶m->url_query.end_range,
¶m->url_query.next_url_init_or_switch_segment, ¶m->url_query.switch_start_range , ¶m->url_query.switch_end_range,
&src_url);
{
u32 timer2 = gf_sys_clock() - timer ;
if (timer2 > 1000) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Waiting for download to end took a long time : %u ms\n", timer2));
}
if (param->url_query.end_range) {
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[MPD_IN] Switching segment playback to %s (Media Range: "LLD"-"LLD")\n", src_url, param->url_query.start_range, param->url_query.end_range));
} else {
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[MPD_IN] Switching segment playback to %s\n", src_url));
}
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[MPD_IN] segment start time %g sec\n", gf_dash_group_current_segment_start_time(mpdin->dash, group_idx) ));
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Waited %d ms - Elements in cache: %u/%u\n\tCache file name %s\n", timer2, gf_dash_group_get_num_segments_ready(mpdin->dash, group_idx, &group_done), gf_dash_group_get_max_segments_in_cache(mpdin->dash, group_idx), param->url_query.next_url ));
}
return GF_OK;
}
return GF_OK;
}
GF_Err mpdin_dash_io_on_dash_event(GF_DASHFileIO *dashio, GF_DASHEventType dash_evt, GF_Err error_code)
{
GF_Err e;
u32 i;
GF_MPD_In *mpdin = (GF_MPD_In *)dashio->udta;
if (dash_evt==GF_DASH_EVENT_PERIOD_SETUP_ERROR) {
if (!mpdin->connection_ack_sent) {
gf_term_on_connect(mpdin->service, NULL, error_code);
mpdin->connection_ack_sent=1;
}
return GF_OK;
}
if (dash_evt==GF_DASH_EVENT_SELECT_GROUPS) {
const char *opt;
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
/*todo: select groups based on user criteria*/
gf_dash_group_select(mpdin->dash, i, 1);
}
opt = gf_modules_get_option((GF_BaseInterface *)mpdin->plug, "Systems", "Language3CC");
if (opt && strcmp(opt, "und"))
gf_dash_groups_set_language(mpdin->dash, opt);
return GF_OK;
}
/*for all selected groups, create input service and connect to init/first segment*/
if (dash_evt==GF_DASH_EVENT_CREATE_PLAYBACK) {
/*select input services if possible*/
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
const char *mime, *init_segment;
if (!gf_dash_is_group_selected(mpdin->dash, i))
continue;
mime = gf_dash_group_get_segment_mime(mpdin->dash, i);
init_segment = gf_dash_group_get_segment_init_url(mpdin->dash, i, NULL, NULL);
e = MPD_LoadMediaService(mpdin, i, mime, init_segment);
if (e != GF_OK) {
gf_dash_group_select(mpdin->dash, i, 0);
} else {
/*connect our media service*/
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, i);
e = group->segment_ifce->ConnectService(group->segment_ifce, mpdin->service, init_segment);
if (e) {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[MPD_IN] Unable to connect input service to %s\n", init_segment));
gf_dash_group_select(mpdin->dash, i, 0);
} else {
u32 w, h;
group->service_connected = 1;
w = h = 0;
gf_dash_group_get_video_info(mpdin->dash, i, &w, &h);
if (w && h && w>mpdin->width && h>mpdin->height) {
mpdin->width = w;
mpdin->height = h;
}
}
}
}
if (!mpdin->connection_ack_sent) {
gf_term_on_connect(mpdin->service, NULL, GF_OK);
mpdin->connection_ack_sent=1;
}
return GF_OK;
}
/*for all running services, stop service*/
if (dash_evt==GF_DASH_EVENT_DESTROY_PLAYBACK) {
mpdin->service->subservice_disconnect = 1;
gf_term_on_disconnect(mpdin->service, NULL, GF_OK);
mpdin->service->subservice_disconnect = 2;
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, i);
if (!group) continue;
if (group->segment_ifce) {
if (group->service_connected) {
group->segment_ifce->CloseService(group->segment_ifce);
group->service_connected = 0;
}
gf_modules_close_interface((GF_BaseInterface *) group->segment_ifce);
}
gf_free(group);
gf_dash_set_group_udta(mpdin->dash, i, NULL);
}
mpdin->service->subservice_disconnect = 0;
}
return GF_OK;
}
GF_Err mpdin_dash_io_on_dash_event(GF_DASHFileIO *dashio, GF_DASHEventType dash_evt, s32 group_idx, GF_Err error_code)
{
GF_Err e;
u32 i;
GF_MPD_In *mpdin = (GF_MPD_In *)dashio->udta;
if (dash_evt==GF_DASH_EVENT_PERIOD_SETUP_ERROR) {
if (!mpdin->connection_ack_sent) {
mpdin->fn_connect_ack(mpdin->service, NULL, error_code);
mpdin->connection_ack_sent= GF_TRUE;
}
return GF_OK;
}
if (dash_evt==GF_DASH_EVENT_SELECT_GROUPS) {
const char *opt;
//configure buffer in dynamic mode without low latency: we indicate how much the player will buffer
if (gf_dash_is_dynamic_mpd(mpdin->dash) && !mpdin->use_low_latency) {
u32 buffer_ms = 0;
const char *opt = gf_modules_get_option((GF_BaseInterface *)mpdin->plug, "Network", "BufferLength");
if (opt) buffer_ms = atoi(opt);
//use min buffer from MPD
if (mpdin->buffer_mode>=MPDIN_BUFFER_MIN) {
u32 mpd_buffer_ms = gf_dash_get_min_buffer_time(mpdin->dash);
if (mpd_buffer_ms > buffer_ms)
buffer_ms = mpd_buffer_ms;
}
if (buffer_ms) {
gf_dash_set_user_buffer(mpdin->dash, buffer_ms);
}
}
//let the player decide which group to play: we declare everything
//however select the default languague
opt = gf_modules_get_option((GF_BaseInterface *)mpdin->plug, "Systems", "LanguageName");
if (opt)
gf_dash_groups_set_language(mpdin->dash, opt);
return GF_OK;
}
/*for all selected groups, create input service and connect to init/first segment*/
if (dash_evt==GF_DASH_EVENT_CREATE_PLAYBACK) {
/*select input services if possible*/
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
const char *mime, *init_segment;
//let the player decide which group to play
if (!gf_dash_is_group_selectable(mpdin->dash, i))
continue;
mime = gf_dash_group_get_segment_mime(mpdin->dash, i);
init_segment = gf_dash_group_get_segment_init_url(mpdin->dash, i, NULL, NULL);
e = MPD_LoadMediaService(mpdin, i, mime, init_segment);
if (e != GF_OK) {
gf_dash_group_select(mpdin->dash, i, 0);
} else {
u32 w, h;
/*connect our media service*/
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, i);
gf_dash_group_get_video_info(mpdin->dash, i, &w, &h);
if (w && h && w>mpdin->width && h>mpdin->height) {
mpdin->width = w;
mpdin->height = h;
}
e = group->segment_ifce->ConnectService(group->segment_ifce, mpdin->service, init_segment);
if (e) {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[MPD_IN] Unable to connect input service to %s\n", init_segment));
gf_dash_group_select(mpdin->dash, i, 0);
} else {
group->service_connected = 1;
}
if (mpdin->closed) return GF_OK;
}
}
if (!mpdin->connection_ack_sent) {
mpdin->fn_connect_ack(mpdin->service, NULL, GF_OK);
mpdin->connection_ack_sent=1;
}
//we had a seek outside of the period we were setting up, during period setup !
//request the seek again from the player
if (mpdin->seek_request>=0) {
GF_NetworkCommand com;
memset(&com, 0, sizeof(GF_NetworkCommand));
com.command_type = GF_NET_SERVICE_SEEK;
com.play.start_range = mpdin->seek_request;
mpdin->seek_request = 0;
gf_service_command(mpdin->service, &com, GF_OK);
}
return GF_OK;
}
/*for all running services, stop service*/
if (dash_evt==GF_DASH_EVENT_DESTROY_PLAYBACK) {
mpdin->service->subservice_disconnect = 1;
gf_service_disconnect_ack(mpdin->service, NULL, GF_OK);
mpdin->service->subservice_disconnect = 2;
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, i);
if (!group) continue;
if (group->segment_ifce) {
if (group->service_connected) {
group->segment_ifce->CloseService(group->segment_ifce);
group->service_connected = 0;
}
gf_modules_close_interface((GF_BaseInterface *) group->segment_ifce);
}
gf_free(group);
gf_dash_set_group_udta(mpdin->dash, i, NULL);
}
mpdin->service->subservice_disconnect = 0;
return GF_OK;
}
if (dash_evt==GF_DASH_EVENT_BUFFERING) {
u32 tot, done;
gf_dash_get_buffer_info(mpdin->dash, &tot, &done);
fprintf(stderr, "DASH: Buffering %g%% out of %d ms\n", (100.0*done)/tot, tot);
return GF_OK;
}
if (dash_evt==GF_DASH_EVENT_SEGMENT_AVAILABLE) {
if (group_idx>=0) {
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, group_idx);
if (group) MPD_NotifyData(group, 0);
}
return GF_OK;
}
if (dash_evt==GF_DASH_EVENT_QUALITY_SWITCH) {
if (group_idx>=0) {
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, group_idx);
if (group) {
GF_NetworkCommand com;
memset(&com, 0, sizeof(GF_NetworkCommand) );
com.command_type = GF_NET_SERVICE_EVENT;
com.send_event.evt.type = GF_EVENT_QUALITY_SWITCHED;
gf_service_command(mpdin->service, &com, GF_OK);
}
}
return GF_OK;
}
if (dash_evt==GF_DASH_EVENT_TIMESHIFT_OVERFLOW) {
GF_NetworkCommand com;
com.command_type = GF_NET_SERVICE_EVENT;
com.send_event.evt.type = (group_idx>=0) ? GF_EVENT_TIMESHIFT_OVERFLOW : GF_EVENT_TIMESHIFT_UNDERRUN;
gf_service_command(mpdin->service, &com, GF_OK);
}
if (dash_evt==GF_DASH_EVENT_TIMESHIFT_UPDATE) {
GF_NetworkCommand com;
com.command_type = GF_NET_SERVICE_EVENT;
com.send_event.evt.type = GF_EVENT_TIMESHIFT_UPDATE;
gf_service_command(mpdin->service, &com, GF_OK);
}
return GF_OK;
}
static GF_Err MPD_ClientQuery(GF_InputService *ifce, GF_NetworkCommand *param)
{
u32 i;
GF_Err e;
GF_MPD_In *mpdin = (GF_MPD_In *) ifce->proxy_udta;
if (!param || !ifce || !ifce->proxy_udta) return GF_BAD_PARAM;
mpdin->in_seek = 0;
/*gets byte range of init segment (for local validation)*/
if (param->command_type==GF_NET_SERVICE_QUERY_INIT_RANGE) {
param->url_query.next_url = NULL;
param->url_query.start_range = 0;
param->url_query.end_range = 0;
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
GF_MPDGroup *group;
if (!gf_dash_is_group_selectable(mpdin->dash, i)) continue;
group = gf_dash_get_group_udta(mpdin->dash, i);
if (group->segment_ifce == ifce) {
gf_dash_group_get_segment_init_url(mpdin->dash, i, ¶m->url_query.start_range, ¶m->url_query.end_range);
param->url_query.current_download = 0;
return GF_OK;
}
}
return GF_SERVICE_ERROR;
}
/*gets URL and byte range of next segment - if needed, adds bitstream switching segment info*/
if (param->command_type==GF_NET_SERVICE_QUERY_NEXT) {
Bool group_done;
u32 nb_segments_cached;
u32 group_idx=0;
GF_MPDGroup *group=NULL;
const char *src_url;
Bool discard_first_cache_entry = param->url_query.drop_first_segment;
Bool check_current_download = param->url_query.current_download;
u32 timer = gf_sys_clock();
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Received Service Query Next request from input service %s\n", ifce->module_name));
param->url_query.current_download = 0;
param->url_query.discontinuity_type = 0;
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
if (!gf_dash_is_group_selected(mpdin->dash, i)) continue;
group = gf_dash_get_group_udta(mpdin->dash, i);
if (group->segment_ifce == ifce) {
group_idx = i;
break;
}
group=NULL;
}
if (!group) {
return GF_SERVICE_ERROR;
}
if (group->in_seek) {
group->in_seek = 0;
param->url_query.discontinuity_type = 2;
discard_first_cache_entry = 0;
}
//update group idx
if (group->idx != group_idx) {
group->idx = group_idx;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] New AdaptationSet detected after MPD update ?\n"));
}
if (discard_first_cache_entry) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Discarding first segment in cache\n"));
gf_dash_group_discard_segment(mpdin->dash, group_idx);
}
while (gf_dash_is_running(mpdin->dash) ) {
group_done=0;
nb_segments_cached = gf_dash_group_get_num_segments_ready(mpdin->dash, group_idx, &group_done);
if (nb_segments_cached>=1)
break;
if (group_done) {
if (!gf_dash_get_period_switch_status(mpdin->dash) && !gf_dash_in_last_period(mpdin->dash) ) {
GF_NetworkCommand com;
param->url_query.in_end_of_period = 1;
memset(&com, 0, sizeof(GF_NetworkCommand));
com.command_type = GF_NET_BUFFER_QUERY;
if (gf_dash_get_period_switch_status(mpdin->dash) != 1) {
gf_service_command(mpdin->service, &com, GF_OK);
//we only switch period once no more data is in our buffers
if (!com.buffer.occupancy) {
param->url_query.in_end_of_period = 0;
gf_dash_request_period_switch(mpdin->dash);
}
}
if (param->url_query.in_end_of_period)
return GF_BUFFER_TOO_SMALL;
} else {
return GF_EOS;
}
}
if (check_current_download && mpdin->use_low_latency) {
Bool is_switched=GF_FALSE;
gf_dash_group_probe_current_download_segment_location(mpdin->dash, group_idx, ¶m->url_query.next_url, NULL, ¶m->url_query.next_url_init_or_switch_segment, &src_url, &is_switched);
if (param->url_query.next_url) {
param->url_query.current_download = 1;
param->url_query.has_new_data = group->has_new_data;
param->url_query.discontinuity_type = is_switched ? 1 : 0;
if (gf_dash_group_loop_detected(mpdin->dash, group_idx))
param->url_query.discontinuity_type = 2;
group->has_new_data = 0;
return GF_OK;
}
return GF_BUFFER_TOO_SMALL;
}
return GF_BUFFER_TOO_SMALL;
}
param->url_query.current_download = 0;
nb_segments_cached = gf_dash_group_get_num_segments_ready(mpdin->dash, group_idx, &group_done);
if (nb_segments_cached < 1) {
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[MPD_IN] No more file in cache, EOS\n"));
return GF_EOS;
} else {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Had to wait for %u ms for the only cache file to be downloaded\n", (gf_sys_clock() - timer)));
}
e = gf_dash_group_get_next_segment_location(mpdin->dash, group_idx, param->url_query.dependent_representation_index, ¶m->url_query.next_url, ¶m->url_query.start_range, ¶m->url_query.end_range,
NULL, ¶m->url_query.next_url_init_or_switch_segment, ¶m->url_query.switch_start_range , ¶m->url_query.switch_end_range,
&src_url, ¶m->url_query.has_next);
if (e)
return e;
if (gf_dash_group_loop_detected(mpdin->dash, group_idx))
param->url_query.discontinuity_type = 2;
#ifndef GPAC_DISABLE_LOG
{
u32 timer2 = gf_sys_clock() - timer ;
if (timer2 > 1000) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Waiting for download to end took a long time : %u ms\n", timer2));
}
if (param->url_query.end_range) {
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[MPD_IN] Next Segment is %s bytes "LLD"-"LLD"\n", src_url, param->url_query.start_range, param->url_query.end_range));
} else {
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[MPD_IN] Next Segment is %s\n", src_url));
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Waited %d ms - Elements in cache: %u/%u\n\tCache file name %s\n\tsegment start time %g sec\n", timer2, gf_dash_group_get_num_segments_ready(mpdin->dash, group_idx, &group_done), gf_dash_group_get_max_segments_in_cache(mpdin->dash, group_idx), param->url_query.next_url, gf_dash_group_current_segment_start_time(mpdin->dash, group_idx) ));
}
#endif
}
return GF_OK;
}
void mpdin_data_packet(GF_ClientService *service, LPNETCHANNEL ns, char *data, u32 data_size, GF_SLHeader *hdr, GF_Err reception_status)
{
s32 i;
GF_MPD_In *mpdin = (GF_MPD_In*) service->ifce->priv;
GF_Channel *ch;
GF_MPDGroup *group;
Bool do_map_time = 0;
if (!ns || !hdr) {
mpdin->fn_data_packet(service, ns, data, data_size, hdr, reception_status);
return;
}
ch = (GF_Channel *) ns;
assert(ch->odm && ch->odm->OD);
i = gf_dash_get_group_idx_from_service(mpdin, (GF_InputService *) ch->odm->OD->service_ifce);
if (i<0) {
mpdin->fn_data_packet(service, ns, data, data_size, hdr, reception_status);
return;
}
group = gf_dash_get_group_udta(mpdin->dash, i);
//if sync is based on timestamps do not adjust the timestamps back
if (! group->is_timestamp_based) {
if (!group->pto_setup) {
Double scale;
s64 start, dur;
u64 pto;
gf_dash_group_get_presentation_time_offset(mpdin->dash, i, &pto, &group->timescale);
group->pto = (s64) pto;
group->pto_setup = 1;
if (group->timescale && (group->timescale != ch->esd->slConfig->timestampResolution)) {
group->pto *= ch->esd->slConfig->timestampResolution;
group->pto /= group->timescale;
}
scale = ch->esd->slConfig->timestampResolution;
scale /= 1000;
dur = (u64) (scale * gf_dash_get_period_duration(mpdin->dash) );
if (dur) {
group->max_cts_in_period = group->pto + dur;
} else {
group->max_cts_in_period = 0;
}
start = (u64) (scale * gf_dash_get_period_start(mpdin->dash) );
group->pto -= start;
}
//filter any packet outside the current period
if (group->max_cts_in_period && (s64) hdr->compositionTimeStamp > group->max_cts_in_period) {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[DASH] Packet timestamp "LLU" larger than max CTS in period "LLU" - skipping\n", hdr->compositionTimeStamp, group->max_cts_in_period));
return;
}
//remap timestamps to our timeline
if ((s64) hdr->decodingTimeStamp >= group->pto)
hdr->decodingTimeStamp -= group->pto;
else {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[DASH] Packet DTS "LLU" less than PTO "LLU" - forcing CTS to 0\n", hdr->compositionTimeStamp, group->pto));
hdr->decodingTimeStamp = 0;
}
if ((s64) hdr->compositionTimeStamp >= group->pto)
hdr->compositionTimeStamp -= group->pto;
else {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[DASH] Packet CTS "LLU" less than PTO "LLU" - forcing CTS to 0\n", hdr->compositionTimeStamp, group->pto));
hdr->compositionTimeStamp = 0;
}
} else if (!group->pto_setup) {
do_map_time = 1;
group->pto_setup = 1;
}
mpdin->fn_data_packet(service, ns, data, data_size, hdr, reception_status);
if (do_map_time) {
GF_NetworkCommand com;
memset(&com, 0, sizeof(com));
com.command_type = GF_NET_CHAN_SET_MEDIA_TIME;
com.map_time.media_time = mpdin->media_start_range;
com.map_time.timestamp = hdr->compositionTimeStamp;
com.base.on_channel = ns;
gf_service_command(service, &com, GF_OK);
}
}
GF_Err MPD_ServiceCommand(GF_InputService *plug, GF_NetworkCommand *com)
{
s32 idx;
GF_Err e;
GF_MPD_In *mpdin = (GF_MPD_In*) plug->priv;
GF_InputService *segment_ifce = NULL;
if (!plug || !plug->priv || !com ) return GF_SERVICE_ERROR;
segment_ifce = MPD_GetInputServiceForChannel(mpdin, com->base.on_channel);
switch (com->command_type) {
case GF_NET_SERVICE_INFO:
{
s32 idx;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Received Info command from terminal on Service (%p)\n", mpdin->service));
e = GF_OK;
if (segment_ifce) {
/* defer to the real input service */
e = segment_ifce->ServiceCommand(segment_ifce, com);
}
if (e!= GF_OK || !com->info.name || 2 > strlen(com->info.name)) {
gf_dash_get_info(mpdin->dash, &com->info.name, &com->info.comment);
}
idx = MPD_GetGroupIndexForChannel(mpdin, com->play.on_channel);
if (idx>=0) {
//gather role and co
if (!com->info.role) {
gf_dash_group_enum_descriptor(mpdin->dash, idx, GF_MPD_DESC_ROLE, 0, NULL, NULL, &com->info.role);
}
if (!com->info.accessibility) {
gf_dash_group_enum_descriptor(mpdin->dash, idx, GF_MPD_DESC_ACCESSIBILITY, 0, NULL, NULL, &com->info.accessibility);
}
if (!com->info.rating) {
gf_dash_group_enum_descriptor(mpdin->dash, idx, GF_MPD_DESC_RATING, 0, NULL, NULL, &com->info.rating);
}
}
return GF_OK;
}
/*we could get it from MPD*/
case GF_NET_SERVICE_HAS_AUDIO:
case GF_NET_SERVICE_FLUSH_DATA:
if (segment_ifce) {
/* defer to the real input service */
return segment_ifce->ServiceCommand(segment_ifce, com);
}
return GF_NOT_SUPPORTED;
case GF_NET_SERVICE_HAS_FORCED_VIDEO_SIZE:
com->par.width = mpdin->use_max_res ? mpdin->width : 0;
com->par.height = mpdin->use_max_res ? mpdin->height : 0;
return GF_OK;
case GF_NET_SERVICE_QUALITY_SWITCH:
if (com->switch_quality.set_auto) {
gf_dash_set_automatic_switching(mpdin->dash, 1);
} else if (com->base.on_channel) {
segment_ifce = MPD_GetInputServiceForChannel(mpdin, com->base.on_channel);
if (!segment_ifce) return GF_NOT_SUPPORTED;
idx = MPD_GetGroupIndexForChannel(mpdin, com->play.on_channel);
if (idx < 0) return GF_BAD_PARAM;
gf_dash_set_automatic_switching(mpdin->dash, 0);
gf_dash_group_select_quality(mpdin->dash, idx, com->switch_quality.ID);
} else {
gf_dash_switch_quality(mpdin->dash, com->switch_quality.up, mpdin->immediate_switch);
}
return GF_OK;
case GF_NET_GET_TIMESHIFT:
com->timeshift.time = gf_dash_get_timeshift_buffer_pos(mpdin->dash);
return GF_OK;
default:
break;
}
/*not supported*/
if (!com->base.on_channel) return GF_NOT_SUPPORTED;
segment_ifce = MPD_GetInputServiceForChannel(mpdin, com->base.on_channel);
if (!segment_ifce) return GF_NOT_SUPPORTED;
switch (com->command_type) {
case GF_NET_CHAN_INTERACTIVE:
/* TODO - we are interactive if not live without timeshift */
return GF_OK;
case GF_NET_GET_STATS:
{
idx = MPD_GetGroupIndexForChannel(mpdin, com->base.on_channel);
if (idx < 0) return GF_BAD_PARAM;
com->net_stats.bw_down = 8 * gf_dash_group_get_download_rate(mpdin->dash, idx);
}
return GF_OK;
case GF_NET_SERVICE_QUALITY_QUERY:
{
GF_DASHQualityInfo qinfo;
GF_Err e;
u32 count;
idx = MPD_GetGroupIndexForChannel(mpdin, com->quality_query.on_channel);
if (idx < 0) return GF_BAD_PARAM;
count = gf_dash_group_get_num_qualities(mpdin->dash, idx);
if (!com->quality_query.index) {
com->quality_query.index = count;
return GF_OK;
}
if (com->quality_query.index>count) return GF_BAD_PARAM;
e = gf_dash_group_get_quality_info(mpdin->dash, idx, com->quality_query.index-1, &qinfo);
if (e) return e;
com->quality_query.bandwidth = qinfo.bandwidth;
com->quality_query.ID = qinfo.ID;
com->quality_query.mime = qinfo.mime;
com->quality_query.codec = qinfo.codec;
com->quality_query.width = qinfo.width;
com->quality_query.height = qinfo.height;
com->quality_query.interlaced = qinfo.interlaced;
if (qinfo.fps_den) {
com->quality_query.fps = qinfo.fps_num;
com->quality_query.fps /= qinfo.fps_den;
}
com->quality_query.par_num = qinfo.par_num;
com->quality_query.par_den = qinfo.par_den;
com->quality_query.sample_rate = qinfo.sample_rate;
com->quality_query.nb_channels = qinfo.nb_channels;
com->quality_query.disabled = qinfo.disabled;
com->quality_query.is_selected = qinfo.is_selected;
com->quality_query.automatic = gf_dash_get_automatic_switching(mpdin->dash);
return GF_OK;
}
break;
case GF_NET_CHAN_BUFFER:
/*get it from MPD minBufferTime - if not in low latency mode, indicate the value given in MPD (not possible to fetch segments earlier) - to be more precise we should get the min segment duration for this group*/
if (!mpdin->use_low_latency && (mpdin->buffer_mode>=MPDIN_BUFFER_MIN) ) {
u32 max = gf_dash_get_min_buffer_time(mpdin->dash);
if (max>com->buffer.max)
com->buffer.max = max;
if (! gf_dash_is_dynamic_mpd(mpdin->dash)) {
com->buffer.min = 1;
}
}
return GF_OK;
case GF_NET_CHAN_DURATION:
com->duration.duration = gf_dash_get_duration(mpdin->dash);
idx = MPD_GetGroupIndexForChannel(mpdin, com->play.on_channel);
if (idx >= 0) {
com->duration.time_shift_buffer = gf_dash_group_get_time_shift_buffer_depth(mpdin->dash, idx);
}
return GF_OK;
case GF_NET_CHAN_PLAY:
idx = MPD_GetGroupIndexForChannel(mpdin, com->play.on_channel);
if (idx < 0) return GF_BAD_PARAM;
//adjust play range from media timestamps to MPD time
if (com->play.timestamp_based) {
u32 timescale;
u64 pto;
Double offset;
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, idx);
if (com->play.timestamp_based==1) {
gf_dash_group_get_presentation_time_offset(mpdin->dash, idx, &pto, ×cale);
offset = (Double) pto;
offset /= timescale;
com->play.start_range -= offset;
if (com->play.start_range < 0) com->play.start_range = 0;
}
group->is_timestamp_based = 1;
group->pto_setup = 0;
mpdin->media_start_range = com->play.start_range;
} else {
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, idx);
group->is_timestamp_based = 0;
group->pto_setup = 0;
if (com->play.start_range<0) com->play.start_range = 0;
}
//we cannot handle seek request outside of a period being setup, this messes up our internal service setup
//we postpone the seek and will request it later on ...
if (gf_dash_in_period_setup(mpdin->dash)) {
u64 p_end = gf_dash_get_period_duration(mpdin->dash);
if (p_end) {
p_end += gf_dash_get_period_start(mpdin->dash);
if (p_end<1000*com->play.start_range) {
mpdin->seek_request = com->play.start_range;
return GF_OK;
}
}
}
gf_dash_set_speed(mpdin->dash, com->play.speed);
/*don't seek if this command is the first PLAY request of objects declared by the subservice*/
if (! mpdin->in_seek && (!com->play.initial_broadcast_play || (com->play.start_range>2.0) ) ) {
Bool skip_seek;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Received Play command from terminal on channel %p on Service (%p)\n", com->base.on_channel, mpdin->service));
mpdin->in_seek = 1;
/*if start range request is the same as previous one, don't process it
- this happens at period switch when new objects are declared*/
skip_seek = 0;
if (com->play.initial_broadcast_play && (mpdin->previous_start_range==com->play.start_range))
skip_seek = 1;
mpdin->previous_start_range = com->play.start_range;
if (!skip_seek) {
if (com->play.end_range<=0) {
u32 ms = (u32) ( 1000 * (-com->play.end_range) );
if (ms<1000) ms = 0;
gf_dash_set_timeshift(mpdin->dash, ms);
}
gf_dash_seek(mpdin->dash, com->play.start_range);
//we have issued a seek request, mark the group as seeking
if (mpdin->in_seek) {
//group->in_seek = 1;
}
//and check if current segment playback should be aborted
com->play.dash_segment_switch = gf_dash_group_segment_switch_forced(mpdin->dash, idx);
}
//to remove once we manage to keep the service alive
/*don't forward commands if a switch of period is to be scheduled, we are killing the service anyway ...*/
if (gf_dash_get_period_switch_status(mpdin->dash) ) return GF_OK;
}
gf_dash_group_select(mpdin->dash, idx, GF_TRUE);
gf_dash_set_group_done(mpdin->dash, (u32) idx, 0);
//adjust start range from MPD time to media time
{
u64 pto;
u32 timescale;
com->play.start_range = gf_dash_group_get_start_range(mpdin->dash, idx);
gf_dash_group_get_presentation_time_offset(mpdin->dash, idx, &pto, ×cale);
com->play.start_range += ((Double)pto ) / timescale;
}
return segment_ifce->ServiceCommand(segment_ifce, com);
case GF_NET_CHAN_STOP:
{
s32 idx = MPD_GetGroupIndexForChannel(mpdin, com->play.on_channel);
if (idx>=0) {
gf_dash_set_group_done(mpdin->dash, (u32) idx, 1);
}
mpdin->previous_start_range = -1;
}
return segment_ifce->ServiceCommand(segment_ifce, com);
/*we could get it from MPD*/
case GF_NET_CHAN_GET_PIXEL_AR:
/* defer to the real input service */
return segment_ifce->ServiceCommand(segment_ifce, com);
case GF_NET_CHAN_SET_SPEED:
gf_dash_set_speed(mpdin->dash, com->play.speed);
return segment_ifce->ServiceCommand(segment_ifce, com);
default:
return segment_ifce->ServiceCommand(segment_ifce, com);
}
}
GF_Err mpdin_dash_io_on_dash_event(GF_DASHFileIO *dashio, GF_DASHEventType dash_evt, s32 group_idx, GF_Err error_code)
{
GF_Err e;
u32 i;
GF_MPD_In *mpdin = (GF_MPD_In *)dashio->udta;
if (dash_evt==GF_DASH_EVENT_PERIOD_SETUP_ERROR) {
if (!mpdin->connection_ack_sent) {
gf_term_on_connect(mpdin->service, NULL, error_code);
mpdin->connection_ack_sent= GF_TRUE;
}
return GF_OK;
}
if (dash_evt==GF_DASH_EVENT_SELECT_GROUPS) {
//configure buffer in dynamic mode without low latency: we indicate how much the player will buffer
if (gf_dash_is_dynamic_mpd(mpdin->dash) && !mpdin->use_low_latency) {
u32 buffer_ms = 0;
const char *opt = gf_modules_get_option((GF_BaseInterface *)mpdin->plug, "Network", "BufferLength");
if (opt) buffer_ms = atoi(opt);
//use min buffer from MPD
if (mpdin->buffer_mode>=MPDIN_BUFFER_MIN) {
u32 mpd_buffer_ms = gf_dash_get_min_buffer_time(mpdin->dash);
if (mpd_buffer_ms > buffer_ms)
buffer_ms = mpd_buffer_ms;
}
if (buffer_ms) {
gf_dash_set_user_buffer(mpdin->dash, buffer_ms);
}
}
//let the player decide which group to play: we declare everything
return GF_OK;
}
/*for all selected groups, create input service and connect to init/first segment*/
if (dash_evt==GF_DASH_EVENT_CREATE_PLAYBACK) {
/*select input services if possible*/
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
const char *mime, *init_segment;
//let the player decide which group to play
if (!gf_dash_is_group_selectable(mpdin->dash, i))
continue;
mime = gf_dash_group_get_segment_mime(mpdin->dash, i);
init_segment = gf_dash_group_get_segment_init_url(mpdin->dash, i, NULL, NULL);
e = MPD_LoadMediaService(mpdin, i, mime, init_segment);
if (e != GF_OK) {
gf_dash_group_select(mpdin->dash, i, 0);
} else {
u32 w, h;
/*connect our media service*/
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, i);
gf_dash_group_get_video_info(mpdin->dash, i, &w, &h);
if (w && h && w>mpdin->width && h>mpdin->height) {
mpdin->width = w;
mpdin->height = h;
}
e = group->segment_ifce->ConnectService(group->segment_ifce, mpdin->service, init_segment);
if (e) {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[MPD_IN] Unable to connect input service to %s\n", init_segment));
gf_dash_group_select(mpdin->dash, i, 0);
} else {
group->service_connected = 1;
}
}
}
if (!mpdin->connection_ack_sent) {
gf_term_on_connect(mpdin->service, NULL, GF_OK);
mpdin->connection_ack_sent=1;
}
return GF_OK;
}
/*for all running services, stop service*/
if (dash_evt==GF_DASH_EVENT_DESTROY_PLAYBACK) {
mpdin->service->subservice_disconnect = 1;
gf_term_on_disconnect(mpdin->service, NULL, GF_OK);
mpdin->service->subservice_disconnect = 2;
for (i=0; i<gf_dash_get_group_count(mpdin->dash); i++) {
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, i);
if (!group) continue;
if (group->segment_ifce) {
if (group->service_connected) {
group->segment_ifce->CloseService(group->segment_ifce);
group->service_connected = 0;
}
gf_modules_close_interface((GF_BaseInterface *) group->segment_ifce);
}
gf_free(group);
gf_dash_set_group_udta(mpdin->dash, i, NULL);
}
mpdin->service->subservice_disconnect = 0;
return GF_OK;
}
if (dash_evt==GF_DASH_EVENT_BUFFERING) {
u32 tot, done;
gf_dash_get_buffer_info_buffering(mpdin->dash, &tot, &done);
fprintf(stderr, "DASH: Buffering %g%% out of %d ms\n", (100.0*done)/tot, tot);
return GF_OK;
}
if (dash_evt==GF_DASH_EVENT_SEGMENT_AVAILABLE) {
if (group_idx>=0) {
GF_MPDGroup *group = gf_dash_get_group_udta(mpdin->dash, group_idx);
if (group) MPD_NotifyData(group, 0);
}
}
return GF_OK;
}
