static GF_Err ISMA_GetGPAC_KMS(ISMAEAPriv *priv, GF_Channel *ch, const char *kms_url)
{
GF_Err e;
FILE *t;
GF_DownloadSession * sess;
if (!strnicmp(kms_url, "(ipmp)", 6)) return GF_NOT_SUPPORTED;
else if (!strnicmp(kms_url, "(uri)", 5)) kms_url += 5;
else if (!strnicmp(kms_url, "file://", 7)) kms_url += 7;
e = GF_OK;
/*try local*/
t = (strstr(kms_url, "://") == NULL) ? gf_f64_open(kms_url, "r") : NULL;
if (t) {
fclose(t);
return gf_ismacryp_gpac_get_info(ch->esd->ESID, (char *)kms_url, priv->key, priv->salt);
}
/*note that gpac doesn't have TLS support -> not really usefull. As a general remark, ISMACryp
is supported as a proof of concept, crypto and IPMP being the last priority on gpac...*/
GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("[CENC/ISMA] Fetching ISMACryp key for channel %d\n", ch->esd->ESID) );
sess = gf_term_download_new(ch->service, kms_url, 0, ISMA_KMS_NetIO, ch);
if (!sess) return GF_IO_ERR;
/*start our download (threaded)*/
gf_dm_sess_process(sess);
while (1) {
e = gf_dm_sess_get_stats(sess, NULL, NULL, NULL, NULL, NULL, NULL);
if (e) break;
}
if (e==GF_EOS) {
e = gf_ismacryp_gpac_get_info(ch->esd->ESID, (char *) gf_dm_sess_get_cache_name(sess), priv->key, priv->salt);
}
gf_term_download_del(sess);
return e;
}
GF_DASHFileIOSession mpdin_dash_io_create(GF_DASHFileIO *dashio, Bool persistent, const char *url)
{
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;
sess = gf_term_download_new(mpdin->service, url, flags, NULL, NULL);
return (GF_DASHFileIOSession ) sess;
}
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);
}
}
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*/
}
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_term_download_new(mpdin->service, url, flags, mpdin_dash_segment_netio, group);
} else {
sess = gf_term_download_new(mpdin->service, url, flags, NULL, NULL);
}
return (GF_DASHFileIOSession ) sess;
}
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 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*/
}
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*/
}
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;
}
void RP_SaveSessionState(RTPClient *rtp)
{
GF_Err e;
char *sdp_buf;
const char *opt;
GF_X_Attribute*att;
u32 i, j;
GF_SDPInfo *sdp;
RTSPSession *sess = NULL;
if (!rtp->session_state_data) return;
sdp_buf = rtp->session_state_data + strlen("data:application/sdp,");
sdp = gf_sdp_info_new();
e = gf_sdp_info_parse(sdp, sdp_buf, (u32) strlen(sdp_buf) );
for (i=0; i<gf_list_count(rtp->channels); i++) {
GF_SDPMedia *media = NULL;
RTPStream *ch = gf_list_get(rtp->channels, i);
if (!ch->control) continue;
for (j=0; j<gf_list_count(sdp->media_desc); j++) {
u32 k;
GF_SDPMedia *med = (GF_SDPMedia*)gf_list_get(sdp->media_desc, j);
for (k=0; k<gf_list_count(med->Attributes); k++) {
att = (GF_X_Attribute*)gf_list_get(med->Attributes, k);
if (!stricmp(att->Name, "control") && (strstr(att->Value, ch->control)!=NULL) ) {
media = med;
break;
}
}
if (media)
break;
}
if (!media) continue;
if (ch->rtp_ch->net_info.IsUnicast) {
char szPorts[4096];
u16 porta, portb;
media->PortNumber = ch->rtp_ch->net_info.client_port_first;
/*remove x-server-port extension*/
for (j=0; j<gf_list_count(media->Attributes); j++) {
att = (GF_X_Attribute*)gf_list_get(media->Attributes, j);
if (!stricmp(att->Name, "x-stream-state") ) {
gf_free(att->Name);
gf_free(att->Value);
gf_free(att);
gf_list_rem(media->Attributes, j);
}
}
ch->current_start += gf_rtp_get_current_time(ch->rtp_ch);
GF_SAFEALLOC(att, GF_X_Attribute);
att->Name = gf_strdup("x-stream-state");
porta = ch->rtp_ch->net_info.port_first ? ch->rtp_ch->net_info.port_first : ch->rtp_ch->net_info.client_port_first;
portb = ch->rtp_ch->net_info.port_last ? ch->rtp_ch->net_info.port_last : ch->rtp_ch->net_info.client_port_last;
sprintf(szPorts, "server-port=%d-%d;ssrc=%X;npt=%g;seq=%d;rtptime=%d",
porta,
portb,
ch->rtp_ch->SenderSSRC,
ch->current_start,
ch->rtp_ch->rtp_first_SN,
ch->rtp_ch->rtp_time
);
att->Value = gf_strdup(szPorts);
gf_list_add(media->Attributes, att);
if (ch->rtsp)
sess = ch->rtsp;
} else {
media->PortNumber = ch->rtp_ch->net_info.port_first;
}
}
/*remove x-server-port/x-session-id extension*/
for (j=0; j<gf_list_count(sdp->Attributes); j++) {
att = (GF_X_Attribute*)gf_list_get(sdp->Attributes, j);
if (!stricmp(att->Name, "x-session-id") || !stricmp(att->Name, "x-session-name")
) {
gf_free(att->Name);
gf_free(att->Value);
gf_free(att);
gf_list_rem(sdp->Attributes, j);
}
}
if (sess) {
char szURL[4096];
if (sess->session_id) {
GF_SAFEALLOC(att, GF_X_Attribute);
att->Name = gf_strdup("x-session-id");
att->Value = gf_strdup(sess->session_id);
gf_list_add(sdp->Attributes, att);
}
GF_SAFEALLOC(att, GF_X_Attribute);
att->Name = gf_strdup("x-session-name");
sprintf(szURL, "rtsp://%s:%d/%s", sess->session->Server, sess->session->Port, sess->session->Service);
att->Value = gf_strdup(szURL);
gf_list_add(sdp->Attributes, att);
}
gf_free(rtp->session_state_data);
sdp_buf = NULL;
gf_sdp_info_write(sdp, &sdp_buf);
if (sdp_buf) {
rtp->session_state_data = gf_malloc(sizeof(char) * (strlen("data:application/sdp,") + strlen(sdp_buf) + 1) );
strcpy(rtp->session_state_data, "data:application/sdp,");
strcat(rtp->session_state_data, sdp_buf);
gf_free(sdp_buf);
}
gf_sdp_info_del(sdp);
opt = (char *) gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(rtp->service), "Streaming", "SessionMigrationServer");
if (opt) {
if (rtp->dnload) gf_term_download_del(rtp->dnload);
rtp->dnload = NULL;
if (strnicmp(opt, "http://", 7)) {
rtp->dnload = gf_term_download_new(rtp->service, opt, GF_NETIO_SESSION_NOT_THREADED, MigrateSDP_NetIO, rtp);
while (1) {
char buffer[100];
u32 read;
e = gf_dm_sess_fetch_data(rtp->dnload, buffer, 100, &read);
if (e && (e!=GF_IP_NETWORK_EMPTY)) break;
}
gf_term_download_del(rtp->dnload);
rtp->dnload = NULL;
} else {
FILE *f = gf_f64_open(opt, "wt");
if (f) {
sdp_buf = rtp->session_state_data + strlen("data:application/sdp,");
gf_fwrite(sdp_buf, 1, strlen(sdp_buf), f);
fclose(f);
} else {
e = GF_IO_ERR;
}
}
if (e<0) {
gf_term_on_message(sess->owner->service, e, "Error saving session state");
}
}
}
static GF_Err FFD_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
GF_Err e;
s64 last_aud_pts;
u32 i;
s32 res;
Bool is_local;
const char *sOpt;
char *ext, szName[1024];
FFDemux *ffd = plug->priv;
AVInputFormat *av_in = NULL;
char szExt[20];
if (ffd->ctx) return GF_SERVICE_ERROR;
assert( url && strlen(url) < 1024);
strcpy(szName, url);
ext = strrchr(szName, '#');
ffd->service_type = 0;
e = GF_NOT_SUPPORTED;
ffd->service = serv;
if (ext) {
if (!stricmp(&ext[1], "video")) ffd->service_type = 1;
else if (!stricmp(&ext[1], "audio")) ffd->service_type = 2;
ext[0] = 0;
}
/*some extensions not supported by ffmpeg, overload input format*/
ext = strrchr(szName, '.');
strcpy(szExt, ext ? ext+1 : "");
strlwr(szExt);
if (!strcmp(szExt, "cmp")) av_in = av_find_input_format("m4v");
is_local = (strnicmp(url, "file://", 7) && strstr(url, "://")) ? 0 : 1;
GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[FFMPEG] opening file %s - local %d - av_in %08x\n", url, is_local, av_in));
if (!is_local) {
AVProbeData pd;
/*setup wraper for FFMPEG I/O*/
ffd->buffer_size = 8192;
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "FFMPEG", "IOBufferSize");
if (sOpt) ffd->buffer_size = atoi(sOpt);
ffd->buffer = gf_malloc(sizeof(char)*ffd->buffer_size);
#ifdef FFMPEG_DUMP_REMOTE
ffd->outdbg = gf_f64_open("ffdeb.raw", "wb");
#endif
#ifdef USE_PRE_0_7
init_put_byte(&ffd->io, ffd->buffer, ffd->buffer_size, 0, ffd, ff_url_read, NULL, NULL);
ffd->io.is_streamed = 1;
#else
ffd->io.seekable = 1;
#endif
ffd->dnload = gf_term_download_new(ffd->service, url, GF_NETIO_SESSION_NOT_THREADED | GF_NETIO_SESSION_NOT_CACHED, NULL, ffd);
if (!ffd->dnload) return GF_URL_ERROR;
while (1) {
u32 read;
e = gf_dm_sess_fetch_data(ffd->dnload, ffd->buffer + ffd->buffer_used, ffd->buffer_size - ffd->buffer_used, &read);
if (e==GF_EOS) break;
/*we're sync!!*/
if (e==GF_IP_NETWORK_EMPTY) continue;
if (e) goto err_exit;
ffd->buffer_used += read;
if (ffd->buffer_used == ffd->buffer_size) break;
}
if (e==GF_EOS) {
const char *cache_file = gf_dm_sess_get_cache_name(ffd->dnload);
res = open_file(&ffd->ctx, cache_file, av_in);
} else {
pd.filename = szName;
pd.buf_size = ffd->buffer_used;
pd.buf = (u8 *) ffd->buffer;
av_in = av_probe_input_format(&pd, 1);
if (!av_in) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[FFMPEG] error probing file %s - probe start with %c %c %c %c\n", url, ffd->buffer[0], ffd->buffer[1], ffd->buffer[2], ffd->buffer[3]));
return GF_NOT_SUPPORTED;
}
/*setup downloader*/
av_in->flags |= AVFMT_NOFILE;
#if FF_API_FORMAT_PARAMETERS /*commit ffmpeg 603b8bc2a109978c8499b06d2556f1433306eca7*/
res = avformat_open_input(&ffd->ctx, szName, av_in, NULL);
#else
res = av_open_input_stream(&ffd->ctx, &ffd->io, szName, av_in, NULL);
#endif
}
} else {
res = open_file(&ffd->ctx, szName, av_in);
}
switch (res) {
#ifndef _WIN32_WCE
case 0:
e = GF_OK;
break;
case AVERROR_IO:
e = GF_URL_ERROR;
goto err_exit;
case AVERROR_INVALIDDATA:
e = GF_NON_COMPLIANT_BITSTREAM;
goto err_exit;
case AVERROR_NOMEM:
e = GF_OUT_OF_MEM;
goto err_exit;
case AVERROR_NOFMT:
e = GF_NOT_SUPPORTED;
goto err_exit;
#endif
default:
e = GF_SERVICE_ERROR;
goto err_exit;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[FFMPEG] looking for streams in %s - %d streams - type %s\n", ffd->ctx->filename, ffd->ctx->nb_streams, ffd->ctx->iformat->name));
res = av_find_stream_info(ffd->ctx);
if (res <0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[FFMPEG] cannot locate streams - error %d\n", res));
e = GF_NOT_SUPPORTED;
goto err_exit;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[FFMPEG] file %s opened - %d streams\n", url, ffd->ctx->nb_streams));
/*figure out if we can use codecs or not*/
ffd->audio_st = ffd->video_st = -1;
for (i = 0; i < ffd->ctx->nb_streams; i++) {
AVCodecContext *enc = ffd->ctx->streams[i]->codec;
switch(enc->codec_type) {
case AVMEDIA_TYPE_AUDIO:
if ((ffd->audio_st<0) && (ffd->service_type!=1)) {
ffd->audio_st = i;
ffd->audio_tscale = ffd->ctx->streams[i]->time_base;
}
break;
case AVMEDIA_TYPE_VIDEO:
if ((ffd->video_st<0) && (ffd->service_type!=2)) {
ffd->video_st = i;
ffd->video_tscale = ffd->ctx->streams[i]->time_base;
}
break;
default:
break;
}
}
if ((ffd->service_type==1) && (ffd->video_st<0)) goto err_exit;
if ((ffd->service_type==2) && (ffd->audio_st<0)) goto err_exit;
if ((ffd->video_st<0) && (ffd->audio_st<0)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[FFMPEG] No supported streams in file\n"));
goto err_exit;
}
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "FFMPEG", "DataBufferMS");
ffd->data_buffer_ms = 0;
if (sOpt) ffd->data_buffer_ms = atoi(sOpt);
if (!ffd->data_buffer_ms) ffd->data_buffer_ms = FFD_DATA_BUFFER;
/*build seek*/
if (is_local) {
/*check we do have increasing pts. If not we can't rely on pts, we must skip SL
we assume video pts is always present*/
if (ffd->audio_st>=0) {
last_aud_pts = 0;
for (i=0; i<20; i++) {
AVPacket pkt;
pkt.stream_index = -1;
if (av_read_frame(ffd->ctx, &pkt) <0) break;
if (pkt.pts == AV_NOPTS_VALUE) pkt.pts = pkt.dts;
if (pkt.stream_index==ffd->audio_st) last_aud_pts = pkt.pts;
}
if (last_aud_pts*ffd->audio_tscale.den<10*ffd->audio_tscale.num) ffd->unreliable_audio_timing = 1;
}
ffd->seekable = (av_seek_frame(ffd->ctx, -1, 0, AVSEEK_FLAG_BACKWARD)<0) ? 0 : 1;
if (!ffd->seekable) {
av_close_input_file(ffd->ctx);
ffd->ctx = NULL;
open_file(&ffd->ctx, szName, av_in);
av_find_stream_info(ffd->ctx);
}
}
/*let's go*/
gf_term_on_connect(serv, NULL, GF_OK);
/*if (!ffd->service_type)*/ FFD_SetupObjects(ffd);
ffd->service_type = 0;
return GF_OK;
err_exit:
GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[FFMPEG] Error opening file %s: %s\n", url, gf_error_to_string(e)));
if (ffd->ctx) av_close_input_file(ffd->ctx);
ffd->ctx = NULL;
gf_term_on_connect(serv, NULL, e);
return GF_OK;
}
