BOOL COptDecoder::OnInitDialog()
{
u32 i;
CDialog::OnInitDialog();
COsmo4 *gpac = GetApp();
const char *sOpt;
/*audio dec enum*/
while (m_Audio.GetCount()) m_Audio.DeleteString(0);
sOpt = gf_cfg_get_key(gpac->m_user.config, "Systems", "DefAudioDec");
u32 count = gf_modules_get_count(gpac->m_user.modules);
GF_BaseDecoder *ifce;
s32 select = 0;
s32 to_sel = 0;
for (i=0; i<count; i++) {
ifce = (GF_BaseDecoder *) gf_modules_load_interface(gpac->m_user.modules, i, GF_MEDIA_DECODER_INTERFACE);
if (!ifce) continue;
if (ifce->CanHandleStream(ifce, GF_STREAM_AUDIO, NULL, 0)) {
if (sOpt && !stricmp(((GF_BaseInterface *)ifce)->module_name, sOpt)) select = to_sel;
TCHAR wzTmp[500];
CE_CharToWide((char *) ifce->module_name, (u16 *)wzTmp);
m_Audio.AddString(wzTmp);
to_sel++;
}
gf_modules_close_interface((GF_BaseInterface *) ifce);
}
m_Audio.SetCurSel(select);
/*audio dec enum*/
while (m_Video.GetCount()) m_Video.DeleteString(0);
sOpt = gf_cfg_get_key(gpac->m_user.config, "Systems", "DefVideoDec");
count = gf_modules_get_count(gpac->m_user.modules);
select = 0;
to_sel = 0;
for (i=0; i<count; i++) {
ifce = (GF_BaseDecoder *) gf_modules_load_interface(gpac->m_user.modules, i, GF_MEDIA_DECODER_INTERFACE);
if (!ifce) continue;
if (ifce->CanHandleStream(ifce, GF_STREAM_VISUAL, NULL, 0)) {
if (sOpt && !stricmp(((GF_BaseInterface *)ifce)->module_name, sOpt)) select = to_sel;
TCHAR wzTmp[500];
CE_CharToWide((char *) ifce->module_name, (u16 *)wzTmp);
m_Video.AddString(wzTmp);
to_sel++;
}
gf_modules_close_interface((GF_BaseInterface *) ifce);
}
m_Video.SetCurSel(select);
return TRUE;
}
BOOL COptAudio::OnInitDialog()
{
CDialog::OnInitDialog();
m_AudioSpin.SetBuddy(& m_AudioEdit);
m_SpinDur.SetBuddy(& m_AudioDur);
m_SpinDur.SetRange(0, 1000);
COsmo4 *gpac = GetApp();
const char *sOpt;
TCHAR wTmp[500];
sOpt = gf_cfg_get_key(gpac->m_user.config, "Audio", "ForceConfig");
m_ForceConfig.SetCheck( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(gpac->m_user.config, "Audio", "NumBuffers");
if (sOpt) {
CE_CharToWide((char *)sOpt, (u16 *)wTmp);
m_AudioEdit.SetWindowText(wTmp);
} else {
m_AudioEdit.SetWindowText(_T("2"));
}
sOpt = gf_cfg_get_key(gpac->m_user.config, "Audio", "TotalDuration");
if (sOpt) {
CE_CharToWide((char *)sOpt, (u16 *)wTmp);
m_AudioDur.SetWindowText(wTmp);
} else {
m_AudioDur.SetWindowText(_T("200"));
}
OnForceAudio();
sOpt = gf_cfg_get_key(gpac->m_user.config, "Audio", "NoResync");
if (sOpt && !stricmp(sOpt, "yes")) {
m_AudioResync.SetCheck(1);
} else {
m_AudioResync.SetCheck(0);
}
/*driver enum*/
while (m_DriverList.GetCount()) m_DriverList.DeleteString(0);
sOpt = gf_cfg_get_key(gpac->m_user.config, "Audio", "DriverName");
u32 count = gf_modules_get_count(gpac->m_user.modules);
GF_BaseInterface *ifce;
s32 select = 0;
s32 to_sel = 0;
for (u32 i=0; i<count; i++) {
ifce = gf_modules_load_interface(gpac->m_user.modules, i, GF_AUDIO_OUTPUT_INTERFACE);
if (!ifce) continue;
if (sOpt && !stricmp(((GF_BaseInterface *)ifce)->module_name, sOpt)) select = to_sel;
CE_CharToWide((char *) ((GF_BaseInterface *)ifce)->module_name, (u16 *)wTmp);
m_DriverList.AddString(wTmp);
gf_modules_close_interface(ifce);
to_sel++;
}
m_DriverList.SetCurSel(select);
return TRUE;
}
//Create window message fuction. when the window is created, also initialize a instance of
//GPAC player instance.
LRESULT CGPAXPlugin::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
if (m_term) return 0;
const char *str;
if (m_hWnd==NULL) return 0;
//Create a structure m_user for initialize the terminal. the parameters to set:
//1)config file path
//2)Modules file path
//3)window handler
//4)EventProc
memset(&m_user, 0, sizeof(m_user));
m_user.config = gf_cfg_init(NULL, NULL);
if(!m_user.config) {
#ifdef _WIN32_WCE
::MessageBox(NULL, _T("GPAC Configuration file not found"), _T("Fatal Error"), MB_OK);
#else
::MessageBox(NULL, "GPAC Configuration file not found", "Fatal Error", MB_OK);
#endif
goto err_exit;
}
str = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
m_user.modules = gf_modules_new(str, m_user.config);
if(!gf_modules_get_count(m_user.modules)) goto err_exit;
m_user.os_window_handler = m_hWnd;
m_user.opaque = this;
m_user.EventProc = GPAX_EventProc;
//create a terminal
m_term = gf_term_new(&m_user);
if (!m_term) goto err_exit;
gf_term_set_option(m_term, GF_OPT_AUDIO_VOLUME, 100);
LoadDATAUrl();
RECT rc;
::GetWindowRect(m_hWnd, &rc);
m_width = rc.right-rc.left;
m_height = rc.bottom-rc.top;
if (m_bAutoStart && strlen(m_url)) Play();
return 0;
//Error Processing
err_exit:
if(m_user.modules)
gf_modules_del(m_user.modules);
m_user.modules = NULL;
if(m_user.config)
gf_cfg_del(m_user.config);
m_user.config = NULL;
return 1;
}
GF_FontManager *gf_font_manager_new(GF_User *user)
{
char *def_font = "SERIF";
u32 i, count;
GF_FontManager *font_mgr;
GF_FontReader *ifce;
const char *opt;
ifce = NULL;
opt = gf_cfg_get_key(user->config, "FontEngine", "FontReader");
if (opt) {
ifce = (GF_FontReader *) gf_modules_load_interface_by_name(user->modules, opt, GF_FONT_READER_INTERFACE);
if (ifce && ifce->init_font_engine(ifce) != GF_OK) {
gf_modules_close_interface((GF_BaseInterface *)ifce);
ifce = NULL;
}
}
if (!ifce) {
count = gf_modules_get_count(user->modules);
for (i=0; i<count; i++) {
ifce = (GF_FontReader *) gf_modules_load_interface(user->modules, i, GF_FONT_READER_INTERFACE);
if (!ifce) continue;
if (ifce->init_font_engine(ifce) != GF_OK) {
gf_modules_close_interface((GF_BaseInterface *)ifce);
ifce = NULL;
continue;
}
gf_cfg_set_key(user->config, "FontEngine", "FontReader", ifce->module_name);
break;
}
}
GF_SAFEALLOC(font_mgr, GF_FontManager);
font_mgr->reader = ifce;
font_mgr->id_buffer_size = 20;
font_mgr->id_buffer = gf_malloc(sizeof(u32)*font_mgr->id_buffer_size);
gf_font_manager_set_font(font_mgr, &def_font, 1, 0);
font_mgr->default_font = font_mgr->font;
font_mgr->line_path= gf_path_new();
gf_path_add_move_to(font_mgr->line_path, -FIX_ONE/2, FIX_ONE/2);
gf_path_add_line_to(font_mgr->line_path, FIX_ONE/2, FIX_ONE/2);
gf_path_add_line_to(font_mgr->line_path, FIX_ONE/2, -FIX_ONE/2);
gf_path_add_line_to(font_mgr->line_path, -FIX_ONE/2, -FIX_ONE/2);
gf_path_close(font_mgr->line_path);
opt = gf_cfg_get_key(user->config, "FontEngine", "WaitForFontLoad");
if (!opt) gf_cfg_set_key(user->config, "FontEngine", "WaitForFontLoad", "no");
if (opt && !strcmp(opt, "yes")) font_mgr->wait_font_load = 1;
return font_mgr;
}
/*locates input service (demuxer) based on mime type or segment name*/
static GF_Err MPD_LoadMediaService(GF_MPD_In *mpdin, u32 group_index, const char *mime, const char *init_segment_name)
{
GF_InputService *segment_ifce;
u32 i;
const char *sPlug;
if (mime) {
/* Check MIME type to start the right InputService */
sPlug = gf_cfg_get_key(mpdin->service->term->user->config, "MimeTypes", mime);
if (sPlug) sPlug = strrchr(sPlug, '"');
if (sPlug) {
sPlug += 2;
segment_ifce = (GF_InputService *) gf_modules_load_interface_by_name(mpdin->service->term->user->modules, sPlug, GF_NET_CLIENT_INTERFACE);
if (segment_ifce) {
GF_MPDGroup *group;
GF_SAFEALLOC(group, GF_MPDGroup);
group->segment_ifce = segment_ifce;
group->segment_ifce->proxy_udta = mpdin;
group->segment_ifce->query_proxy = MPD_ClientQuery;
group->mpdin = mpdin;
group->idx = group_index;
gf_dash_set_group_udta(mpdin->dash, group_index, group);
return GF_OK;
}
}
}
if (init_segment_name) {
for (i=0; i< gf_modules_get_count(mpdin->service->term->user->modules); i++) {
GF_InputService *ifce = (GF_InputService *) gf_modules_load_interface(mpdin->service->term->user->modules, i, GF_NET_CLIENT_INTERFACE);
if (!ifce) continue;
if (ifce->CanHandleURL && ifce->CanHandleURL(ifce, init_segment_name)) {
GF_MPDGroup *group;
GF_SAFEALLOC(group, GF_MPDGroup);
group->segment_ifce = ifce;
group->segment_ifce->proxy_udta = mpdin;
group->segment_ifce->query_proxy = MPD_ClientQuery;
group->mpdin = mpdin;
group->idx = group_index;
gf_dash_set_group_udta(mpdin->dash, group_index, group);
return GF_OK;
}
gf_modules_close_interface((GF_BaseInterface *) ifce);
}
}
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[MPD_IN] Error locating plugin for segment - mime type %s - name %s\n", mime, init_segment_name));
return GF_CODEC_NOT_FOUND;
}
GF_Err gf_afc_load(GF_AudioFilterChain *afc, GF_User *user, char *filterstring)
{
struct _audiofilterentry *prev_filter = NULL;
while (filterstring) {
u32 i, count;
GF_AudioFilter *filter;
char *sep = strstr(filterstring, ";;");
if (sep) sep[0] = 0;
count = gf_modules_get_count(user->modules);
filter = NULL;
for (i=0; i<count; i++) {
filter = (GF_AudioFilter *)gf_modules_load_interface(user->modules, i, GF_AUDIO_FILTER_INTERFACE);
if (filter) {
if (filter->SetFilter
&& filter->Configure
&& filter->Process
&& filter->Reset
&& filter->SetOption
&& filter->GetOption
&& filter->SetFilter(filter, filterstring)
)
break;
gf_modules_close_interface((GF_BaseInterface *)filter);
}
filter = NULL;
}
if (filter) {
struct _audiofilterentry *entry;
GF_SAFEALLOC(entry, struct _audiofilterentry);
entry->filter = filter;
if (prev_filter) prev_filter->next = entry;
else afc->filters = entry;
prev_filter = entry;
}
if (sep) {
sep[0] = ';';
filterstring = sep + 2;
} else {
break;
}
}
return GF_OK;
}
void SR_SetFontEngine(GF_Renderer *sr)
{
const char *sOpt;
u32 i, count;
GF_FontRaster *ifce;
ifce = NULL;
sOpt = gf_cfg_get_key(sr->user->config, "FontEngine", "DriverName");
if (sOpt) ifce = (GF_FontRaster *) gf_modules_load_interface_by_name(sr->user->modules, sOpt, GF_FONT_RASTER_INTERFACE);
if (!ifce) {
count = gf_modules_get_count(sr->user->modules);
for (i=0; i<count; i++) {
ifce = (GF_FontRaster *) gf_modules_load_interface(sr->user->modules, i, GF_FONT_RASTER_INTERFACE);
if (ifce) {
gf_cfg_set_key(sr->user->config, "FontEngine", "DriverName", ifce->module_name);
sOpt = ifce->module_name;
break;
}
}
}
if (!ifce) return;
/*cannot init font engine*/
if (ifce->init_font_engine(ifce) != GF_OK) {
gf_modules_close_interface((GF_BaseInterface *)ifce);
return;
}
/*shutdown current*/
gf_sr_lock(sr, 1);
if (sr->font_engine) {
sr->font_engine->shutdown_font_engine(sr->font_engine);
gf_modules_close_interface((GF_BaseInterface *)sr->font_engine);
}
sr->font_engine = ifce;
/*success*/
gf_cfg_set_key(sr->user->config, "FontEngine", "DriverName", sOpt);
sr->draw_next_frame = 1;
gf_sr_lock(sr, 0);
}
BOOL COptFont::OnInitDialog()
{
u32 i;
GF_BaseInterface *ifce;
CDialog::OnInitDialog();
COsmo4 *gpac = GetApp();
TCHAR wTmp[500];
const char *sOpt;
/*video drivers enum*/
while (m_Fonts.GetCount()) m_Fonts.DeleteString(0);
sOpt = gf_cfg_get_key(gpac->m_user.config, "FontEngine", "DriverName");
s32 to_sel = 0;
s32 select = 0;
u32 count = gf_modules_get_count(gpac->m_user.modules);
for (i=0; i<count; i++) {
ifce = gf_modules_load_interface(gpac->m_user.modules, i, GF_FONT_READER_INTERFACE);
if (!ifce) continue;
if (sOpt && !stricmp(((GF_BaseInterface *)ifce)->module_name, sOpt)) select = to_sel;
CE_CharToWide((char *) ifce->module_name, (u16 *)wTmp);
m_Fonts.AddString(wTmp);
gf_modules_close_interface(ifce);
to_sel++;
}
m_Fonts.SetCurSel(select);
sOpt = gf_cfg_get_key(gpac->m_user.config, "FontEngine", "FontDirectory");
CE_CharToWide((char *)sOpt, (u16 *)wTmp);
if (sOpt) m_BrowseFont.SetWindowText(wTmp);
sOpt = gf_cfg_get_key(gpac->m_user.config, "Compositor", "TextureTextMode");
m_UseTexture.SetCheck( (!sOpt || stricmp(sOpt, "Never")) ? 1 : 0);
return TRUE;
}
void gf_es_config_drm(GF_Channel *ch, GF_NetComDRMConfig *drm_cfg)
{
GF_Terminal *term = ch->odm->term;
u32 i, count;
GF_Err e;
GF_IPMPEvent evt;
GF_OMADRM2Config cfg;
GF_OMADRM2Config isma_cfg;
/*always buffer when fetching keys*/
ch_buffer_on(ch);
ch->is_protected = 1;
memset(&evt, 0, sizeof(GF_IPMPEvent));
evt.event_type = GF_IPMP_TOOL_SETUP;
evt.channel = ch;
/*push all cfg data*/
if (drm_cfg->contentID) {
evt.config_data_code = GF_4CC('o','d','r','m');
memset(&cfg, 0, sizeof(cfg));
cfg.scheme_version = drm_cfg->scheme_version;
cfg.scheme_type = drm_cfg->scheme_type;
cfg.scheme_uri = drm_cfg->scheme_uri;
cfg.kms_uri = drm_cfg->kms_uri;
memcpy(cfg.hash, drm_cfg->hash, sizeof(char)*20);
cfg.contentID = drm_cfg->contentID;
cfg.oma_drm_crypt_type = drm_cfg->oma_drm_crypt_type;
cfg.oma_drm_use_pad = drm_cfg->oma_drm_use_pad;
cfg.oma_drm_use_hdr = drm_cfg->oma_drm_use_hdr;
cfg.oma_drm_textual_headers = drm_cfg->oma_drm_textual_headers;
cfg.oma_drm_textual_headers_len = drm_cfg->oma_drm_textual_headers_len;
evt.config_data = &cfg;
} else {
evt.config_data_code = GF_4CC('i','s','m','a');
memset(&isma_cfg, 0, sizeof(isma_cfg));
isma_cfg.scheme_version = drm_cfg->scheme_version;
isma_cfg.scheme_type = drm_cfg->scheme_type;
isma_cfg.scheme_uri = drm_cfg->scheme_uri;
isma_cfg.kms_uri = drm_cfg->kms_uri;
evt.config_data = &isma_cfg;
}
if (ch->ipmp_tool) {
e = ch->ipmp_tool->process(ch->ipmp_tool, &evt);
if (e) gf_term_message(ch->odm->term, ch->service->url, "Error setting up DRM tool", e);
ch_buffer_off(ch);
return;
}
/*browse all available tools*/
count = gf_modules_get_count(term->user->modules);
for (i=0; i< count; i++) {
ch->ipmp_tool = (GF_IPMPTool *) gf_modules_load_interface(term->user->modules, i, GF_IPMP_TOOL_INTERFACE);
if (!ch->ipmp_tool) continue;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[IPMP] Checking if IPMP tool %s can handle channel protection scheme\n", ch->ipmp_tool->module_name));
e = ch->ipmp_tool->process(ch->ipmp_tool, &evt);
if (e==GF_OK) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[IPMP] Associating IPMP tool %s to channel %d\n", ch->ipmp_tool->module_name, ch->esd->ESID));
ch_buffer_off(ch);
return;
}
gf_modules_close_interface((GF_BaseInterface *) ch->ipmp_tool);
ch->ipmp_tool = NULL;
}
GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[IPMP] No IPMP tool suitable to handle channel protection scheme %s (KMS URI %s)\n", drm_cfg->scheme_uri, drm_cfg->kms_uri));
ch_buffer_off(ch);
}
static GF_Err IS_AttachStream(GF_BaseDecoder *plug, GF_ESD *esd)
{
GF_BitStream *bs;
u32 len, size, i;
char devName[255];
u16 termSeq[20];
ISPriv *is = (ISPriv *)plug->privateStack;
if (esd->decoderConfig->upstream) return GF_NOT_SUPPORTED;
if (!esd->decoderConfig->decoderSpecificInfo || !esd->decoderConfig->decoderSpecificInfo->dataLength) return GF_NON_COMPLIANT_BITSTREAM;
/*no more than one UI stream per object*/
if (is->ES_ID) return GF_NOT_SUPPORTED;
is->ES_ID = esd->ESID;
/*parse config*/
bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ);
len = gf_bs_read_int(bs, 8);
for (i=0; i<len; i++) {
devName[i] = gf_bs_read_int(bs, 8);
}
devName[i] = 0;
is->type = gf_crc_32(devName, len);
size = len + 1;
if (!stricmp(devName, "KeySensor")) {
is->type = IS_KeySensor;
add_field(is, GF_SG_VRML_SFINT32, "keyPressed");
add_field(is, GF_SG_VRML_SFINT32, "keyReleased");
add_field(is, GF_SG_VRML_SFINT32, "actionKeyPressed");
add_field(is, GF_SG_VRML_SFINT32, "actionKeyReleased");
add_field(is, GF_SG_VRML_SFBOOL, "shiftKeyPressed");
add_field(is, GF_SG_VRML_SFBOOL, "controlKeyPressed");
add_field(is, GF_SG_VRML_SFBOOL, "altKeyPressed");
} else if (!stricmp(devName, "StringSensor")) {
is->type = IS_StringSensor;
add_field(is, GF_SG_VRML_SFSTRING, "enteredText");
add_field(is, GF_SG_VRML_SFSTRING, "finalText");
is->termChar = '\r';
is->delChar = '\b';
/*get escape chars if any specified*/
if (size<esd->decoderConfig->decoderSpecificInfo->dataLength) {
const char *src = esd->decoderConfig->decoderSpecificInfo->data + size;
gf_utf8_mbstowcs(termSeq, esd->decoderConfig->decoderSpecificInfo->dataLength - size, &src);
is->termChar = termSeq[0];
is->delChar = termSeq[1];
}
} else if (!stricmp(devName, "Mouse")) {
is->type = IS_Mouse;
add_field(is, GF_SG_VRML_SFVEC2F, "position");
add_field(is, GF_SG_VRML_SFBOOL, "leftButtonDown");
add_field(is, GF_SG_VRML_SFBOOL, "middleButtonDown");
add_field(is, GF_SG_VRML_SFBOOL, "rightButtonDown");
add_field(is, GF_SG_VRML_SFFLOAT, "wheel");
}
else {
GF_InputSensorDevice *ifce;
/*not found, check all modules*/
u32 plugCount = gf_modules_get_count(is->scene->root_od->term->user->modules);
for (i = 0; i < plugCount ; i++) {
ifce = (GF_InputSensorDevice *) gf_modules_load_interface(is->scene->root_od->term->user->modules, i, GF_INPUT_DEVICE_INTERFACE);
if (!ifce) continue;
ifce->input_decoder = plug;
if (ifce->RegisterDevice && ifce->RegisterDevice(ifce, devName, bs, isdev_add_field) ) {
is->io_dev = ifce;
break;
}
gf_modules_close_interface((GF_BaseInterface *) ifce);
}
if (!is->io_dev) return GF_NOT_SUPPORTED;
is->io_dev->DispatchFrame = isdev_dispatch_frame;
plug->module_name = is->io_dev->module_name;
plug->author_name = is->io_dev->author_name;
}
gf_bs_del(bs);
return GF_OK;
}
// -----------------------------------------------------------------------------
// COsmo4AppView::ConstructL()
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void COsmo4AppView::ConstructL( const TRect& aRect )
{
const char *opt;
Bool first_launch = 0;
#if defined(__SERIES60_3X__)
selector = CRemConInterfaceSelector::NewL();
target = CRemConCoreApiTarget::NewL(*selector, *this);
selector->OpenTargetL();
#endif
// Create a window for this application view
CreateWindowL();
// Set the windows size
SetRect( aRect );
//draw
ActivateL();
#ifndef GPAC_GUI_ONLY
m_window = Window();
m_session = CEikonEnv::Static()->WsSession();
m_mx = gf_mx_new("Osmo4");
//load config file
m_user.config = gf_cfg_init(NULL, &first_launch);
if (!m_user.config) {
MessageBox("Cannot create GPAC Config file", "Fatal Error");
User::Leave(KErrGeneral);
}
if (first_launch) {
MessageBox("Osmo4", "Thank you for Installing");
}
/*load modules*/
opt = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
m_user.modules = gf_modules_new(opt, m_user.config);
if (!m_user.modules || !gf_modules_get_count(m_user.modules)) {
MessageBox(m_user.modules ? "No modules available" : "Cannot create module manager", "Fatal Error");
if (m_user.modules) gf_modules_del(m_user.modules);
gf_cfg_del(m_user.config);
User::Leave(KErrGeneral);
}
if (first_launch) {
/*first launch, register all files ext*/
for (u32 i=0; i<gf_modules_get_count(m_user.modules); i++) {
GF_InputService *ifce = (GF_InputService *) gf_modules_load_interface(m_user.modules, i, GF_NET_CLIENT_INTERFACE);
if (!ifce) continue;
if (ifce) {
ifce->CanHandleURL(ifce, "test.test");
gf_modules_close_interface((GF_BaseInterface *)ifce);
}
}
}
/*we don't thread the terminal, ie appart from the audio renderer, media decoding and visual rendering is
handled by the app process*/
m_user.init_flags = GF_TERM_NO_VISUAL_THREAD | GF_TERM_NO_REGULATION;
m_user.EventProc = GPAC_EventProc;
m_user.opaque = this;
m_user.os_window_handler = (void *) &m_window;
m_user.os_display = (void *) &m_session;
m_term = gf_term_new(&m_user);
if (!m_term) {
MessageBox("Cannot load GPAC terminal", "Fatal Error");
gf_modules_del(m_user.modules);
gf_cfg_del(m_user.config);
User::Leave(KErrGeneral);
}
//MessageBox("GPAC terminal loaded", "Success !");
/*ok set output size*/
TSize s = m_window.Size();
gf_term_set_size(m_term, s.iWidth, s.iHeight);
/*start our callback (every ms)*/
const TInt KTickInterval = 33000;
m_pTimer = CPeriodic::NewL(CActive::EPriorityStandard);
m_pTimer->Start(KTickInterval, KTickInterval, TCallBack(myTick, this));
opt = gf_cfg_get_key(m_user.config, "General", "StartupFile");
if (opt) gf_term_connect(m_term, opt);
#endif
}
BOOL COsmo4::InitInstance()
{
if (!AfxSocketInit())
{
AfxMessageBox(IDP_SOCKETS_INIT_FAILED);
return FALSE;
}
gf_sys_init();
SetRegistryKey(_T("GPAC"));
m_prev_batt_bl = m_prev_ac_bl = 0;
m_screen_width = GetSystemMetrics(SM_CXSCREEN);
m_screen_height = GetSystemMetrics(SM_CYSCREEN);
m_menu_height = GetSystemMetrics(SM_CYMENU);
m_scene_width = m_scene_height = 0;
CMainFrame* pFrame = new CMainFrame;
m_pMainWnd = pFrame;
pFrame->LoadFrame(IDR_MAINFRAME, WS_VISIBLE, NULL, NULL);
pFrame->ShowWindow(m_nCmdShow);
pFrame->UpdateWindow();
char config_path[MAX_PATH];
CE_WideToChar((unsigned short *) (LPCTSTR) AfxGetApp()->m_pszHelpFilePath, (char *) config_path);
while (config_path[strlen((char *) config_path)-1] != '\\') config_path[strlen((char *) config_path)-1] = 0;
/*setup user*/
memset(&m_user, 0, sizeof(GF_User));
/*init config and plugins*/
m_user.config = gf_cfg_new((const char *) config_path, "GPAC.cfg");
if (!m_user.config) {
/*create blank config file in the exe dir*/
unsigned char config_file[MAX_PATH];
strcpy((char *) config_file, (const char *) config_path);
strcat((char *) config_file, "GPAC.cfg");
FILE *ft = fopen((const char *) config_file, "wt");
fclose(ft);
m_user.config = gf_cfg_new((const char *) config_path, "GPAC.cfg");
if (!m_user.config) {
MessageBox(NULL, _T("GPAC Configuration file not found"), _T("Fatal Error"), MB_OK);
m_pMainWnd->PostMessage(WM_CLOSE);
}
}
const char *str = gf_cfg_get_key(m_user.config, "General", "LogLevel");
EnableLogs((str && !strcmp(str, "debug")) ? 1 : 0);
str = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
m_user.modules = gf_modules_new(str, m_user.config);
if (!m_user.modules) {
unsigned char str_path[MAX_PATH];
const char *sOpt;
/*inital launch*/
m_user.modules = gf_modules_new(config_path, m_user.config);
if (m_user.modules) {
gf_cfg_set_key(m_user.config, "General", "ModulesDirectory", (const char *) config_path);
gf_cfg_set_key(m_user.config, "Rendering", "RendererName", "GPAC 2D Renderer");
sOpt = gf_cfg_get_key(m_user.config, "Rendering", "Raster2D");
if (!sOpt) gf_cfg_set_key(m_user.config, "Rendering", "Raster2D", "GPAC 2D Raster");
sOpt = gf_cfg_get_key(m_user.config, "General", "CacheDirectory");
if (!sOpt) {
sprintf((char *) str_path, "%scache", config_path);
gf_cfg_set_key(m_user.config, "General", "CacheDirectory", (const char *) str_path);
}
/*setup UDP traffic autodetect*/
gf_cfg_set_key(m_user.config, "Network", "AutoReconfigUDP", "yes");
gf_cfg_set_key(m_user.config, "Network", "UDPNotAvailable", "no");
gf_cfg_set_key(m_user.config, "Network", "UDPTimeout", "10000");
gf_cfg_set_key(m_user.config, "Network", "BufferLength", "3000");
/*first launch, register all files ext*/
u32 i;
for (i=0; i<gf_modules_get_count(m_user.modules); i++) {
GF_InputService *ifce = (GF_InputService *) gf_modules_load_interface(m_user.modules, i, GF_NET_CLIENT_INTERFACE);
if (!ifce) continue;
if (ifce) {
ifce->CanHandleURL(ifce, "test.test");
gf_modules_close_interface((GF_BaseInterface *)ifce);
}
}
}
/*check audio config on windows, force config*/
sOpt = gf_cfg_get_key(m_user.config, "Audio", "ForceConfig");
if (!sOpt) {
gf_cfg_set_key(m_user.config, "Audio", "ForceConfig", "yes");
gf_cfg_set_key(m_user.config, "Audio", "NumBuffers", "2");
gf_cfg_set_key(m_user.config, "Audio", "TotalDuration", "200");
}
/*by default use GDIplus, much faster than freetype on font loading*/
gf_cfg_set_key(m_user.config, "FontEngine", "DriverName", "ft_font");
sprintf((char *) str_path, "%sgpac.mp4", config_path);
gf_cfg_set_key(m_user.config, "General", "StartupFile", (const char *) str_path);
::MessageBox(NULL, _T("Osmo4/GPAC Setup complete"), _T("Initial launch"), MB_OK);
}
if (! gf_modules_get_count(m_user.modules) ) {
MessageBox(NULL, _T("No plugins available - system cannot work"), _T("Fatal Error"), MB_OK);
m_pMainWnd->PostMessage(WM_QUIT);
}
/*setup font dir*/
str = gf_cfg_get_key(m_user.config, "FontEngine", "FontDirectory");
if (!str || !strlen(str) ) {
strcpy((char *) config_path, "\\Windows");
gf_cfg_set_key(m_user.config, "FontEngine", "FontDirectory", (const char *) config_path);
}
/*work with iPaq's default fonts ...*/
str = gf_cfg_get_key(m_user.config, "FontEngine", "FontSerif");
if (!str) gf_cfg_set_key(m_user.config, "FontEngine", "FontSerif", "Tahoma");
str = gf_cfg_get_key(m_user.config, "FontEngine", "FontSans");
if (!str) gf_cfg_set_key(m_user.config, "FontEngine", "FontSans", "Frutiger");
str = gf_cfg_get_key(m_user.config, "FontEngine", "FontFixed");
if (!str) gf_cfg_set_key(m_user.config, "FontEngine", "FontFixed", "Courier New");
/*check video driver, if none or raw_out use dx_hw by default*/
str = gf_cfg_get_key(m_user.config, "Video", "DriverName");
if (!str || !stricmp(str, "raw_out")) {
gf_cfg_set_key(m_user.config, "Video", "DriverName", "gapi");
}
m_user.config = m_user.config;
m_user.modules = m_user.modules;
m_user.EventProc = Osmo4CE_EventProc;
m_user.opaque = this;
m_user.os_window_handler = pFrame->m_wndView.m_hWnd;
m_term = gf_term_new(&m_user);
if (! m_term) {
MessageBox(NULL, _T("Cannot load MPEG-4 Terminal"), _T("Fatal Error"), MB_OK);
m_pMainWnd->PostMessage(WM_QUIT);
}
m_stoped = 0;
m_open = 0;
m_can_seek = 0;
m_DoResume = 0;
SetOptions();
pFrame->SendMessage(WM_SETSIZE, 0, 0);
ShowTaskBar(0);
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
if (! cmdInfo.m_strFileName.IsEmpty()) {
m_filename = cmdInfo.m_strFileName;
m_pMainWnd->PostMessage(WM_OPENURL);
} else {
str = gf_cfg_get_key(m_user.config, "General", "StartupFile");
if (str) gf_term_connect(m_term, str);
}
return TRUE;
}
GF_Err gf_term_service_cache_load(GF_ClientService *ns)
{
GF_Err e;
const char *sOpt;
char szName[GF_MAX_PATH], szURL[1024];
GF_NetworkCommand com;
u32 i;
GF_StreamingCache *mcache = NULL;
/*is service cachable*/
com.base.on_channel = NULL;
com.base.command_type = GF_NET_IS_CACHABLE;
if (ns->ifce->ServiceCommand(ns->ifce, &com) != GF_OK) return GF_OK;
/*locate a cache*/
for (i=0; i< gf_modules_get_count(ns->term->user->modules); i++) {
mcache = (GF_StreamingCache *) gf_modules_load_interface(ns->term->user->modules, i, GF_STREAMING_MEDIA_CACHE);
if (mcache && mcache->Open && mcache->Close && mcache->Write && mcache->ChannelGetSLP && mcache->ChannelReleaseSLP && mcache->ServiceCommand) break;
if (mcache) gf_modules_close_interface((GF_BaseInterface *)mcache);
mcache = NULL;
}
if (!mcache) return GF_NOT_SUPPORTED;
sOpt = gf_cfg_get_key(ns->term->user->config, "StreamingCache", "RecordDirectory");
if (!sOpt) sOpt = gf_cfg_get_key(ns->term->user->config, "General", "CacheDirectory");
if (sOpt) {
strcpy(szName, sOpt);
if (szName[strlen(szName)-1]!='\\') strcat(szName, "\\");
} else {
strcpy(szName, "");
}
sOpt = gf_cfg_get_key(ns->term->user->config, "StreamingCache", "BaseFileName");
if (sOpt) {
strcat(szName, sOpt);
} else {
char *sep;
strcat(szName, "rec_");
sOpt = strrchr(ns->url, '/');
if (!sOpt) sOpt = strrchr(ns->url, '\\');
if (sOpt) sOpt += 1;
else {
sOpt = strstr(ns->url, "://");
if (sOpt) sOpt += 3;
else sOpt = ns->url;
}
strcpy(szURL, sOpt);
sep = strrchr(szURL, '.');
if (sep) sep[0] = 0;
for (i=0; i<strlen(szURL); i++) {
switch (szURL[i]) {
case '/': case '\\': case '.': case ':': case '?':
szURL[i] = '_';
break;
}
}
strcat(szName, szURL);
}
sOpt = gf_cfg_get_key(ns->term->user->config, "StreamingCache", "KeepExistingFiles");
e = mcache->Open(mcache, ns, szName, (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
if (e) {
gf_modules_close_interface((GF_BaseInterface *)mcache);
return e;
}
ns->cache = mcache;
return GF_OK;
}
//-------------------------------
// dir should end with /
int CNativeWrapper::init(JNIEnv * env, void * bitmap, jobject * callback, int width, int height, const char * cfg_dir, const char * modules_dir, const char * cache_dir, const char * font_dir, const char * gui_dir, const char * urlToLoad) {
LOGI("Initializing GPAC with URL=%s...", urlToLoad);
strcpy(m_modules_dir, modules_dir);
strcpy(m_cache_dir, cache_dir);
strcpy(m_font_dir, font_dir);
if (cfg_dir)
strcpy(m_cfg_dir, cfg_dir);
char m_cfg_filename[GF_MAX_PATH];
if (m_cfg_dir) {
LOGI("GPAC.cfg found in %s, force using it.\n", m_cfg_dir);
strcpy(m_cfg_filename, m_cfg_dir);
strcat(m_cfg_filename, "GPAC.cfg");
}
int m_Width = width;
int m_Height = height;
int first_launch = 0;
const char *opt;
m_window = env;
m_session = bitmap;
if (!mainJavaEnv)
mainJavaEnv = (JavaEnvTh *) gf_malloc(sizeof(JavaEnvTh));
memset(mainJavaEnv, 0, sizeof(JavaEnvTh));
setJavaEnv(mainJavaEnv, env, env->NewGlobalRef(*callback));
if (pthread_setspecific( jni_thread_env_key, mainJavaEnv)) {
LOGE("Failed to set specific thread data to jni_thread_env_key=%d for main thread !", jni_thread_env_key);
}
m_mx = gf_mx_new("Osmo4");
//load config file
LOGI("Loading User Config %s...", "GPAC.cfg");
m_user.config = gf_cfg_init(m_cfg_dir ? m_cfg_filename : NULL, NULL);
gf_set_progress_callback(this, Osmo4_progress_cbk);
opt = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
LOGI("loading modules in directory %s...", opt);
m_user.modules = gf_modules_new(opt, m_user.config);
if (!m_user.modules || !gf_modules_get_count(m_user.modules)) {
LOGE("No modules found in directory %s !", opt);
if (m_user.modules)
gf_modules_del(m_user.modules);
gf_cfg_del(m_user.config);
m_user.config = NULL;
return Quit(KErrGeneral);
}
/*we don't thread the visual compositor to be able to minimize the app and still have audio running*/
m_user.init_flags = GF_TERM_NO_COMPOSITOR_THREAD;
m_user.opaque = this;
m_user.os_window_handler = m_window;
m_user.os_display = m_session;
m_user.EventProc = GPAC_EventProc;
if (!javaVM) {
LOGE("NO JAVA VM FOUND, m_user=%p !!!!\n", &m_user);
return Quit(KErrGeneral);
}
LOGD("Loading GPAC terminal, m_user=%p...", &m_user);
gf_sys_init(GF_MemTrackerNone);
gf_fm_request_set_callback(this, on_fm_request);
SetupLogs();
m_term = gf_term_new(&m_user);
if (!m_term) {
LOGE("Cannot load GPAC Terminal with m_user=%p", &m_user);
MessageBox("Cannot load GPAC terminal", "Fatal Error", GF_SERVICE_ERROR);
gf_modules_del(m_user.modules);
m_user.modules = NULL;
gf_cfg_del(m_user.config);
m_user.config = NULL;
return Quit(KErrGeneral);
}
/*force fullscreen*/
gf_term_set_option(m_term, GF_OPT_FULLSCREEN, 1);
//setAudioEnvironment(javaVM);
LOGD("Setting term size m_user=%p...", &m_user);
gf_term_set_size(m_term, m_Width, m_Height);
opt = gf_cfg_get_key(m_user.config, "General", "StartupFile");
LOGD("File loaded at startup=%s.", opt);
if (!urlToLoad)
urlToLoad = opt;
if (urlToLoad) {
LOGI("Connecting to %s...", urlToLoad);
gf_term_connect(m_term, urlToLoad);
}
debug_log("init end");
LOGD("Saving config file...\n");
gf_cfg_save(m_user.config);
LOGI("Initialization complete, config file saved.\n");
return 0;
}
static GF_Err Codec_LoadModule(GF_Codec *codec, GF_ESD *esd, u32 PL)
{
char szPrefDec[500];
const char *sOpt;
GF_BaseDecoder *ifce, *dec_ifce;
u32 i, plugCount;
u32 ifce_type;
char *cfg;
u32 cfg_size, dec_confidence;
GF_Terminal *term = codec->odm->term;
if (esd->decoderConfig->decoderSpecificInfo) {
cfg = esd->decoderConfig->decoderSpecificInfo->data;
cfg_size = esd->decoderConfig->decoderSpecificInfo->dataLength;
} else {
cfg = NULL;
cfg_size = 0;
}
switch (esd->decoderConfig->streamType) {
case GF_STREAM_AUDIO:
case GF_STREAM_VISUAL:
case GF_STREAM_ND_SUBPIC:
ifce_type = GF_MEDIA_DECODER_INTERFACE;
codec->process = MediaCodec_Process;
break;
case GF_STREAM_PRIVATE_MEDIA:
ifce_type = GF_PRIVATE_MEDIA_DECODER_INTERFACE;
codec->process = gf_codec_process_private_media;
break;
case GF_STREAM_PRIVATE_SCENE:
ifce_type = GF_SCENE_DECODER_INTERFACE;
codec->process = PrivateScene_Process;
break;
default:
ifce_type = GF_SCENE_DECODER_INTERFACE;
codec->process = SystemCodec_Process;
if (esd->decoderConfig->objectTypeIndication==GPAC_OTI_SCENE_AFX) {
ifce_type = GF_NODE_DECODER_INTERFACE;
}
break;
}
/*a bit dirty, if FFMPEG is used for demuxer load it for decoder too*/
if (0 && !stricmp(codec->odm->net_service->ifce->module_name, "FFMPEG demuxer")) {
sOpt = "FFMPEG decoder";
} else {
/*use user-defined module if any*/
sOpt = NULL;
switch (esd->decoderConfig->streamType) {
case GF_STREAM_VISUAL:
if ((esd->decoderConfig->objectTypeIndication==GPAC_OTI_IMAGE_JPEG) || (esd->decoderConfig->objectTypeIndication==GPAC_OTI_IMAGE_PNG))
sOpt = gf_cfg_get_key(term->user->config, "Systems", "DefImageDec");
else
sOpt = gf_cfg_get_key(term->user->config, "Systems", "DefVideoDec");
break;
case GF_STREAM_AUDIO:
sOpt = gf_cfg_get_key(term->user->config, "Systems", "DefAudioDec");
break;
default:
break;
}
}
dec_confidence = 0;
ifce = NULL;
if (sOpt) {
ifce = (GF_BaseDecoder *) gf_modules_load_interface_by_name(term->user->modules, sOpt, ifce_type);
if (ifce) {
if (ifce->CanHandleStream) {
dec_confidence = ifce->CanHandleStream(ifce, esd->decoderConfig->streamType, esd, PL);
if (dec_confidence==GF_CODEC_SUPPORTED) {
codec->decio = ifce;
return GF_OK;
}
if (dec_confidence==GF_CODEC_NOT_SUPPORTED) {
gf_modules_close_interface((GF_BaseInterface *) ifce);
ifce = NULL;
}
} else {
gf_modules_close_interface((GF_BaseInterface *) ifce);
}
}
}
dec_ifce = ifce;
/*prefered codec module per streamType/objectType from config*/
sprintf(szPrefDec, "codec_%02X_%02X", esd->decoderConfig->streamType, esd->decoderConfig->objectTypeIndication);
sOpt = gf_cfg_get_key(term->user->config, "Systems", szPrefDec);
if (sOpt) {
ifce = (GF_BaseDecoder *) gf_modules_load_interface_by_name(term->user->modules, sOpt, ifce_type);
if (ifce) {
if (ifce->CanHandleStream) {
u32 conf = ifce->CanHandleStream(ifce, esd->decoderConfig->streamType, esd, PL);
if ((conf!=GF_CODEC_NOT_SUPPORTED) && (conf>=dec_confidence)) {
/*switch*/
if (dec_ifce) gf_modules_close_interface((GF_BaseInterface *) dec_ifce);
dec_confidence = conf;
dec_ifce = ifce;
ifce = NULL;
if (dec_confidence==GF_CODEC_SUPPORTED) {
codec->decio = dec_ifce;
return GF_OK;
}
}
}
if (ifce)
gf_modules_close_interface((GF_BaseInterface *) ifce);
}
}
/*not found, check all modules*/
plugCount = gf_modules_get_count(term->user->modules);
for (i = 0; i < plugCount ; i++) {
ifce = (GF_BaseDecoder *) gf_modules_load_interface(term->user->modules, i, ifce_type);
if (!ifce) continue;
if (ifce->CanHandleStream) {
u32 conf = ifce->CanHandleStream(ifce, esd->decoderConfig->streamType, esd, PL);
if ((conf!=GF_CODEC_NOT_SUPPORTED) && (conf>=dec_confidence)) {
/*switch*/
if (dec_ifce) gf_modules_close_interface((GF_BaseInterface *) dec_ifce);
dec_confidence = conf;
dec_ifce = ifce;
ifce = NULL;
}
}
if (ifce)
gf_modules_close_interface((GF_BaseInterface *) ifce);
}
if (dec_ifce) {
codec->decio = dec_ifce;
sprintf(szPrefDec, "codec_%02X_%02X", esd->decoderConfig->streamType, esd->decoderConfig->objectTypeIndication);
gf_cfg_set_key(term->user->config, "Systems", szPrefDec, dec_ifce->module_name);
return GF_OK;
}
return GF_CODEC_NOT_FOUND;
}
BOOL Osmo4::InitInstance()
{
CCommandLineInfo cmdInfo;
m_logs = NULL;
m_term = NULL;
memset(&m_user, 0, sizeof(GF_User));
/*get Osmo4.exe path*/
strcpy((char *) szApplicationPath, AfxGetApp()->m_pszHelpFilePath);
while (szApplicationPath[strlen((char *) szApplicationPath)-1] != '\\') szApplicationPath[strlen((char *) szApplicationPath)-1] = 0;
if (szApplicationPath[strlen((char *) szApplicationPath)-1] != '\\') strcat(szApplicationPath, "\\");
gf_sys_init(0);
/*setup user*/
memset(&m_user, 0, sizeof(GF_User));
Bool first_launch = 0;
/*init config and modules*/
m_user.config = gf_cfg_init(NULL, &first_launch);
if (!m_user.config) {
MessageBox(NULL, "GPAC Configuration file not found", "Fatal Error", MB_OK);
m_pMainWnd->PostMessage(WM_CLOSE);
}
char *name = gf_cfg_get_filename(m_user.config);
char *sep = strrchr(name, '\\');
if (sep) sep[0] = 0;
strcpy(szUserPath, name);
if (sep) sep[0] = '\\';
gf_free(name);
const char *opt = gf_cfg_get_key(m_user.config, "General", "SingleInstance");
m_SingleInstance = (opt && !stricmp(opt, "yes")) ? 1 : 0;
m_hMutex = NULL;
if (m_SingleInstance) {
m_hMutex = CreateMutex(NULL, FALSE, "Osmo4_GPAC_INSTANCE");
if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
char szDIR[1024];
if (m_hMutex) CloseHandle(m_hMutex);
m_hMutex = NULL;
if (!static_gpac_hwnd || !IsWindow(static_gpac_hwnd) ) {
::MessageBox(NULL, "Osmo4 ghost process detected", "Error at last shutdown" , MB_OK);
} else {
::SetForegroundWindow(static_gpac_hwnd);
if (m_lpCmdLine && strlen(m_lpCmdLine)) {
DWORD res;
u32 len;
char *the_url, *cmd;
GetCurrentDirectory(1024, szDIR);
if (szDIR[strlen(szDIR)-1] != '\\') strcat(szDIR, "\\");
cmd = (char *)(const char *) m_lpCmdLine;
strcpy(static_szCmdLine, "");
if (cmd[0]=='"') cmd+=1;
if (!strnicmp(cmd, "-queue ", 7)) {
strcat(static_szCmdLine, "-queue ");
cmd += 7;
}
the_url = gf_url_concatenate(szDIR, cmd);
if (!the_url) {
strcat(static_szCmdLine, cmd);
} else {
strcat(static_szCmdLine, the_url);
gf_free(the_url);
}
while ( (len = strlen(static_szCmdLine)) ) {
char s = static_szCmdLine[len-1];
if ((s==' ') || (s=='"')) static_szCmdLine[len-1]=0;
else break;
}
::SendMessageTimeout(static_gpac_hwnd, WM_NEWINSTANCE, 0, 0, 0, 1000, &res);
}
}
return FALSE;
}
}
#if 0
// Standard initialization
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
#endif
SetRegistryKey(_T("GPAC"));
CMainFrame* pFrame = new CMainFrame;
m_pMainWnd = pFrame;
pFrame->LoadFrame(IDR_MAINFRAME, WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, NULL, NULL);
m_pMainWnd->DragAcceptFiles();
if (m_SingleInstance) static_gpac_hwnd = m_pMainWnd->m_hWnd;
const char *str = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
m_user.modules = gf_modules_new(str, m_user.config);
if (!m_user.modules || ! gf_modules_get_count(m_user.modules) ) {
MessageBox(NULL, "No modules available - system cannot work", "Fatal Error", MB_OK);
m_pMainWnd->PostMessage(WM_CLOSE);
}
else if (first_launch) {
/*first launch, register all files ext*/
u32 i;
for (i=0; i<gf_modules_get_count(m_user.modules); i++) {
GF_InputService *ifce = (GF_InputService *) gf_modules_load_interface(m_user.modules, i, GF_NET_CLIENT_INTERFACE);
if (!ifce) continue;
if (ifce) {
ifce->CanHandleURL(ifce, "test.test");
gf_modules_close_interface((GF_BaseInterface *)ifce);
}
}
/*set some shortcuts*/
gf_cfg_set_key(m_user.config, "Shortcuts", "VolumeUp", "ctrl+Up");
gf_cfg_set_key(m_user.config, "Shortcuts", "VolumeDown", "ctrl+Down");
gf_cfg_set_key(m_user.config, "Shortcuts", "FastRewind", "ctrl+Left");
gf_cfg_set_key(m_user.config, "Shortcuts", "FastForward", "ctrl+Right");
gf_cfg_set_key(m_user.config, "Shortcuts", "Play", "ctrl+ ");
}
/*check log file*/
str = gf_cfg_get_key(m_user.config, "General", "LogFile");
if (str) {
m_logs = gf_f64_open(str, "wt");
gf_log_set_callback(m_logs, osmo4_do_log);
}
else m_logs = NULL;
/*set log level*/
if (gf_log_set_tools_levels(gf_cfg_get_key(m_user.config, "General", "Logs")) != GF_OK)
fprintf(stdout, "osmo4: invalid log level specified\n");
m_user.opaque = this;
m_user.os_window_handler = pFrame->m_pWndView->m_hWnd;
m_user.EventProc = Osmo4_EventProc;
m_reset = 0;
orig_width = 320;
orig_height = 240;
gf_set_progress_callback(this, Osmo4_progress_cbk);
m_term = gf_term_new(&m_user);
if (! m_term) {
MessageBox(NULL, "Cannot load GPAC Terminal", "Fatal Error", MB_OK);
m_pMainWnd->PostMessage(WM_CLOSE);
return TRUE;
}
SetOptions();
UpdateRenderSwitch();
pFrame->SendMessage(WM_SETSIZE, orig_width, orig_height);
pFrame->m_Address.ReloadURLs();
pFrame->m_Sliders.SetVolume();
m_reconnect_time = 0;
ParseCommandLine(cmdInfo);
start_mode = 0;
if (! cmdInfo.m_strFileName.IsEmpty()) {
pFrame->m_pPlayList->QueueURL(cmdInfo.m_strFileName);
pFrame->m_pPlayList->RefreshList();
pFrame->m_pPlayList->PlayNext();
} else {
char sPL[MAX_PATH];
strcpy((char *) sPL, szUserPath);
strcat(sPL, "gpac_pl.m3u");
pFrame->m_pPlayList->OpenPlayList(sPL);
const char *sOpt = gf_cfg_get_key(GetApp()->m_user.config, "General", "PLEntry");
if (sOpt) {
s32 count = (s32)gf_list_count(pFrame->m_pPlayList->m_entries);
pFrame->m_pPlayList->m_cur_entry = atoi(sOpt);
if (pFrame->m_pPlayList->m_cur_entry>=count)
pFrame->m_pPlayList->m_cur_entry = count-1;
} else {
pFrame->m_pPlayList->m_cur_entry = -1;
}
#if 0
if (pFrame->m_pPlayList->m_cur_entry>=0) {
start_mode = 1;
pFrame->m_pPlayList->Play();
}
#endif
sOpt = gf_cfg_get_key(GetApp()->m_user.config, "General", "StartupFile");
if (sOpt) gf_term_connect(m_term, sOpt);
}
pFrame->SetFocus();
pFrame->SetForegroundWindow();
return TRUE;
}
GF_AudioRenderer *gf_sc_ar_load(GF_User *user)
{
const char *sOpt;
u32 i, count;
u32 num_buffers, total_duration;
GF_Err e;
GF_AudioRenderer *ar;
ar = (GF_AudioRenderer *) gf_malloc(sizeof(GF_AudioRenderer));
memset(ar, 0, sizeof(GF_AudioRenderer));
num_buffers = total_duration = 0;
sOpt = gf_cfg_get_key(user->config, "Audio", "ForceConfig");
if (sOpt && !stricmp(sOpt, "yes")) {
sOpt = gf_cfg_get_key(user->config, "Audio", "NumBuffers");
num_buffers = sOpt ? atoi(sOpt) : 6;
sOpt = gf_cfg_get_key(user->config, "Audio", "TotalDuration");
total_duration = sOpt ? atoi(sOpt) : 400;
}
sOpt = gf_cfg_get_key(user->config, "Audio", "NoResync");
ar->disable_resync = (sOpt && !stricmp(sOpt, "yes")) ? GF_TRUE : GF_FALSE;
sOpt = gf_cfg_get_key(user->config, "Audio", "DisableMultiChannel");
ar->disable_multichannel = (sOpt && !stricmp(sOpt, "yes")) ? GF_TRUE : GF_FALSE;
ar->mixer = gf_mixer_new(ar);
ar->user = user;
sOpt = gf_cfg_get_key(user->config, "Audio", "Volume");
ar->volume = sOpt ? atoi(sOpt) : 75;
sOpt = gf_cfg_get_key(user->config, "Audio", "Pan");
ar->pan = sOpt ? atoi(sOpt) : 50;
if (! (user->init_flags & GF_TERM_NO_AUDIO) ) {
/*get a prefered compositor*/
sOpt = gf_cfg_get_key(user->config, "Audio", "DriverName");
if (sOpt) {
ar->audio_out = (GF_AudioOutput *) gf_modules_load_interface_by_name(user->modules, sOpt, GF_AUDIO_OUTPUT_INTERFACE);
if (!ar->audio_out) {
ar->audio_out = NULL;
sOpt = NULL;
}
}
if (!ar->audio_out) {
GF_AudioOutput *raw_out = NULL;
count = gf_modules_get_count(ar->user->modules);
for (i=0; i<count; i++) {
ar->audio_out = (GF_AudioOutput *) gf_modules_load_interface(ar->user->modules, i, GF_AUDIO_OUTPUT_INTERFACE);
if (!ar->audio_out) continue;
//in enum mode, only use raw out if everything else failed ...
if (!stricmp(ar->audio_out->module_name, "Raw Audio Output")) {
raw_out = ar->audio_out;
ar->audio_out = NULL;
continue;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_AUDIO, ("[AudioRender] Audio output module %s loaded\n", ar->audio_out->module_name));
/*check that's a valid audio compositor*/
if ((ar->audio_out->SelfThreaded && ar->audio_out->SetPriority) || ar->audio_out->WriteAudio) {
/*remember the module we use*/
gf_cfg_set_key(user->config, "Audio", "DriverName", ar->audio_out->module_name);
break;
}
gf_modules_close_interface((GF_BaseInterface *)ar->audio_out);
ar->audio_out = NULL;
}
if (raw_out) {
if (ar->audio_out) gf_modules_close_interface((GF_BaseInterface *)raw_out);
else ar->audio_out = raw_out;
}
}
/*if not init we run with a NULL audio compositor*/
if (ar->audio_out) {
ar->audio_out->FillBuffer = gf_ar_fill_output;
ar->audio_out->audio_renderer = ar;
GF_LOG(GF_LOG_DEBUG, GF_LOG_AUDIO, ("[AudioRender] Setting up audio module %s\n", ar->audio_out->module_name));
e = ar->audio_out->Setup(ar->audio_out, ar->user->os_window_handler, num_buffers, total_duration);
/*load main audio filter*/
gf_afc_load(&ar->filter_chain, user, (char*)gf_cfg_get_key(user->config, "Audio", "Filter"));
if (e != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("Could not setup audio out %s\n", ar->audio_out->module_name));
gf_modules_close_interface((GF_BaseInterface *)ar->audio_out);
ar->audio_out = NULL;
} else {
if (!ar->audio_out->SelfThreaded) {
ar->th = gf_th_new("AudioRenderer");
gf_th_run(ar->th, gf_ar_proc, ar);
} else {
gf_ar_setup_output_format(ar);
if (ar->audio_out->SetPriority) ar->audio_out->SetPriority(ar->audio_out, GF_THREAD_PRIORITY_REALTIME);
}
}
}
if (!ar->audio_out) {
gf_cfg_set_key(user->config, "Audio", "DriverName", "No Audio Output Available");
} else {
if (user->init_flags & GF_TERM_USE_AUDIO_HW_CLOCK)
ar->clock_use_audio_out = GF_TRUE;
}
}
/*init compositor timer*/
ar->start_time = gf_sys_clock_high_res();
ar->current_time = 0;
return ar;
}
/*generates an intertwined bmp from a scene file with 5 different viewpoints*/
void bifs3d_viewpoints_merger(GF_ISOFile *file, char *szConfigFile, u32 width, u32 height, char *rad_name, u32 dump_type, char *out_dir, Double fps, s32 frameID, s32 dump_time)
{
GF_User user;
char out_path[GF_MAX_PATH];
char old_driv[1024];
BIFSVID b2v;
Bool needs_raw;
GF_Err e;
GF_VideoSurface fb;
unsigned char **rendered_frames;
u32 nb_viewpoints = 5;
u32 viewpoint_index;
/* Configuration of the Rendering Capabilities */
{
const char *test;
char config_path[GF_MAX_PATH];
memset(&user, 0, sizeof(GF_User));
user.config = gf_cfg_init(szConfigFile, NULL);
if (!user.config) {
fprintf(stdout, "Error: Configuration File \"%s\" not found in %s\n", GPAC_CFG_FILE, config_path);
return;
}
test = gf_cfg_get_key(user.config, "General", "ModulesDirectory");
user.modules = gf_modules_new((const unsigned char *) test, user.config);
strcpy(old_driv, "raw_out");
if (!gf_modules_get_count(user.modules)) {
printf("Error: no modules found\n");
goto err_exit;
}
/*switch driver to raw_driver*/
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (test) strcpy(old_driv, test);
needs_raw = 0;
test = gf_cfg_get_key(user.config, "Compositor", "RendererName");
/*since we only support RGB24 for MP42AVI force using RAW out with 2D driver*/
if (test && strstr(test, "2D")) {
gf_cfg_set_key(user.config, "Video", "DriverName", "Raw Video Output");
needs_raw = 1;
}
if (needs_raw) {
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (stricmp(test, "raw_out") && stricmp(test, "Raw Video Output")) {
printf("couldn't load raw output driver (%s used)\n", test);
goto err_exit;
}
}
}
memset(&b2v, 0, sizeof(BIFSVID));
user.init_flags = GF_TERM_NO_AUDIO;
/* Initialization of the compositor */
b2v.sr = gf_sc_new(&user, 0, NULL);
gf_sc_set_option(b2v.sr, GF_OPT_VISIBLE, 0);
/* Initialization of the scene graph */
b2v.sg = gf_sg_new();
gf_sg_set_scene_time_callback(b2v.sg, get_scene_time, &b2v);
gf_sg_set_init_callback(b2v.sg, node_init, &b2v);
gf_sg_set_modified_callback(b2v.sg, node_modif, &b2v);
/*load config*/
gf_sc_set_option(b2v.sr, GF_OPT_RELOAD_CONFIG, 1);
{
u32 di;
u32 track_number;
GF_ESD *esd;
u16 es_id;
b2v.bifs = gf_bifs_decoder_new(b2v.sg, 0);
for (track_number=0; track_number<gf_isom_get_track_count(file); track_number++) {
esd = gf_isom_get_esd(file, track_number+1, 1);
if (!esd) continue;
if (!esd->dependsOnESID && (esd->decoderConfig->streamType == GF_STREAM_SCENE)) break;
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
}
if (!esd) {
printf("no bifs track found\n");
goto err_exit;
}
es_id = (u16) gf_isom_get_track_id(file, track_number+1);
e = gf_bifs_decoder_configure_stream(b2v.bifs, es_id, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, esd->decoderConfig->objectTypeIndication);
if (e) {
printf("BIFS init error %s\n", gf_error_to_string(e));
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
goto err_exit;
}
{
GF_ISOSample *samp = gf_isom_get_sample(file, track_number+1, 1, &di);
b2v.cts = samp->DTS + samp->CTS_Offset;
/*apply command*/
gf_bifs_decode_au(b2v.bifs, es_id, samp->data, samp->dataLength, ((Double)(s64)b2v.cts)/1000.0);
gf_isom_sample_del(&samp);
}
b2v.duration = gf_isom_get_media_duration(file, track_number+1);
gf_odf_desc_del((GF_Descriptor *) esd);
}
gf_sc_set_scene(b2v.sr, b2v.sg);
if (!width || !height) {
gf_sg_get_scene_size_info(b2v.sg, &width, &height);
}
/*we work in RGB24, and we must make sure the pitch is %4*/
if ((width*3)%4) {
printf("Adjusting width (%d) to have a stride multiple of 4\n", width);
while ((width*3)%4) width--;
}
gf_sc_set_size(b2v.sr, width, height);
gf_sc_get_screen_buffer(b2v.sr, &fb);
width = fb.width;
height = fb.height;
gf_sc_release_screen_buffer(b2v.sr, &fb);
GF_SAFEALLOC(rendered_frames, nb_viewpoints*sizeof(char *));
for (viewpoint_index = 1; viewpoint_index <= nb_viewpoints; viewpoint_index++) {
GF_SAFEALLOC(rendered_frames[viewpoint_index-1], fb.width*fb.height*3);
gf_sc_set_viewpoint(b2v.sr, viewpoint_index, NULL);
gf_sc_draw_frame(b2v.sr);
/*needed for background2D !!*/
gf_sc_draw_frame(b2v.sr);
strcpy(out_path, "");
if (out_dir) {
strcat(out_path, out_dir);
if (out_path[strlen(out_path)-1] != '\\') strcat(out_path, "\\");
}
strcat(out_path, rad_name);
strcat(out_path, "_view");
gf_sc_get_screen_buffer(b2v.sr, &fb);
write_bmp(&fb, out_path, viewpoint_index);
memcpy(rendered_frames[viewpoint_index-1], fb.video_buffer, fb.width*fb.height*3);
gf_sc_release_screen_buffer(b2v.sr, &fb);
}
if (width != 800 || height != 480) {
printf("Wrong scene dimension, cannot produce output\n");
goto err_exit;
} else {
u32 x, y;
GF_VideoSurface out_fb;
u32 bpp = 3;
out_fb.width = 800;
out_fb.height = 480;
out_fb.pitch = 800*bpp;
out_fb.pixel_format = GF_PIXEL_RGB_24;
out_fb.is_hardware_memory = 0;
GF_SAFEALLOC(out_fb.video_buffer, out_fb.pitch*out_fb.height)
#if 1
for (y=0; y<out_fb.height; y++) {
/*starting red pixel is R1, R5, R4, R3, R2, R1, R5, ... when increasing line num*/
u32 line_shift = (5-y) % 5;
for (x=0; x<out_fb.width; x++) {
u32 view_shift = (line_shift+bpp*x)%5;
u32 offset = out_fb.pitch*y + x*bpp;
/* red */
out_fb.video_buffer[offset] = rendered_frames[view_shift][offset];
/* green */
out_fb.video_buffer[offset+1] = rendered_frames[(view_shift+1)%5][offset+1];
/* blue */
out_fb.video_buffer[offset+2] = rendered_frames[(view_shift+2)%5][offset+2];
}
}
#else
/*calibration*/
for (y=0; y<out_fb.height; y++) {
u32 line_shift = (5- y%5) % 5;
for (x=0; x<out_fb.width; x++) {
u32 view_shift = (line_shift+bpp*x)%5;
u32 offset = out_fb.pitch*y + x*bpp;
out_fb.video_buffer[offset] = ((view_shift)%5 == 2) ? 0xFF : 0;
out_fb.video_buffer[offset+1] = ((view_shift+1)%5 == 2) ? 0xFF : 0;
out_fb.video_buffer[offset+2] = ((view_shift+2)%5 == 2) ? 0xFF : 0;
}
}
#endif
write_bmp(&out_fb, "output", 0);
}
/*destroy everything*/
gf_bifs_decoder_del(b2v.bifs);
gf_sg_del(b2v.sg);
gf_sc_set_scene(b2v.sr, NULL);
gf_sc_del(b2v.sr);
err_exit:
/* if (rendered_frames) {
for (viewpoint_index = 1; viewpoint_index <= nb_viewpoints; viewpoint_index++) {
if (rendered_frames[viewpoint_index-1]) gf_free(rendered_frames[viewpoint_index-1]);
}
gf_free(rendered_frames);
}
if (output_merged_frame) gf_free(output_merged_frame);
*/
if (user.modules) gf_modules_del(user.modules);
if (needs_raw) gf_cfg_set_key(user.config, "Video", "DriverName", old_driv);
gf_cfg_del(user.config);
}
void bifs_to_vid(GF_ISOFile *file, char *szConfigFile, u32 width, u32 height, char *rad_name, u32 dump_type, char *out_dir, Double fps, s32 frameID, s32 dump_time)
{
GF_User user;
BIFSVID b2v;
u16 es_id;
Bool first_dump, needs_raw;
u32 i, j, di, count, timescale, frameNum;
u32 duration, cur_time;
GF_VideoSurface fb;
GF_Err e;
char old_driv[1024];
const char *test;
char config_path[GF_MAX_PATH];
avi_t *avi_out;
Bool reset_fps;
GF_ESD *esd;
char comp[5];
char *conv_buf;
memset(&user, 0, sizeof(GF_User));
if (szConfigFile && strlen(szConfigFile)) {
user.config = gf_cfg_init(config_path, NULL);
} else {
user.config = gf_cfg_init(NULL, NULL);
}
if (!user.config) {
fprintf(stdout, "Error: Configuration File \"%s\" not found in %s\n", GPAC_CFG_FILE, config_path);
return;
}
avi_out = NULL;
conv_buf = NULL;
esd = NULL;
needs_raw = 0;
test = gf_cfg_get_key(user.config, "General", "ModulesDirectory");
user.modules = gf_modules_new((const unsigned char *) test, user.config);
strcpy(old_driv, "raw_out");
if (!gf_modules_get_count(user.modules)) {
printf("Error: no modules found\n");
goto err_exit;
}
/*switch driver to raw_driver*/
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (test) strcpy(old_driv, test);
test = gf_cfg_get_key(user.config, "Compositor", "RendererName");
/*since we only support RGB24 for MP42AVI force using RAW out with 2D driver*/
if (test && strstr(test, "2D")) {
gf_cfg_set_key(user.config, "Video", "DriverName", "Raw Video Output");
needs_raw = 1;
}
needs_raw = 0;
user.init_flags = GF_TERM_NO_AUDIO | GF_TERM_FORCE_3D;
b2v.sr = gf_sc_new(&user, 0, NULL);
gf_sc_set_option(b2v.sr, GF_OPT_VISIBLE, 0);
b2v.sg = gf_sg_new();
gf_sg_set_scene_time_callback(b2v.sg, get_scene_time, &b2v);
gf_sg_set_init_callback(b2v.sg, node_init, &b2v);
gf_sg_set_modified_callback(b2v.sg, node_modif, &b2v);
/*load config*/
gf_sc_set_option(b2v.sr, GF_OPT_RELOAD_CONFIG, 1);
b2v.bifs = gf_bifs_decoder_new(b2v.sg, 0);
if (needs_raw) {
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (stricmp(test, "raw_out") && stricmp(test, "Raw Video Output")) {
printf("couldn't load raw output driver (%s used)\n", test);
goto err_exit;
}
}
strcpy(config_path, "");
if (out_dir) {
strcat(config_path, out_dir);
if (config_path[strlen(config_path)-1] != '\\') strcat(config_path, "\\");
}
strcat(config_path, rad_name);
strcat(config_path, "_bifs");
if (!dump_type) {
strcat(config_path, ".avi");
avi_out = AVI_open_output_file(config_path);
comp[0] = comp[1] = comp[2] = comp[3] = comp[4] = 0;
if (!avi_out) goto err_exit;
}
for (i=0; i<gf_isom_get_track_count(file); i++) {
esd = gf_isom_get_esd(file, i+1, 1);
if (!esd) continue;
if (!esd->dependsOnESID && (esd->decoderConfig->streamType == GF_STREAM_SCENE)) break;
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
}
if (!esd) {
printf("no bifs track found\n");
goto err_exit;
}
b2v.duration = gf_isom_get_media_duration(file, i+1);
timescale = gf_isom_get_media_timescale(file, i+1);
es_id = (u16) gf_isom_get_track_id(file, i+1);
e = gf_bifs_decoder_configure_stream(b2v.bifs, es_id, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, esd->decoderConfig->objectTypeIndication);
if (e) {
printf("BIFS init error %s\n", gf_error_to_string(e));
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
goto err_exit;
}
if (dump_time>=0) dump_time = dump_time *1000 / timescale;
gf_sc_set_scene(b2v.sr, b2v.sg);
count = gf_isom_get_sample_count(file, i+1);
reset_fps = 0;
if (!fps) {
fps = (Float) (count * timescale);
fps /= (Double) (s64) b2v.duration;
printf("Estimated BIFS FrameRate %g\n", fps);
reset_fps = 1;
}
if (!width || !height) {
gf_sg_get_scene_size_info(b2v.sg, &width, &height);
}
/*we work in RGB24, and we must make sure the pitch is %4*/
if ((width*3)%4) {
printf("Adjusting width (%d) to have a stride multiple of 4\n", width);
while ((width*3)%4) width--;
}
gf_sc_set_size(b2v.sr, width, height);
gf_sc_draw_frame(b2v.sr);
gf_sc_get_screen_buffer(b2v.sr, &fb);
width = fb.width;
height = fb.height;
if (avi_out) {
AVI_set_video(avi_out, width, height, fps, comp);
conv_buf = gf_malloc(sizeof(char) * width * height * 3);
}
printf("Dumping at BIFS resolution %d x %d\n\n", width, height);
gf_sc_release_screen_buffer(b2v.sr, &fb);
cur_time = 0;
duration = (u32)(timescale / fps);
if (reset_fps) fps = 0;
frameNum = 1;
first_dump = 1;
for (j=0; j<count; j++) {
GF_ISOSample *samp = gf_isom_get_sample(file, i+1, j+1, &di);
b2v.cts = samp->DTS + samp->CTS_Offset;
/*apply command*/
gf_bifs_decode_au(b2v.bifs, es_id, samp->data, samp->dataLength, ((Double)(s64)b2v.cts)/1000.0);
gf_isom_sample_del(&samp);
if ((frameID>=0) && (j<(u32)frameID)) continue;
if ((dump_time>=0) && ((u32) dump_time>b2v.cts)) continue;
/*render frame*/
gf_sc_draw_frame(b2v.sr);
/*needed for background2D !!*/
if (first_dump) {
gf_sc_draw_frame(b2v.sr);
first_dump = 0;
}
if (fps) {
if (cur_time > b2v.cts) continue;
while (1) {
printf("dumped frame time %f (frame %d - sample %d)\r", ((Float)cur_time)/timescale, frameNum, j+1);
dump_frame(b2v, conv_buf, config_path, dump_type, avi_out, frameNum);
frameNum++;
cur_time += duration;
if (cur_time > b2v.cts) break;
}
} else {
dump_frame(b2v, conv_buf, config_path, dump_type, avi_out, (frameID>=0) ? frameID : frameNum);
if (frameID>=0 || dump_time>=0) break;
frameNum++;
printf("dumped frame %d / %d\r", j+1, count);
}
}
gf_odf_desc_del((GF_Descriptor *) esd);
/*destroy everything*/
gf_bifs_decoder_del(b2v.bifs);
gf_sg_del(b2v.sg);
gf_sc_set_scene(b2v.sr, NULL);
gf_sc_del(b2v.sr);
err_exit:
if (avi_out) AVI_close(avi_out);
if (conv_buf) gf_free(conv_buf);
if (user.modules) gf_modules_del(user.modules);
if (needs_raw) gf_cfg_set_key(user.config, "Video", "DriverName", old_driv);
gf_cfg_del(user.config);
}
BOOL COsmo4::InitInstance()
{
Bool first_load = 0;
if (!AfxSocketInit())
{
AfxMessageBox(IDP_SOCKETS_INIT_FAILED);
return FALSE;
}
gf_sys_init();
SetRegistryKey(_T("GPAC"));
m_prev_batt_bl = m_prev_ac_bl = 0;
m_screen_width = GetSystemMetrics(SM_CXSCREEN);
m_screen_height = GetSystemMetrics(SM_CYSCREEN);
m_menu_height = GetSystemMetrics(SM_CYMENU);
m_scene_width = m_scene_height = 0;
CMainFrame* pFrame = new CMainFrame;
m_pMainWnd = pFrame;
pFrame->LoadFrame(IDR_MAINFRAME, WS_VISIBLE, NULL, NULL);
pFrame->ShowWindow(m_nCmdShow);
pFrame->UpdateWindow();
TCHAR w_config_path[MAX_PATH];
char config_path[MAX_PATH];
GetModuleFileName(NULL, w_config_path, MAX_PATH);
CE_WideToChar((u16 *) w_config_path, (char *) config_path);
while (config_path[strlen((char *) config_path)-1] != '\\') config_path[strlen((char *) config_path)-1] = 0;
/*setup user*/
memset(&m_user, 0, sizeof(GF_User));
/*init config and plugins*/
m_user.config = gf_cfg_init(NULL, &first_load);
if (!m_user.config) {
MessageBox(NULL, _T("GPAC Configuration file not found"), _T("Fatal Error"), MB_OK);
m_pMainWnd->PostMessage(WM_CLOSE);
}
const char *str = gf_cfg_get_key(m_user.config, "General", "LogLevel");
EnableLogs((str && !strcmp(str, "debug")) ? 1 : 0);
if (first_load) {
/*first launch, register all files ext*/
u32 i;
for (i=0; i<gf_modules_get_count(m_user.modules); i++) {
GF_InputService *ifce = (GF_InputService *) gf_modules_load_interface(m_user.modules, i, GF_NET_CLIENT_INTERFACE);
if (!ifce) continue;
if (ifce) {
ifce->CanHandleURL(ifce, "test.test");
gf_modules_close_interface((GF_BaseInterface *)ifce);
}
}
::MessageBox(NULL, _T("Osmo4/GPAC Setup complete"), _T("Initial launch"), MB_OK);
}
str = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
m_user.modules = gf_modules_new(str, m_user.config);
if (!m_user.modules || ! gf_modules_get_count(m_user.modules) ) {
MessageBox(NULL, _T("No plugins available - system cannot work"), _T("Fatal Error"), MB_OK);
m_pMainWnd->PostMessage(WM_QUIT);
return FALSE;
}
m_user.config = m_user.config;
m_user.modules = m_user.modules;
m_user.EventProc = Osmo4CE_EventProc;
m_user.opaque = this;
m_user.os_window_handler = pFrame->m_wndView.m_hWnd;
m_term = gf_term_new(&m_user);
if (! m_term) {
MessageBox(NULL, _T("Cannot load MPEG-4 Terminal"), _T("Fatal Error"), MB_OK);
m_pMainWnd->PostMessage(WM_QUIT);
}
m_stopped = 0;
m_open = 0;
m_can_seek = 0;
m_DoResume = 0;
SetOptions();
pFrame->SendMessage(WM_SETSIZE, 0, 0);
ShowTaskBar(0);
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
if (! cmdInfo.m_strFileName.IsEmpty()) {
m_filename = cmdInfo.m_strFileName;
m_pMainWnd->PostMessage(WM_OPENURL);
} else {
str = gf_cfg_get_key(m_user.config, "General", "StartupFile");
if (str) gf_term_connect(m_term, str);
}
return TRUE;
}
static GF_InputService *gf_term_can_handle_service(GF_Terminal *term, const char *url, const char *parent_url, Bool no_mime_check, char **out_url, GF_Err *ret_code, GF_DownloadSession **the_session)
{
u32 i;
GF_Err e;
char *sURL, *qm, *frag, *ext, *mime_type, *url_res;
char szExt[50];
const char *force_module = NULL;
GF_InputService *ifce;
Bool skip_mime = 0;
memset(szExt, 0, sizeof(szExt));
(*ret_code) = GF_OK;
ifce = NULL;
mime_type = NULL;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] Looking for plugin for URL %s\n", url));
*out_url = NULL;
sURL = NULL;
if (!url || !strncmp(url, "\\\\", 2) ) {
(*ret_code) = GF_URL_ERROR;
goto exit;
}
if (!strnicmp(url, "libplayer://", 12)) {
force_module = "LibPlayer";
}
/*used by GUIs scripts to skip URL concatenation*/
if (!strncmp(url, "gpac://", 7)) sURL = gf_strdup(url+7);
/*opera-style localhost URLs*/
else if (!strncmp(url, "file://localhost", 16)) sURL = gf_strdup(url+16);
else if (parent_url) sURL = gf_url_concatenate(parent_url, url);
/*path absolute*/
if (!sURL) sURL = gf_strdup(url);
if (gf_url_is_local(sURL))
gf_url_to_fs_path(sURL);
if (the_session) *the_session = NULL;
if (no_mime_check) {
mime_type = NULL;
} else {
/*fetch a mime type if any. If error don't even attempt to open the service
TRYTOFIXME: it would be nice to reuse the downloader created while fetching the mime type, however
we don't know if the plugin will want it threaded or not....
*/
mime_type = get_mime_type(term, sURL, &e, the_session);
if (e) {
(*ret_code) = e;
goto exit;
}
}
if (mime_type &&
(!stricmp(mime_type, "text/plain")
|| !stricmp(mime_type, "video/quicktime")
|| !stricmp(mime_type, "application/octet-stream")
)
) {
skip_mime = 1;
}
ifce = NULL;
/*load from mime type*/
if (mime_type && !skip_mime) {
const char *sPlug = gf_cfg_get_key(term->user->config, "MimeTypes", mime_type);
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] Mime type found: %s\n", mime_type));
if (!sPlug) {
gf_free(mime_type);
mime_type=NULL;
}
if (sPlug) sPlug = strrchr(sPlug, '"');
if (sPlug) {
sPlug += 2;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("%s:%d FOUND matching module %s\n", __FILE__, __LINE__, sPlug));
ifce = (GF_InputService *) gf_modules_load_interface_by_name(term->user->modules, sPlug, GF_NET_CLIENT_INTERFACE);
if (force_module && ifce && !strstr(ifce->module_name, force_module)) {
gf_modules_close_interface((GF_BaseInterface *) ifce);
ifce = NULL;
}
if (ifce && !net_check_interface(ifce) ) {
gf_modules_close_interface((GF_BaseInterface *) ifce);
ifce = NULL;
}
}
}
/* The file extension, if any, is before '?' if any or before '#' if any.*/
url_res = strrchr(sURL, '/');
if (!url_res) url_res = strrchr(sURL, '\\');
if (!url_res) url_res = sURL;
qm = strchr(url_res, '?');
if (qm) {
qm[0] = 0;
ext = strrchr(url_res, '.');
qm[0] = '?';
} else {
frag = strchr(url_res, '#');
if (frag) {
frag[0] = 0;
ext = strrchr(url_res, '.');
frag[0] = '#';
} else {
ext = strrchr(url_res, '.');
}
}
if (ext && !stricmp(ext, ".gz")) {
char *anext;
ext[0] = 0;
anext = strrchr(sURL, '.');
ext[0] = '.';
ext = anext;
}
/*no mime type: either local or streaming. If streaming discard extension checking*/
if (!ifce && !mime_type && strstr(sURL, "://") && strnicmp(sURL, "file://", 7)) ext = NULL;
/*browse extensions for prefered module*/
if (!ifce && ext) {
u32 keyCount;
strncpy(szExt, &ext[1], 49);
ext = strrchr(szExt, '?');
if (ext) ext[0] = 0;
ext = strrchr(szExt, '#');
if (ext) ext[0] = 0;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] No mime type found - checking by extension %s\n", szExt));
assert( term && term->user && term->user->modules);
keyCount = gf_cfg_get_key_count(term->user->config, "MimeTypes");
for (i=0; i<keyCount; i++) {
char *sPlug;
const char *sKey;
const char *sMime;
sMime = gf_cfg_get_key_name(term->user->config, "MimeTypes", i);
if (!sMime) continue;
sKey = gf_cfg_get_key(term->user->config, "MimeTypes", sMime);
if (!sKey) continue;
if (!check_extension(sKey, szExt)) continue;
sPlug = strrchr(sKey, '"');
if (!sPlug) continue; /*bad format entry*/
sPlug += 2;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] Trying module[%i]=%s, mime=%s\n", i, sPlug, sMime));
ifce = (GF_InputService *) gf_modules_load_interface_by_name(term->user->modules, sPlug, GF_NET_CLIENT_INTERFACE);
if (!ifce){
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] module[%i]=%s, mime=%s, cannot be loaded for GF_NET_CLIENT_INTERFACE.\n", i, sPlug, sMime));
continue;
}
if (force_module && ifce && !strstr(ifce->module_name, force_module)) {
gf_modules_close_interface((GF_BaseInterface *) ifce);
ifce = NULL;
continue;
}
if (ifce && !net_check_interface(ifce)) {
gf_modules_close_interface((GF_BaseInterface *) ifce);
ifce = NULL;
continue;
}
break;
}
}
/*browse all modules*/
if (!ifce) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] Not found any interface, trying browsing all modules...\n"));
for (i=0; i< gf_modules_get_count(term->user->modules); i++) {
ifce = (GF_InputService *) gf_modules_load_interface(term->user->modules, i, GF_NET_CLIENT_INTERFACE);
if (!ifce) continue;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] Checking if module %s supports URL %s\n", ifce->module_name, sURL));
if (force_module && ifce && !strstr(ifce->module_name, force_module)) {
}
else if (net_check_interface(ifce) && ifce->CanHandleURL(ifce, sURL)) {
break;
}
gf_modules_close_interface((GF_BaseInterface *) ifce);
ifce = NULL;
}
}
exit:
if (!ifce){
GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[Terminal] Did not find any input plugin for URL %s (%s)\n", sURL ? sURL : url, mime_type ? mime_type : "no mime type"));
if (sURL) gf_free(sURL);
if ( (*ret_code) == GF_OK) (*ret_code) = GF_NOT_SUPPORTED;
*out_url = NULL;
if (the_session && *the_session) {
gf_dm_sess_del(*the_session);
}
} else {
*out_url = sURL;
GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("[Terminal] Found input plugin %s for URL %s (%s)\n", ifce->module_name, sURL, mime_type ? mime_type : "no mime type"));
}
if (mime_type)
gf_free(mime_type);
mime_type = NULL;
return ifce;
}
//-------------------------------
// dir should end with /
int CNativeWrapper::init(JNIEnv * env, void * bitmap, jobject * callback, int width, int height, const char * cfg_dir, const char * modules_dir, const char * cache_dir, const char * font_dir, const char * urlToLoad) {
LOGI("Initializing GPAC with URL=%s...", urlToLoad);
strcpy(m_cfg_dir, cfg_dir);
strcpy(m_modules_dir, modules_dir);
strcpy(m_cache_dir, cache_dir);
strcpy(m_font_dir, font_dir);
char m_cfg_filename[GF_MAX_PATH];
strcpy(m_cfg_filename, m_cfg_dir);
strcat(m_cfg_filename, "GPAC.cfg");
int m_Width = width;
int m_Height = height;
int first_launch = 0;
const char *opt;
m_window = env;
m_session = bitmap;
if (!mainJavaEnv)
mainJavaEnv = (JavaEnvTh *) gf_malloc(sizeof(JavaEnvTh));
memset(mainJavaEnv, 0, sizeof(JavaEnvTh));
setJavaEnv(mainJavaEnv, env, env->NewGlobalRef(*callback));
if (pthread_setspecific( jni_thread_env_key, mainJavaEnv)) {
LOGE("Failed to set specific thread data to jni_thread_env_key=%p for main thread !", jni_thread_env_key);
}
m_mx = gf_mx_new("Osmo4");
//load config file
LOGI("Loading User Config %s...", "GPAC.cfg");
m_user.config = gf_cfg_force_new(cfg_dir, "GPAC.cfg");
gf_set_progress_callback(this, Osmo4_progress_cbk);
opt = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
if (!opt) {
FILE * fstart;
char msg[256];
LOGI("First launch, initializing new Config %s...", "GPAC.cfg");
/*hardcode module directory*/
gf_cfg_set_key(m_user.config, "Downloader", "CleanCache", "yes");
/*startup file*/
snprintf(msg, 256, "%sgui/gui.bt", cfg_dir);
fstart = fopen(msg, "r");
if (fstart) {
fclose(fstart);
gf_cfg_set_key(m_user.config, "General", "StartupFile", msg);
} else {
gf_cfg_set_key(m_user.config, "General", "#StartupFile", msg);
}
gf_cfg_set_key(m_user.config, "GUI", "UnhideControlPlayer", "1");
/*setup UDP traffic autodetect*/
gf_cfg_set_key(m_user.config, "Network", "AutoReconfigUDP", "yes");
gf_cfg_set_key(m_user.config, "Network", "UDPTimeout", "10000");
gf_cfg_set_key(m_user.config, "Network", "BufferLength", "3000");
gf_cfg_set_key(m_user.config, "Compositor", "TextureTextMode", "Default");
//gf_cfg_set_key(m_user.config, "Compositor", "FrameRate", "30");
gf_cfg_set_key(m_user.config, "Audio", "ForceConfig", "no");
gf_cfg_set_key(m_user.config, "Audio", "NumBuffers", "1");
gf_cfg_set_key(m_user.config, "FontEngine", "FontReader", "ft_font");
}
/* All of this has to be done for every instance */
gf_cfg_set_key(m_user.config, "General", "ModulesDirectory", modules_dir ? modules_dir : GPAC_MODULES_DIR);
gf_cfg_set_key(m_user.config, "General", "CacheDirectory", cache_dir ? cache_dir : GPAC_CACHE_DIR);
gf_cfg_set_key(m_user.config, "General", "LastWorkingDir", cfg_dir);
gf_cfg_set_key(m_user.config, "FontEngine", "FontDirectory", GPAC_FONT_DIR);
gf_cfg_set_key(m_user.config, "Video", "DriverName", "Android Video Output");
gf_cfg_set_key(m_user.config, "Audio", "DriverName", "Android Audio Output");
opt = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
LOGI("loading modules in directory %s...", opt);
m_user.modules = gf_modules_new(opt, m_user.config);
if (!m_user.modules || !gf_modules_get_count(m_user.modules)) {
LOGE("No modules found in directory %s !", opt);
if (m_user.modules)
gf_modules_del(m_user.modules);
gf_cfg_del(m_user.config);
m_user.config = NULL;
return Quit(KErrGeneral);
}
/*we don't thread the visual compositor to be able to minimize the app and still have audio running*/
m_user.init_flags = GF_TERM_NO_COMPOSITOR_THREAD;
m_user.opaque = this;
m_user.os_window_handler = m_window;
m_user.os_display = m_session;
m_user.EventProc = GPAC_EventProc;
if (!javaVM) {
LOGE("NO JAVA VM FOUND, m_user=%p !!!!\n", &m_user);
return Quit(KErrGeneral);
}
LOGD("Loading GPAC terminal, m_user=%p...", &m_user);
gf_sys_init(GF_FALSE);
gf_fm_request_set_callback(this, on_fm_request);
SetupLogs();
m_term = gf_term_new(&m_user);
if (!m_term) {
LOGE("Cannot load GPAC Terminal with m_user=%p", m_user);
MessageBox("Cannot load GPAC terminal", "Fatal Error", GF_SERVICE_ERROR);
gf_modules_del(m_user.modules);
m_user.modules = NULL;
gf_cfg_del(m_user.config);
m_user.config = NULL;
return Quit(KErrGeneral);
}
//setAudioEnvironment(javaVM);
LOGD("Setting term size m_user=%p...", &m_user);
gf_term_set_size(m_term, m_Width, m_Height);
opt = gf_cfg_get_key(m_user.config, "General", "StartupFile");
LOGD("File loaded at startup=%s.", opt);
if (!urlToLoad)
urlToLoad = opt;
if (urlToLoad) {
LOGI("Connecting to %s...", urlToLoad);
gf_term_connect(m_term, urlToLoad);
}
debug_log("init end");
LOGD("Saving config file %s...\n", m_cfg_filename);
gf_cfg_save(m_user.config);
LOGI("Initialization complete, config file saved as %s.\n", m_cfg_filename);
return 0;
}
wxGPACControl::wxGPACControl(wxWindow *parent)
: wxDialog(parent, -1, wxString(wxT("GPAC Control Panel")))
{
const char *sOpt;
SetSize(320, 240);
u32 i;
wxBoxSizer *bs;
Centre();
m_pApp = (wxOsmo4Frame *)parent;
s_main = new wxBoxSizer(wxVERTICAL);
s_header = new wxBoxSizer(wxHORIZONTAL);
//s_header->Add(new wxStaticText(this, 0, wxT("Category"), wxDefaultPosition, wxSize(60, 20)), wxALIGN_CENTER);
m_select = new wxComboBox(this, ID_SELECT, wxT(""), wxDefaultPosition, wxSize(120, 30), 0, NULL, wxCB_READONLY);
s_header->Add(m_select, 2, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_header->Add( new wxButton(this, ID_APPLY, wxT("Apply"), wxDefaultPosition,
#ifdef WIN32
wxSize(40, 20)
#else
wxSize(40, 30)
#endif
),
1, wxALIGN_TOP|wxALIGN_RIGHT|wxADJUST_MINSIZE);
s_main->Add(s_header, 0, wxEXPAND, 0);
/*general section*/
s_general = new wxBoxSizer(wxVERTICAL);
m_loop = new wxCheckBox(this, 0, wxT("Loop at End"), wxPoint(10, 40), wxSize(140, 20));
s_general->Add(m_loop);
m_lookforsubs = new wxCheckBox(this, 0, wxT("Look for Subtitles"), wxPoint(180, 40), wxSize(140, 20));
s_general->Add(m_lookforsubs);
m_noconsole = new wxCheckBox(this, 0, wxT("Disable console messages"), wxPoint(10, 80), wxSize(180, 20));
s_general->Add(m_noconsole);
m_viewxmt = new wxCheckBox(this, 0, wxT("View graph in XMT-A format"), wxPoint(10, 120), wxSize(180, 20));
s_general->Add(m_viewxmt);
s_main->Add(s_general, 0, wxEXPAND, 0);
/*MPEG-4 systems*/
s_mpeg4 = new wxBoxSizer(wxVERTICAL);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Prefered Stream Language")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_lang = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_lang, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_mpeg4->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Decoder Threading Mode")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_thread = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_thread, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_mpeg4->Add(bs, 0, wxALL|wxEXPAND, 2);
m_bifsalwaysdrawn = new wxCheckBox(this, 0, wxT("Always draw late BIFS frames"));
s_mpeg4->Add(m_bifsalwaysdrawn);
m_singletime = new wxCheckBox(this, 0, wxT("Force Single Timeline"));
s_mpeg4->Add(m_singletime);
s_main->Add(s_mpeg4, 0, wxEXPAND, 0);
/*media decoders*/
s_mdec = new wxBoxSizer(wxVERTICAL);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Prefered Audio Output")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_decaudio = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_decaudio, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_mdec->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Prefered Video Output")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_decvideo = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_decvideo, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_mdec->Add(bs, 0, wxALL|wxEXPAND, 2);
s_main->Add(s_mdec, 0, wxEXPAND, 0);
/*Rendering*/
s_rend = new wxBoxSizer(wxVERTICAL);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Target Frame Rate")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_fps = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_fps, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_rend->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Anti-Aliasing")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_aa = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_aa, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_rend->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Graphics Driver")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_graph = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_graph, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_rend->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
m_draw_bounds = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(new wxStaticText(this, 0, wxT("Bounds")), wxALIGN_CENTER | wxADJUST_MINSIZE | wxALIGN_RIGHT);
bs->Add(m_draw_bounds, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_rend->Add(bs, 0, wxALL|wxEXPAND, 2);
m_fast = new wxCheckBox(this, 0, wxT("Fast Rendering"));
m_force_size = new wxCheckBox(this, 0, wxT("Force Scene Size"));
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(m_fast, wxALIGN_CENTER | wxADJUST_MINSIZE);
bs->Add(m_force_size, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_rend->Add(bs, 0, wxALL|wxEXPAND, 2);
m_use3D = new wxCheckBox(this, 0, wxT("Use 3D Renderer"));
s_rend->Add(m_use3D, 0, wxALL|wxEXPAND, 2);
m_bWas3D = m_use3D->GetValue();
s_main->Add(s_rend, 0, wxEXPAND, 0);
/*Render 2D*/
s_rend2d = new wxBoxSizer(wxVERTICAL);
m_direct = new wxCheckBox(this, 0, wxT("Direct Rendering"));
s_rend2d->Add(m_direct, 0, wxALL|wxEXPAND, 2);
m_scalable = new wxCheckBox(this, 0, wxT("Scalable Zoom"));
s_rend2d->Add(m_scalable, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
m_noyuv = new wxCheckBox(this, 0, wxT("Disable YUV hardware"));
bs->Add(m_noyuv, wxALIGN_CENTER | wxADJUST_MINSIZE);
m_yuvtxt = new wxStaticText(this, 0, wxT("(No YUV used)"), wxDefaultPosition, wxSize(60, 20), wxALIGN_LEFT);
bs->Add(m_yuvtxt, wxALIGN_CENTER|wxADJUST_MINSIZE);
s_rend2d->Add(bs, 0, wxALL|wxEXPAND, 2);
s_main->Add(s_rend2d, 0, wxEXPAND, 0);
/*Render 3D*/
s_rend3d = new wxBoxSizer(wxVERTICAL);
m_raster_outlines = new wxCheckBox(this, 0, wxT("Use OpenGL Raster outlines"));
s_rend3d->Add(m_raster_outlines, 0, wxALL|wxEXPAND, 2);
m_polyaa = new wxCheckBox(this, 0, wxT("Enable polygon anti-aliasing"));
s_rend3d->Add(m_polyaa, 0, wxALL|wxEXPAND, 2);
m_nobackcull = new wxCheckBox(this, 0, wxT("Disable backface culling"));
s_rend3d->Add(m_nobackcull, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Wireframe mode")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_wire = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_wire, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_rend3d->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Draw Normals")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_normals = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_normals, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_rend3d->Add(bs, 0, wxALL|wxEXPAND, 2);
m_emulpow2 = new wxCheckBox(this, 0, wxT("Emulate power-of-two textures for video"));
s_rend3d->Add(m_emulpow2, 0, wxALL|wxEXPAND, 2);
m_norectext = new wxCheckBox(this, 0, wxT("Disable rectangular texture extensions"));
s_rend3d->Add(m_norectext, 0, wxALL|wxEXPAND, 2);
m_copypixels = new wxCheckBox(this, 0, wxT("Bitmap node uses direct pixel copy"));
s_rend3d->Add(m_copypixels, 0, wxALL|wxEXPAND, 2);
s_main->Add(s_rend3d, 0, wxEXPAND, 0);
/*video*/
s_video = new wxBoxSizer(wxVERTICAL);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Video Driver")), wxALIGN_CENTER | wxADJUST_MINSIZE | wxALIGN_RIGHT);
m_video = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_video , wxALIGN_CENTER | wxADJUST_MINSIZE);
s_video->Add(bs, 0, wxALL|wxEXPAND, 2);
m_switchres = new wxCheckBox(this, 0, wxT("Change video resolution in fullscreen"));
s_video->Add(m_switchres, 0, wxALL|wxEXPAND, 2);
m_usehwmem = new wxCheckBox(this, 0, wxT("Use hardware memory in 2D mode"));
s_video->Add(m_usehwmem, 0, wxALL|wxEXPAND, 2);
s_main->Add(s_video, 0, wxEXPAND, 0);
/*audio*/
s_audio = new wxBoxSizer(wxVERTICAL);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Audio Driver")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_audio = new wxComboBox(this, ID_AUDIO_DRIVER, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_audio, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_audio->Add(bs, 0, wxALL|wxEXPAND, 2);
m_forcecfg = new wxCheckBox(this, ID_FORCE_AUDIO, wxT("Force Audio Config"));
m_forcecfg->SetValue(1);
s_audio->Add(m_forcecfg, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Number of buffers")), wxALIGN_CENTER|wxADJUST_MINSIZE);
m_nbbuf = new wxSpinCtrl(this, -1, wxT(""), wxDefaultPosition, wxSize(20, 20), wxSP_WRAP | wxSP_ARROW_KEYS, 1, 30, 15);
m_nbbuf->SetValue(8);
bs->Add(m_nbbuf, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_audio->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Total length in ms")), wxALIGN_CENTER | wxADJUST_MINSIZE);
m_buflen = new wxSpinCtrl(this, -1, wxT(""), wxDefaultPosition, wxSize(20, 20), wxSP_WRAP | wxSP_ARROW_KEYS, 1, 1000);
m_buflen->SetValue(400);
bs->Add(m_buflen, wxALIGN_CENTER | wxADJUST_MINSIZE|wxLEFT,10);
s_audio->Add(bs, 0, wxALL|wxEXPAND, 2);
m_noresync = new wxCheckBox(this, -1, wxT("Disable Resynchronization"));
s_audio->Add(m_noresync);
m_nomulitch = new wxCheckBox(this, -1, wxT("Disable Multichannel"));
s_audio->Add(m_nomulitch);
#ifdef WIN32
m_notifs = new wxCheckBox(this, -1, wxT("Disable DirectSound Notifications"));
s_audio->Add(m_notifs);
#endif
s_main->Add(s_audio, 0, wxEXPAND, 0);
/*font*/
s_font = new wxBoxSizer(wxVERTICAL);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Font Engine")), wxALIGN_CENTER | wxADJUST_MINSIZE | wxALIGN_RIGHT);
m_font = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_font, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_font->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("System Font Directory")), wxALIGN_CENTER | wxADJUST_MINSIZE | wxALIGN_RIGHT);
m_fontdir = new wxButton(this, ID_FONT_DIR, wxT("..."), wxDefaultPosition, wxDefaultSize);
bs->Add(m_fontdir, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_font->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Text Texturing Mode")), wxALIGN_CENTER | wxADJUST_MINSIZE | wxALIGN_RIGHT);
m_texturemode = new wxComboBox(this, 0, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_READONLY);
bs->Add(m_texturemode, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_font->Add(bs, 0, wxALL|wxEXPAND, 2);
s_main->Add(s_font, 0, wxEXPAND, 0);
/*download*/
s_dnld = new wxBoxSizer(wxVERTICAL);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Cache Directory")), wxALIGN_CENTER | wxADJUST_MINSIZE | wxALIGN_RIGHT);
m_cachedir = new wxButton(this, ID_CACHE_DIR, wxT("..."));
bs->Add(m_cachedir, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_dnld->Add(bs, 0, wxALL|wxEXPAND, 2);
m_cleancache = new wxCheckBox(this, -1, wxT("Remove temp files on exit"));
s_dnld->Add(m_cleancache);
m_restartcache = new wxCheckBox(this, -1, wxT("Always redownload incomplete cached files"));
s_dnld->Add(m_restartcache);
bs = new wxBoxSizer(wxHORIZONTAL);
m_progressive = new wxCheckBox(this, ID_PROGRESSIVE, wxT("XML progressive load"));
bs->Add(m_progressive, wxALIGN_CENTER | wxADJUST_MINSIZE);
m_sax_duration = new wxTextCtrl(this, 0, wxT(""), wxPoint(10, 120), wxSize(60, 20));
bs->Add(m_sax_duration, wxALIGN_CENTER | wxADJUST_MINSIZE);
bs->Add(new wxStaticText(this, 0, wxT("max load slice (ms)")), wxADJUST_MINSIZE | wxALIGN_CENTER);
s_dnld->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
m_use_proxy = new wxCheckBox(this, ID_USE_PROXY, wxT("Use proxy"));
bs->Add(m_use_proxy, wxALIGN_CENTER | wxADJUST_MINSIZE);
m_proxy_name = new wxTextCtrl(this, 0, wxT(""), wxPoint(10, 120), wxSize(60, 20));
bs->Add(m_proxy_name, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_dnld->Add(bs, 0, wxALL|wxEXPAND, 2);
s_main->Add(s_dnld, 0, wxEXPAND, 0);
/*streaming*/
s_stream = new wxBoxSizer(wxVERTICAL);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Default RTSP port")), wxALIGN_CENTER | wxADJUST_MINSIZE | wxALIGN_RIGHT);
m_port = new wxComboBox(this, ID_RTSP_PORT, wxT(""), wxPoint(160, 40), wxSize(140, 30), 0, NULL, wxCB_READONLY);
bs->Add(m_port, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_stream->Add(bs, 0, wxALL|wxEXPAND, 2);
m_rtsp = new wxCheckBox(this, ID_RTP_OVER_RTSP, wxT("RTP over RTSP"), wxPoint(10, 80), wxSize(140, 20));
m_reorder = new wxCheckBox(this, -1, wxT("use RTP reordering"), wxPoint(160, 80), wxSize(130, 20));
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(m_rtsp, wxALIGN_CENTER | wxADJUST_MINSIZE);
bs->Add(m_reorder, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_stream->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
m_timeout = new wxTextCtrl(this, 0, wxT(""), wxPoint(10, 120), wxSize(60, 20));
bs->Add(new wxStaticText(this, 0, wxT("Control Timeout (ms): ")), wxALIGN_CENTER | wxADJUST_MINSIZE | wxALIGN_RIGHT);
bs->Add(m_timeout, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_stream->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
m_buffer = new wxTextCtrl(this, 0, wxT(""), wxPoint(10, 150), wxSize(60, 20));
bs->Add(new wxStaticText(this, 0, wxT("Media Buffering (ms): ")), wxALIGN_CENTER | wxADJUST_MINSIZE | wxALIGN_RIGHT);
bs->Add(m_buffer, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_stream->Add(bs, 0, wxALL|wxEXPAND, 2);
bs = new wxBoxSizer(wxHORIZONTAL);
m_dorebuffer = new wxCheckBox(this, ID_RTSP_REBUFFER, wxT("Rebuffer if below"));
bs->Add(m_dorebuffer, wxALIGN_CENTER | wxADJUST_MINSIZE);
m_rebuffer = new wxTextCtrl(this, 0, wxT(""), wxPoint(200, 180), wxSize(60, 20));
bs->Add(m_rebuffer, wxALIGN_CENTER | wxADJUST_MINSIZE);
m_rebuffer->Disable();
s_stream->Add(bs, 0, wxALL|wxEXPAND, 2);
s_main->Add(s_stream, 0, wxEXPAND, 0);
/*streaming cache*/
s_rec = new wxBoxSizer(wxVERTICAL);
bs = new wxBoxSizer(wxHORIZONTAL);
bs->Add(new wxStaticText(this, 0, wxT("Record To: ")), wxALIGN_CENTER | wxADJUST_MINSIZE | wxALIGN_RIGHT);
m_recdir = new wxButton(this, ID_RECORD_DIR, wxT("..."));
bs->Add(m_recdir, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_rec->Add(bs, 0, wxALL|wxEXPAND, 2);
m_overwrite = new wxCheckBox(this, -1, wxT("Overwrite existing files"));
s_rec->Add(m_overwrite);
bs = new wxBoxSizer(wxHORIZONTAL);
m_usename = new wxCheckBox(this, ID_USE_FILENAME, wxT("Use filename"));
m_recfile = new wxTextCtrl(this, 0, wxT(""));
bs->Add(m_usename, wxALIGN_CENTER | wxADJUST_MINSIZE);
bs->Add(m_recfile, wxALIGN_CENTER | wxADJUST_MINSIZE);
s_rec->Add(bs, 0, wxALL|wxEXPAND, 2);
s_main->Add(s_rec, 0, wxEXPAND, 0);
/*load options*/
GF_Config *cfg = m_pApp->m_user.config;
/*general*/
sOpt = gf_cfg_get_key(cfg, "General", "Loop");
m_loop->SetValue((sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "General", "LookForSubtitles");
m_lookforsubs->SetValue((sOpt && !stricmp(sOpt, "no")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "General", "ConsoleOff");
m_noconsole->SetValue((sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "General", "ViewXMT");
m_viewxmt->SetValue((sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
/*systems config*/
sOpt = gf_cfg_get_key(cfg, "Systems", "Language3CC");
if (!sOpt) sOpt = "eng";
u32 select = 0;
i=0;
while (GF_ISO639_Lang[i]) {
/*only use common languages (having both 2- and 3-char code names)*/
if (GF_ISO639_Lang[i+2][0]) {
m_lang->Append(wxString(GF_ISO639_Lang[i], wxConvUTF8) );
if (sOpt && !stricmp(sOpt, GF_ISO639_Lang[i+1])) select = m_lang->GetCount() - 1;
}
i+=3;
}
m_lang->SetSelection(select);
sOpt = gf_cfg_get_key(cfg, "Systems", "ThreadingPolicy");
select = 0;
m_thread->Append(wxT("Single Thread"));
m_thread->Append(wxT("Mutli Thread"));
if (sOpt && !stricmp(sOpt, "Multi")) select = 1;
m_thread->Append(wxT("Free"));
if (sOpt && !stricmp(sOpt, "Free")) select = 2;
m_thread->SetSelection(select);
sOpt = gf_cfg_get_key(cfg, "Systems", "ForceSingleClock");
m_singletime->SetValue((sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Systems", "AlwaysDrawBIFS");
m_bifsalwaysdrawn->SetValue((sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
/*audio dec enum*/
sOpt = gf_cfg_get_key(cfg, "Systems", "DefAudioDec");
u32 count = gf_modules_get_count(m_pApp->m_user.modules);
GF_BaseDecoder *ifc_d;
select = 0;
s32 to_sel = 0;
for (i=0; i<count; i++) {
ifc_d = (GF_BaseDecoder *) gf_modules_load_interface(m_pApp->m_user.modules, i, GF_MEDIA_DECODER_INTERFACE);
if (!ifc_d) continue;
if (ifc_d->CanHandleStream(ifc_d, GF_STREAM_AUDIO, NULL, 0)) {
if (sOpt && !stricmp(ifc_d->module_name, sOpt)) select = to_sel;
m_decaudio->Append(wxString(ifc_d->module_name, wxConvUTF8) );
to_sel++;
}
gf_modules_close_interface((GF_BaseInterface *) ifc_d);
}
m_decaudio->SetSelection(select);
/*video dec enum*/
sOpt = gf_cfg_get_key(cfg, "Systems", "DefVideoDec");
select = to_sel = 0;
for (i=0; i<count; i++) {
ifc_d = (GF_BaseDecoder *) gf_modules_load_interface(m_pApp->m_user.modules, i, GF_MEDIA_DECODER_INTERFACE);
if (!ifc_d) continue;
if (ifc_d->CanHandleStream(ifc_d, GF_STREAM_VISUAL, NULL, 0)) {
if (sOpt && !stricmp(ifc_d->module_name, sOpt)) select = to_sel;
m_decvideo->Append(wxString(ifc_d->module_name, wxConvUTF8) );
to_sel++;
}
gf_modules_close_interface((GF_BaseInterface *) ifc_d);
}
m_decvideo->SetSelection(select);
/*rendering FIXME*/
m_bWas3D = 0;
m_use3D->SetValue(m_bWas3D ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Compositor", "ForceSceneSize");
m_force_size->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Compositor", "FrameRate");
if (!sOpt) sOpt = "30.0";
select = 0;
for (i = 0; i<NUM_RATES; i++) {
m_fps->Append(wxString(BIFSRates[i], wxConvUTF8) );
if (sOpt && !stricmp(sOpt, BIFSRates[i]) ) select = i;
}
m_fps->SetSelection(select);
sOpt = gf_cfg_get_key(cfg, "Compositor", "HighSpeed");
m_fast->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Compositor", "AntiAlias");
m_aa->Append(wxT("None"));
m_aa->Append(wxT("Text only"));
m_aa->Append(wxT("Complete"));
select = 2;
if (sOpt && !stricmp(sOpt, "Text")) select = 1;
else if (sOpt && !stricmp(sOpt, "None")) select = 0;
m_aa->SetSelection(select);
sOpt = gf_cfg_get_key(cfg, "Compositor", "BoundingVolume");
m_draw_bounds->Append(wxT("None"));
m_draw_bounds->Append(wxT("Box/Rect"));
m_draw_bounds->Append(wxT("AABB Tree"));
select = 0;
if (sOpt && !stricmp(sOpt, "Box")) select = 1;
else if (sOpt && !stricmp(sOpt, "AABB")) select = 2;
m_draw_bounds->SetSelection(select);
/*render2d*/
sOpt = gf_cfg_get_key(cfg, "Compositor", "DirectDraw");
m_direct->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Compositor", "ScalableZoom");
m_scalable->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Compositor", "DisableYUV");
m_noyuv->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
SetYUVLabel();
/*graphics driver enum*/
sOpt = gf_cfg_get_key(cfg, "Compositor", "Raster2D");
GF_BaseInterface *ifce;
select = to_sel = 0;
for (i=0; i<count; i++) {
ifce = gf_modules_load_interface(m_pApp->m_user.modules, i, GF_RASTER_2D_INTERFACE);
if (!ifce) continue;
if (sOpt && !stricmp(((GF_BaseInterface *)ifce)->module_name, sOpt)) select = to_sel;
m_graph->Append(wxString(((GF_BaseInterface *)ifce)->module_name, wxConvUTF8) );
gf_modules_close_interface(ifce);
to_sel++;
}
m_graph->SetSelection(select);
/*render3d*/
sOpt = gf_cfg_get_key(cfg, "Compositor", "RasterOutlines");
m_raster_outlines->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Compositor", "EmulatePOW2");
m_emulpow2->SetValue((sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Compositor", "PolygonAA");
m_polyaa->SetValue((sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Compositor", "BackFaceCulling");
m_nobackcull->SetValue((sOpt && !stricmp(sOpt, "Off")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Compositor", "Wireframe");
sOpt = gf_cfg_get_key(cfg, "Compositor", "BitmapCopyPixels");
m_copypixels->SetValue((sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Compositor", "DisableRectExt");
m_norectext->SetValue((sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
m_wire->Append(wxT("No Wireframe"));
m_wire->Append(wxT("Wireframe Only"));
m_wire->Append(wxT("Solid and Wireframe"));
sOpt = gf_cfg_get_key(cfg, "Compositor", "Wireframe");
if (sOpt && !stricmp(sOpt, "WireOnly")) m_wire->SetSelection(1);
else if (sOpt && !stricmp(sOpt, "WireOnSolid")) m_wire->SetSelection(2);
else m_wire->SetSelection(0);
m_normals->Append(wxT("Never"));
m_normals->Append(wxT("Per Face"));
m_normals->Append(wxT("Per Vertex"));
sOpt = gf_cfg_get_key(cfg, "Compositor", "DrawNormals");
if (sOpt && !stricmp(sOpt, "PerFace")) m_normals->SetSelection(1);
else if (sOpt && !stricmp(sOpt, "PerVertex")) m_normals->SetSelection(2);
else m_normals->SetSelection(0);
/*video*/
sOpt = gf_cfg_get_key(cfg, "Video", "SwitchResolution");
m_switchres->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Video", "UseHardwareMemory");
m_usehwmem->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Video", "DriverName");
select = to_sel = 0;
for (i=0; i<count; i++) {
ifce = gf_modules_load_interface(m_pApp->m_user.modules, i, GF_VIDEO_OUTPUT_INTERFACE);
if (!ifce) continue;
if (sOpt && !stricmp(((GF_BaseInterface *)ifce)->module_name, sOpt)) select = to_sel;
m_video->Append(wxString(((GF_BaseInterface *)ifce)->module_name, wxConvUTF8) );
gf_modules_close_interface(ifce);
to_sel++;
}
m_video->SetSelection(select);
/*audio*/
sOpt = gf_cfg_get_key(cfg, "Audio", "ForceConfig");
m_forcecfg->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Audio", "NumBuffers");
m_nbbuf->SetValue( sOpt ? wxString(sOpt, wxConvUTF8) : wxT("2"));
sOpt = gf_cfg_get_key(cfg, "Audio", "TotalDuration");
m_buflen->SetValue( sOpt ? wxString(sOpt, wxConvUTF8) : wxT("120"));
wxCommandEvent event;
ForceAudio(event);
sOpt = gf_cfg_get_key(cfg, "Audio", "NoResync");
m_noresync->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Audio", "DisableMultiChannel");
m_nomulitch->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
/*driver enum*/
sOpt = gf_cfg_get_key(cfg, "Audio", "DriverName");
select = to_sel = 0;
for (i=0; i<count; i++) {
ifce = gf_modules_load_interface(m_pApp->m_user.modules, i, GF_AUDIO_OUTPUT_INTERFACE);
if (!ifce) continue;
if (sOpt && !stricmp(((GF_BaseInterface *)ifce)->module_name, sOpt)) select = to_sel;
m_audio->Append(wxString(((GF_BaseInterface *)ifce)->module_name, wxConvUTF8) );
gf_modules_close_interface(ifce);
to_sel++;
}
m_audio->SetSelection(select);
#ifdef WIN32
sOpt = gf_cfg_get_key(cfg, "Audio", "DisableNotification");
m_notifs->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
wxCommandEvent audevt;
OnSetAudioDriver(audevt);
#endif
/*font*/
sOpt = gf_cfg_get_key(cfg, "FontEngine", "FontReader");
to_sel = select = 0;
for (i=0; i<count; i++) {
ifce = gf_modules_load_interface(m_pApp->m_user.modules, i, GF_FONT_READER_INTERFACE);
if (!ifce) continue;
if (sOpt && !stricmp(((GF_BaseInterface *)ifce)->module_name, sOpt)) select = to_sel;
m_font->Append(wxString(((GF_BaseInterface *)ifce)->module_name, wxConvUTF8) );
gf_modules_close_interface(ifce);
to_sel++;
}
m_font->SetSelection(select);
sOpt = gf_cfg_get_key(cfg, "FontEngine", "FontDirectory");
if (sOpt) m_fontdir->SetLabel(wxString(sOpt, wxConvUTF8) );
sOpt = gf_cfg_get_key(cfg, "Compositor", "TextureTextMode");
m_texturemode->Append(wxT("Default"));
m_texturemode->Append(wxT("Never"));
m_texturemode->Append(wxT("Always"));
if (sOpt && !stricmp(sOpt, "Always")) m_texturemode->SetSelection(2);
else if (sOpt && !stricmp(sOpt, "3D")) m_texturemode->SetSelection(1);
else m_texturemode->SetSelection(0);
/*downloader*/
sOpt = gf_cfg_get_key(cfg, "General", "CacheDirectory");
if (sOpt) m_cachedir->SetLabel(wxString(sOpt, wxConvUTF8) );
sOpt = gf_cfg_get_key(cfg, "Downloader", "CleanCache");
m_cleancache->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "Downloader", "RestartFiles");
m_restartcache->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "SAXLoader", "Progressive");
m_progressive->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
sOpt = gf_cfg_get_key(cfg, "SAXLoader", "MaxDuration");
m_sax_duration->SetValue(sOpt ? wxString(sOpt, wxConvUTF8) : wxT("30"));
if (! m_progressive->GetValue()) m_sax_duration->Enable(0);
sOpt = gf_cfg_get_key(cfg, "HTTPProxy", "Enabled");
m_use_proxy->SetValue( (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0);
char szProxy[GF_MAX_PATH];
strcpy(szProxy, "");
sOpt = gf_cfg_get_key(cfg, "HTTPProxy", "Name");
if (sOpt) {
strcat(szProxy, sOpt);
sOpt = gf_cfg_get_key(cfg, "HTTPProxy", "Port");
if (sOpt) {
strcat(szProxy, ":");
strcat(szProxy, sOpt);
}
} else {
m_use_proxy->SetValue(0);
}
m_proxy_name->SetValue( wxString((char *)szProxy, wxConvUTF8) );
if (! m_use_proxy->GetValue()) m_proxy_name->Enable(0);
/*streaming*/
m_port->Append(wxT("554 (RTSP standard)"));
m_port->Append(wxT("7070 (RTSP ext)"));
m_port->Append(wxT("80 (RTSP / HTTP tunnel)"));
m_port->Append(wxT("8080 (RTSP / HTTP tunnel)"));
sOpt = gf_cfg_get_key(cfg, "Streaming", "DefaultPort");
u32 port = 554;
Bool force_rtsp = 0;
if (sOpt) port = atoi(sOpt);
switch (port) {
case 8080:
m_port->SetSelection(3);
force_rtsp = 1;
break;
case 80:
m_port->SetSelection(2);
force_rtsp = 1;
break;
case 7070:
m_port->SetSelection(1);
break;
default:
m_port->SetSelection(0);
break;
}
Bool use_rtsp = 0;
sOpt = gf_cfg_get_key(cfg, "Streaming", "RTPoverRTSP");
if (sOpt && !stricmp(sOpt, "yes")) use_rtsp = 1;
if (force_rtsp) {
m_rtsp->SetValue(1);
m_rtsp->Enable(0);
m_reorder->SetValue(0);
m_reorder->Enable(0);
} else {
m_rtsp->SetValue(use_rtsp ? 1 : 0);
m_rtsp->Enable(1);
m_reorder->Enable(1);
sOpt = gf_cfg_get_key(cfg, "Streaming", "ReorderSize");
m_reorder->SetValue( (sOpt && !stricmp(sOpt, "0")) ? 1 : 0);
}
sOpt = gf_cfg_get_key(cfg, "Streaming", "RTSPTimeout");
m_timeout->SetValue(sOpt ? wxString(sOpt, wxConvUTF8) : wxT("30000"));
sOpt = gf_cfg_get_key(cfg, "Network", "BufferLength");
m_buffer->SetValue(sOpt ? wxString(sOpt, wxConvUTF8) : wxT("3000"));
sOpt = gf_cfg_get_key(cfg, "Network", "RebufferLength");
u32 buf_len = 0;
if (sOpt) buf_len = atoi(sOpt);
if (buf_len) {
m_dorebuffer->SetValue(1);
m_rebuffer->SetValue(wxString(sOpt, wxConvUTF8));
m_rebuffer->Enable(1);
} else {
m_dorebuffer->SetValue(0);
m_rebuffer->SetValue(wxT("0"));
m_rebuffer->Enable(0);
}
RTPoverRTSP(event);
sOpt = gf_cfg_get_key(cfg, "StreamingCache", "RecordDirectory");
if (!sOpt) sOpt = gf_cfg_get_key(cfg, "General", "CacheDirectory");
if (sOpt) m_recdir->SetLabel(wxString(sOpt, wxConvUTF8));
sOpt = gf_cfg_get_key(cfg, "StreamingCache", "KeepExistingFiles");
m_overwrite->SetValue((sOpt && !stricmp(sOpt, "yes")) ? 0 : 1);
sOpt = gf_cfg_get_key(cfg, "StreamingCache", "BaseFileName");
if (sOpt) {
m_usename->SetValue(1);
m_recfile->Enable(1);
m_recfile->SetValue(wxString(sOpt, wxConvUTF8));
} else {
m_usename->SetValue(0);
m_recfile->Enable(0);
m_recfile->SetValue(wxT("uses service URL"));
}
m_select->Append(wxT("General"));
m_select->Append(wxT("MPEG-4 Systems"));
m_select->Append(wxT("Media Decoders"));
m_select->Append(wxT("Compositor"));
m_select->Append(wxT("Renderer 2D"));
m_select->Append(wxT("Renderer 3D"));
m_select->Append(wxT("Video Output"));
m_select->Append(wxT("Audio Output"));
m_select->Append(wxT("Text Engine"));
m_select->Append(wxT("File Download"));
m_select->Append(wxT("Real-Time Streaming"));
m_select->Append(wxT("Streaming Cache"));
sOpt = gf_cfg_get_key(cfg, "General", "ConfigPanel");
m_sel = sOpt ? atoi(sOpt) : 0;
if (m_sel>11) m_sel=11;
m_select->SetSelection(m_sel);
DoSelect();
}
bool GPACInit(void *application, GF_Terminal **term, GF_User *user, bool quiet)
{
memset(user, 0, sizeof(GF_User));
/*locate exec dir for cfg file*/
wxPathList pathList;
wxString currentDir(wxGetCwd());
wxString abs_gpac_path = "";
const char *gpac_cfg;
if (!quiet) ::wxLogMessage("Looking for GPAC configuration file");
#if defined(__WXMAC__) && !defined(__DARWIN__)
// On Mac, the current directory is the relevant one when the application starts.
abs_gpac_path = wxGetCwd();
gpac_cfg = "GPAC.cfg";
#else
#ifdef WIN32
V4StudioApp &app = wxGetApp();
gpac_cfg = "GPAC.cfg";
/*locate exe*/
if (wxIsAbsolutePath(app.argv[0])) {
abs_gpac_path = wxPathOnly(app.argv[0]);
} else {
if (currentDir.Last() != wxFILE_SEP_PATH) currentDir += wxFILE_SEP_PATH;
abs_gpac_path = currentDir + app.argv[0];
if (wxFileExists(abs_gpac_path)) {
abs_gpac_path = wxPathOnly(abs_gpac_path);
} else {
abs_gpac_path = "";
pathList.AddEnvList(wxT("PATH"));
abs_gpac_path = pathList.FindAbsoluteValidPath(app.argv[0]);
if (!abs_gpac_path.IsEmpty()) {
abs_gpac_path = wxPathOnly(abs_gpac_path);
} else {
/*ask user*/
wxDirDialog dlg(NULL, "Locate GPAC config file directory");
if ( dlg.ShowModal() != wxID_OK ) return 0;
abs_gpac_path = dlg.GetPath();
}
}
}
#else
gpac_cfg = ".gpacrc";
char *cfg_dir = getenv("HOME");
if (cfg_dir) {
abs_gpac_path = cfg_dir;
} else {
/*ask user*/
wxDirDialog dlg(NULL, "Locate GPAC config file directory");
if ( dlg.ShowModal() != wxID_OK ) return 0;
abs_gpac_path = dlg.GetPath();
}
#endif
#endif
/*load config*/
Bool first_launch = 0;
user->config = gf_cfg_init(NULL, &first_launch);
if (!user->config) {
wxMessageDialog(NULL, "Cannot create GPAC config file", "Init error", wxOK).ShowModal();
}
if (!quiet) ::wxLogMessage("GPAC configuration file opened - looking for modules");
const char *str = gf_cfg_get_key(user->config, "General", "ModulesDirectory");
user->modules = gf_modules_new(str, user->config);
if (! gf_modules_get_count(user->modules) ) {
wxMessageDialog(NULL, "No modules available - system cannot work", "Fatal Error", wxOK).ShowModal();
gf_modules_del(user->modules);
gf_cfg_del(user->config);
return 0;
}
if (!quiet) ::wxLogMessage("%d modules found:", gf_modules_get_count(user->modules));
for (u32 i=0; i<gf_modules_get_count(user->modules); i++) {
if (!quiet) ::wxLogMessage("\t%s", gf_modules_get_file_name(user->modules, i));
}
if (!quiet) ::wxLogMessage("Starting GPAC Terminal");
/*now load terminal*/
user->opaque = application;
user->EventProc = V4S_EventProc;
// user->os_window_handler = ((wxGPACPanel *)application)->GetV4SceneManager()->GetV4StudioFrame()->GetHandle();
// Forces the renderer to not use a thread and do the rendering by itfe
gf_cfg_set_key(user->config, "Systems", "NoVisualThread", "No");
*term = gf_term_new(user);
if (!*term) {
wxMessageDialog(NULL, "Fatal Error", "Cannot load GPAC Terminal", wxOK).ShowModal();
return 0;
} else {
if (!quiet) ::wxLogMessage("GPAC Terminal started");
}
return 1;
}
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
#ifdef _WIN32_WCE
LPWSTR lpCmdLine,
#else
LPSTR lpCmdLine,
#endif
int nShowCmd
) {
MSG msg;
#ifdef _WIN32_WCE
TCHAR wzExePath[GF_MAX_PATH];
#endif
HWND hwndOld = NULL;
const char *str;
Bool initial_launch = 0;
if (hwndOld = FindWindow(_T("Osmophone"), NULL))
{
SetForegroundWindow(hwndOld);
return 0;
}
memset(&user, 0, sizeof(GF_User));
term = NULL;
g_hinst = hInstance;
screen_w = GetSystemMetrics(SM_CXSCREEN);
screen_h = GetSystemMetrics(SM_CYSCREEN);
/*are we in low res or high res*/
RawFrameBufferInfo Info;
HDC DC = GetDC(NULL);
ExtEscape(DC, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char*)&Info);
ReleaseDC(NULL,DC);
if (Info.pFramePointer) {
recompute_res(Info.cxPixels, Info.cyPixels);
} else {
recompute_res(screen_w, screen_h);
}
#ifdef _WIN32_WCE
TCHAR szBuf[MAX_PATH];
SystemParametersInfo(SPI_GETPLATFORMTYPE, MAX_PATH, szBuf, 0);
if (! lstrcmp(szBuf, __TEXT("PocketPC"))) is_ppc = 1;
else if (! lstrcmp(szBuf, __TEXT("Palm PC2"))) is_ppc = 1;
#endif
user.config = gf_cfg_init(NULL, &initial_launch);
if (!user.config) {
MessageBox(NULL, _T("Couldn't locate GPAC config file"), _T("Fatal Error"), MB_OK);
return 0;
}
str = gf_cfg_get_key(user.config, "Compositor", "ScreenWidth");
if (str) screen_w = atoi(str);
str = gf_cfg_get_key(user.config, "Compositor", "ScreenHeight");
if (str) screen_h = atoi(str);
disp_w = screen_w;
#ifdef _WIN32_WCE
disp_h = screen_h - menu_h /*- caption_h*/;
#else
disp_h = screen_h;
#endif
str = gf_cfg_get_key(user.config, "General", "ModulesDirectory");
if (!str) {
gf_cfg_del(user.config);
MessageBox(NULL, _T("Couldn't locate GPAC plugins"), _T("Fatal Error"), MB_OK);
return 0;
}
gf_sys_init(0);
user.modules = gf_modules_new(str, user.config);
if (!gf_modules_get_count(user.modules)) {
MessageBox(GetForegroundWindow(), _T("No modules found"), _T("GPAC Init Error"), MB_OK);
gf_modules_del(user.modules);
gf_cfg_del(user.config);
memset(&user, 0, sizeof(GF_User));
gf_sys_close();
return 0;
}
/*first launch, register all files ext*/
if (initial_launch) {
/*FFMPEG registration - FFMPEG DLLs compiled with CEGCC cannot be loaded directly under WM 6.1
cf http://cegcc.sourceforge.net/docs/faq.html#DllDoesNotWorkWithWindowsMobile6.1
*/
HKEY hKey = NULL;
DWORD dwSize;
DWORD dwValue;
RegCreateKeyEx(HKEY_LOCAL_MACHINE, _T("System\\Loader\\LoadModuleLow"), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwSize);
dwSize = 4; dwValue = 1;
LONG res = RegSetValueEx(hKey, _T("avcodec-52.dll"), NULL, REG_DWORD, (unsigned char *)&dwValue, dwSize);
res = RegSetValueEx(hKey, _T("avformat-52.dll"), NULL, REG_DWORD, (unsigned char *)&dwValue, dwSize);
res = RegSetValueEx(hKey, _T("avutil-50.dll"), NULL, REG_DWORD, (unsigned char *)&dwValue, dwSize);
res = RegSetValueEx(hKey, _T("swscale-0.dll"), NULL, REG_DWORD, (unsigned char *)&dwValue, dwSize);
RegCloseKey(hKey);
u32 i;
for (i=0; i<gf_modules_get_count(user.modules); i++) {
GF_InputService *ifce = (GF_InputService *) gf_modules_load_interface(user.modules, i, GF_NET_CLIENT_INTERFACE);
if (!ifce) continue;
if (ifce) {
ifce->CanHandleURL(ifce, "test.test");
gf_modules_close_interface((GF_BaseInterface *)ifce);
}
}
MessageBox(NULL, _T("Thank you for installing GPAC"), _T("Initial setup done"), MB_OK);
}
str = gf_cfg_get_key(user.config, "General", "Loop");
loop = (!str || !stricmp(str, "yes")) ? 1 : 0;
str = gf_cfg_get_key(user.config, "SAXLoader", "Progressive");
use_svg_prog = (str && !strcmp(str, "yes")) ? 1 : 0;
str = gf_cfg_get_key(user.config, "General", "RTIRefreshPeriod");
if (str) {
rti_update_time_ms = atoi(str);
} else {
gf_cfg_set_key(user.config, "General", "RTIRefreshPeriod", "200");
}
str = gf_cfg_get_key(user.config, "General", "ShowStatusBar");
show_status = (str && !strcmp(str, "yes")) ? 1 : 0;
#ifdef _WIN32_WCE
if (is_ppc) GXOpenInput();
#endif
if (InitInstance(nShowCmd)) {
SetForegroundWindow(g_hwnd);
show_taskbar(0);
force_2d_gl = gf_term_get_option(term, GF_OPT_USE_OPENGL);
while (GetMessage(&msg, NULL, 0,0) == TRUE) {
TranslateMessage (&msg);
DispatchMessage (&msg);
if (playlist_act) {
switch_playlist(playlist_act-1);
playlist_act = 0;
}
}
show_taskbar(1);
}
#ifdef _WIN32_WCE
if (is_ppc) GXCloseInput();
#endif
/*and destroy*/
if (term) gf_term_del(term);
if (user.modules) gf_modules_del(user.modules);
if (user.config) gf_cfg_del(user.config);
if (backlight_off) set_backlight_state(0);
gf_sys_close();
if (log_file) fclose(log_file);
return 0;
}
static GF_Renderer *SR_New(GF_User *user)
{
const char *sOpt;
GF_VisualRenderer *vrend;
GF_GLConfig cfg, *gl_cfg;
Bool forced = 1;
GF_Renderer *tmp;
GF_SAFEALLOC(tmp, GF_Renderer);
if (!tmp) return NULL;
tmp->user = user;
/*load renderer to check for GL flag*/
if (! (user->init_flags & (GF_TERM_FORCE_2D | GF_TERM_FORCE_3D)) ) {
sOpt = gf_cfg_get_key(user->config, "Rendering", "RendererName");
if (sOpt) {
tmp->visual_renderer = (GF_VisualRenderer *) gf_modules_load_interface_by_name(user->modules, sOpt, GF_RENDERER_INTERFACE);
if (!tmp->visual_renderer) sOpt = NULL;
}
forced = 0;
}
if (!tmp->visual_renderer) {
u32 i, count;
count = gf_modules_get_count(user->modules);
for (i=0; i<count; i++) {
tmp->visual_renderer = (GF_VisualRenderer *) gf_modules_load_interface(user->modules, i, GF_RENDERER_INTERFACE);
if (tmp->visual_renderer) {
if ((tmp->visual_renderer->bNeedsGL && (user->init_flags & GF_TERM_FORCE_2D))
|| (!tmp->visual_renderer->bNeedsGL && (user->init_flags & GF_TERM_FORCE_3D)) ) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Renderer] Renderer %s loaded but not matching init flags %08x\n", tmp->visual_renderer->module_name, user->init_flags));
gf_modules_close_interface((GF_BaseInterface *)tmp->visual_renderer);
tmp->visual_renderer = NULL;
continue;
}
break;
}
}
if (!forced && tmp->visual_renderer) gf_cfg_set_key(user->config, "Rendering", "RendererName", tmp->visual_renderer->module_name);
}
if (!tmp->visual_renderer) {
GF_LOG(GF_LOG_ERROR, GF_LOG_RENDER, ("[Renderer] Cannot load any visual renderer - aborting\n"));
free(tmp);
return NULL;
}
memset(&cfg, 0, sizeof(cfg));
cfg.double_buffered = 1;
gl_cfg = tmp->visual_renderer->bNeedsGL ? &cfg : NULL;
vrend = tmp->visual_renderer;
tmp->visual_renderer = NULL;
/*load video out*/
sOpt = gf_cfg_get_key(user->config, "Video", "DriverName");
if (sOpt) {
tmp->video_out = (GF_VideoOutput *) gf_modules_load_interface_by_name(user->modules, sOpt, GF_VIDEO_OUTPUT_INTERFACE);
if (tmp->video_out) {
tmp->video_out->evt_cbk_hdl = tmp;
tmp->video_out->on_event = gf_sr_on_event;
/*init hw*/
if (tmp->video_out->Setup(tmp->video_out, user->os_window_handler, user->os_display, user->init_flags, gl_cfg) != GF_OK) {
gf_modules_close_interface((GF_BaseInterface *)tmp->video_out);
tmp->video_out = NULL;
}
} else {
sOpt = NULL;
}
}
if (!tmp->video_out) {
u32 i, count;
count = gf_modules_get_count(user->modules);
for (i=0; i<count; i++) {
tmp->video_out = (GF_VideoOutput *) gf_modules_load_interface(user->modules, i, GF_VIDEO_OUTPUT_INTERFACE);
if (!tmp->video_out) continue;
tmp->video_out->evt_cbk_hdl = tmp;
tmp->video_out->on_event = gf_sr_on_event;
/*init hw*/
if (tmp->video_out->Setup(tmp->video_out, user->os_window_handler, user->os_display, user->init_flags, gl_cfg)==GF_OK) {
gf_cfg_set_key(user->config, "Video", "DriverName", tmp->video_out->module_name);
break;
}
gf_modules_close_interface((GF_BaseInterface *)tmp->video_out);
tmp->video_out = NULL;
}
}
tmp->visual_renderer = vrend;
if (!tmp->video_out ) {
gf_modules_close_interface((GF_BaseInterface *)tmp->visual_renderer);
free(tmp);
return NULL;
}
/*try to load a raster driver*/
sOpt = gf_cfg_get_key(user->config, "Rendering", "Raster2D");
if (sOpt) {
tmp->r2d = (GF_Raster2D *) gf_modules_load_interface_by_name(user->modules, sOpt, GF_RASTER_2D_INTERFACE);
if (!tmp->r2d) {
sOpt = NULL;
} else if (!check_graphics2D_driver(tmp->r2d)) {
gf_modules_close_interface((GF_BaseInterface *)tmp->r2d);
tmp->r2d = NULL;
sOpt = NULL;
}
}
if (!tmp->r2d) {
u32 i, count;
count = gf_modules_get_count(user->modules);
for (i=0; i<count; i++) {
tmp->r2d = (GF_Raster2D *) gf_modules_load_interface(user->modules, i, GF_RASTER_2D_INTERFACE);
if (!tmp->r2d) continue;
if (check_graphics2D_driver(tmp->r2d)) break;
gf_modules_close_interface((GF_BaseInterface *)tmp->r2d);
tmp->r2d = NULL;
}
if (tmp->r2d) gf_cfg_set_key(user->config, "Rendering", "Raster2D", tmp->r2d->module_name);
}
/*and init*/
if (tmp->visual_renderer->LoadRenderer(tmp->visual_renderer, tmp) != GF_OK) {
gf_modules_close_interface((GF_BaseInterface *)tmp->visual_renderer);
tmp->video_out->Shutdown(tmp->video_out);
gf_modules_close_interface((GF_BaseInterface *)tmp->video_out);
free(tmp);
return NULL;
}
tmp->mx = gf_mx_new();
tmp->textures = gf_list_new();
tmp->frame_rate = 30.0;
tmp->frame_duration = 33;
tmp->time_nodes = gf_list_new();
#ifdef GF_SR_EVENT_QUEUE
tmp->events = gf_list_new();
tmp->ev_mx = gf_mx_new();
#endif
SR_ResetFrameRate(tmp);
/*set font engine if any*/
SR_SetFontEngine(tmp);
tmp->extra_scenes = gf_list_new();
tmp->interaction_level = GF_INTERACT_NORMAL | GF_INTERACT_INPUT_SENSOR | GF_INTERACT_NAVIGATION;
return tmp;
}
