GF_EXPORT
char *gf_rtp_streamer_format_sdp_header(char *app_name, char *ip_dest, char *session_name, char *iod64)
{
u64 size;
char *sdp, *tmp_fn = NULL;
FILE *tmp = gf_temp_file_new(&tmp_fn);
if (!tmp) return NULL;
/* write SDP header*/
fprintf(tmp, "v=0\n");
fprintf(tmp, "o=%s 3326096807 1117107880000 IN IP%d %s\n", app_name, gf_net_is_ipv6(ip_dest) ? 6 : 4, ip_dest);
fprintf(tmp, "s=%s\n", (session_name ? session_name : "GPAC Scene Streaming Session"));
fprintf(tmp, "c=IN IP%d %s\n", gf_net_is_ipv6(ip_dest) ? 6 : 4, ip_dest);
fprintf(tmp, "t=0 0\n");
if (iod64) fprintf(tmp, "a=mpeg4-iod:\"data:application/mpeg4-iod;base64,%s\"\n", iod64);
gf_fseek(tmp, 0, SEEK_END);
size = gf_ftell(tmp);
gf_fseek(tmp, 0, SEEK_SET);
sdp = (char*)gf_malloc(sizeof(char) * (size_t)(size+1));
size = fread(sdp, 1, (size_t)size, tmp);
sdp[size] = 0;
gf_fclose(tmp);
gf_delete_file(tmp_fn);
gf_free(tmp_fn);
return sdp;
}
static void imagetexture_destroy(GF_Node *node, void *rs, Bool is_destroy)
{
if (is_destroy) {
GF_TextureHandler *txh = (GF_TextureHandler *) gf_node_get_private(node);
/*cleanup cache if needed*/
if (gf_node_get_tag(node)==TAG_MPEG4_CacheTexture) {
char section[64];
const char *opt, *file;
Bool delete_file = 1;
M_CacheTexture *ct = (M_CacheTexture*)node;
sprintf(section, "@cache=%p", ct);
file = gf_cfg_get_key(txh->compositor->user->config, section, "cacheFile");
opt = gf_cfg_get_key(txh->compositor->user->config, section, "expireAfterNTP");
if (opt) {
u32 sec, frac, exp;
sscanf(opt, "%u", &exp);
gf_net_get_ntp(&sec, &frac);
if (!exp || (exp>sec)) delete_file=0;
}
if (delete_file) {
gf_delete_file((char*)file);
gf_cfg_del_section(txh->compositor->user->config, section);
}
if (txh->data) gf_free(txh->data);
txh->data = NULL;
}
gf_sc_texture_destroy(txh);
gf_free(txh);
}
}
static GF_Err TTIn_CloseService(GF_InputService *plug)
{
TTIn *tti;
if (!plug)
return GF_BAD_PARAM;
tti = (TTIn *)plug->priv;
if (!tti)
return GF_BAD_PARAM;
if (tti->samp)
gf_isom_sample_del(&tti->samp);
tti->samp = NULL;
if (tti->mp4)
gf_isom_delete(tti->mp4);
tti->mp4 = NULL;
if (tti->szFile) {
gf_delete_file(tti->szFile);
gf_free(tti->szFile);
tti->szFile = NULL;
}
if (tti->dnload)
gf_term_download_del(tti->dnload);
tti->dnload = NULL;
if (tti->service)
gf_term_on_disconnect(tti->service, NULL, GF_OK);
tti->service = NULL;
return GF_OK;
}
void gf_cfg_remove(GF_Config *iniFile)
{
if (!iniFile) return;
gf_delete_file(iniFile->fileName);
gf_cfg_clear(iniFile);
gf_free(iniFile);
}
GF_Err gf_cache_write_to_cache( const DownloadedCacheEntry entry, const GF_DownloadSession * sess, const char * data, const u32 size) {
u32 read;
CHECK_ENTRY;
if (!data || (!entry->writeFilePtr && !entry->mem_storage) || sess != entry->write_session) {
GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("Incorrect parameter : data=%p, writeFilePtr=%p mem_storage=%p at "__FILE__"\n", data, entry->writeFilePtr, entry->mem_storage));
return GF_BAD_PARAM;
}
if (entry->memory_stored) {
if (entry->written_in_cache + size > entry->mem_allocated) {
u32 new_size = MAX(entry->mem_allocated*2, entry->written_in_cache + size);
entry->mem_storage = gf_realloc(entry->mem_storage, (new_size+2));
entry->mem_allocated = new_size;
sprintf(entry->cache_filename, "gmem://%d@%p", entry->contentLength, entry->mem_storage);
GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[CACHE] Reallocating memory cache to %d bytes\n", new_size));
}
memcpy(entry->mem_storage + entry->written_in_cache, data, size);
entry->written_in_cache += size;
memset(entry->mem_storage + entry->written_in_cache, 0, 2);
sprintf(entry->cache_filename, "gmem://%d@%p", entry->written_in_cache, entry->mem_storage);
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[CACHE] Writing %d bytes to cache\n", size));
return GF_OK;
}
read = (u32) gf_fwrite(data, sizeof(char), size, entry->writeFilePtr);
if (read > 0)
entry->written_in_cache+= read;
if (read != size) {
/* Something bad happened */
GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK,
("[CACHE] Error while writting %d bytes of data to cache : has written only %d bytes.", size, read));
gf_cache_close_write_cache(entry, sess, 0);
gf_delete_file(entry->cache_filename);
return GF_IO_ERR;
}
if (fflush(entry->writeFilePtr)) {
GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK,
("[CACHE] Error while flushing data bytes to cache file : %s.", entry->cache_filename));
gf_cache_close_write_cache(entry, sess, 0);
gf_delete_file(entry->cache_filename);
return GF_IO_ERR;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[CACHE] Writing %d bytes to cache\n", size));
return GF_OK;
}
static Bool delete_dir(void *cbck, char *item_name, char *item_path, GF_FileEnumInfo *file_info)
{
Bool directory_clean_mode = *(Bool*)cbck;
if(directory_clean_mode) {
gf_cleanup_dir(item_path);
gf_rmdir(item_path);
} else {
gf_delete_file(item_path);
}
return 0;
}
static void CTXLoad_Reset(CTXLoadPriv *priv)
{
if (priv->ctx) gf_sm_del(priv->ctx);
priv->ctx = NULL;
gf_sg_reset(priv->scene->graph);
if (priv->load_flags != 3) priv->load_flags = 0;
while (gf_list_count(priv->files_to_delete)) {
char *fileName = (char*)gf_list_get(priv->files_to_delete, 0);
gf_list_rem(priv->files_to_delete, 0);
gf_delete_file(fileName);
gf_free(fileName);
}
}
Bool delete_cache_files(void *cbck, char *item_name, char *item_path) {
const char * startPattern;
int sz;
assert( cbck );
assert( item_name );
assert( item_path);
startPattern = (const char *) cbck;
sz = (u32) strlen( startPattern );
if (!strncmp(startPattern, item_name, sz)) {
if (GF_OK != gf_delete_file(item_path))
GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[CACHE] : failed to cleanup file %s\n", item_path));
}
return GF_FALSE;
}
void gf_isom_fdm_del(GF_FileDataMap *ptr)
{
if (!ptr || (ptr->type != GF_ISOM_DATA_FILE)) return;
if (ptr->bs) gf_bs_del(ptr->bs);
if (ptr->stream) fclose(ptr->stream);
#ifndef GPAC_DISABLE_ISOM_WRITE
if (ptr->temp_file) {
gf_delete_file(ptr->temp_file);
gf_free(ptr->temp_file);
}
#endif
gf_free(ptr);
}
void compositor_init_imagetexture(GF_Compositor *compositor, GF_Node *node)
{
GF_TextureHandler *txh;
GF_SAFEALLOC(txh, GF_TextureHandler);
gf_sc_texture_setup(txh, compositor, node);
txh->update_texture_fcnt = imagetexture_update;
gf_node_set_private(node, txh);
gf_node_set_callback_function(node, imagetexture_destroy);
txh->flags = 0;
if (gf_node_get_tag(txh->owner)!=TAG_MPEG4_CacheTexture) {
if (((M_ImageTexture*)node)->repeatS) txh->flags |= GF_SR_TEXTURE_REPEAT_S;
if (((M_ImageTexture*)node)->repeatT) txh->flags |= GF_SR_TEXTURE_REPEAT_T;
} else {
const char *url;
u32 i, count;
M_CacheTexture*ct = (M_CacheTexture*)node;
if (!ct->image.buffer) return;
if (ct->repeatS) txh->flags |= GF_SR_TEXTURE_REPEAT_S;
if (ct->repeatT) txh->flags |= GF_SR_TEXTURE_REPEAT_T;
/*locate existing cache*/
url = gf_scene_get_service_url( gf_node_get_graph(node) );
count = gf_cfg_get_section_count(compositor->user->config);
for (i=0; i<count; i++) {
const char *opt;
const char *name = gf_cfg_get_section_name(compositor->user->config, i);
if (strncmp(name, "@cache=", 7)) continue;
opt = gf_cfg_get_key(compositor->user->config, name, "serviceURL");
if (!opt || stricmp(opt, url)) continue;
opt = gf_cfg_get_key(compositor->user->config, name, "cacheName");
if (opt && ct->cacheURL.buffer && !stricmp(opt, ct->cacheURL.buffer)) {
opt = gf_cfg_get_key(compositor->user->config, name, "cacheFile");
if (opt) gf_delete_file((char*)opt);
gf_cfg_del_section(compositor->user->config, name);
break;
}
}
}
}
void gf_dm_sess_del(GF_DownloadSession *sess)
{
const char *opt;
/*self-destruction, let the download manager destroy us*/
if (sess->th && sess->in_callback) {
sess->destroy = 1;
return;
}
gf_dm_disconnect(sess);
/*if threaded wait for thread exit*/
if (sess->th) {
while (!(sess->flags & GF_DOWNLOAD_SESSION_THREAD_DEAD))
gf_sleep(1);
gf_th_del(sess->th);
gf_mx_del(sess->mx);
}
gf_list_del_item(sess->dm->sessions, sess);
if (sess->cache_name) {
opt = gf_cfg_get_key(sess->dm->cfg, "Downloader", "CleanCache");
if (opt && !stricmp(opt, "yes")) gf_delete_file(sess->cache_name);
free(sess->cache_name);
}
if (sess->server_name) free(sess->server_name);
if (sess->remote_path) free(sess->remote_path);
if (sess->user) free(sess->user);
if (sess->passwd) free(sess->passwd);
if (sess->mime_type) free(sess->mime_type);
if (sess->cache) fclose(sess->cache);
if (sess->init_data) free(sess->init_data);
free(sess);
}
static GF_Config *create_default_config(char *file_path)
{
FILE *f;
GF_Config *cfg;
#if !defined(GPAC_IPHONE) && !defined(GPAC_ANDROID)
char *cache_dir;
#endif
char szPath[GF_MAX_PATH];
char gui_path[GF_MAX_PATH];
if (! get_default_install_path(file_path, GF_PATH_CFG)) {
gf_delete_file(szPath);
return NULL;
}
/*Create the config file*/
sprintf(szPath, "%s%c%s", file_path, GF_PATH_SEPARATOR, CFG_FILE_NAME);
GF_LOG(GF_LOG_INFO, GF_LOG_CORE, ("Trying to create config file: %s\n", szPath ));
f = fopen(szPath, "wt");
if (!f) return NULL;
fclose(f);
#ifndef GPAC_IPHONE
if (! get_default_install_path(szPath, GF_PATH_MODULES)) {
gf_delete_file(szPath);
GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] default modules not found\n"));
return NULL;
}
#else
get_default_install_path(szPath, GF_PATH_APP);
#endif
cfg = gf_cfg_new(file_path, CFG_FILE_NAME);
if (!cfg) return NULL;
gf_cfg_set_key(cfg, "General", "ModulesDirectory", szPath);
#if defined(GPAC_IPHONE)
gf_ios_refresh_cache_directory(cfg, file_path);
#elif defined(GPAC_ANDROID)
if (get_default_install_path(szPath, GF_PATH_APP)) {
strcat(szPath, "/cache");
gf_cfg_set_key(cfg, "General", "CacheDirectory", szPath);
}
#else
/*get default temporary directoy */
cache_dir = gf_get_default_cache_directory();
if (cache_dir) {
gf_cfg_set_key(cfg, "General", "CacheDirectory", cache_dir);
gf_free(cache_dir);
}
#endif
#if defined(GPAC_IPHONE)
gf_cfg_set_key(cfg, "General", "DeviceType", "iOS");
#elif defined(GPAC_ANDROID)
gf_cfg_set_key(cfg, "General", "DeviceType", "Android");
#else
gf_cfg_set_key(cfg, "General", "DeviceType", "Desktop");
#endif
gf_cfg_set_key(cfg, "Compositor", "Raster2D", "GPAC 2D Raster");
gf_cfg_set_key(cfg, "Audio", "ForceConfig", "yes");
gf_cfg_set_key(cfg, "Audio", "NumBuffers", "2");
gf_cfg_set_key(cfg, "Audio", "TotalDuration", "120");
gf_cfg_set_key(cfg, "Audio", "DisableNotification", "no");
/*Setup font engine to FreeType by default, and locate TrueType font directory on the system*/
gf_cfg_set_key(cfg, "FontEngine", "FontReader", "FreeType Font Reader");
gf_cfg_set_key(cfg, "FontEngine", "RescanFonts", "yes");
#if defined(_WIN32_WCE)
/*FIXME - is this true on all WinCE systems??*/
strcpy(szPath, "\\Windows");
#elif defined(WIN32)
GetWindowsDirectory((char*)szPath, MAX_PATH);
if (szPath[strlen((char*)szPath)-1] != '\\') strcat((char*)szPath, "\\");
strcat((char *)szPath, "Fonts");
#elif defined(__APPLE__)
#ifdef GPAC_IPHONE
strcpy(szPath, "/System/Library/Fonts/Cache,/System/Library/Fonts/AppFonts,/System/Library/Fonts/Core,/System/Library/Fonts/Extra");
#else
strcpy(szPath, "/Library/Fonts");
#endif
#elif defined(GPAC_ANDROID)
strcpy(szPath, "/system/fonts/");
#else
strcpy(szPath, "/usr/share/fonts/truetype/");
#endif
gf_cfg_set_key(cfg, "FontEngine", "FontDirectory", szPath);
gf_cfg_set_key(cfg, "Downloader", "CleanCache", "yes");
gf_cfg_set_key(cfg, "Compositor", "AntiAlias", "All");
gf_cfg_set_key(cfg, "Compositor", "FrameRate", "30.0");
/*use power-of-2 emulation in OpenGL if no rectangular texture extension*/
gf_cfg_set_key(cfg, "Compositor", "EmulatePOW2", "yes");
gf_cfg_set_key(cfg, "Compositor", "ScalableZoom", "yes");
#if defined(_WIN32_WCE)
gf_cfg_set_key(cfg, "Video", "DriverName", "GAPI Video Output");
#elif defined(WIN32)
gf_cfg_set_key(cfg, "Video", "DriverName", "DirectX Video Output");
#elif defined(__DARWIN__) || defined(__APPLE__)
gf_cfg_set_key(cfg, "Video", "DriverName", "SDL Video Output");
#elif defined(GPAC_ANDROID)
gf_cfg_set_key(cfg, "Video", "DriverName", "Android Video Output");
gf_cfg_set_key(cfg, "Audio", "DriverName", "Android Audio Output");
#else
gf_cfg_set_key(cfg, "Video", "DriverName", "X11 Video Output");
gf_cfg_set_key(cfg, "Audio", "DriverName", "SDL Audio Output");
#endif
#ifdef GPAC_IPHONE
gf_cfg_set_key(cfg, "Compositor", "DisableGLUScale", "yes");
#endif
gf_cfg_set_key(cfg, "Video", "SwitchResolution", "no");
gf_cfg_set_key(cfg, "Video", "HardwareMemory", "Auto");
gf_cfg_set_key(cfg, "Network", "AutoReconfigUDP", "yes");
gf_cfg_set_key(cfg, "Network", "UDPTimeout", "10000");
gf_cfg_set_key(cfg, "Network", "BufferLength", "3000");
/*locate GUI*/
if ( get_default_install_path(szPath, GF_PATH_GUI) ) {
char *sep = strrchr(szPath, GF_PATH_SEPARATOR);
if (!sep) sep = strrchr(szPath, GF_PATH_SEPARATOR);
sprintf(gui_path, "%s%cgui.bt", szPath, GF_PATH_SEPARATOR);
f = gf_fopen(gui_path, "rt");
if (f) {
gf_fclose(f);
gf_cfg_set_key(cfg, "General", "StartupFile", gui_path);
}
/*shaders are at the same location*/
assert(sep);
sep[0] = 0;
sprintf(gui_path, "%s%cshaders%cvertex.glsl", szPath, GF_PATH_SEPARATOR, GF_PATH_SEPARATOR);
gf_cfg_set_key(cfg, "Compositor", "VertexShader", gui_path);
sprintf(gui_path, "%s%cshaders%cfragment.glsl", szPath, GF_PATH_SEPARATOR, GF_PATH_SEPARATOR);
gf_cfg_set_key(cfg, "Compositor", "FragmentShader", gui_path);
}
/*store and reload*/
gf_cfg_del(cfg);
return gf_cfg_new(file_path, CFG_FILE_NAME);
}
static Bool get_default_install_path(char *file_path, u32 path_type)
{
char app_path[GF_MAX_PATH];
char *sep;
u32 size = GF_MAX_PATH;
/*on OSX, Linux & co, user home is where we store the cfg file*/
if (path_type==GF_PATH_CFG) {
char *user_home = getenv("HOME");
#ifdef GPAC_IPHONE
char buf[PATH_MAX];
char *res;
#endif
if (!user_home) return 0;
#ifdef GPAC_IPHONE
res = realpath(user_home, buf);
if (res) {
strcpy(file_path, buf);
strcat(file_path, "/Documents");
} else
#endif
strcpy(file_path, user_home);
if (file_path[strlen(file_path)-1] == '/') file_path[strlen(file_path)-1] = 0;
//cleanup of old install in .gpacrc
if (check_file_exists(".gpacrc", file_path, file_path)) {
strcpy(app_path, file_path);
strcat(app_path, "/.gpacrc");
gf_delete_file(app_path);
}
strcat(file_path, "/.gpac");
if (!gf_dir_exists(file_path)) {
gf_mkdir(file_path);
}
return 1;
}
if (path_type==GF_PATH_APP) {
#if (defined(__DARWIN__) || defined(__APPLE__) )
if (_NSGetExecutablePath(app_path, &size) ==0) {
realpath(app_path, file_path);
char *sep = strrchr(file_path, '/');
if (sep) sep[0] = 0;
return 1;
}
#elif defined(GPAC_CONFIG_LINUX)
size = readlink("/proc/self/exe", file_path, GF_MAX_PATH);
if (size>0) {
char *sep = strrchr(file_path, '/');
if (sep) sep[0] = 0;
return 1;
}
#endif
return 0;
}
/*locate the app*/
if (!get_default_install_path(app_path, GF_PATH_APP)) return 0;
/*installed or symlink on system, user user home directory*/
if (!strnicmp(app_path, "/usr/", 5) || !strnicmp(app_path, "/opt/", 5)) {
if (path_type==GF_PATH_GUI) {
/*look in possible install dirs ...*/
if (check_file_exists("gui.bt", "/usr/share/gpac/gui", file_path)) return 1;
if (check_file_exists("gui.bt", "/usr/local/share/gpac/gui", file_path)) return 1;
if (check_file_exists("gui.bt", "/opt/share/gpac/gui", file_path)) return 1;
if (check_file_exists("gui.bt", "/opt/local/share/gpac/gui", file_path)) return 1;
} else if (path_type==GF_PATH_MODULES) {
/*look in possible install dirs ...*/
if (check_file_exists(TEST_MODULE, "/usr/lib/gpac", file_path)) return 1;
if (check_file_exists(TEST_MODULE, "/usr/local/lib/gpac", file_path)) return 1;
if (check_file_exists(TEST_MODULE, "/opt/lib/gpac", file_path)) return 1;
if (check_file_exists(TEST_MODULE, "/opt/local/lib/gpac", file_path)) return 1;
if (check_file_exists(TEST_MODULE, "/usr/lib/x86_64-linux-gnu/gpac", file_path)) return 1;
if (check_file_exists(TEST_MODULE, "/usr/lib/i386-linux-gnu/gpac", file_path)) return 1;
}
}
if (path_type==GF_PATH_GUI) {
if (get_default_install_path(app_path, GF_PATH_CFG)) {
/*GUI not found, look in ~/.gpac/gui/ */
strcat(app_path, "/.gpac/gui");
if (check_file_exists("gui.bt", app_path, file_path)) return 1;
}
/*GUI not found, look in gpac distribution if any */
if (get_default_install_path(app_path, GF_PATH_APP)) {
char *sep = strstr(app_path, "/bin/gcc");
if (!sep) sep = strstr(app_path, "/bin/osx");
if (sep) {
sep[0] = 0;
strcat(app_path, "/gui");
if (check_file_exists("gui.bt", app_path, file_path)) return 1;
}
}
/*GUI not found, look in .app for OSX case*/
}
if (path_type==GF_PATH_MODULES) {
/*look in gpac compilation tree (modules are output in the same folder as apps) */
if (get_default_install_path(app_path, GF_PATH_APP)) {
if (check_file_exists(TEST_MODULE, app_path, file_path)) return 1;
/*on OSX check modules subdirectory */
strcat(app_path, "/modules");
if (check_file_exists(TEST_MODULE, app_path, file_path)) return 1;
}
/*modules not found, look in ~/.gpac/modules/ */
if (get_default_install_path(app_path, GF_PATH_CFG)) {
strcpy(app_path, file_path);
strcat(app_path, "/.gpac/modules");
if (check_file_exists(TEST_MODULE, app_path, file_path)) return 1;
}
/*modules not found, failure*/
return 0;
}
/*OSX way vs iPhone*/
sep = strstr(app_path, ".app/");
if (sep) sep[4] = 0;
/*we are looking for .app install path, or GUI */
if (path_type==GF_PATH_GUI) {
#ifndef GPAC_IPHONE
strcat(app_path, "/Contents/MacOS/gui");
if (check_file_exists("gui.bt", app_path, file_path)) return 1;
#else /*iOS: for now, everything is set flat within the package*/
/*iOS app is distributed with embedded GUI*/
get_default_install_path(app_path, GF_PATH_APP);
strcat(app_path, "/gui");
if (check_file_exists("gui.bt", app_path, file_path)) return 1;
#endif
}
else { // (path_type==GF_PATH_MODULES)
strcat(app_path, "/Contents/MacOS/modules");
if (check_file_exists(TEST_MODULE, app_path, file_path)) return 1;
}
/*not found ...*/
return 0;
}
static Bool get_default_install_path(char *file_path, u32 path_type)
{
FILE *f;
char *sep;
char szPath[GF_MAX_PATH];
#ifdef _WIN32_WCE
TCHAR w_szPath[GF_MAX_PATH];
GetModuleFileName(NULL, w_szPath, GF_MAX_PATH);
CE_WideToChar((u16 *) w_szPath, file_path);
#else
GetModuleFileNameA(NULL, file_path, GF_MAX_PATH);
#endif
/*remove exe name*/
if (strstr(file_path, ".exe")) {
sep = strrchr(file_path, '\\');
if (sep) sep[0] = 0;
}
strcpy(szPath, file_path);
strlwr(szPath);
/*if this is run from a browser, we do not get our app path - fortunately on Windows, we always use 'GPAC' in the
installation path*/
if (!strstr(file_path, "gpac") && !strstr(file_path, "GPAC") ) {
HKEY hKey = NULL;
DWORD dwSize = GF_MAX_PATH;
/*locate the key in current user, then in local machine*/
#ifdef _WIN32_WCE
DWORD dwType = REG_SZ;
u16 w_path[1024];
RegOpenKeyEx(HKEY_CURRENT_USER, TEXT("Software\\GPAC"), 0, KEY_READ, &hKey);
#ifdef _DEBUG
if (RegQueryValueEx(hKey, TEXT("DebugDir"), 0, &dwType, (LPBYTE) w_path, &dwSize) != ERROR_SUCCESS)
#endif
RegQueryValueEx(hKey, TEXT("InstallDir"), 0, &dwType, (LPBYTE) w_path, &dwSize);
CE_WideToChar(w_path, (char *)file_path);
RegCloseKey(hKey);
#else
if (RegOpenKeyEx(HKEY_CURRENT_USER, "Software\\GPAC", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\GPAC", 0, KEY_READ, &hKey);
dwSize = GF_MAX_PATH;
#ifdef _DEBUG
if (RegQueryValueEx(hKey, "DebugDir", NULL, NULL,(unsigned char*) file_path, &dwSize) != ERROR_SUCCESS)
#endif
RegQueryValueEx(hKey, "InstallDir", NULL, NULL,(unsigned char*) file_path, &dwSize);
RegCloseKey(hKey);
#endif
}
if (path_type==GF_PATH_APP) return GF_TRUE;
if (path_type==GF_PATH_GUI) {
char *sep;
strcat(file_path, "\\gui");
if (check_file_exists("gui.bt", file_path, file_path)) return GF_TRUE;
sep = strstr(file_path, "\\bin\\");
if (sep) {
sep[0] = 0;
strcat(file_path, "\\gui");
if (check_file_exists("gui.bt", file_path, file_path)) return GF_TRUE;
}
return GF_FALSE;
}
/*modules are stored in the GPAC directory (should be changed to GPAC/modules)*/
if (path_type==GF_PATH_MODULES) return GF_TRUE;
/*we are looking for the config file path - make sure it is writable*/
assert(path_type == GF_PATH_CFG);
strcpy(szPath, file_path);
strcat(szPath, "\\gpaccfgtest.txt");
//do not use gf_fopen here, we don't want to through any error if failure
f = fopen(szPath, "wb");
if (f != NULL) {
fclose(f);
gf_delete_file(szPath);
return GF_TRUE;
}
#ifdef _WIN32_WCE
return 0;
#else
/*no write access, get user home directory*/
SHGetFolderPath(NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, file_path);
if (file_path[strlen(file_path)-1] != '\\') strcat(file_path, "\\");
strcat(file_path, "GPAC");
/*create GPAC dir*/
_mkdir(file_path);
strcpy(szPath, file_path);
strcat(szPath, "\\gpaccfgtest.txt");
f = fopen(szPath, "wb");
/*COMPLETE FAILURE*/
if (!f) return GF_FALSE;
fclose(f);
gf_delete_file(szPath);
return GF_TRUE;
#endif
}
GF_Err gf_cache_delete_entry ( const DownloadedCacheEntry entry )
{
if ( !entry )
return GF_OK;
GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[CACHE] gf_cache_delete_entry:%d, entry=%p\n", __LINE__, entry));
if (entry->writeFilePtr) {
/** Cache should have been close before, abornormal situation */
GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[CACHE] gf_cache_delete_entry:%d, entry=%p, cache has not been closed properly\n", __LINE__, entry));
fclose(entry->writeFilePtr);
}
#ifdef ENABLE_WRITE_MX
if (entry->write_mutex) {
gf_mx_del(entry->write_mutex);
}
#endif
if (entry->file_exists && entry->deletableFilesOnDelete) {
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[CACHE] url %s cleanup, deleting %s...\n", entry->url, entry->cache_filename));
if (GF_OK != gf_delete_file(entry->cache_filename))
GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[CACHE] gf_cache_delete_entry:%d, failed to delete file %s\n", __LINE__, entry->cache_filename));
}
#ifdef ENABLE_WRITE_MX
entry->write_mutex = NULL;
#endif
entry->write_session = NULL;
entry->writeFilePtr = NULL;
if (entry->serverETag)
gf_free(entry->serverETag);
entry->serverETag = NULL;
if (entry->diskETag)
gf_free(entry->diskETag);
entry->diskETag = NULL;
if (entry->serverLastModified)
gf_free(entry->serverLastModified);
entry->serverLastModified = NULL;
if (entry->diskLastModified)
gf_free(entry->diskLastModified);
entry->diskLastModified = NULL;
if ( entry->hash )
{
gf_free ( entry->hash );
entry->hash = NULL;
}
if ( entry->url )
{
gf_free ( entry->url );
entry->url = NULL;
}
if ( entry->mimeType )
{
gf_free ( entry->mimeType );
entry->mimeType = NULL;
}
if (entry->mem_storage) {
gf_free(entry->mem_storage);
}
if ( entry->cache_filename )
{
gf_free ( entry->cache_filename );
entry->cache_filename = NULL;
}
if ( entry->properties )
{
char * propfile;
if (entry->deletableFilesOnDelete)
propfile = gf_cfg_get_filename(entry->properties);
else
propfile = NULL;
gf_cfg_del ( entry->properties );
entry->properties = NULL;
if (propfile) {
if (GF_OK != gf_delete_file( propfile ))
GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[CACHE] gf_cache_delete_entry:%d, failed to delete file %s\n", __LINE__, propfile));
gf_free ( propfile );
}
}
entry->dm = NULL;
if (entry->sessions) {
assert( gf_list_count(entry->sessions) == 0);
gf_list_del(entry->sessions);
entry->sessions = NULL;
}
gf_free (entry);
return GF_OK;
}
BOOL HandleCommand(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam)) {
case IDM_FILE_OPEN:
open_file(hwnd);
break;
case IDM_FILE_LOG_RTI:
log_rti = !log_rti;
setup_logs();
break;
case IDM_FILE_PAUSE:
pause_file();
break;
case IDM_VIEW_ABOUT:
view_about(hwnd);
break;
case IDM_VIEW_FS:
set_full_screen();
break;
case IDM_VIEW_STATUS:
show_status = !show_status;
gf_cfg_set_key(user.config, "General", "ShowStatusBar", show_status ? "yes" : "no");
do_layout(1);
break;
case IDM_VIEW_CPU:
view_cpu = !view_cpu;
break;
case IDM_VIEW_FORCEGL:
force_2d_gl = !force_2d_gl;
gf_cfg_set_key(user.config, "Compositor", "ForceOpenGL", force_2d_gl ? "yes" : "no");
gf_term_set_option(term, GF_OPT_USE_OPENGL, force_2d_gl);
break;
case IDM_NAV_RESET:
gf_term_set_option(term, GF_OPT_NAVIGATION_TYPE, 0);
break;
case IDM_NAV_NONE:
gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_NONE);
break;
case IDM_NAV_SLIDE:
gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_SLIDE);
break;
case IDM_NAV_WALK:
gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_WALK);
break;
case IDM_NAV_FLY:
gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_FLY);
break;
case IDM_NAV_EXAMINE:
gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_EXAMINE);
break;
case IDM_NAV_HEADLIGHT:
gf_term_set_option(term, GF_OPT_HEADLIGHT, !gf_term_get_option(term, GF_OPT_HEADLIGHT) );
break;
case IDM_NAV_COL_NONE:
gf_term_set_option(term, GF_OPT_COLLISION, GF_COLLISION_NONE);
break;
case IDM_NAV_COL_REG:
gf_term_set_option(term, GF_OPT_COLLISION, GF_COLLISION_NORMAL);
break;
case IDM_NAV_COL_DISP:
gf_term_set_option(term, GF_OPT_COLLISION, GF_COLLISION_DISPLACEMENT);
break;
case IDM_NAV_GRAVITY:
gf_term_set_option(term, GF_OPT_GRAVITY, !gf_term_get_option(term, GF_OPT_GRAVITY));
break;
case IDM_VIEW_AR_NONE:
gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_KEEP);
break;
case IDM_VIEW_AR_FILL:
gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_FILL_SCREEN);
break;
case IDM_VIEW_AR_4_3:
gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_4_3);
break;
case IDM_VIEW_AR_16_9:
gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_16_9);
break;
case IDM_VIEW_LOW_RATE:
use_low_fps = !use_low_fps;
gf_term_set_simulation_frame_rate(term, use_low_fps ? 15.0 : 30.0);
break;
case ID_VIDEO_DIRECTDRAW:
{
u32 drend = (gf_term_get_option(term, GF_OPT_DRAW_MODE)==GF_DRAW_MODE_IMMEDIATE) ? GF_DRAW_MODE_DEFER : GF_DRAW_MODE_IMMEDIATE;
gf_term_set_option(term, GF_OPT_DRAW_MODE, drend);
gf_cfg_set_key(user.config, "Compositor", "DrawMode", drend ? "immediate" : "defer");
}
break;
case ID_FILE_CUT_PASTE:
do_copy_paste();
break;
case IDM_OPEN_FILE1:
case IDM_OPEN_FILE2:
case IDM_OPEN_FILE3:
case IDM_OPEN_FILE4:
case IDM_OPEN_FILE5:
case IDM_OPEN_FILE6:
case IDM_OPEN_FILE7:
case IDM_OPEN_FILE8:
case IDM_OPEN_FILE9:
case IDM_OPEN_FILE10:
load_recent_file(LOWORD(wParam) - IDM_OPEN_FILE1);
break;
case IDS_CAP_DISABLE_PLAYLIST:
playlist_navigation_on = !playlist_navigation_on;
break;
case IDM_VIEW_SVG_LOAD:
set_svg_progressive();
break;
case ID_VIDEO_DIRECTFB:
set_gx_mode(0);
break;
case ID_VIDEO_GAPI:
set_gx_mode(1);
break;
case ID_VIDEO_GDI:
set_gx_mode(2);
break;
case ID_LOGLEVEL_NONE:
log_level = GF_LOG_QUIET;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_LOGLEVEL_ERROR:
log_level = GF_LOG_ERROR;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_LOGLEVEL_WARNING:
log_level = GF_LOG_WARNING;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_LOGLEVEL_INFO:
log_level = GF_LOG_INFO;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_LOGLEVEL_DEBUG:
log_level = GF_LOG_DEBUG;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_TOOLS_CORE: rewrite_log_tools(GF_LOG_CORE); break;
case ID_TOOLS_CODING: rewrite_log_tools(GF_LOG_CODING); break;
case ID_TOOLS_CONTAINER: rewrite_log_tools(GF_LOG_CONTAINER); break;
case ID_TOOLS_NETWORK: rewrite_log_tools(GF_LOG_NETWORK); break;
case ID_TOOLS_RTP: rewrite_log_tools(GF_LOG_RTP); break;
case ID_TOOLS_SCRIPT: rewrite_log_tools(GF_LOG_SCRIPT); break;
case ID_TOOLS_CODEC: rewrite_log_tools(GF_LOG_CODEC); break;
case ID_TOOLS_PARSER: rewrite_log_tools(GF_LOG_PARSER); break;
case ID_TOOLS_MEDIA: rewrite_log_tools(GF_LOG_MEDIA); break;
case ID_TOOLS_SCENE: rewrite_log_tools(GF_LOG_SCENE); break;
case ID_TOOLS_INTERACT: rewrite_log_tools(GF_LOG_INTERACT); break;
case ID_TOOLS_COMPOSE: rewrite_log_tools(GF_LOG_COMPOSE); break;
case ID_TOOLS_MMIO: rewrite_log_tools(GF_LOG_MMIO); break;
case ID_TOOLS_RTI: rewrite_log_tools(GF_LOG_RTI); break;
case ID_TOOLS_ALL: rewrite_log_tools(GF_LOG_ALL); break;
case ID_TOOLS_NONE:
log_level = GF_LOG_QUIET;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_LOGS_RESET:
if (log_file) {
fclose(log_file);
log_file = NULL;
}
{
const char *filename = gf_cfg_get_key(user.config, "General", "LogFile");
if (filename) gf_delete_file(filename);
}
setup_logs();
break;
case IDM_ITEM_QUIT:
DestroyWindow(hwnd);
return FALSE;
}
return TRUE;
}
static GF_Config *create_default_config(char *file_path)
{
FILE *f;
GF_Config *cfg;
char *cache_dir;
char szPath[GF_MAX_PATH];
char gui_path[GF_MAX_PATH];
if (! get_default_install_path(file_path, GF_PATH_CFG)) {
gf_delete_file(szPath);
return NULL;
}
/*Create the config file*/
sprintf(szPath, "%s%c%s", file_path, GF_PATH_SEPARATOR, CFG_FILE_NAME);
f = gf_f64_open(szPath, "wt");
if (!f) return NULL;
fclose(f);
if (! get_default_install_path(szPath, GF_PATH_MODULES)) {
gf_delete_file(szPath);
fprintf(stdout, "default modules not found\n");
return NULL;
}
cfg = gf_cfg_new(file_path, CFG_FILE_NAME);
if (!cfg) return NULL;
gf_cfg_set_key(cfg, "General", "ModulesDirectory", szPath);
/*get default temporary directoy */
cache_dir = gf_get_default_cache_directory();
if (cache_dir) {
gf_cfg_set_key(cfg, "General", "CacheDirectory", cache_dir);
gf_free(cache_dir);
}
gf_cfg_set_key(cfg, "Compositor", "Raster2D", "GPAC 2D Raster");
gf_cfg_set_key(cfg, "Audio", "ForceConfig", "yes");
gf_cfg_set_key(cfg, "Audio", "NumBuffers", "2");
gf_cfg_set_key(cfg, "Audio", "TotalDuration", "120");
gf_cfg_set_key(cfg, "Audio", "DisableNotification", "no");
/*Setup font engine to FreeType by default, and locate TrueType font directory on the system*/
gf_cfg_set_key(cfg, "FontEngine", "FontReader", "ft_font");
gf_cfg_set_key(cfg, "FontEngine", "RescanFonts", "yes");
#if defined(_WIN32_WCE)
/*FIXME - is this true on all WinCE systems??*/
strcpy(szPath, "\\Windows");
#elif defined(WIN32)
GetWindowsDirectory((char*)szPath, MAX_PATH);
if (szPath[strlen((char*)szPath)-1] != '\\') strcat((char*)szPath, "\\");
strcat((char *)szPath, "Fonts");
#elif defined(__APPLE__)
#ifdef GPAC_IPHONE
strcpy(szPath, "/System/Library/Fonts/Cache");
#else
strcpy(szPath, "/Library/Fonts");
#endif
#else
strcpy(szPath, "/usr/share/fonts/truetype/");
#endif
gf_cfg_set_key(cfg, "FontEngine", "FontDirectory", szPath);
gf_cfg_set_key(cfg, "Downloader", "CleanCache", "yes");
gf_cfg_set_key(cfg, "Compositor", "AntiAlias", "All");
gf_cfg_set_key(cfg, "Compositor", "FrameRate", "30");
/*use power-of-2 emulation in OpenGL if no rectangular texture extension*/
gf_cfg_set_key(cfg, "Compositor", "EmulatePOW2", "yes");
gf_cfg_set_key(cfg, "Compositor", "ScalableZoom", "yes");
#if defined(_WIN32_WCE)
gf_cfg_set_key(cfg, "Video", "DriverName", "GAPI Video Output");
#elif defined(WIN32)
gf_cfg_set_key(cfg, "Video", "DriverName", "DirectX Video Output");
#elif defined(__DARWIN__) || defined(__APPLE__)
gf_cfg_set_key(cfg, "Video", "DriverName", "SDL Video Output");
#else
gf_cfg_set_key(cfg, "Video", "DriverName", "X11 Video Output");
gf_cfg_set_key(cfg, "Audio", "DriverName", "SDL Audio Output");
#endif
gf_cfg_set_key(cfg, "Video", "SwitchResolution", "no");
gf_cfg_set_key(cfg, "Video", "HardwareMemory", "Auto");
gf_cfg_set_key(cfg, "Network", "AutoReconfigUDP", "yes");
gf_cfg_set_key(cfg, "Network", "UDPTimeout", "10000");
gf_cfg_set_key(cfg, "Network", "BufferLength", "3000");
/*locate GUI*/
if ( get_default_install_path(szPath, GF_PATH_GUI) ) {
sprintf(gui_path, "%s%cgui.bt", szPath, GF_PATH_SEPARATOR);
f = fopen(gui_path, "rt");
if (f) {
fclose(f);
gf_cfg_set_key(cfg, "General", "StartupFile", gui_path);
}
}
/*store and reload*/
gf_cfg_del(cfg);
return gf_cfg_new(file_path, CFG_FILE_NAME);
}