char *
emphasis_cover_db_search(const char *artist, const char *album)
{
char *config_path;
char *cover_path = NULL;
char *key;
int size;
void *cover = NULL;
Eet_File *ef;
asprintf(&config_path, "%s/.e/apps/emphasis/cover.eet", getenv("HOME"));
ef = eet_open(config_path, EET_FILE_MODE_READ);
asprintf(&key, "/%s/%s", artist, album);
cover_path = eet_read(ef, key, &size);
eet_close(ef);
if (!cover_path)
{
cover = emphasis_cover_file_get_from_amazon(artist, album, &size);
cover_path = emphasis_cover_db_add(artist, album, cover, size);
}
if (cover_path && !strcmp(cover_path, "not found"))
{
free(cover_path);
cover_path = NULL;
}
free(config_path);
free(key);
return cover_path;
}
void _show_hs(void *data, Evas_Object *obj, void *event_info)
{
elm_genlist_clear(highscores_genlist);
if(!_itc)
{
_itc = elm_genlist_item_class_new();
_itc->item_style = "default";
_itc->func.text_get = _item_label_get;
_itc->func.content_get = NULL;
_itc->func.state_get = NULL;
_itc->func.del = NULL;
}
Eet_File *eef = eet_open(RESULTS_FILE, EET_FILE_MODE_READ);
int game_type = (int)(uintptr_t)(data);
int j = 0;
for(; j < 10; ++j)
{
char buf[50];
int *res;
sprintf(buf, "%d%d", game_type, j);
res = eet_read(eef, buf, NULL);
if(res && res[0] != -1)
{
elm_genlist_item_append(highscores_genlist, _itc, res, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
}
}
//free(res); //MEMORY LEAK?
eet_close(eef);
}
static CNP_ITEM *storage_item_load(StorageData *sd, int index)
{
if (!sd->ef)
{
DMSG("eet_file is NULL\n");
return EINA_FALSE;
}
if (index >= STORAGE_ITEM_CNT)
return NULL;
indexType copyTable[STORAGE_ITEM_CNT];
memcpy(copyTable, sd->indexTable, sizeof(copyTable));
int i;
for (i = 0; i < index; i++)
{
int maxIndex = getMaxIndex(copyTable, STORAGE_ITEM_CNT);
if (maxIndex == -1)
maxIndex = 0;
copyTable[maxIndex] = 0;
}
char datakey[10];
snprintf(datakey, 10, STORAGE_KEY_FORMAT, i);
int read_size;
char *read_data = eet_read(sd->ef, datakey, &read_size);
if (!read_data)
{
DMSG("read failed index: %d\n", index);
return NULL;
}
CNP_ITEM *item = CALLOC(1, sizeof(CNP_ITEM));
if (item)
{
char *data = read_data + sizeof(int);
int data_size = read_size - sizeof(int);
char *buf = CALLOC(1, data_size);
if (!buf)
{
FREE(item);
return NULL;
}
item->type_index = ((int *)read_data)[0];
memcpy(buf, data, data_size);
item->data = buf;
item->len = data_size;
}
return item;
}
int
main(void)
{
Eet_File *ef;
char *ret;
int size;
char *entries[] =
{
"Entry 1",
"Big text string here compared to others",
"Eet is cool"
};
eet_init();
// blindly open an file for output and write strings with their NUL char
ef = eet_open("test.eet", EET_FILE_MODE_WRITE);
eet_write(ef, "Entry 1", entries[0], strlen(entries[0]) + 1, 0);
eet_write(ef, "Entry 2", entries[1], strlen(entries[1]) + 1, 1);
eet_write(ef, "Entry 3", entries[2], strlen(entries[2]) + 1, 0);
eet_close(ef);
// open the file again and blindly get the entries we wrote
ef = eet_open("test.eet", EET_FILE_MODE_READ);
ret = eet_read(ef, "Entry 1", &size);
printf("%s\n", ret);
free(ret);
ret = eet_read(ef, "Entry 2", &size);
printf("%s\n", ret);
free(ret);
ret = eet_read(ef, "Entry 3", &size);
printf("%s\n", ret);
free(ret);
eet_close(ef);
eet_shutdown();
}
void
fill_tree_with_db(Etk_Tree *tree)
{
int num, i;
char **entries;
char *cover_path;
Etk_Tree_Col *col;
Etk_Tree_Row *row;
Eet_File *ef;
char *cover_db_path;
asprintf(&cover_db_path, "%s/.e/apps/emphasis/cover.eet", getenv("HOME"));
ef = eet_open(cover_db_path, EET_FILE_MODE_READ);
if (!ef)
{
fprintf(stderr, "Can't open %s\n", cover_db_path);
free(cover_db_path);
exit(-1);
}
col = etk_tree_col_new(tree, "/artist/album", 0, 0.0);
etk_tree_col_model_add(col, etk_tree_model_text_new());
etk_tree_build(tree);
etk_tree_freeze(tree);
entries = eet_list(ef, "*", &num);
for (i=0; i<num; i++)
{
cover_path = eet_read(ef, entries[i], NULL);
row = etk_tree_row_append(tree, NULL, col, entries[i], NULL);
if (strcmp("not found", cover_path))
{
etk_tree_row_data_set(row, cover_path);
}
else
{
etk_tree_row_data_set(row, NULL);
}
}
eet_close(ef);
free(cover_db_path);
etk_tree_col_sort_set(etk_tree_nth_col_get(tree, 0), tree_sort, NULL);
etk_tree_thaw(tree);
}
Ecore_Config_Type
_ecore_config_db_key_type_get(Ecore_Config_DB_File *db, const char *key)
{
char *data;
int size;
data = eet_read(db->ef, (char*)key, &size);
if (data)
{
if (size <= 2)
{
free(data);
return ECORE_CONFIG_NIL;
}
if (data[size - 1] != 0)
{
free(data);
return ECORE_CONFIG_NIL;
}
return (Ecore_Config_Type) data[0];
}
return ECORE_CONFIG_NIL;
}
static int
_evas_gl_common_shader_program_binary_init(Evas_GL_Program *p,
const char *pname,
Eet_File *ef)
{
int res = 0, num = 0, length = 0;
int *formats = NULL;
void *data = NULL;
GLint ok = 0;
if (!ef) return res;
data = eet_read(ef, pname, &length);
if ((!data) || (length <= 0)) goto finish;
glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &num);
if (num <= 0) goto finish;
formats = calloc(num, sizeof(int));
if (!formats) goto finish;
glGetIntegerv(GL_PROGRAM_BINARY_FORMATS, formats);
if (!formats[0]) goto finish;
p->prog = glCreateProgram();
#if 1
// TODO: invalid rendering error occurs when attempting to use a
// glProgramBinary. in order to render correctly we should create a dummy
// vertex shader.
p->vert = glCreateShader(GL_VERTEX_SHADER);
glAttachShader(p->prog, p->vert);
p->frag = glCreateShader(GL_FRAGMENT_SHADER);
glAttachShader(p->prog, p->frag);
#endif
glsym_glProgramBinary(p->prog, formats[0], data, length);
glBindAttribLocation(p->prog, SHAD_VERTEX, "vertex");
glBindAttribLocation(p->prog, SHAD_COLOR, "color");
glBindAttribLocation(p->prog, SHAD_TEXUV, "tex_coord");
glBindAttribLocation(p->prog, SHAD_TEXUV2, "tex_coord2");
glBindAttribLocation(p->prog, SHAD_TEXUV3, "tex_coord3");
glBindAttribLocation(p->prog, SHAD_TEXM, "tex_coordm");
glGetProgramiv(p->prog, GL_LINK_STATUS, &ok);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
if (!ok)
{
gl_compile_link_error(p->prog, "load a program object");
ERR("Abort load of program (%s)", pname);
goto finish;
}
res = 1;
finish:
if (formats) free(formats);
if (data) free(data);
if ((!res) && (p->prog))
{
glDeleteProgram(p->prog);
p->prog = 0;
}
return res;
}
int
_ecore_config_db_read(Ecore_Config_DB_File *db, const char *key)
{
char *data, *value;
int size;
Ecore_Config_Type type;
data = eet_read(db->ef, (char*)key, &size);
if (data)
{
int l;
char *prev_locale;
if (size <= 2)
{
free(data);
return 0;
}
if (data[size - 1] != 0)
{
free(data);
return 0;
}
/* "type" NIL 1242 NIL */
l = strlen(data);
if (l >= (size - 1))
{
free(data);
return 0;
}
type = data[0];
value = data + l + 1;
switch (type)
{
case ECORE_CONFIG_INT:
case ECORE_CONFIG_BLN:
{
int tmp;
prev_locale = setlocale(LC_NUMERIC, "C");
tmp = atoi(value);
if (prev_locale) setlocale(LC_NUMERIC, prev_locale);
ecore_config_typed_set(key, (void *)&tmp, type);
break;
}
case ECORE_CONFIG_FLT:
{
float tmp;
prev_locale = setlocale(LC_NUMERIC, "C");
tmp = atof(value);
if (prev_locale) setlocale(LC_NUMERIC, prev_locale);
ecore_config_typed_set(key, (void *)&tmp, type);
break;
}
case ECORE_CONFIG_RGB:
ecore_config_argbstr_set(key, value);
break;
case ECORE_CONFIG_STR:
case ECORE_CONFIG_THM:
ecore_config_typed_set(key, (void *)value, type);
break;
case ECORE_CONFIG_SCT:
INF("loading struct %s", key);
break;
default:
WRN("Type %d not handled", type);
}
free(data);
return 1;
}
return 0;
}
static Font_Source_Info *
_font_slave_source_load(const char *file, const char *name)
{
int error;
Font_Source_Info *fsi = calloc(1, sizeof(*fsi));
if (!name)
{
error = FT_New_Face(cserve2_ft_lib, file, 0, &(fsi->face));
if (error)
{
ERR("could not open font file: %s", file);
free(fsi);
return NULL;
}
}
else
{
Eet_File *ef;
void *fdata;
int fsize = 0;
ef = eet_open(file, EET_FILE_MODE_READ);
if (!ef)
{
ERR("failed to read eet: %s", file);
free(fsi);
return NULL;
}
fdata = eet_read(ef, name, &fsize);
eet_close(ef);
if (!fdata)
{
ERR("failed to read font from eet: %s:%s", file, name);
free(fsi);
return NULL;
}
fsi->data = fdata;
fsi->datasize = fsize;
error = FT_New_Memory_Face(cserve2_ft_lib, fsi->data, fsi->datasize,
0, &(fsi->face));
if (error)
{
ERR("failed to load font: %s:%s", file, name);
free(fsi->data);
free(fsi);
return NULL;
}
}
error = FT_Select_Charmap(fsi->face, ft_encoding_unicode);
if (error)
{
ERR("could not select unicode charmap for font: %s:%s", file, name);
FT_Done_Face(fsi->face);
free(fsi->data);
free(fsi);
return NULL;
}
fsi->orig_upem = fsi->face->units_per_EM;
fsi->current_size = 0;
fsi->current_dpi = 0;
return fsi;
}
static Evas_GL_Program *
_evas_gl_common_shader_program_binary_load(Eet_File *ef, unsigned int flags)
{
int num = 0, length = 0;
int *formats = NULL;
void *data = NULL;
char pname[32];
GLint ok = 0, prg, vtx = GL_NONE, frg = GL_NONE;
Evas_GL_Program *p = NULL;
Eina_Bool direct = 1;
if (!ef || !glsym_glProgramBinary) return NULL;
sprintf(pname, SHADER_PROG_NAME_FMT, flags);
data = (void *) eet_read_direct(ef, pname, &length);
if (!data)
{
data = eet_read(ef, pname, &length);
direct = 0;
}
if ((!data) || (length <= 0)) goto finish;
glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &num);
if (num <= 0) goto finish;
formats = calloc(num, sizeof(int));
if (!formats) goto finish;
glGetIntegerv(GL_PROGRAM_BINARY_FORMATS, formats);
if (!formats[0]) goto finish;
prg = glCreateProgram();
#if 1
// TODO: invalid rendering error occurs when attempting to use a
// glProgramBinary. in order to render correctly we should create a dummy
// vertex shader.
vtx = glCreateShader(GL_VERTEX_SHADER);
glAttachShader(prg, vtx);
frg = glCreateShader(GL_FRAGMENT_SHADER);
glAttachShader(prg, frg);
#endif
glsym_glProgramBinary(prg, formats[0], data, length);
_attributes_bind(prg);
glGetProgramiv(prg, GL_LINK_STATUS, &ok);
if (!ok)
{
gl_compile_link_error(prg, "load a program object", EINA_FALSE);
ERR("Abort load of program (%s)", pname);
glDeleteProgram(prg);
goto finish;
}
p = calloc(1, sizeof(*p));
p->flags = flags;
p->prog = prg;
p->reset = EINA_TRUE;
p->bin_saved = EINA_TRUE;
p->uniform.mvp = glGetUniformLocation(prg, "mvp");
p->uniform.rotation_id = glGetUniformLocation(prg, "rotation_id");
evas_gl_common_shader_textures_bind(p);
finish:
if (vtx) glDeleteShader(vtx);
if (frg) glDeleteShader(frg);
free(formats);
if (!direct) free(data);
return p;
}
/*
* (params[0] | (top of stack)) == filename
* params[1 | 0] == key
* params[2 | 1] == (cipher pass)
*/
static const Elixir_Loader_File *
_elixir_eet_request(int param, const char **params)
{
Elixir_Loader_File *result = NULL;
Elixir_Eet_Filename *top = NULL;
Elixir_Eet_Filename *lookup = NULL;
Eet_File *eet = NULL;
char *filename;
char *section = NULL;
char *compiled_key;
char *content = NULL;
char *compiled = NULL;
const char *key;
const char *cipher;
Eina_Bool free_compiled = EINA_FALSE;
Eina_Bool free_content = EINA_FALSE;
int content_length;
int compiled_length;
unsigned int i;
if (param < 1 || param > 3) return NULL;
cipher = NULL;
switch (param)
{
case 1:
if (stack && eina_array_count_get(stack) > 0)
{
top = eina_array_data_get(stack, eina_array_count_get(stack) - 1);
filename = top->filename;
key = params[0];
}
else
{
filename = (char*) params[0];
key = "elixir/main";
}
break;
case 2:
filename = (char*) params[0];
key = params[1];
break;
case 3:
filename = (char*) params[0];
key = params[1];
cipher = params[2];
break;
default:
return NULL;
}
filename = elixir_exe_canonicalize(filename);
if (!filename) return NULL;
section = strdup(key);
if (!section) goto on_error;
eet = eet_open(filename, EET_FILE_MODE_READ);
if (!eet) goto on_error;
/* Use a cache to prevent useless security check. */
lookup = eina_hash_find(cache, filename);
if (lookup && lookup->eet == eet)
{
eet_close(eet);
if (top != lookup)
{
eina_array_push(stack, lookup);
top = lookup;
}
eet = lookup->eet;
lru = eina_list_remove(lru, lookup);
}
else
{
/* Lookup is no longer valid, remove it from cache. */
if (lookup)
{
lru = eina_list_remove(lru, lookup);
eina_hash_del(cache, filename, lookup);
}
if (!_elixir_eet_security_check(eet)) goto on_error;
}
compiled_key = alloca(strlen(key) + 2);
snprintf(compiled_key, strlen(key) + 2, "%sx", key);
if (cipher)
{
free_content = EINA_TRUE;
content = eet_read_cipher(eet, key, &content_length, cipher);
if (!content) goto on_error;
compiled = eet_read_cipher(eet, compiled_key, &compiled_length, cipher);
}
else
{
content = (char*) eet_read_direct(eet, key, &content_length);
if (!content)
{
free_content = EINA_TRUE;
content = eet_read(eet, key, &content_length);
}
if (!content) goto on_error;
compiled = (char*) eet_read_direct(eet, compiled_key, &compiled_length);
if (!compiled)
{
free_compiled = EINA_TRUE;
compiled = eet_read(eet, compiled_key, &compiled_length);
}
}
if (memchr(content, '\0', content_length))
goto on_error;
if (compiled)
{
for (i = 0; i < sizeof (_jsx_header) / sizeof (_jsx_header[0]); ++i)
if (*(unsigned int*) compiled == _jsx_header[i])
break;
if (i == sizeof (_jsx_header) / sizeof (_jsx_header[0]))
if (free_compiled)
{
free(compiled);
free_compiled = EINA_FALSE;
compiled = NULL;
}
}
result = malloc(sizeof (Elixir_Loader_File));
if (!result) goto on_error;
result->content_length = content_length;
result->content = content;
result->free_content = free_content;
result->compiled_length = compiled_length;
result->compiled = compiled;
result->free_compiled = free_compiled;
/* Ref counting helper to find current open file. */
if (top)
{
top->reference++;
free(filename);
}
else
{
top = malloc(sizeof (Elixir_Eet_Filename) + strlen(filename));
if (!top) goto on_error;
top->reference = 1;
top->filename = filename;
top->eet = eet;
eina_array_push(stack, top);
eina_hash_add(cache, filename, top);
}
result->file = top;
result->section = section;
return result;
on_error:
if (result) free(result);
if (content && free_content) free(content);
if (compiled && free_compiled) free(compiled);
if (eet) eet_close(eet);
if (section) free(section);
free(filename);
return NULL;
}
