void VTT_load_script(VTTDec *vttdec, GF_SceneGraph *graph)
{
GF_Node *n, *root;
GF_FieldInfo info;
const char *path;
FILE *jsfile;
if (!graph) return;
gf_sg_add_namespace(graph, "http://www.w3.org/2000/svg", NULL);
gf_sg_add_namespace(graph, "http://www.w3.org/1999/xlink", "xlink");
gf_sg_add_namespace(graph, "http://www.w3.org/2001/xml-events", "ev");
gf_sg_set_scene_size_info(graph, 800, 600, GF_TRUE);
/* modify the scene with an Inline/Animation pointing to the VTT Renderer */
n = root = gf_node_new(graph, TAG_SVG_svg);
gf_node_register(root, NULL);
gf_sg_set_root_node(graph, root);
gf_node_get_attribute_by_name(n, "xmlns", 0, GF_TRUE, GF_FALSE, &info);
gf_svg_parse_attribute(n, &info, "http://www.w3.org/2000/svg", 0);
VTT_UpdateSizeInfo(vttdec);
gf_node_init(n);
n = gf_node_new(graph, TAG_SVG_script);
gf_node_register(n, root);
gf_node_list_add_child(&((GF_ParentNode *)root)->children, n);
path = gf_modules_get_option((GF_BaseInterface *)vttdec->module, "WebVTT", "RenderingScript");
if (!path) {
/* try to find the JS renderer in the default GPAC installation folder */
const char *startuppath = gf_modules_get_option((GF_BaseInterface *)vttdec->module, "General", "StartupFile");
path = gf_url_concatenate(startuppath, "webvtt-renderer.js");
jsfile = gf_fopen(path, "rt");
if (jsfile) {
gf_modules_set_option((GF_BaseInterface *)vttdec->module, "WebVTT", "RenderingScript", path);
gf_fclose(jsfile);
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[WebVTT] Cannot find Rendering Script [WebVTT:RenderingScript] - check config file\n"));
return;
}
}
jsfile = gf_fopen(path, "rt");
if (jsfile) {
gf_fclose(jsfile);
gf_node_get_attribute_by_tag(n, TAG_XLINK_ATT_href, GF_TRUE, GF_FALSE, &info);
if (strstr(path, ":\\")) {
gf_svg_parse_attribute(n, &info, (char *) path, 0);
} else {
char szPath[GF_MAX_PATH];
strcpy(szPath, "file://");
strcat(szPath, path);
gf_svg_parse_attribute(n, &info, (char *) szPath, 0);
}
vttdec->has_rendering_script = GF_TRUE;
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[WebVTT] Cannot open Rendering Script - %s\n", path));
return;
}
gf_node_init(n);
}
static GF_Err ALSA_Setup(GF_AudioOutput*dr, void *os_handle, u32 num_buffers, u32 total_duration)
{
int err;
const char *opt;
ALSAContext *ctx = (ALSAContext*)dr->opaque;
opt = gf_modules_get_option((GF_BaseInterface *)dr, "ALSA", "ForceSampleRate");
if (opt) ctx->force_sr = atoi(opt);
ctx->dev_name = gf_modules_get_option((GF_BaseInterface *)dr, "ALSA", "DeviceName");
if (!ctx->dev_name) {
ctx->dev_name = "hw:0,0";
gf_modules_set_option((GF_BaseInterface *)dr, "ALSA", "DeviceName", ctx->dev_name);
}
/*test device*/
err = snd_pcm_open(&ctx->playback_handle, ctx->dev_name, SND_PCM_STREAM_PLAYBACK, 0);
if (err < 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[ALSA] Cannot open audio device %s: %s\n", ctx->dev_name, snd_strerror (err)) );
return GF_IO_ERR;
}
ctx->num_buffers = num_buffers;
ctx->total_duration = total_duration;
return GF_OK;
}
GF_Err RP_InitStream(RTPStream *ch, Bool ResetOnly)
{
gf_rtp_depacketizer_reset(ch->depacketizer, !ResetOnly);
if (!ResetOnly) {
const char *ip_ifce = NULL;
u32 reorder_size = 0;
if (!ch->owner->transport_mode) {
const char *sOpt = gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(ch->owner->service), "Streaming", "ReorderSize");
if (sOpt) reorder_size = atoi(sOpt);
else reorder_size = 10;
ip_ifce = gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(ch->owner->service), "Network", "DefaultMCastInterface");
if (!ip_ifce) {
const char *mob_on = gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(ch->owner->service), "Network", "MobileIPEnabled");
if (mob_on && !strcmp(mob_on, "yes")) {
ip_ifce = gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(ch->owner->service), "Network", "MobileIP");
ch->flags |= RTP_MOBILEIP;
}
}
}
return gf_rtp_initialize(ch->rtp_ch, RTP_BUFFER_SIZE, 0, 0, reorder_size, 200, (char *)ip_ifce);
}
//just reset the sockets
gf_rtp_reset_buffers(ch->rtp_ch);
return GF_OK;
}
static GF_Err ft_init_font_engine(GF_FontReader *dr)
{
const char *sOpt;
FTBuilder *ftpriv = (FTBuilder *)dr->udta;
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontDirectory");
if (!sOpt) return GF_BAD_PARAM;
/*inits freetype*/
if (FT_Init_FreeType(&ftpriv->library) ) {
GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[FreeType] Cannot initialize FreeType\n"));
return GF_IO_ERR;
}
while (sOpt) {
char dir[GF_MAX_PATH];
char *sep = (char *) strchr(sOpt, ',');
if (sep) sep[0] = 0;
strcpy(dir, sOpt);
while ( (dir[strlen(dir)-1] == '\n') || (dir[strlen(dir)-1] == '\r') )
dir[strlen(dir)-1] = 0;
if (dir[strlen(dir)-1] != GF_PATH_SEPARATOR) {
char ext[2];
ext[0] = GF_PATH_SEPARATOR;
ext[1] = 0;
strcat(dir, ext);
}
gf_list_add(ftpriv->font_dirs, gf_strdup(dir) );
if (!sep) break;
sep[0] = ',';
sOpt = sep+1;
}
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "RescanFonts");
if (!sOpt || !strcmp(sOpt, "yes") )
ft_rescan_fonts(dr);
if (!ftpriv->font_serif) {
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSerif");
ftpriv->font_serif = gf_strdup(sOpt ? sOpt : "");
}
if (!ftpriv->font_sans) {
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSans");
ftpriv->font_sans = gf_strdup(sOpt ? sOpt : "");
}
if (!ftpriv->font_fixed) {
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontFixed");
ftpriv->font_fixed = gf_strdup(sOpt ? sOpt : "");
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("[FreeType] Init OK - %d font directory (first %s)\n", gf_list_count(ftpriv->font_dirs), gf_list_get(ftpriv->font_dirs, 0) ));
return GF_OK;
}
static void dd_init_gl_offscreen(GF_VideoOutput *driv)
{
const char *opt;
DDContext *dd = driv->opaque;
opt = gf_modules_get_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode");
#ifndef _WIN32_WCE
wglCreatePbufferARB = (CREATEPBUFFERARB) wglGetProcAddress("wglCreatePbufferARB");
if (opt && strcmp(opt, "PBuffer")) wglCreatePbufferARB = NULL;
if (wglCreatePbufferARB) {
wglChoosePixelFormatARB = (CHOOSEPFFORMATARB) wglGetProcAddress("wglChoosePixelFormatARB");
wglDestroyPbufferARB = (DESTROYBUFFERARB) wglGetProcAddress("wglDestroyPbufferARB");
wglGetPbufferDCARB = (GETPBUFFERDCARB ) wglGetProcAddress("wglGetPbufferDCARB");
wglReleasePbufferDCARB = (RELEASEPBUFFERDCARB ) wglGetProcAddress("wglReleasePbufferDCARB");
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX] Using PBuffer for OpenGL Offscreen Rendering\n"));
driv->hw_caps |= GF_VIDEO_HW_OPENGL_OFFSCREEN | GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA;
if (!opt) gf_modules_set_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode", "PBuffer");
} else
#endif
{
u32 gl_type = 1;
HINSTANCE hInst;
#ifndef _WIN32_WCE
hInst = GetModuleHandle("gm_dx_hw.dll");
#else
hInst = GetModuleHandle(_T("gm_dx_hw.dll"));
#endif
opt = gf_modules_get_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode");
if (opt) {
if (!strcmp(opt, "Window")) gl_type = 1;
else if (!strcmp(opt, "VisibleWindow")) gl_type = 2;
else gl_type = 0;
} else {
gf_modules_set_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode", "Window");
}
if (gl_type) {
#ifdef _WIN32_WCE
dd->gl_hwnd = CreateWindow(_T("GPAC DirectDraw Output"), _T("GPAC OpenGL Offscreen"), WS_POPUP, 0, 0, 120, 100, NULL, NULL, hInst, NULL);
#else
dd->gl_hwnd = CreateWindow("GPAC DirectDraw Output", "GPAC OpenGL Offscreen", WS_POPUP, 0, 0, 120, 100, NULL, NULL, hInst, NULL);
#endif
if (!dd->gl_hwnd)
return;
ShowWindow(dd->gl_hwnd, (gl_type == 2) ? SW_SHOW : SW_HIDE);
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX] Using %s window for OpenGL Offscreen Rendering\n", (gl_type == 2) ? "Visible" : "Hidden"));
driv->hw_caps |= GF_VIDEO_HW_OPENGL_OFFSCREEN | GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA;
}
}
}
static GF_Err CTXLoad_AttachStream(GF_BaseDecoder *plug, GF_ESD *esd)
{
const char *ext;
GF_BitStream *bs;
u32 size;
CTXLoadPriv *priv = (CTXLoadPriv *)plug->privateStack;
if (esd->decoderConfig->upstream) return GF_NOT_SUPPORTED;
/*animation stream like*/
if (priv->ctx) {
GF_StreamContext *sc;
u32 i = 0;
while ((sc = (GF_StreamContext *)gf_list_enum(priv->ctx->streams, &i))) {
if (esd->ESID == sc->ESID) {
priv->nb_streams++;
return GF_OK;
}
}
return GF_NON_COMPLIANT_BITSTREAM;
}
/*main dummy stream we need a dsi*/
if (!esd->decoderConfig->decoderSpecificInfo)
return GF_NON_COMPLIANT_BITSTREAM;
bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ);
priv->file_size = gf_bs_read_u32(bs);
gf_bs_del(bs);
size = esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32);
priv->file_name = (char *) gf_malloc(sizeof(char)*(1 + size) );
memcpy(priv->file_name, esd->decoderConfig->decoderSpecificInfo->data + sizeof(u32), sizeof(char)*(esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32)) );
priv->file_name[size] = 0;
priv->nb_streams = 1;
priv->load_flags = 0;
priv->base_stream_id = esd->ESID;
priv->service_url = esd->service_url;
CTXLoad_Setup(plug);
priv->progressive_support = GF_FALSE;
priv->sax_max_duration = 0;
ext = strrchr(priv->file_name, '.');
if (!ext) return GF_OK;
ext++;
if (!stricmp(ext, "xmt") || !stricmp(ext, "xmtz") || !stricmp(ext, "xmta")
|| !stricmp(ext, "x3d") || !stricmp(ext, "x3dz")
) {
ext = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "Progressive");
priv->progressive_support = (ext && !stricmp(ext, "yes")) ? GF_TRUE : GF_FALSE;
}
if (priv->progressive_support) {
ext = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration");
if (ext) priv->sax_max_duration = atoi(ext);
}
return GF_OK;
}
static Bool uir_process(GF_TermExt *termext, u32 action, void *param)
{
const char *opt, *uifile;
GF_UIRecord *uir = termext->udta;
switch (action) {
case GF_TERM_EXT_START:
uir->term = (GF_Terminal *) param;
opt = gf_modules_get_option((GF_BaseInterface*)termext, "UIRecord", "Mode");
if (!opt) return 0;
uifile = gf_modules_get_option((GF_BaseInterface*)termext, "UIRecord", "File");
if (!opt) return 0;
if (!strcmp(opt, "Play")) {
uir->uif = gf_f64_open(uifile, "rb");
if (!uir->uif) return 0;
uir->bs = gf_bs_from_file(uir->uif, GF_BITSTREAM_READ);
termext->caps |= GF_TERM_EXTENSION_NOT_THREADED;
uir->evt_filter.on_event = uir_on_event_play;
uir->evt_filter.udta = uir;
gf_term_add_event_filter(uir->term, &uir->evt_filter);
uir_load_event(uir);
} else if (!strcmp(opt, "Record")) {
uir->uif = fopen(uifile, "wb");
if (!uir->uif) return 0;
uir->bs = gf_bs_from_file(uir->uif, GF_BITSTREAM_WRITE);
uir->evt_filter.on_event = uir_on_event_record;
uir->evt_filter.udta = uir;
gf_term_add_event_filter(uir->term, &uir->evt_filter);
} else {
return 0;
}
return 1;
case GF_TERM_EXT_STOP:
if (uir->uif) fclose(uir->uif);
if (uir->bs) gf_bs_del(uir->bs);
gf_term_remove_event_filter(uir->term, &uir->evt_filter);
uir->term = NULL;
/*auto-disable the plugin by default*/
gf_modules_set_option((GF_BaseInterface*)termext, "UIRecord", "Mode", "Disable");
break;
case GF_TERM_EXT_PROCESS:
/*flush all events until current time if reached*/
while (uir->evt_loaded && uir->ck && (uir->next_time <= gf_clock_time(uir->ck) )) {
uir->term->compositor->video_out->on_event(uir->term->compositor->video_out->evt_cbk_hdl, &uir->next_event);
uir_load_event(uir);
}
break;
}
return 0;
}
GF_Err SDLVid_ResizeWindow(GF_VideoOutput *dr, u32 width, u32 height)
{
SDLVID();
GF_Event evt;
/*lock X mutex to make sure the event queue is not being processed*/
gf_mx_p(ctx->evt_mx);
if (ctx->output_3d_type==1) {
u32 flags, nb_bits;
const char *opt;
if ((ctx->width==width) && (ctx->height==height) ) {
gf_mx_v(ctx->evt_mx);
return GF_OK;
}
flags = SDL_GL_WINDOW_FLAGS;
if (ctx->os_handle) flags &= ~SDL_RESIZABLE;
if (ctx->fullscreen) flags |= SDL_FULLSCREEN_FLAGS;
if (!ctx->screen) ctx->screen = SDL_SetVideoMode(width, height, 0, flags);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
opt = gf_modules_get_option((GF_BaseInterface *)dr, "Video", "GLNbBitsDepth");
nb_bits = opt ? atoi(opt) : 16;
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, nb_bits);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
opt = gf_modules_get_option((GF_BaseInterface *)dr, "Video", "GLNbBitsPerComponent");
nb_bits = opt ? atoi(opt) : 5;
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, nb_bits);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, nb_bits);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, nb_bits);
assert(width);
assert(height);
ctx->screen = SDL_SetVideoMode(width, height, 0, flags);
assert(ctx->screen);
ctx->width = width;
ctx->height = height;
memset(&evt, 0, sizeof(GF_Event));
evt.type = GF_EVENT_VIDEO_SETUP;
dr->on_event(dr->evt_cbk_hdl, &evt);
} else {
u32 flags;
#ifdef GPAC_IPHONE
flags = SDL_FULLSCREEN_FLAGS;
//SDL readme says it would make us faster
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, 1);
#else
flags = SDL_WINDOW_FLAGS;
#endif
if (ctx->os_handle) flags &= ~SDL_RESIZABLE;
ctx->screen = SDL_SetVideoMode(width, height, 0, flags);
}
gf_mx_v(ctx->evt_mx);
return ctx->screen ? GF_OK : GF_IO_ERR;
}
static GF_Err SVG_AttachStream(GF_BaseDecoder *plug, GF_ESD *esd)
{
const char *sOpt;
GF_BitStream *bs;
SVGIn *svgin = (SVGIn *)plug->privateStack;
if (esd->decoderConfig->upstream) return GF_NOT_SUPPORTED;
svgin->loader.type = GF_SM_LOAD_SVG;
/* decSpecInfo is not null only when reading from an SVG file (local or distant, cached or not) */
switch (esd->decoderConfig->objectTypeIndication) {
case GPAC_OTI_SCENE_SVG:
case GPAC_OTI_SCENE_SVG_GZ:
svgin->loader.flags |= GF_SM_LOAD_CONTEXT_STREAMING;
/*no decSpecInfo defined for streaming svg yet*/
break;
case GPAC_OTI_SCENE_DIMS:
svgin->loader.type = GF_SM_LOAD_DIMS;
svgin->loader.flags |= GF_SM_LOAD_CONTEXT_STREAMING;
/*decSpecInfo not yet supported for DIMS svg - we need properties at the scene level to store the
various indications*/
break;
case GPAC_OTI_PRIVATE_SCENE_SVG:
default:
if (!esd->decoderConfig->decoderSpecificInfo) return GF_NON_COMPLIANT_BITSTREAM;
bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ);
svgin->file_size = gf_bs_read_u32(bs);
svgin->file_pos = 0;
gf_bs_del(bs);
svgin->file_name = (char *) gf_malloc(sizeof(char)*(1 + esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32)) );
memcpy(svgin->file_name, esd->decoderConfig->decoderSpecificInfo->data + sizeof(u32), esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32) );
svgin->file_name[esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32) ] = 0;
break;
}
svgin->oti = esd->decoderConfig->objectTypeIndication;
if (!esd->dependsOnESID) svgin->base_es_id = esd->ESID;
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "Progressive");
if (sOpt && !strcmp(sOpt, "yes")) {
svgin->sax_max_duration = 30;
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration");
if (sOpt) {
svgin->sax_max_duration = atoi(sOpt);
} else {
svgin->sax_max_duration = 30;
gf_modules_set_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration", "30");
}
} else {
svgin->sax_max_duration = (u32) -1;
}
return GF_OK;
}
GF_Err gdip_init_font_engine(GF_FontReader *dr)
{
const char *sOpt;
FontPriv *ctx = (FontPriv *)dr->udta;
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSerif");
strcpy(ctx->font_serif, sOpt ? sOpt : "Times New Roman");
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSans");
strcpy(ctx->font_sans, sOpt ? sOpt : "Arial");
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontFixed");
strcpy(ctx->font_fixed, sOpt ? sOpt : "Courier New");
return GF_OK;
}
static void M2TS_GetNetworkType(GF_InputService *plug,M2TSIn *reader)
{
const char *mob_on;
const char *mcast_ifce;
mob_on = gf_modules_get_option((GF_BaseInterface*)plug, "Network", "MobileIPEnabled");
if(mob_on && !strcmp(mob_on, "yes")) {
reader->ts->MobileIPEnabled = 1;
reader->ts->network_type = gf_modules_get_option((GF_BaseInterface*)plug, "Network", "MobileIP");
}
mcast_ifce = gf_modules_get_option((GF_BaseInterface*)plug, "Network", "DefaultMCastInterface");
if(mcast_ifce) reader->ts->network_type = gf_strdup(mcast_ifce);
}
static GF_Err ft_init_font_engine(GF_FontReader *dr)
{
const char *sOpt;
FTBuilder *ftpriv = (FTBuilder *)dr->udta;
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontDirectory");
if (!sOpt) return GF_BAD_PARAM;
/*inits freetype*/
if (FT_Init_FreeType(&ftpriv->library) ) {
GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[FreeType] Cannot initialize FreeType\n"));
return GF_IO_ERR;
}
/*remove the final delimiter*/
ftpriv->font_dir = gf_strdup(sOpt);
while ( (ftpriv->font_dir[strlen(ftpriv->font_dir)-1] == '\n') || (ftpriv->font_dir[strlen(ftpriv->font_dir)-1] == '\r') )
ftpriv->font_dir[strlen(ftpriv->font_dir)-1] = 0;
/*store font path*/
if (ftpriv->font_dir[strlen(ftpriv->font_dir)-1] != GF_PATH_SEPARATOR) {
char ext[2], *temp;
ext[0] = GF_PATH_SEPARATOR;
ext[1] = 0;
temp = gf_malloc(sizeof(char) * (strlen(ftpriv->font_dir) + 2));
strcpy(temp, ftpriv->font_dir);
strcat(temp, ext);
gf_free(ftpriv->font_dir);
ftpriv->font_dir = temp;
}
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "RescanFonts");
if (!sOpt || !strcmp(sOpt, "yes") )
ft_rescan_fonts(dr);
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSerif");
ftpriv->font_serif = gf_strdup(sOpt ? sOpt : "");
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontSans");
ftpriv->font_sans = gf_strdup(sOpt ? sOpt : "");
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "FontEngine", "FontFixed");
ftpriv->font_fixed = gf_strdup(sOpt ? sOpt : "");
GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("[FreeType] Init OK - font directory %s\n", ftpriv->font_dir));
return GF_OK;
}
GF_Err SDLVid_SetFullScreen(GF_VideoOutput *dr, u32 bFullScreenOn, u32 *screen_width, u32 *screen_height)
{
u32 bpp, pref_bpp;
SDLVID();
if (ctx->fullscreen==bFullScreenOn) return GF_OK;
/*lock to get sure the event queue is not processed under X*/
gf_mx_p(ctx->evt_mx);
ctx->fullscreen = bFullScreenOn;
pref_bpp = bpp = ctx->screen->format->BitsPerPixel;
if (ctx->fullscreen) {
u32 flags;
Bool switch_res = 0;
const char *sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "Video", "SwitchResolution");
if (sOpt && !stricmp(sOpt, "yes")) switch_res = 1;
if (!dr->max_screen_width || !dr->max_screen_height) switch_res = 1;
flags = (ctx->output_3d_type==1) ? SDL_GL_FULLSCREEN_FLAGS : SDL_FULLSCREEN_FLAGS;
ctx->store_width = *screen_width;
ctx->store_height = *screen_height;
if (switch_res) {
u32 i;
ctx->fs_width = *screen_width;
ctx->fs_height = *screen_height;
for(i=0; i<nb_video_modes; i++) {
if (ctx->fs_width<=video_modes[2*i] && ctx->fs_height<=video_modes[2*i + 1]) {
if ((pref_bpp = SDL_VideoModeOK(video_modes[2*i], video_modes[2*i+1], bpp, flags))) {
ctx->fs_width = video_modes[2*i];
ctx->fs_height = video_modes[2*i + 1];
break;
}
}
}
} else {
ctx->fs_width = dr->max_screen_width;
ctx->fs_height = dr->max_screen_height;
}
ctx->screen = SDL_SetVideoMode(ctx->fs_width, ctx->fs_height, pref_bpp, flags);
/*we switched bpp, clean all objects*/
if (bpp != pref_bpp) SDLVid_DestroyObjects(ctx);
*screen_width = ctx->fs_width;
*screen_height = ctx->fs_height;
/*GL has changed*/
if (ctx->output_3d_type==1) {
GF_Event evt;
evt.type = GF_EVENT_VIDEO_SETUP;
dr->on_event(dr->evt_cbk_hdl, &evt);
}
} else {
SDLVid_ResizeWindow(dr, ctx->store_width, ctx->store_height);
*screen_width = ctx->store_width;
*screen_height = ctx->store_height;
}
gf_mx_v(ctx->evt_mx);
if (!ctx->screen) return GF_IO_ERR;
return GF_OK;
}
GF_Err SDLVid_SetBackbufferSize(GF_VideoOutput *dr, u32 newWidth, u32 newHeight, Bool system_mem)
{
u32 col;
const char *opt;
SDLVID();
if (ctx->output_3d_type==1) return GF_BAD_PARAM;
opt = gf_modules_get_option((GF_BaseInterface *)dr, "Video", "HardwareMemory");
if (system_mem) {
if (opt && !strcmp(opt, "Always")) system_mem = 0;
} else {
if (opt && !strcmp(opt, "Never")) system_mem = 1;
}
ctx->use_systems_memory = system_mem;
/*clear screen*/
col = SDL_MapRGB(ctx->screen->format, 0, 0, 0);
SDL_FillRect(ctx->screen, NULL, col);
SDL_Flip(ctx->screen);
if (ctx->back_buffer && ((u32) ctx->back_buffer->w==newWidth) && ((u32) ctx->back_buffer->h==newHeight)) {
return GF_OK;
}
if (ctx->back_buffer) SDL_FreeSurface(ctx->back_buffer);
ctx->back_buffer = SDL_CreateRGBSurface(ctx->use_systems_memory ? SDL_SWSURFACE : SDL_HWSURFACE, newWidth, newHeight, ctx->screen->format->BitsPerPixel, ctx->screen->format->Rmask, ctx->screen->format->Gmask, ctx->screen->format->Bmask, 0);
ctx->width = newWidth;
ctx->height = newHeight;
if (!ctx->back_buffer) return GF_IO_ERR;
return GF_OK;
}
static Bool WII_RegisterDevice(struct __input_device *ifce, const char *urn, GF_BitStream *dsi, void (*AddField)(struct __input_device *_this, u32 fieldType, const char *name))
{
const char *opt;
GF_WiiMote *wii = (GF_WiiMote *)ifce->udta;
if (strcmp(urn, "WiiMote")) return 0;
/*init wiiuse lib*/
opt = gf_modules_get_option((GF_BaseInterface*)ifce, "WII", "MaxWiimotes");
if (opt) wii->nb_wiimotes = atoi(opt);
if (!wii->nb_wiimotes) wii->nb_wiimotes = 1;
wii->wiimotes = wiiuse_init(wii->nb_wiimotes);
if (!wii->wiimotes) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[Wii] Cannot initialize wiiuse library\n"));
return 0;
}
/*declare the interface*/
AddField(ifce, GF_SG_VRML_SFINT32, "uid");
AddField(ifce, GF_SG_VRML_SFBOOL, "1");
AddField(ifce, GF_SG_VRML_SFBOOL, "2");
AddField(ifce, GF_SG_VRML_SFBOOL, "A");
AddField(ifce, GF_SG_VRML_SFBOOL, "B");
AddField(ifce, GF_SG_VRML_SFBOOL, "-");
AddField(ifce, GF_SG_VRML_SFBOOL, "home");
AddField(ifce, GF_SG_VRML_SFBOOL, "+");
AddField(ifce, GF_SG_VRML_SFBOOL, "left");
AddField(ifce, GF_SG_VRML_SFBOOL, "right");
AddField(ifce, GF_SG_VRML_SFBOOL, "down");
AddField(ifce, GF_SG_VRML_SFBOOL, "up");
AddField(ifce, GF_SG_VRML_SFVEC3F, "ypr");
AddField(ifce, GF_SG_VRML_SFVEC3F, "gravity");
return 1;
}
RTSPSession *RP_NewSession(RTPClient *rtp, char *session_control)
{
char *szCtrl, *szExt;
RTSPSession *tmp;
GF_RTSPSession *rtsp;
if (!session_control) return NULL;
/*little fix: some servers don't understand DESCRIBE URL/trackID=, so remove the trackID...*/
szCtrl = gf_strdup(session_control);
szExt = szCtrl ? strrchr(szCtrl, '.') : NULL;
if (szExt) {
szExt = strchr(szExt, '/');
if (szExt) {
if (!strnicmp(szExt+1, "trackID=", 8) || !strnicmp(szExt+1, "ESID=", 5) || !strnicmp(szExt+1, "ES_ID=", 6)) szExt[0] = 0;
}
}
rtsp = gf_rtsp_session_new(szCtrl, rtp->default_port);
gf_free(szCtrl);
if (!rtsp) return NULL;
GF_SAFEALLOC(tmp, RTSPSession);
tmp->owner = rtp;
tmp->session = rtsp;
szCtrl = (char *)gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(rtp->service), "Network", "MobileIPEnabled");
if (szCtrl && !strcmp(szCtrl, "yes")) {
char *ip = (char *)gf_modules_get_option((GF_BaseInterface *) gf_term_get_service_interface(rtp->service), "Network", "MobileIP");
gf_rtsp_set_mobile_ip(rtsp, ip);
}
if (rtp->transport_mode) {
gf_rtsp_set_buffer_size(rtsp, RTSP_TCP_BUFFER_SIZE);
} else {
gf_rtsp_set_buffer_size(rtsp, RTSP_BUFFER_SIZE);
}
tmp->rtsp_commands = gf_list_new();
tmp->rtsp_rsp = gf_rtsp_response_new();
gf_list_add(rtp->sessions, tmp);
return tmp;
}
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 XVID_GetCapabilities(GF_BaseDecoder *ifcg, GF_CodecCapability *capability)
{
XVIDCTX();
switch (capability->CapCode) {
case GF_CODEC_RESILIENT:
capability->cap.valueInt = 1;
break;
case GF_CODEC_WIDTH:
capability->cap.valueInt = ctx->width;
break;
case GF_CODEC_HEIGHT:
capability->cap.valueInt = ctx->height;
break;
case GF_CODEC_STRIDE:
capability->cap.valueInt = ctx->width;
break;
case GF_CODEC_FPS:
capability->cap.valueFloat = ctx->FPS;
break;
case GF_CODEC_PAR:
capability->cap.valueInt = ctx->pixel_ar;
break;
case GF_CODEC_OUTPUT_SIZE:
capability->cap.valueInt = ctx->out_size;
break;
case GF_CODEC_PIXEL_FORMAT:
capability->cap.valueInt = ctx->depth_codec ? GF_PIXEL_YUVD : GF_PIXEL_YV12;
break;
case GF_CODEC_BUFFER_MIN:
capability->cap.valueInt = 1;
break;
case GF_CODEC_BUFFER_MAX:
capability->cap.valueInt = 4;
break;
/*by default we use 4 bytes padding (otherwise it happens that XviD crashes on some videos...)*/
case GF_CODEC_PADDING_BYTES:
capability->cap.valueInt = 32;
break;
/*XviD performs frame reordering internally*/
case GF_CODEC_REORDER:
capability->cap.valueInt = 1;
break;
case GF_CODEC_WANTS_THREAD:
{
const char *sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "XviD", "Threaded");
capability->cap.valueInt = (sOpt && stricmp(sOpt, "yes")) ? 1 : 0;
}
break;
/*not known at our level...*/
case GF_CODEC_CU_DURATION:
default:
capability->cap.valueInt = 0;
break;
}
return GF_OK;
}
GF_Err Dektec_Setup(GF_VideoOutput *dr, void *os_handle, void *os_display, u32 init_flags)
{
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[Dektec Out] Dektec_Setup\n"));
DtContext *dtc = (DtContext*)dr->opaque;
dtc->bpp = 3; //needed because lock_buffer expects RGB
dtc->pixel_format = GF_PIXEL_YV12;
dtc->isSending = false;
Dektec_resize(dr, DWIDTH, DHEIGHT);
int port = 1;
const char *opt;
opt = gf_modules_get_option((GF_BaseInterface *)dr, "DektecVideo", "SDIOutput");
if (opt) {
port = atoi(opt);
} else {
GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("[Dektec Out] No port specified, using default port: %d\n", port));
}
// Attach device and output channel objects to hardware
DtDevice *dvc = dtc->dvc;
DtFrameBuffer *dtf = dtc->dtf;
DTAPI_RESULT res;
res = dvc->AttachToType(2154);
if (res != DTAPI_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] No DTA-2154 in system: %s\n", DtapiResult2Str(res)));
return GF_BAD_PARAM;
}
res = dvc->SetIoConfig(port, DTAPI_IOCONFIG_IODIR, DTAPI_IOCONFIG_OUTPUT, DTAPI_IOCONFIG_OUTPUT);
if (res != DTAPI_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] Can't set I/O config for the device: %s\n", DtapiResult2Str(res)));
return GF_BAD_PARAM;
}
res = dtf->AttachToOutput(dvc, port, 0);
if (res != DTAPI_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] Can't attach to port %d: %s\n", port, DtapiResult2Str(res)));
return GF_BAD_PARAM;
}
int IoStdValue=-1, IoStdSubValue=-1;
res = DtapiVidStd2IoStd(DFORMAT, IoStdValue, IoStdSubValue);
if (res != DTAPI_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] Unknown VidStd: %s\n", DtapiResult2Str(res)));
return GF_BAD_PARAM;
}
res = dtf->SetIoConfig(DTAPI_IOCONFIG_IOSTD, IoStdValue, IoStdSubValue);
if (res != DTAPI_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Dektec Out] Can't set I/O config: %s\n", DtapiResult2Str(res)));
return GF_BAD_PARAM;
}
dtc->frameNum = -1;
return GF_OK;
}
static Bool M2TS_CanHandleURLInService(GF_InputService *plug, const char *url)
{
Bool ret = 0;
M2TSIn *m2ts;
if (!plug || !url)
return 0;
m2ts = (M2TSIn *)plug->priv;
if (!m2ts)
return 0;
if (!strnicmp(url, "pid://", 6)) {
u32 pid = atoi(url+6);
if (pid>=GF_M2TS_MAX_STREAMS) return 0;
if (m2ts->ts->ess[pid]) return 1;
return 0;
}
#ifdef GPAC_HAS_LINUX_DVB
if (!stricmp(url, "dvb://EPG")) return 1;
if (!strnicmp(url, "dvb://", 6)) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[DVBIn] Checking reuse of the same tuner for %s\n", url));
const char *chan_conf = gf_modules_get_option((GF_BaseInterface *)plug, "DVB", "ChannelsFile");
if (!chan_conf) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[DVBIn] Cannot locate channel configuration file\n"));
ret = 0;
}
/* if the tuner is already tuned to the same frequence, nothing needs to be done */
else if (m2ts->ts->tuner->freq != 0) {
char *frag = strchr(url, '#');
if (frag) frag[0] = 0;
if (m2ts->ts->tuner->freq == gf_dvb_get_freq_from_url(chan_conf, url)) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[DVBIn] Reusing the same tuner for %s\n", url));
ret = 1;
}
if (frag) frag[0] = '#';
}
} else
#endif
if (!strnicmp(url, "udp://", 6)
|| !strnicmp(url, "mpegts-udp://", 13)
|| !strnicmp(url, "mpegts-tcp://", 13))
{
/* TODO: check IP address ...*/
ret = 0;
} else {
char *frag = strchr(url, '#');
if (frag) frag[0] = 0;
if (!strlen(url) || !strcmp(url, m2ts->ts->filename)) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[DVBIn] Reusing the same input file for %s\n", url));
ret = 1;
}
if (frag) frag[0] = '#';
}
return ret;
}
void *SDL_NewVideo()
{
SDLVidCtx *ctx;
GF_VideoOutput *driv;
driv = gf_malloc(sizeof(GF_VideoOutput));
memset(driv, 0, sizeof(GF_VideoOutput));
GF_REGISTER_MODULE_INTERFACE(driv, GF_VIDEO_OUTPUT_INTERFACE, "SDL Video Output", "gpac distribution");
ctx = gf_malloc(sizeof(SDLVidCtx));
memset(ctx, 0, sizeof(SDLVidCtx));
#ifdef SDL_WINDOW_THREAD
ctx->sdl_th = gf_th_new("SDLVideo");
#endif
ctx->evt_mx = gf_mx_new("SDLEvents");
driv->opaque = ctx;
driv->Setup = SDLVid_Setup;
driv->Shutdown = SDLVid_Shutdown;
driv->SetFullScreen = SDLVid_SetFullScreen;
driv->Flush = SDLVid_Flush;
driv->ProcessEvent = SDLVid_ProcessEvent;
/*no offscreen opengl with SDL*/
driv->hw_caps |= GF_VIDEO_HW_OPENGL;
/*no YUV hardware blitting in SDL (only overlays)*/
driv->hw_caps |= GF_VIDEO_HW_HAS_YUV_OVERLAY | GF_VIDEO_HW_HAS_RGB | GF_VIDEO_HW_HAS_RGBA;
driv->Blit = SDL_Blit;
driv->LockBackBuffer = SDLVid_LockBackBuffer;
driv->LockOSContext = NULL;
/*color keying with overlays are not supported in SDL ...*/
#if 0
/*get YUV overlay key*/
opt = gf_modules_get_option((GF_BaseInterface *)driv, "Video", "OverlayColorKey");
/*no set is the default*/
if (!opt) {
opt = "0101FE";
gf_modules_set_option((GF_BaseInterface *)driv, "Video", "OverlayColorKey", "0101FE");
}
sscanf(opt, "%06x", &driv->overlay_color_key);
if (driv->overlay_color_key) driv->overlay_color_key |= 0xFF000000;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[SDL Out] YUV Overlays enabled - ColorKey enabled: %s (key %x)\n",
driv->overlay_color_key ? "Yes" : "No", driv->overlay_color_key
));
#endif
#ifndef SDL_TEXTINPUTEVENT_TEXT_SIZE
SDL_EnableUNICODE(1);
#else
SDL_StartTextInput();
#endif /* SDL_TEXTINPUTEVENT_TEXT_SIZE */
return driv;
}
static GF_Err HEVC_AttachStream(GF_BaseDecoder *ifcg, GF_ESD *esd)
{
GF_SystemRTInfo rti;
const char *sOpt;
u32 nb_threads = 1;
HEVCDec *ctx = (HEVCDec*) ifcg->privateStack;
if (gf_sys_get_rti(0, &rti, 0) ) {
nb_threads = (rti.nb_cores>1) ? rti.nb_cores-1 : 1;
}
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "NumThreads");
if (!sOpt) {
char szO[100];
sprintf(szO, "%d", nb_threads);
gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "NumThreads", szO);
ctx->nb_threads = nb_threads;
GF_LOG(GF_LOG_INFO, GF_LOG_CODEC, ("[OpenHEVC] Initializing with %d threads\n", ctx->nb_threads));
} else {
ctx->nb_threads = atoi(sOpt);
if (ctx->nb_threads > nb_threads) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CODEC, ("[OpenHEVC] Initializing with %d threads but only %d available cores detected on the system\n", ctx->nb_threads, rti.nb_cores));
}
}
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "ThreadingType");
if (sOpt && !strcmp(sOpt, "wpp")) ctx->threading_type = 2;
else if (sOpt && !strcmp(sOpt, "frame+wpp")) ctx->threading_type = 4;
else {
ctx->threading_type = 1;
if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "ThreadingType", "frame");
}
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "Systems", "Output8bit");
if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "Systems", "Output8bit", (ctx->display_bpp>8) ? "no" : "yes");
if (sOpt && !strcmp(sOpt, "yes")) ctx->output_as_8bit = GF_TRUE;
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "CBUnits");
if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "CBUnits", "4");
if (sOpt) ctx->output_cb_size = atoi(sOpt);
if (!ctx->output_cb_size) ctx->output_cb_size = 4;
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "PackHFR");
if (sOpt && !strcmp(sOpt, "yes") ) ctx->pack_mode = GF_TRUE;
else if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "PackHFR", "no");
if (!ctx->raw_out) {
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "InputRipFile");
if (sOpt) ctx->raw_out = fopen(sOpt, "wb");
}
/*RTP case: configure enhancement now*/
if (esd->dependsOnESID) {
HEVC_ConfigurationScalableStream(ctx, esd);
return GF_OK;
}
ctx->esd = esd;
return HEVC_ConfigureStream(ctx, esd);
}
GF_EXPORT
Bool gf_term_check_extension(GF_InputService *ifce, const char *mimeType, const char *extList, const char *description, const char *fileExt)
{
const char *szExtList;
char *ext, szExt[500];
if (!ifce || !mimeType || !extList || !description || !fileExt) return 0;
memset(szExt, 0, sizeof(szExt));
/*this is a URL*/
if ( (strlen(fileExt)>20) || strchr(fileExt, '/')) return 0;
if (fileExt[0]=='.') fileExt++;
strcpy(szExt, fileExt);
strlwr(szExt);
ext = strchr(szExt, '#');
if (ext) ext[0]=0;
szExtList = gf_modules_get_option((GF_BaseInterface *)(GF_BaseInterface *)ifce, "MimeTypes", mimeType);
if (!szExtList) {
gf_term_register_mime_type(ifce, mimeType, extList, description);
szExtList = gf_modules_get_option((GF_BaseInterface *)(GF_BaseInterface *)ifce, "MimeTypes", mimeType);
}
if (!strstr(szExtList, ifce->module_name)) return 0;
return check_extension((char *)szExtList, szExt);
}
static GF_Err SVG_AttachScene(GF_SceneDecoder *plug, GF_Scene *scene, Bool is_scene_decoder)
{
SVGIn *svgin = (SVGIn *)plug->privateStack;
memset(&svgin->loader, 0, sizeof(GF_SceneLoader));
svgin->loader.is = scene;
svgin->scene = scene;
svgin->loader.scene_graph = scene->graph;
svgin->loader.localPath = gf_modules_get_option((GF_BaseInterface *)plug, "General", "CacheDirectory");
/*Warning: svgin->loader.type may be overriden in attach stream */
svgin->loader.type = GF_SM_LOAD_SVG;
svgin->loader.flags = GF_SM_LOAD_FOR_PLAYBACK;
if (svgin->oti!= GPAC_OTI_PRIVATE_SCENE_SVG)
gf_sm_load_init(&svgin->loader);
return GF_OK;
}
static GF_Err CTXLoad_Setup(GF_BaseDecoder *plug)
{
CTXLoadPriv *priv = (CTXLoadPriv *)plug->privateStack;
if (!priv->file_name) return GF_BAD_PARAM;
priv->ctx = gf_sm_new(priv->scene->graph);
memset(&priv->load, 0, sizeof(GF_SceneLoader));
priv->load.ctx = priv->ctx;
priv->load.is = priv->scene;
priv->load.scene_graph = priv->scene->graph;
priv->load.fileName = priv->file_name;
priv->load.flags = GF_SM_LOAD_FOR_PLAYBACK;
priv->load.localPath = gf_modules_get_option((GF_BaseInterface *)plug, "General", "CacheDirectory");
priv->load.swf_import_flags = GF_SM_SWF_STATIC_DICT | GF_SM_SWF_QUAD_CURVE | GF_SM_SWF_SCALABLE_LINE | GF_SM_SWF_SPLIT_TIMELINE;
return GF_OK;
}
static Bool osd_process(GF_TermExt *termext, u32 action, void *param)
{
const char *opt;
GF_OSD *osd = termext->udta;
switch (action) {
case GF_TERM_EXT_START:
osd->term = (GF_Terminal *) param;
opt = gf_modules_get_option((GF_BaseInterface*)termext, "OSD", "Enabled");
if (opt && strcmp(opt, "yes")) return 0;
/*load scene*/
if (! osd_load_scene(osd)) return 0;
/*attach scene to compositor*/
gf_sc_register_extra_graph(osd->term->compositor, osd->odm->subscene->graph, 0);
/*we are not threaded*/
termext->caps |= GF_TERM_EXTENSION_NOT_THREADED;
osd->refresh_time_ms = 500;
osd->evt_filter.on_event = osd_on_event_play;
osd->evt_filter.udta = osd;
gf_term_add_event_filter(osd->term, &osd->evt_filter);
return 1;
case GF_TERM_EXT_STOP:
osd->text->string.vals[0] = NULL;
/*remove scene to compositor*/
gf_sc_register_extra_graph(osd->term->compositor, osd->odm->subscene->graph, 1);
gf_odm_disconnect(osd->odm, 1);
osd->odm = NULL;
gf_term_remove_event_filter(osd->term, &osd->evt_filter);
osd->term = NULL;
break;
case GF_TERM_EXT_PROCESS:
/*flush all events until current time if reached*/
if ((osd->visible->whichChoice==0) && gf_sys_get_rti(osd->refresh_time_ms, &osd->rti, 0)) {
sprintf(osd->statBuffer, "CPU %02d - FPS %02.2f - MEM "LLU" KB", osd->rti.process_cpu_usage, gf_sc_get_fps(osd->term->compositor, 0), osd->rti.process_memory/1000);
gf_node_dirty_set((GF_Node *) osd->text, GF_SG_NODE_DIRTY, 1);
}
break;
}
return 0;
}
static GF_Err RP_CloseService(GF_InputService *plug)
{
u32 i;
const char *opt;
RTSPSession *sess;
RTPClient *rtp = (RTPClient *)plug->priv;
GF_LOG(GF_LOG_DEBUG, GF_LOG_RTP, ("[RTP] Closing service\n"));
RP_FlushCommands(rtp);
if (rtp->session_migration) {
opt = gf_modules_get_option((GF_BaseInterface *) plug, "Streaming", "SessionMigrationPause");
if (opt && !strcmp(opt, "yes")) {
GF_NetworkCommand com;
com.command_type = GF_NET_CHAN_PAUSE;
com.base.on_channel = NULL;
/*send pause on all sessions*/
i=0;
while ((sess = (RTSPSession *)gf_list_enum(rtp->sessions, &i))) {
RP_UserCommand(sess, NULL, &com);
}
}
RP_SaveSessionState(rtp);
} else {
/*remove session state file*/
if (rtp->session_state_data) {
gf_free(rtp->session_state_data);
rtp->session_state_data = NULL;
}
/*send teardown on all sessions*/
i=0;
while ((sess = (RTSPSession *)gf_list_enum(rtp->sessions, &i))) {
RP_Teardown(sess, NULL);
}
}
RP_FlushCommands(rtp);
/*shutdown thread*/
if (rtp->th_state==1) rtp->th_state = 0;
/*confirm close*/
gf_term_on_disconnect(rtp->service, NULL, GF_OK);
return GF_OK;
}
static void SetWindowless(GF_VideoOutput *vout, HWND hWnd)
{
const char *opt;
u32 a, r, g, b;
COLORREF ckey;
typSetLayeredWindowAttributes _SetLayeredWindowAttributes;
HMODULE hUser32;
u32 isWin2K;
OSVERSIONINFO Version = {sizeof(OSVERSIONINFO)};
GetVersionEx(&Version);
isWin2K = (Version.dwPlatformId == VER_PLATFORM_WIN32_NT && Version.dwMajorVersion >= 5);
if (!isWin2K) return;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX Out] Enabling windowless mode\n"));
hUser32 = GetModuleHandle("USER32.DLL");
if (hUser32 == NULL) return;
_SetLayeredWindowAttributes = (typSetLayeredWindowAttributes) GetProcAddress(hUser32,"SetLayeredWindowAttributes");
if (_SetLayeredWindowAttributes == NULL) {
GF_LOG(GF_LOG_WARNING, GF_LOG_MMIO, ("[DX Out] Win32 layered windows not supported\n"));
return;
}
SetWindowLong(hWnd, GWL_EXSTYLE, GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_LAYERED);
/*get background ckey*/
opt = gf_modules_get_option((GF_BaseInterface *)vout, "Rendering", "ColorKey");
if (!opt) {
gf_modules_set_option((GF_BaseInterface *)vout, "Rendering", "ColorKey", "FFFEFEFE");
opt = "FFFEFEFE";
}
sscanf(opt, "%02X%02X%02X%02X", &a, &r, &g, &b);
ckey = RGB(r, g, b);
if (a<255)
_SetLayeredWindowAttributes(hWnd, ckey, (u8) a, LWA_COLORKEY|LWA_ALPHA);
else
_SetLayeredWindowAttributes(hWnd, ckey, 0, LWA_COLORKEY);
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX Out] Using color key %s\n", opt));
}
GF_Err TTIn_LoadFile(GF_InputService *plug, const char *url, Bool is_cache)
{
GF_Err e;
GF_MediaImporter import;
char szFILE[GF_MAX_PATH];
TTIn *tti = (TTIn *)plug->priv;
const char *cache_dir;
if (!tti || !url)
return GF_BAD_PARAM;
cache_dir = gf_modules_get_option((GF_BaseInterface *)plug, "General", "CacheDirectory");
if (cache_dir && strlen(cache_dir)) {
if (cache_dir[strlen(cache_dir)-1] != GF_PATH_SEPARATOR) {
sprintf(szFILE, "%s%csrt_%p_mp4", cache_dir, GF_PATH_SEPARATOR, tti);
} else {
sprintf(szFILE, "%ssrt_%p_mp4", cache_dir, tti);
}
} else {
sprintf(szFILE, "%p_temp_mp4", tti);
}
tti->mp4 = gf_isom_open(szFILE, GF_ISOM_OPEN_WRITE, NULL);
if (!tti->mp4) return gf_isom_last_error(NULL);
if (tti->szFile)
gf_free(tti->szFile);
tti->szFile = gf_strdup(szFILE);
memset(&import, 0, sizeof(GF_MediaImporter));
import.dest = tti->mp4;
/*override layout from sub file*/
import.flags = GF_IMPORT_SKIP_TXT_BOX;
import.in_name = gf_strdup(url);
e = gf_media_import(&import);
if (!e) {
tti->tt_track = 1;
gf_isom_text_set_streaming_mode(tti->mp4, 1);
}
if (import.in_name)
gf_free(import.in_name);
return e;
}
GF_Err RAW_Setup(GF_VideoOutput *dr, void *os_handle, void *os_display, u32 init_flags)
{
const char *opt;
RAWCTX;
opt = gf_modules_get_option((GF_BaseInterface *)dr, "RAWVideo", "RawOutput");
if (opt && !strcmp(opt, "null")) {
rc->passthrough = 1;
dr->Blit = RAW_BlitPassthrough;
dr->hw_caps |= GF_VIDEO_HW_HAS_RGB | GF_VIDEO_HW_HAS_RGBA | GF_VIDEO_HW_HAS_STRETCH | GF_VIDEO_HW_HAS_YUV | GF_VIDEO_HW_OPENGL | GF_VIDEO_HW_HAS_YUV_OVERLAY;
}
if (init_flags & GF_TERM_WINDOW_TRANSPARENT) {
rc->bpp = 4;
rc->pixel_format = GF_PIXEL_ARGB;
} else {
rc->bpp = 3;
rc->pixel_format = GF_PIXEL_RGB_24;
}
raw_resize(dr, 100, 100);
return GF_OK;
}