void
load_syms(void)
{
char sympath[256];
char errbuf[256];
snprintf(sympath, sizeof(sympath), "%s/showtime.syms", showtime_dataroot());
my_trace("sympath: %s\n", sympath);
fa_handle_t *fh = fa_open(sympath, errbuf, sizeof(errbuf));
if(fh == NULL) {
my_trace("Unable to open symbol file %s -- %s",
sympath, errbuf);
return;
}
int size = fa_fsize(fh);
char *buf = halloc(size + 1);
int r = fa_read(fh, buf, size);
if(r != size) {
my_trace("Unable to read %d bytes", size);
hfree(buf, size+1);
} else {
buf[size] = 0;
my_trace("Loaded symbol table %d bytes to %p",
size, buf);
symbuf = buf;
}
fa_close(fh);
}
static void
album_set_art(void *opaque, const char *str)
{
GdkPixbuf *pb;
char path[PATH_MAX];
if(str != NULL) {
gu_pixbuf_async_set(str, 256, -1, GTK_OBJECT(opaque));
return;
}
snprintf(path, sizeof(path), "%s/guresources/cd.png", showtime_dataroot());
pb = gu_pixbuf_get_sync(path, 256, -1);
g_object_set(G_OBJECT(opaque), "pixbuf", pb, NULL);
if(pb != NULL)
g_object_unref(G_OBJECT(pb));
}
int
glw_init(glw_root_t *gr, const char *instance)
{
char skinbuf[PATH_MAX];
const char *skin = gconf.skin;
if(skin == NULL) {
snprintf(skinbuf, sizeof(skinbuf),
"%s/glwskins/"SHOWTIME_GLW_DEFAULT_SKIN, showtime_dataroot());
skin = skinbuf;
}
hts_mutex_init(&gr->gr_mutex);
gr->gr_courier = prop_courier_create_passive();
gr->gr_token_pool = pool_create("glwtokens", sizeof(token_t), POOL_ZERO_MEM);
gr->gr_clone_pool = pool_create("glwclone", sizeof(glw_clone_t),
POOL_ZERO_MEM);
gr->gr_skin = strdup(skin);
gr->gr_vpaths[0] = "skin";
gr->gr_vpaths[1] = gr->gr_skin;
gr->gr_vpaths[2] = NULL;
gr->gr_font_domain = freetype_get_context();
glw_text_bitmap_init(gr);
glw_init_settings(gr, instance);
TAILQ_INIT(&gr->gr_destroyer_queue);
glw_tex_init(gr);
gr->gr_framerate = 60;
gr->gr_frameduration = 1000000 / gr->gr_framerate;
gr->gr_ui_start = showtime_get_ts();
return 0;
}
int
glw_init(glw_root_t *gr)
{
char skinbuf[PATH_MAX];
const char *skin = gconf.skin;
if(gr->gr_prop_dispatcher == NULL)
gr->gr_prop_dispatcher = &prop_courier_poll_timed;
gr->gr_prop_maxtime = -1;
assert(glw_settings.gs_settings != NULL);
if(prop_set_parent(gr->gr_prop_ui, prop_get_global()))
abort();
if(prop_set_parent(gr->gr_prop_nav, prop_get_global()))
abort();
if(skin == NULL) {
snprintf(skinbuf, sizeof(skinbuf),
"%s/glwskins/"SHOWTIME_GLW_DEFAULT_SKIN, showtime_dataroot());
skin = skinbuf;
}
hts_mutex_init(&gr->gr_mutex);
gr->gr_courier = prop_courier_create_passive();
gr->gr_token_pool = pool_create("glwtokens", sizeof(token_t), POOL_ZERO_MEM);
gr->gr_clone_pool = pool_create("glwclone", sizeof(glw_clone_t),
POOL_ZERO_MEM);
gr->gr_skin = strdup(skin);
gr->gr_vpaths[0] = "skin";
gr->gr_vpaths[1] = gr->gr_skin;
gr->gr_vpaths[2] = NULL;
gr->gr_font_domain = freetype_get_context();
glw_text_bitmap_init(gr);
prop_setv(gr->gr_prop_ui, "skin", "path", NULL,
PROP_SET_STRING, gr->gr_skin);
gr->gr_pointer_visible = prop_create(gr->gr_prop_ui, "pointerVisible");
gr->gr_is_fullscreen = prop_create(gr->gr_prop_ui, "fullscreen");
gr->gr_screensaver_active = prop_create(gr->gr_prop_ui, "screensaverActive");
gr->gr_prop_width = prop_create(gr->gr_prop_ui, "width");
gr->gr_prop_height = prop_create(gr->gr_prop_ui, "height");
prop_set_int(gr->gr_screensaver_active, 0);
gr->gr_evsub =
prop_subscribe(0,
PROP_TAG_CALLBACK, glw_eventsink, gr,
PROP_TAG_NAME("ui", "eventSink"),
PROP_TAG_ROOT, gr->gr_prop_ui,
PROP_TAG_COURIER, gr->gr_courier,
NULL);
TAILQ_INIT(&gr->gr_destroyer_queue);
glw_tex_init(gr);
gr->gr_framerate = 60;
gr->gr_frameduration = 1000000 / gr->gr_framerate;
gr->gr_ui_start = showtime_get_ts();
gr->gr_open_osk = glw_osk_open;
return 0;
}
/**
* Consume 'locate' (updatedb) output results and feed into search results.
*/
static void
fa_locate_searcher (fa_search_t *fas)
{
char buf[PATH_MAX];
char iconpath[PATH_MAX];
regex_t preg;
prop_t *entries[2] = {NULL, NULL};
prop_t *nodes[2] = {NULL, NULL};
int t, i;
if (fa_create_paths_regex(&preg) == -1)
return fa_search_destroy(fas);
snprintf(iconpath, sizeof(iconpath), "%s/resources/fileaccess/fs_icon.png",
showtime_dataroot());
/* Consume 'locate' results. */
while (1) {
char url[PATH_MAX+strlen("file://")];
prop_t *p, *metadata;
const char *type;
struct fa_stat fs;
int ctype;
prop_courier_poll(fas->fas_pc);
if (!fas->fas_run)
break;
if (!fgets(buf, sizeof(buf), fas->fas_fp))
break;
if (!*buf || *buf == '\n')
continue;
buf[strlen(buf)-1] = '\0';
/* Ignore dot-files/dirs. */
if (strstr(buf, "/."))
continue;
if (regexec(&preg, buf, 0, NULL, 0)) {
TRACE(TRACE_DEBUG, "FA", "Searcher: %s: \"%s\" not matching regex: SKIP",
fas->fas_query, buf);
continue;
}
/* Probe media type.
*
* FIXME: We might want to hide matching files under a matching directory,
* or the other way around.
* E..g:
* Metallica/
* 01-Metallica-Song1.mp3
* 02-Metallica-Song1.mp3
*
* Should either hide Metallica/ or 01-Metallica-Song1..2..
* But that would require the 'locate' output to be sorted, is it?
* Its also problematic where a sub set of the tracks matches
* the directory name. Then what should we show?.
*
* There is also the problem with:
* Scrubs S01E01/
* Scrubs_s01e01.avi
* Sample/
* Scrubs_s01e01_sample.avi
* Which will show as four separate entries, less than optimal.
*
* For now we provide all matches, directories and files,
* matching on the entire path (not just the basename).
*/
snprintf(url, sizeof(url), "file://%s", buf);
if (fa_stat(url, &fs, NULL, 0))
continue;
metadata = prop_create_root("metadata");
if(fs.fs_type == CONTENT_DIR) {
ctype = CONTENT_DIR;
prop_set_string(prop_create(metadata, "title"), basename(buf));
} else {
metadata_t *md = fa_probe_metadata(url, NULL, 0);
if(md != NULL) {
ctype = md->md_contenttype;
metadata_destroy(md);
} else {
ctype = CONTENT_UNKNOWN;
}
}
if (ctype == CONTENT_UNKNOWN)
continue;
switch(ctype) {
case CONTENT_AUDIO:
t = 0;
break;
case CONTENT_VIDEO:
case CONTENT_DVD:
t = 1;
break;
default:
continue;
}
if(nodes[t] == NULL)
if(search_class_create(fas->fas_nodes, &nodes[t], &entries[t],
t ? "Local video files" : "Local audio files",
iconpath))
break;
prop_add_int(entries[t], 1);
if ((type = content2type(ctype)) == NULL)
continue; /* Unlikely.. */
p = prop_create_root(NULL);
if (prop_set_parent(metadata, p))
prop_destroy(metadata);
prop_set_string(prop_create(p, "url"), url);
prop_set_string(prop_create(p, "type"), type);
if(prop_set_parent(p, nodes[t])) {
prop_destroy(p);
break;
}
}
for(i = 0; i < 2; i++) {
if(nodes[i])
prop_ref_dec(nodes[i]);
if(entries[i])
prop_ref_dec(entries[i]);
}
TRACE(TRACE_DEBUG, "FA", "Searcher: %s: Done", fas->fas_query);
fa_search_destroy(fas);
regfree(&preg);
}
void
showtime_init(void)
{
int r;
hts_mutex_init(&gconf.state_mutex);
hts_cond_init(&gconf.state_cond, &gconf.state_mutex);
gconf.exit_code = 1;
unicode_init();
/* Initialize property tree */
prop_init();
init_global_info();
/* Initiailize logging */
trace_init();
/* Callout framework */
callout_init();
/* Initialize htsmsg_store() */
htsmsg_store_init();
/* Notification framework */
notifications_init();
/* Initialize settings */
settings_init();
TRACE(TRACE_DEBUG, "core", "Loading resources from %s", showtime_dataroot());
/* Try to create cache path */
if(gconf.cache_path != NULL &&
(r = makedirs(gconf.cache_path)) != 0) {
TRACE(TRACE_ERROR, "cache", "Unable to create cache path %s -- %s",
gconf.cache_path, strerror(r));
gconf.cache_path = NULL;
}
/* Initialize sqlite3 */
db_init();
/* Initializte blob cache */
blobcache_init();
/* Try to create settings path */
if(gconf.persistent_path != NULL &&
(r = makedirs(gconf.persistent_path)) != 0) {
TRACE(TRACE_ERROR, "settings",
"Unable to create path for persistent storage %s -- %s",
gconf.persistent_path, strerror(r));
gconf.persistent_path = NULL;
}
/* Metadata init */
metadata_init();
metadb_init();
kvstore_init();
/* Metadata decoration init */
decoration_init();
/* Initialize keyring */
keyring_init();
#if ENABLE_LIBAV
/* Initialize libavcodec & libavformat */
av_lockmgr_register(fflockmgr);
av_log_set_callback(fflog);
av_register_all();
TRACE(TRACE_INFO, "libav", LIBAVFORMAT_IDENT", "LIBAVCODEC_IDENT", "LIBAVUTIL_IDENT);
#endif
/* Freetype */
#if ENABLE_LIBFREETYPE
freetype_init();
rasterizer_ft_init();
#endif
#if ENABLE_GLW
glw_settings_init();
#endif
fontstash_init();
/* Global keymapper */
keymapper_init();
/* Initialize media subsystem */
media_init();
/* Service handling */
service_init();
/* Initialize backend content handlers */
backend_init();
/* Initialize navigator */
nav_init();
/* Initialize audio subsystem */
audio_init();
/* Initialize plugin manager */
plugins_init(gconf.devplugin);
/* Start software installer thread (plugins, upgrade, etc) */
hts_thread_create_detached("swinst", swthread, NULL, THREAD_PRIO_LOW);
/* Internationalization */
i18n_init();
/* Video settings */
video_settings_init();
if(gconf.load_jsfile)
js_load(gconf.load_jsfile);
/* Various interprocess communication stuff (D-Bus on Linux, etc) */
init_group(INIT_GROUP_IPC);
/* Service discovery. Must be after ipc_init() (d-bus and threads, etc) */
if(!gconf.disable_sd)
sd_init();
/* Initialize various external APIs */
init_group(INIT_GROUP_API);
/* HTTP server and UPNP */
#if ENABLE_HTTPSERVER
http_server_init();
if(!gconf.disable_upnp)
upnp_init();
#endif
runcontrol_init();
}
static rsx_vp_t *
load_vp(const char *filename)
{
char errmsg[100];
buf_t *b;
int i;
const char *name;
char url[512];
snprintf(url, sizeof(url), "%s/src/ui/glw/rsx/%s",
showtime_dataroot(), filename);
if((b = fa_load(url, FA_LOAD_ERRBUF(errmsg, sizeof(errmsg)),
NULL)) == NULL) {
TRACE(TRACE_ERROR, "glw", "Unable to load shader %s -- %s\n",
url, log);
return NULL;
}
realityVertexProgram *vp = b->b_ptr;
TRACE(TRACE_DEBUG, "glw", "Loaded Vertex program %s", url);
TRACE(TRACE_DEBUG, "glw", " input mask: %x",
realityVertexProgramGetInputMask(vp));
TRACE(TRACE_DEBUG, "glw", " output mask: %x",
realityVertexProgramGetOutputMask(vp));
realityProgramConst *constants;
constants = realityVertexProgramGetConstants(vp);
for(i = 0; i < vp->num_const; i++) {
if(constants[i].name_off)
name = ((char*)vp)+constants[i].name_off;
else
name = "<anon>";
TRACE(TRACE_DEBUG, "glw", " Constant %s @ 0x%x [%f, %f, %f, %f]",
name,
constants[i].index,
constants[i].values[0].f,
constants[i].values[1].f,
constants[i].values[2].f,
constants[i].values[3].f);
}
realityProgramAttrib *attributes;
attributes = realityVertexProgramGetAttributes(vp);
for(i = 0; i < vp->num_attrib; i++) {
if(attributes[i].name_off)
name = ((char*)vp)+attributes[i].name_off;
else
name = "<anon>";
TRACE(TRACE_DEBUG, "glw", " Attribute %s @ 0x%x",
name, attributes[i].index);
}
rsx_vp_t *rvp = calloc(1, sizeof(rsx_vp_t));
rvp->rvp_binary = vp;
rvp->rvp_u_modelview = realityVertexProgramGetConstant(vp, "u_modelview");
rvp->rvp_u_color = vp_get_vector_const(vp, "u_color");
rvp->rvp_u_color_offset = vp_get_vector_const(vp, "u_color_offset");
rvp->rvp_u_blur = vp_get_vector_const(vp, "u_blur");
TRACE(TRACE_DEBUG, "glw", "%d %d", rvp->rvp_u_modelview, rvp->rvp_u_color);
rvp->rvp_a_position = realityVertexProgramGetAttribute(vp, "a_position");
rvp->rvp_a_color = realityVertexProgramGetAttribute(vp, "a_color");
rvp->rvp_a_texcoord = realityVertexProgramGetAttribute(vp, "a_texcoord");
TRACE(TRACE_DEBUG, "glw", "%d %d %d",
rvp->rvp_a_position, rvp->rvp_a_color, rvp->rvp_a_texcoord);
return rvp;
}
static rsx_fp_t *
load_fp(glw_root_t *gr, const char *filename)
{
char errmsg[100];
buf_t *b;
int i;
const char *name;
char url[512];
snprintf(url, sizeof(url), "%s/src/ui/glw/rsx/%s",
showtime_dataroot(), filename);
if((b = fa_load(url, FA_LOAD_ERRBUF(errmsg, sizeof(errmsg)),
NULL)) == NULL) {
TRACE(TRACE_ERROR, "glw", "Unable to load shader %s -- %s\n",
url, log);
return NULL;
}
realityFragmentProgram *fp = b->b_ptr;
TRACE(TRACE_DEBUG, "glw", "Loaded fragment program %s", url);
TRACE(TRACE_DEBUG, "glw", " num regs: %d", fp->num_regs);
realityProgramConst *constants;
constants = realityFragmentProgramGetConsts(fp);
for(i = 0; i < fp->num_const; i++) {
if(constants[i].name_off)
name = ((char*)fp)+constants[i].name_off;
else
name = "<anon>";
TRACE(TRACE_DEBUG, "glw", " Constant %s @ 0x%x [%f, %f, %f, %f] type=%d",
name,
constants[i].index,
constants[i].values[0].f,
constants[i].values[1].f,
constants[i].values[2].f,
constants[i].values[3].f,
constants[i].type);
}
realityProgramAttrib *attributes;
attributes = realityFragmentProgramGetAttribs(fp);
for(i = 0; i < fp->num_attrib; i++) {
if(attributes[i].name_off)
name = ((char*)fp)+attributes[i].name_off;
else
name = "<anon>";
TRACE(TRACE_DEBUG, "glw", " Attribute %s @ 0x%x",
name, attributes[i].index);
}
int offset = rsx_alloc(fp->num_insn * 16, 256);
uint32_t *buf = rsx_to_ppu(offset);
TRACE(TRACE_DEBUG, "glw", " PPU location: 0x%08x %d bytes",
buf, fp->num_insn * 16);
const uint32_t *src = (uint32_t *)((char*)fp + fp->ucode_off);
memcpy(buf, src, fp->num_insn * 16);
TRACE(TRACE_DEBUG, "glw", " RSX location: 0x%08x", offset);
rsx_fp_t *rfp = calloc(1, sizeof(rsx_fp_t));
rfp->rfp_binary = fp;
rfp->rfp_rsx_location = offset;
rfp->rfp_u_color =
realityFragmentProgramGetConst(fp, "u_color");
rfp->rfp_u_color_matrix =
realityFragmentProgramGetConst(fp, "u_colormtx");
rfp->rfp_u_blend =
realityFragmentProgramGetConst(fp, "u_blend");
for(i = 0; i < 6; i++) {
char name[8];
snprintf(name, sizeof(name), "u_t%d", i);
rfp->rfp_texunit[i] =
realityFragmentProgramGetAttrib(fp, name);
if(rfp->rfp_texunit[i] != -1)
TRACE(TRACE_DEBUG, "glw", " Texture %d via unit %d",
i, rfp->rfp_texunit[i]);
}
return rfp;
}
