void m2ts_net_io(void *cbk, GF_NETIO_Parameter *param)
{
GF_Err e;
M2TSIn *m2ts = (M2TSIn *) cbk;
assert( m2ts );
/*handle service message*/
gf_term_download_update_stats(m2ts->ts->dnload);
if (param->msg_type==GF_NETIO_DATA_TRANSFERED) {
e = GF_EOS;
} else if (param->msg_type==GF_NETIO_DATA_EXCHANGE) {
e = GF_OK;
assert( m2ts->ts);
if (param->size > 0) {
/*process chunk*/
assert(param->data);
if (m2ts->network_buffer_size < param->size) {
m2ts->network_buffer = gf_realloc(m2ts->network_buffer, sizeof(char) * param->size);
m2ts->network_buffer_size = param->size;
}
assert( m2ts->network_buffer );
memcpy(m2ts->network_buffer, param->data, param->size);
gf_m2ts_process_data(m2ts->ts, m2ts->network_buffer, param->size);
}
/*if asked to regulate, wait until we get a play request*/
if (m2ts->ts->run_state && !m2ts->ts->nb_playing && m2ts->ts->file_regulate) {
while (m2ts->ts->run_state && !m2ts->ts->nb_playing && m2ts->ts->file_regulate) {
gf_sleep(50);
continue;
}
} else {
gf_sleep(1);
}
if (!m2ts->ts->run_state) {
if (m2ts->ts->dnload)
gf_term_download_del( m2ts->ts->dnload );
m2ts->ts->dnload = NULL;
}
} else {
e = param->error;
}
switch (e) {
case GF_EOS:
if (!m2ts->is_connected) {
gf_term_on_connect(m2ts->service, NULL, GF_OK);
}
return;
case GF_OK:
return;
default:
if (!m2ts->ts_setup) {
m2ts->ts_setup = 1;
}
GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER,("[MPEGTSIn] : Error while getting data : %s\n", gf_error_to_string(e)));
gf_term_on_connect(m2ts->service, NULL, e);
}
}
GF_Err ISOR_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
char szURL[2048];
char *tmp;
ISOMReader *read;
if (!plug || !plug->priv || !serv) return GF_SERVICE_ERROR;
read = (ISOMReader *) plug->priv;
read->input = plug;
read->service = serv;
if (read->dnload) gf_term_download_del(read->dnload);
read->dnload = NULL;
read->base_track_id = 0;
strcpy(szURL, url);
tmp = strrchr(szURL, '.');
if (tmp) {
tmp = strchr(tmp, '#');
if (tmp) {
if (!strnicmp(tmp, "#trackID=", 9)) {
read->base_track_id = atoi(tmp+9);
} else {
read->base_track_id = atoi(tmp+1);
}
tmp[0] = 0;
}
}
if (isor_is_local(szURL)) {
GF_Err e;
u64 start_range, end_range;
start_range = end_range = 0;
if (plug->query_proxy) {
GF_NetworkCommand param;
param.command_type = GF_NET_SERVICE_QUERY_INIT_RANGE;
if (read->input->query_proxy(read->input, ¶m)==GF_OK) {
start_range = param.url_query.start_range;
end_range = param.url_query.end_range;
}
}
e = gf_isom_open_progressive(szURL, start_range, end_range, &read->mov, &read->missing_bytes);
if (e != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[IsoMedia] : error while opening %s, error=%s\n", szURL, gf_error_to_string(e)));
gf_term_on_connect(serv, NULL, e);
return GF_OK;
}
read->frag_type = gf_isom_is_fragmented(read->mov) ? 1 : 0;
read->time_scale = gf_isom_get_timescale(read->mov);
/*reply to user*/
gf_term_on_connect(serv, NULL, GF_OK);
if (read->no_service_desc) isor_declare_objects(read);
} else {
/*setup downloader*/
isor_setup_download(plug, szURL);
}
return GF_OK;
}
static GF_Err M2TS_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
{
u32 ES_ID;
GF_Err e;
M2TSIn *m2ts = plug->priv;
e = GF_STREAM_NOT_FOUND;
if (strstr(url, "ES_ID")) {
sscanf(url, "ES_ID=%d", &ES_ID);
/* In case there is a real IOD, we need to translate PID into ESID */
if (gf_list_count(m2ts->ts->programs) == 1) {
GF_M2TS_Program *prog = gf_list_get(m2ts->ts->programs, 0);
if (prog->pmt_iod) {
/* IOD is present */
u32 i;
for (i=0; i<GF_M2TS_MAX_STREAMS; i++) {
GF_M2TS_PES *pes = (GF_M2TS_PES *)m2ts->ts->ess[i];
if (!pes || (pes->pid==pes->program->pmt_pid)) continue;
if ((pes->mpeg4_es_id == ES_ID)
/*for pid:// url*/
|| (!pes->mpeg4_es_id && (pes->pid == ES_ID))
) {
if (pes->user) {
e = GF_SERVICE_ERROR;
gf_term_on_connect(m2ts->service, channel, e);
return e;
} else {
pes->user = channel;
e = GF_OK;
gf_term_on_connect(m2ts->service, channel, e);
return e;
}
}
}
/* Stream not found */
return e;
}
}
/* No IOD */
if (ES_ID == 18) {
e = GF_OK; /* 18 is the PID of EIT packets */
m2ts->eit_channel = channel;
} else if ((ES_ID<GF_M2TS_MAX_STREAMS) && m2ts->ts->ess[ES_ID]) {
GF_M2TS_PES *pes = (GF_M2TS_PES *)m2ts->ts->ess[ES_ID];
if (pes->user) {
e = GF_SERVICE_ERROR;
} else {
pes->user = channel;
e = GF_OK;
}
}
}
gf_term_on_connect(m2ts->service, channel, e);
return e;
}
GF_Err LIBPLAYER_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
{
u32 ESID;
LibPlayerIn *read = (LibPlayerIn *) plug->priv;
sscanf(url, "ES_ID=%ud", &ESID);
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[LibPlayerIN] instance %d connect channel %d\n", read->player_id, ESID));
if (ESID != 1+read->player_id) {
gf_term_on_connect(read->service, channel, GF_STREAM_NOT_FOUND);
} else {
gf_term_on_connect(read->service, channel, GF_OK);
}
return GF_OK;
}
void RP_ConfirmChannelConnect(RTPStream *ch, GF_Err e)
{
GF_NetworkCommand com;
/*in case the channel has been disconnected while SETUP was issued&processed. We also could
clean up the command stack*/
if (!ch->channel) return;
gf_term_on_connect(ch->owner->service, ch->channel, e);
if (e != GF_OK || !ch->rtp_ch) return;
/*success, overwrite SL config*/
memset(&com, 0, sizeof(GF_NetworkCommand));
com.command_type = GF_NET_CHAN_RECONFIG;
com.base.on_channel = ch->channel;
gf_rtp_depacketizer_get_slconfig(ch->depacketizer, &com.cfg.sl_config);
/*reconfig*/
gf_term_on_command(ch->owner->service, &com, GF_OK);
/*ISMACryp config*/
if (ch->depacketizer->flags & GF_RTP_HAS_ISMACRYP) {
memset(&com, 0, sizeof(GF_NetworkCommand));
com.base.on_channel = ch->channel;
com.command_type = GF_NET_CHAN_DRM_CFG;
com.drm_cfg.scheme_type = ch->depacketizer->isma_scheme;
com.drm_cfg.scheme_version = 1;
/*not transported in SDP!!!*/
com.drm_cfg.scheme_uri = NULL;
com.drm_cfg.kms_uri = ch->depacketizer->key;
gf_term_on_command(ch->owner->service, &com, GF_OK);
}
}
static GF_Err AC3_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
{
u32 ES_ID=0;
GF_Err e;
AC3Reader *read = plug->priv;
e = GF_SERVICE_ERROR;
if (read->ch==channel) goto exit;
e = GF_STREAM_NOT_FOUND;
if (strstr(url, "ES_ID")) {
sscanf(url, "ES_ID=%ud", &ES_ID);
}
/*URL setup*/
else if (!read->ch && AC3_CanHandleURL(plug, url)) ES_ID = 1;
if (ES_ID==1) {
read->ch = channel;
e = GF_OK;
}
exit:
gf_term_on_connect(read->service, channel, e);
return e;
}
void TTIn_NetIO(void *cbk, GF_NETIO_Parameter *param)
{
GF_Err e;
const char *szCache;
GF_InputService *plug = (GF_InputService *)cbk;
TTIn *tti = (TTIn *) plug->priv;
if (!tti)
return;
gf_term_download_update_stats(tti->dnload);
e = param->error;
/*done*/
if (param->msg_type==GF_NETIO_DATA_TRANSFERED) {
szCache = gf_dm_sess_get_cache_name(tti->dnload);
if (!szCache) e = GF_IO_ERR;
else {
e = TTIn_LoadFile(plug, szCache, 1);
}
}
else if (param->msg_type==GF_NETIO_DATA_EXCHANGE)
return;
/*OK confirm*/
if (tti->needs_connection) {
tti->needs_connection = 0;
gf_term_on_connect(tti->service, NULL, e);
if (!e && !tti->od_done) tti_setup_object(tti);
}
}
static GF_Err V4_ConnectService (GF_InputService *plug, GF_ClientService *serv, const char *url)
{
V4Service *v4serv = (V4Service *)plug->priv;
v4serv->SetService(serv);
gf_term_on_connect(v4serv->GetService(), NULL, GF_OK);
return GF_OK;
}
static GF_Err AC3_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
char szURL[2048];
char *ext;
GF_Err reply;
AC3Reader *read = plug->priv;
read->service = serv;
if (read->dnload) gf_term_download_del(read->dnload);
read->dnload = NULL;
strcpy(szURL, url);
ext = strrchr(szURL, '#');
if (ext) ext[0] = 0;
/*remote fetch*/
read->is_remote = !ac3_is_local(szURL);
if (read->is_remote) {
ac3_download_file(plug, (char *) szURL);
return GF_OK;
}
reply = GF_OK;
read->stream = gf_f64_open(szURL, "rb");
if (!read->stream) {
reply = GF_URL_ERROR;
} else if (!AC3_ConfigureFromFile(read)) {
fclose(read->stream);
read->stream = NULL;
reply = GF_NOT_SUPPORTED;
}
gf_term_on_connect(serv, NULL, reply);
if (!reply && read->is_inline ) AC3_SetupObject(read);
return GF_OK;
}
static void AAC_OnLiveData(AACReader *read, char *data, u32 data_size)
{
u32 pos;
Bool sync;
GF_BitStream *bs;
ADTSHeader hdr;
read->data = realloc(read->data, sizeof(char)*(read->data_size+data_size) );
memcpy(read->data + read->data_size, data, sizeof(char)*data_size);
read->data_size += data_size;
if (read->needs_connection) {
read->needs_connection = 0;
bs = gf_bs_new(read->data, read->data_size, GF_BITSTREAM_READ);
sync = ADTS_SyncFrame(bs, 0, &hdr);
gf_bs_del(bs);
if (!sync) return;
read->nb_ch = hdr.nb_ch;
read->prof = hdr.profile;
read->sr_idx = hdr.sr_idx;
read->oti = hdr.is_mp2 ? read->prof+0x66-1 : 0x40;
read->sample_rate = GF_M4ASampleRates[read->sr_idx];
read->is_live = 1;
memset(&read->sl_hdr, 0, sizeof(GF_SLHeader));
gf_term_on_connect(read->service, NULL, GF_OK);
AAC_SetupObject(read);
}
if (!read->ch) return;
/*need a full adts header*/
if (read->data_size<=7) return;
bs = gf_bs_new(read->data, read->data_size, GF_BITSTREAM_READ);
hdr.frame_size = pos = 0;
while (ADTS_SyncFrame(bs, 0, &hdr)) {
pos = (u32) gf_bs_get_position(bs);
read->sl_hdr.accessUnitStartFlag = 1;
read->sl_hdr.accessUnitEndFlag = 1;
read->sl_hdr.AU_sequenceNumber++;
read->sl_hdr.compositionTimeStampFlag = 1;
read->sl_hdr.compositionTimeStamp += 1024;
gf_term_on_sl_packet(read->service, read->ch, read->data + pos, hdr.frame_size, &read->sl_hdr, GF_OK);
gf_bs_skip_bytes(bs, hdr.frame_size);
}
pos = (u32) gf_bs_get_position(bs);
gf_bs_del(bs);
if (pos) {
char *d;
read->data_size -= pos;
d = malloc(sizeof(char) * read->data_size);
memcpy(d, read->data + pos, sizeof(char) * read->data_size);
free(read->data);
read->data = d;
}
AAC_RegulateDataRate(read);
}
static GF_Err M2TS_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
GF_Err e;
const char *opt;
M2TSIn *m2ts = plug->priv;
M2TS_GetNetworkType(plug,m2ts);
m2ts->owner = plug;
opt = gf_modules_get_option((GF_BaseInterface *)m2ts->owner, "HybRadio", "Activated");
if (opt && !strcmp(opt, "true")) {
m2ts->hybrid_on = 1;
}
m2ts->ts->record_to = gf_modules_get_option((GF_BaseInterface *)m2ts->owner, "M2TS", "RecordTo");
m2ts->service = serv;
if (m2ts->owner->query_proxy) {
m2ts->ts->query_next = M2TS_QueryNextFile;
m2ts->ts->query_udta = m2ts;
}
opt = gf_modules_get_option((GF_BaseInterface *)m2ts->owner, "DSMCC", "Activated");
if (opt && !strcmp(opt, "yes")) {
gf_m2ts_demux_dmscc_init(m2ts->ts);
}
if (url && !strnicmp(url, "http://", 7)) {
m2ts->ts->dnload = gf_term_download_new(m2ts->service, url, GF_NETIO_SESSION_NOT_THREADED | GF_NETIO_SESSION_NOT_CACHED, m2ts_net_io, m2ts);
if (!m2ts->ts->dnload){
gf_term_on_connect(m2ts->service, NULL, GF_NOT_SUPPORTED);
return GF_OK;
} else {
e = gf_m2ts_demuxer_play(m2ts->ts);
}
} else {
e = gf_m2ts_demuxer_setup(m2ts->ts,url,0);
}
if (e) {
gf_term_on_connect(m2ts->service, NULL, e);
}
return e;
}
static GF_Err V4_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
{
u32 ESID;
V4Service *v4serv = (V4Service *)plug->priv;
sscanf(url, "ES_ID=%d", &ESID);
if (!ESID) {
gf_term_on_connect(v4serv->GetService(), channel, GF_STREAM_NOT_FOUND);
} else {
V4Channel *v4c = (V4Channel *)malloc(sizeof(V4Channel));
memset(v4c, 0, sizeof(V4Channel));
v4c->ch = channel;
v4c->ESID = ESID;
gf_list_add(v4serv->GetChannels(), v4c);
gf_term_on_connect(v4serv->GetService(), channel, GF_OK);
}
return GF_OK;
}
GF_Err DC_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
{
u32 ESID;
DCReader *read = (DCReader *) plug->priv;
sscanf(url, "ES_ID=%ud", &ESID);
if (!ESID) {
gf_term_on_connect(read->service, channel, GF_STREAM_NOT_FOUND);
} else {
DummyChannel *dc;
GF_SAFEALLOC(dc, DummyChannel);
dc->ch = channel;
dc->ESID = ESID;
gf_list_add(read->channels, dc);
gf_term_on_connect(read->service, channel, GF_OK);
}
return GF_OK;
}
static void MP3_OnLiveData(MP3Reader *read, char *data, u32 data_size)
{
u32 hdr, size, pos;
if (read->needs_connection) {
hdr = gf_mp3_get_next_header_mem(data, data_size, &pos);
if (!hdr) return;
read->sample_rate = gf_mp3_sampling_rate(hdr);
read->oti = gf_mp3_object_type_indication(hdr);
read->is_live = 1;
memset(&read->sl_hdr, 0, sizeof(GF_SLHeader));
read->needs_connection = 0;
gf_term_on_connect(read->service, NULL, GF_OK);
mp3_setup_object(read);
}
if (!data_size) return;
read->data = gf_realloc(read->data, sizeof(char)*(read->data_size+data_size) );
memcpy(read->data + read->data_size, data, sizeof(char)*data_size);
read->data_size += data_size;
if (!read->ch) return;
data = read->data;
data_size = read->data_size;
while (1) {
hdr = gf_mp3_get_next_header_mem(data, data_size, &pos);
if (hdr) size = gf_mp3_frame_size(hdr);
/*not enough data, copy over*/
if (!hdr || (pos+size>data_size)) {
char *d = gf_malloc(sizeof(char) * data_size);
memcpy(d, data, sizeof(char) * data_size);
gf_free(read->data);
read->data = d;
read->data_size = data_size;
MP3_RegulateDataRate(read);
return;
}
read->sl_hdr.accessUnitStartFlag = 1;
read->sl_hdr.accessUnitEndFlag = 1;
read->sl_hdr.AU_sequenceNumber++;
read->sl_hdr.compositionTimeStampFlag = 1;
read->sl_hdr.compositionTimeStamp += gf_mp3_window_size(hdr);
gf_term_on_sl_packet(read->service, read->ch, data + pos, size, &read->sl_hdr, GF_OK);
data += pos + size;
assert(data_size>=pos+size);
data_size -= pos+size;
}
}
static void AC3_OnLiveData(AC3Reader *read, const char *data, u32 data_size)
{
u64 pos;
Bool sync;
GF_BitStream *bs;
GF_AC3Header hdr;
read->data = gf_realloc(read->data, sizeof(char)*(read->data_size+data_size) );
memcpy(read->data + read->data_size, data, sizeof(char)*data_size);
read->data_size += data_size;
if (read->needs_connection) {
read->needs_connection = 0;
bs = gf_bs_new(read->data, read->data_size, GF_BITSTREAM_READ);
sync = gf_ac3_parser_bs(bs, &hdr, 1);
gf_bs_del(bs);
if (!sync) return;
read->nb_ch = hdr.channels;
read->sample_rate = hdr.sample_rate;
read->is_live = 1;
memset(&read->sl_hdr, 0, sizeof(GF_SLHeader));
gf_term_on_connect(read->service, NULL, GF_OK);
AC3_SetupObject(read);
}
if (!read->ch) return;
/*need a full ac3 header*/
if (read->data_size<=7) return;
bs = gf_bs_new(read->data, read->data_size, GF_BITSTREAM_READ);
hdr.framesize = 0;
pos = 0;
while (gf_ac3_parser_bs(bs, &hdr, 0)) {
pos = gf_bs_get_position(bs);
read->sl_hdr.accessUnitStartFlag = 1;
read->sl_hdr.accessUnitEndFlag = 1;
read->sl_hdr.AU_sequenceNumber++;
read->sl_hdr.compositionTimeStampFlag = 1;
read->sl_hdr.compositionTimeStamp += 1536;
gf_term_on_sl_packet(read->service, read->ch, read->data + pos, hdr.framesize, &read->sl_hdr, GF_OK);
gf_bs_skip_bytes(bs, hdr.framesize);
}
pos = gf_bs_get_position(bs);
gf_bs_del(bs);
if (pos) {
char *d;
read->data_size -= (u32) pos;
d = gf_malloc(sizeof(char) * read->data_size);
memcpy(d, read->data + pos, sizeof(char) * read->data_size);
gf_free(read->data);
read->data = d;
}
AC3_RegulateDataRate(read);
}
static GF_Err HYB_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
u32 i;
GF_Err e = GF_OK;
const size_t nb_masters = sizeof(hyb_masters) / sizeof(GF_HYBMEDIA*);
GF_HYB_In *hyb_in = (GF_HYB_In*)plug->priv;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[HYB_IN] Received Connection request from service %p for %s\n", serv, url));
if (!hyb_in || !serv || !url) return GF_BAD_PARAM;
hyb_in->service = serv;
/*choose the master service*/
for (i=0; i<nb_masters; i++) {
if (hyb_masters[i]->CanHandleURL(url)) {
hyb_in->master = hyb_masters[i];
break;
}
}
assert(hyb_in->master);
/*sanity check about the master*/
e = hybmedia_sanity_check(hyb_in->master);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[HYB_IN] Error - object \"%s\" failed the sanity checks\n", hyb_in->master->name));
gf_term_on_connect(hyb_in->service, NULL, e);
return e;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[HYB_IN] Selected master object \"%s\" for URL: %s\n", hyb_in->master->name, url));
/*connect the master*/
e = hyb_in->master->Connect(hyb_in->master, hyb_in->service, url);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[HYB_IN] Error - cannot connect service, wrong URL %s\n", url));
gf_term_on_connect(hyb_in->service, NULL, GF_BAD_PARAM);
return e;
}
gf_term_on_connect(hyb_in->service, NULL, GF_OK);
gf_term_add_media(hyb_in->service, (GF_Descriptor*)hyb_in->master->GetOD(), 0);
return GF_OK;
}
void isor_setup_download(GF_InputService *plug, const char *url)
{
ISOMReader *read = (ISOMReader *) plug->priv;
read->dnload = gf_term_download_new(read->service, url, 0, isor_net_io, read);
if (!read->dnload) {
gf_term_on_connect(read->service, NULL, GF_NOT_SUPPORTED);
} else {
/*start our download (threaded)*/
gf_dm_sess_process(read->dnload);
}
/*service confirm is done once IOD can be fetched*/
}
void DC_DownloadFile(GF_InputService *plug, char *url)
{
DCReader *read = (DCReader *) plug->priv;
read->dnload = gf_term_download_new(read->service, url, 0, DC_NetIO, read);
if (!read->dnload) {
gf_term_on_connect(read->service, NULL, GF_NOT_SUPPORTED);
} else {
/*start our download (threaded)*/
gf_dm_sess_process(read->dnload);
}
}
u32 RP_Thread(void *param)
{
u32 i;
GF_NetworkCommand com;
RTSPSession *sess;
RTPStream *ch;
RTPClient *rtp = (RTPClient *)param;
rtp->th_state = 1;
com.command_type = GF_NET_CHAN_BUFFER_QUERY;
while (rtp->th_state) {
gf_mx_p(rtp->mx);
/*fecth data on udp*/
i=0;
while ((ch = (RTPStream *)gf_list_enum(rtp->channels, &i))) {
if ((ch->flags & RTP_EOS) || (ch->status!=RTP_Running) ) continue;
/*for interleaved channels don't read too fast, query the buffer occupancy*/
if (ch->flags & RTP_INTERLEAVED) {
com.base.on_channel = ch->channel;
gf_term_on_command(rtp->service, &com, GF_OK);
/*if no buffering, use a default value (3 sec of data should do it)*/
if (!com.buffer.max) com.buffer.max = 3000;
if (com.buffer.occupancy <= com.buffer.max) ch->rtsp->flags |= RTSP_TCP_FLUSH;
} else {
RP_ReadStream(ch);
}
}
/*and process commands / flush TCP*/
i=0;
while ((sess = (RTSPSession *)gf_list_enum(rtp->sessions, &i))) {
RP_ProcessCommands(sess);
if (sess->connect_error) {
gf_term_on_connect(sess->owner->service, NULL, sess->connect_error);
sess->connect_error = 0;
}
}
gf_mx_v(rtp->mx);
gf_sleep(1);
}
if (rtp->dnload) gf_term_download_del(rtp->dnload);
rtp->dnload = NULL;
rtp->th_state = 2;
return 0;
}
void aac_download_file(GF_InputService *plug, char *url)
{
AACReader *read = (AACReader*) plug->priv;
read->needs_connection = 1;
read->dnload = gf_term_download_new(read->service, url, 0, AAC_NetIO, read);
if (!read->dnload ) {
read->needs_connection = 0;
gf_term_on_connect(read->service, NULL, GF_NOT_SUPPORTED);
}
/*service confirm is done once fetched*/
}
static void SAF_DownloadFile(GF_InputService *plug, char *url)
{
SAFIn *read = (SAFIn*) plug->priv;
read->dnload = gf_term_download_new(read->service, url, 0, SAF_NetIO, read);
if (!read->dnload) {
read->needs_connection = 0;
gf_term_on_connect(read->service, NULL, GF_NOT_SUPPORTED);
} else {
/*start our download (threaded)*/
gf_dm_sess_process(read->dnload);
}
/*service confirm is done once fetched*/
}
void VTT_download_file(GF_InputService *plug, const char *url)
{
VTTIn *vttin = (VTTIn *) plug->priv;
if (!plug || !url)
return;
vttin->needs_connection = GF_TRUE;
vttin->dnload = gf_term_download_new(vttin->service, url, 0, VTT_NetIO, plug);
if (!vttin->dnload) {
vttin->needs_connection = GF_FALSE;
gf_term_on_connect(vttin->service, NULL, GF_NOT_SUPPORTED);
} else {
/*start our download (threaded)*/
gf_dm_sess_process(vttin->dnload);
}
/*service confirm is done once fetched*/
}
void TTIn_download_file(GF_InputService *plug, const char *url)
{
TTIn *tti = (TTIn *) plug->priv;
if (!plug || !url)
return;
tti->needs_connection = 1;
tti->dnload = gf_term_download_new(tti->service, url, 0, TTIn_NetIO, plug);
if (!tti->dnload) {
tti->needs_connection = 0;
gf_term_on_connect(tti->service, NULL, GF_NOT_SUPPORTED);
} else {
/*start our download (threaded)*/
gf_dm_sess_process(tti->dnload);
}
/*service confirm is done once fetched*/
}
static GF_Err HYB_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
{
GF_HYB_In *hyb_in;
GF_HYBMEDIA *master;
if (!plug || !plug->priv)
return GF_SERVICE_ERROR;
hyb_in = (GF_HYB_In*)plug->priv;
master = (GF_HYBMEDIA*)hyb_in->master;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[HYB_IN] Received Channel Connection request from service %p for %s\n", channel, url));
master->channel = channel;
gf_term_on_connect(hyb_in->service, channel, GF_OK);
return GF_OK;
}
static GF_Err HYB_CloseService(GF_InputService *plug)
{
GF_Err e;
GF_HYB_In *hyb_in = (GF_HYB_In*)plug->priv;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[HYB_IN] Received Close Service (%p) request from terminal\n", ((GF_HYB_In*)plug->priv)->service));
/*force to stop and disconnect the master*/
hyb_in->master->SetState(hyb_in->master, GF_NET_CHAN_STOP);
e = hyb_in->master->Disconnect(hyb_in->master);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[HYB_IN] Error - cannot disconnect service %p\n", hyb_in->service));
gf_term_on_connect(hyb_in->service, NULL, GF_BAD_PARAM);
return e;
}
gf_term_on_disconnect(hyb_in->service, NULL, GF_OK);
return GF_OK;
}
static GF_Err TTIn_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
GF_Err e;
TTIn *tti = (TTIn *)plug->priv;
if (!plug || !url)
return GF_BAD_PARAM;
tti->service = serv;
if (tti->dnload) gf_term_download_del(tti->dnload);
tti->dnload = NULL;
/*remote fetch*/
if (!TTIn_is_local(url)) {
TTIn_download_file(plug, url);
return GF_OK;
}
e = TTIn_LoadFile(plug, url, 0);
gf_term_on_connect(serv, NULL, e);
if (!e && !tti->od_done) tti_setup_object(tti);
return GF_OK;
}
static GF_Err VTT_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
{
u32 ES_ID;
GF_Err e;
VTTIn *vttin = (VTTIn *)plug->priv;
if (!vttin) return GF_BAD_PARAM;
e = GF_SERVICE_ERROR;
if (!vttin || vttin->channel==channel) goto exit;
e = GF_STREAM_NOT_FOUND;
ES_ID = 0;
if (strstr(url, "ES_ID")) sscanf(url, "ES_ID=%ud", &ES_ID);
if (ES_ID==1) {
vttin->channel = channel;
e = GF_OK;
}
exit:
gf_term_on_connect(vttin->service, channel, e);
return e;
}
static GF_Err FFD_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
{
GF_Err e;
u32 ESID;
FFDemux *ffd = plug->priv;
e = GF_STREAM_NOT_FOUND;
if (upstream) {
e = GF_ISOM_INVALID_FILE;
goto exit;
}
if (!strstr(url, "ES_ID=")) {
e = GF_NOT_SUPPORTED;
goto exit;
}
sscanf(url, "ES_ID=%u", &ESID);
if ((s32) ESID == 1 + ffd->audio_st) {
if (ffd->audio_ch) {
e = GF_SERVICE_ERROR;
goto exit;
}
ffd->audio_ch = channel;
e = GF_OK;
}
else if ((s32) ESID == 1 + ffd->video_st) {
if (ffd->video_ch) {
e = GF_SERVICE_ERROR;
goto exit;
}
ffd->video_ch = channel;
e = GF_OK;
}
exit:
gf_term_on_connect(ffd->service, channel, e);
return GF_OK;
}
static GF_Err VTT_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
GF_Err e;
VTTIn *vttin = (VTTIn *)plug->priv;
if (!plug || !url)
return GF_BAD_PARAM;
vttin->service = serv;
if (vttin->dnload) gf_term_download_del(vttin->dnload);
vttin->dnload = NULL;
/*remote fetch*/
if (!VTT_is_local(url)) {
VTT_download_file(plug, url);
return GF_OK;
} else {
e = GF_OK;
//e = TTIn_LoadFile(plug, url, 0);
gf_term_on_connect(serv, NULL, e);
//if (!e && !vttin->od_done) tti_setup_object(vttin);
}
return GF_OK;
}
void DC_NetIO(void *cbk, GF_NETIO_Parameter *param)
{
GF_Err e;
DCReader *read = (DCReader *) cbk;
/*handle service message*/
gf_term_download_update_stats(read->dnload);
e = param->error;
if (param->msg_type==GF_NETIO_DATA_TRANSFERED) {
} else if (param->msg_type==GF_NETIO_PARSE_HEADER) {
if (!strcmp(param->name, "Content-Type")) {
if (strstr(param->value, "application/x-bt")) read->oti = GPAC_OTI_PRIVATE_SCENE_GENERIC;
if (strstr(param->value, "application/x-xmt")) read->oti = GPAC_OTI_PRIVATE_SCENE_GENERIC;
if (strstr(param->value, "model/vrml")) read->oti = GPAC_OTI_PRIVATE_SCENE_GENERIC;
if (strstr(param->value, "model/x3d+vrml")) read->oti = GPAC_OTI_PRIVATE_SCENE_GENERIC;
if (strstr(param->value, "application/x-shockwave-flash")) read->oti = GPAC_OTI_PRIVATE_SCENE_GENERIC;
if (strstr(param->value, "image/svg+xml")) read->oti = GPAC_OTI_PRIVATE_SCENE_SVG;
if (strstr(param->value, "image/x-svgm")) read->oti = GPAC_OTI_PRIVATE_SCENE_SVG;
if (strstr(param->value, "application/x-LASeR+xml")) read->oti = GPAC_OTI_PRIVATE_SCENE_GENERIC;
if (strstr(param->value, "application/widget")) read->oti = GPAC_OTI_PRIVATE_SCENE_WGT;
if (strstr(param->value, "application/x-mpegu-widget")) read->oti = GPAC_OTI_PRIVATE_SCENE_WGT;
}
return;
} else if (!e && (param->msg_type!=GF_NETIO_DATA_EXCHANGE)) return;
if (!e && !read->oti)
return;
/*OK confirm*/
if (!read->is_service_connected) {
if (!gf_dm_sess_get_cache_name(read->dnload)) e = GF_IO_ERR;
gf_term_on_connect(read->service, NULL, e);
read->is_service_connected = 1;
}
}
