GLuint
glw_compile_shader(const char *url, int type)
{
char *src;
GLint v, len;
GLuint s;
char log[4096];
if((src = fa_load(url, NULL, NULL, log, sizeof(log), NULL)) == NULL) {
TRACE(TRACE_ERROR, "glw", "Unable to load shader %s -- %s",
url, log);
return 0;
}
s = glCreateShader(type);
glShaderSource(s, 1, (const char **)&src, NULL);
glCompileShader(s);
glGetShaderInfoLog(s, sizeof(log), &len, log);
glGetShaderiv(s, GL_COMPILE_STATUS, &v);
free(src);
if(!v) {
TRACE(TRACE_ERROR, "GLW", "Unable to compile shader %s", url);
TRACE(TRACE_ERROR, "GLW", "%s", log);
return 0;
}
return s;
}
static GLuint
glw_compile_shader(const char *path, int type, glw_root_t *gr)
{
GLint v, len;
GLuint s;
char log[4096];
buf_t *b;
if((b = fa_load(path,
FA_LOAD_VPATHS(gr->gr_vpaths),
FA_LOAD_ERRBUF(log, sizeof(log)),
NULL)) == NULL) {
TRACE(TRACE_ERROR, "glw", "Unable to load shader %s -- %s",
path, log);
return 0;
}
b = buf_make_writable(b);
char *src = buf_str(b);
s = glCreateShader(type);
glShaderSource(s, 1, (const char **)&src, NULL);
glCompileShader(s);
glGetShaderInfoLog(s, sizeof(log), &len, log);
glGetShaderiv(s, GL_COMPILE_STATUS, &v);
buf_release(b);
if(!v) {
TRACE(TRACE_ERROR, "GLW", "Unable to compile shader %s", path);
TRACE(TRACE_ERROR, "GLW", "%s", log);
return 0;
}
return s;
}
/**
* Load a view file and do lexographical parsing
*
* Returns pointer to last token, or NULL if an error occured.
* If an error occured 'ei' will be filled with data
*/
token_t *
glw_view_load1(glw_root_t *gr, rstr_t *url, errorinfo_t *ei, token_t *prev,
int may_unlock)
{
token_t *last;
char errbuf[256];
rstr_t *p = fa_absolute_path(url, prev->file);
if(may_unlock)
glw_unlock(gr);
buf_t *b = fa_load(rstr_get(p),
FA_LOAD_VPATHS(gr->gr_vpaths),
FA_LOAD_ERRBUF(errbuf, sizeof(errbuf)),
NULL);
if(may_unlock)
glw_lock(gr);
if(b == NULL) {
snprintf(ei->error, sizeof(ei->error), "Unable to open \"%s\" -- %s",
rstr_get(p), errbuf);
snprintf(ei->file, sizeof(ei->file), "%s", rstr_get(prev->file));
ei->line = prev->line;
rstr_release(p);
return NULL;
}
last = glw_view_lexer(gr, buf_cstr(b), ei, p, prev);
buf_release(b);
rstr_release(p);
return last;
}
static event_t *
be_gmeplayer_play(const char *url0, media_pipe_t *mp,
char *errbuf, size_t errlen, int hold,
const char *mimetype)
{
event_t *e;
char *url, *p;
int track;
url0 += strlen("gmeplayer:");
url = mystrdupa(url0);
p = strrchr(url, '/');
if(p == NULL) {
snprintf(errbuf, errlen, "Invalid filename");
return NULL;
}
*p++= 0;
track = atoi(p) - 1;
buf_t *b;
if((b = fa_load(url, NULL, errbuf, errlen, NULL, 0, NULL, NULL)) == NULL)
return NULL;
e = fa_gme_playfile_internal(mp, b->b_ptr, b->b_size,
errbuf, errlen, hold, track, url0);
buf_release(b);
return e;
}
JSBool
js_get_descriptor(JSContext *cx, JSObject *obj,
uintN argc, jsval *argv, jsval *rval)
{
char pdesc[PATH_MAX];
char *pe, *desc;
char errbuf[128];
JSObject *o;
js_plugin_t *jsp = JS_GetPrivate(cx, obj);
snprintf(pdesc, sizeof(pdesc),"%s", jsp->jsp_url);
pe = strrchr(pdesc, '/');
if (pe == NULL)
return JS_FALSE;
snprintf(pe + 1, sizeof(pdesc) - (pe - pdesc), "plugin.json");
desc = fa_load(pdesc, NULL, NULL, errbuf, sizeof(errbuf),
NULL, 0, NULL, NULL);
if (desc == NULL) {
TRACE(TRACE_ERROR, "JS", "Unable to read %s -- %s", pdesc, errbuf);
return JS_FALSE;
}
if (!JS_EnterLocalRootScope(cx))
return JS_FALSE;
o = json_deserialize(desc, &json_to_jsapi, cx, errbuf, sizeof(errbuf));
free(desc);
*rval = OBJECT_TO_JSVAL(o);
JS_LeaveLocalRootScope(cx);
return JS_TRUE;
}
/**
* Load entire image into memory using fileaccess load method.
* Faster than open+read+close.
*/
static pixmap_t *
fa_imageloader2(const char *url, const char **vpaths,
char *errbuf, size_t errlen)
{
uint8_t *p;
size_t size;
meminfo_t mi;
pixmap_type_t fmt;
int width = -1, height = -1, orientation = 0;
if((p = fa_load(url, &size, vpaths, errbuf, errlen, NULL)) == NULL)
return NULL;
mi.data = p;
mi.size = size;
/* Probe format */
if((p[6] == 'J' && p[7] == 'F' && p[8] == 'I' && p[9] == 'F') ||
(p[6] == 'E' && p[7] == 'x' && p[8] == 'i' && p[9] == 'f')) {
jpeginfo_t ji;
if(jpeg_info(&ji, jpeginfo_mem_reader, &mi,
JPEG_INFO_DIMENSIONS | JPEG_INFO_ORIENTATION,
p, size, errbuf, errlen)) {
free(p);
return NULL;
}
fmt = PIXMAP_JPEG;
width = ji.ji_width;
height = ji.ji_height;
orientation = ji.ji_orientation;
jpeg_info_clear(&ji);
} else if(!memcmp(pngsig, p, 8)) {
fmt = PIXMAP_PNG;
} else if(!memcmp(gif87sig, p, sizeof(gif87sig)) ||
!memcmp(gif89sig, p, sizeof(gif89sig))) {
fmt = PIXMAP_GIF;
} else {
snprintf(errbuf, errlen, "%s: unknown format", url);
free(p);
return NULL;
}
pixmap_t *pm = pixmap_alloc_coded(p, size, fmt);
pm->pm_width = width;
pm->pm_height = height;
pm->pm_orientation = orientation;
free(p);
return pm;
}
static htsmsg_t *
tmdb_load_movie_cast(const char *lookup_id)
{
char url[300];
char errbuf[256];
buf_t *result;
snprintf(url, sizeof(url), "http://api.themoviedb.org/3/movie/%s/casts",
lookup_id);
retry:
tmdb_check_rate_limit();
int http_response_code = 0;
struct http_header_list response_headers;
LIST_INIT(&response_headers);
result = fa_load(url,
FA_LOAD_ERRBUF(errbuf, sizeof(errbuf)),
FA_LOAD_QUERY_ARG("api_key", TMDB_APIKEY),
FA_LOAD_QUERY_ARG("language", getlang()),
FA_LOAD_RESPONSE_HEADERS(&response_headers),
FA_LOAD_PROTOCOL_CODE(&http_response_code),
FA_LOAD_FLAGS(FA_COMPRESSION),
NULL);
if(result == NULL) {
if(http_response_code == 429) {
tmdb_handle_rate_limit(&response_headers);
goto retry;
}
http_headers_free(&response_headers);
TRACE(TRACE_INFO, "TMDB", "Load error %s", errbuf);
return NULL;
}
http_headers_free(&response_headers);
htsmsg_t *doc = htsmsg_json_deserialize2(buf_cstr(result),
errbuf, sizeof(errbuf));
if(doc == NULL) {
TRACE(TRACE_ERROR, "TMDB", "Got bad JSON from %s -- %s", url, errbuf);
}
buf_release(result);
return doc;
}
/**
* Load entire image into memory using fileaccess load method.
* Faster than open+read+close.
*/
static image_t *
fa_imageloader2(const char *url, const char **vpaths,
char *errbuf, size_t errlen, int *cache_control,
cancellable_t *c)
{
buf_t *buf;
buf = fa_load(url,
FA_LOAD_VPATHS(vpaths),
FA_LOAD_ERRBUF(errbuf, errlen),
FA_LOAD_CACHE_CONTROL(cache_control),
FA_LOAD_CANCELLABLE(c),
FA_LOAD_FLAGS(FA_CONTENT_ON_ERROR),
NULL);
if(buf == NULL || buf == NOT_MODIFIED)
return (image_t *)buf;
image_t *img = fa_imageloader_buf(buf, errbuf, errlen);
buf_release(buf);
return img;
}
static int
tmdb_configure(void)
{
hts_mutex_lock(&tmdb_mutex);
if(!tmdb_configured) {
buf_t *result;
char errbuf[256];
result = fa_load("http://api.themoviedb.org/3/configuration",
FA_LOAD_ERRBUF(errbuf, sizeof(errbuf)),
FA_LOAD_QUERY_ARG("api_key", TMDB_APIKEY),
FA_LOAD_QUERY_ARG("language", getlang()),
FA_LOAD_FLAGS(FA_COMPRESSION | FA_IMPORTANT),
NULL);
if(result == NULL) {
TRACE(TRACE_INFO, "TMDB", "Unable to get configuration -- %s", errbuf);
goto done;
}
htsmsg_t *doc = htsmsg_json_deserialize2(buf_cstr(result),
errbuf, sizeof(errbuf));
buf_release(result);
if(doc == NULL) {
TRACE(TRACE_ERROR, "TMDB", "Got bad JSON from config -- %s", errbuf);
goto done;
}
tmdb_parse_config(doc);
htsmsg_release(doc);
tmdb_configured = 1;
}
done:
hts_mutex_unlock(&tmdb_mutex);
return !tmdb_configured;
}
/**
* Load a file using the 'glw_rawloader' method
*
* Returns pointer to last token, or NULL if an error occured.
* If an error occured 'ei' will be filled with data
*
*/
token_t *
glw_view_load1(glw_root_t *gr, rstr_t *url, errorinfo_t *ei, token_t *prev)
{
char *src;
token_t *last;
char errbuf[256];
rstr_t *p = fa_absolute_path(url, prev->file);
src = fa_load(rstr_get(p), NULL, gr->gr_vpaths,
errbuf, sizeof(errbuf), NULL, 0, NULL, NULL);
if(src == NULL) {
snprintf(ei->error, sizeof(ei->error), "Unable to open \"%s\" -- %s",
rstr_get(p), errbuf);
snprintf(ei->file, sizeof(ei->file), "%s", rstr_get(prev->file));
ei->line = prev->line;
rstr_release(p);
return NULL;
}
last = lexer(gr, src, ei, p, prev);
free(src);
rstr_release(p);
return last;
}
/**
* Play given track.
*
* We only expect this to be called from the playqueue system.
*/
static event_t *
be_sid2player_play(const char *url0, media_pipe_t *mp,
char *errbuf, size_t errlen, int hold,
const char *mimetype)
{
media_queue_t *mq = &mp->mp_audio;
char *url, *p;
int sample = 0;
media_buf_t *mb = NULL;
event_t *e;
int subsong;
int registered_play = 0;
void *player;
url0 += strlen("sidplayer:");
url = mystrdupa(url0);
p = strrchr(url, '/');
if(p == NULL) {
snprintf(errbuf, errlen, "Invalid filename");
return NULL;
}
*p++= 0;
subsong = atoi(p);
buf_t *b;
if((b = fa_load(url, NULL, errbuf, errlen, NULL, 0,
NULL, NULL)) == NULL)
return NULL;
player = sidcxx_load(b->b_ptr, b->b_size, subsong, errbuf, errlen);
buf_release(b);
if(player == NULL)
return NULL;
mp_set_playstatus_by_hold(mp, hold, NULL);
mp->mp_audio.mq_stream = 0;
mp_configure(mp, MP_PLAY_CAPS_PAUSE, MP_BUFFER_NONE, 0);
mp_become_primary(mp);
while(1) {
if(mb == NULL) {
mb = media_buf_alloc_unlocked(mp, sizeof(int16_t) * CHUNK_SIZE * 2);
mb->mb_data_type = MB_AUDIO;
mb->mb_channels = 2;
mb->mb_rate = 44100;
mb->mb_pts = sample * 1000000LL / mb->mb_rate;
mb->mb_drive_clock = 1;
if(!registered_play && mb->mb_pts > METADB_AUDIO_PLAY_THRESHOLD) {
registered_play = 1;
metadb_register_play(url0, 1, CONTENT_AUDIO);
}
sample += CHUNK_SIZE;
int16_t *samples = mb->mb_data;
sidcxx_play(player, samples,
CHUNK_SIZE * sizeof(int16_t) * mb->mb_channels);
// Crossmix 25%
int i, l, r, L, R;
for(i = 0; i < CHUNK_SIZE; i++) {
l = samples[i * 2 + 0];
r = samples[i * 2 + 1];
L = 3 * l + r * 2;
R = 3 * r + l * 2;
L = L / 4;
R = R / 4;
if(L > 32767)
L = 32767;
if(L < -32768)
L = -32768;
if(R > 32767)
R = 32767;
if(R < -32768)
R = -32768;
samples[i * 2 + 0] = L;
samples[i * 2 + 1] = R;
}
}
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_action(e, ACTION_SKIP_BACKWARD) ||
event_is_action(e, ACTION_SKIP_FORWARD) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
sidcxx_stop(player);
return e;
}
static rsx_vp_t *
load_vp(const char *url)
{
char errmsg[100];
realityVertexProgram *vp;
int i;
const char *name;
if((vp = fa_load(url, NULL, NULL, errmsg, sizeof(errmsg), NULL)) == NULL) {
TRACE(TRACE_ERROR, "glw", "Unable to load shader %s -- %s\n",
url, log);
return NULL;
}
TRACE(TRACE_INFO, "glw", "Loaded Vertex program %s", url);
TRACE(TRACE_INFO, "glw", " input mask: %x",
realityVertexProgramGetInputMask(vp));
TRACE(TRACE_INFO, "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_INFO, "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_INFO, "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_amount = vp_get_vector_const(vp, "u_blur_amount");
TRACE(TRACE_INFO, "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_INFO, "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 *url)
{
char errmsg[100];
realityFragmentProgram *fp;
int i;
const char *name;
if((fp = fa_load(url, NULL, NULL, errmsg, sizeof(errmsg), NULL)) == NULL) {
TRACE(TRACE_ERROR, "glw", "Unable to load shader %s -- %s\n",
url, log);
return NULL;
}
TRACE(TRACE_INFO, "glw", "Loaded fragment program %s", url);
TRACE(TRACE_INFO, "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_INFO, "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_INFO, "glw", " Attribute %s @ 0x%x",
name, attributes[i].index);
}
int offset = rsx_alloc(gr, fp->num_insn * 16, 256);
uint32_t *buf = rsx_to_ppu(gr, offset);
TRACE(TRACE_INFO, "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_INFO, "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_INFO, "glw", " Texture %d via unit %d",
i, rfp->rfp_texunit[i]);
}
return rfp;
}
void
load_site_news(void)
{
#if ENABLE_WEBPOPUP
struct http_header_list response_headers;
buf_t *b;
char errbuf[512];
b = fa_load("https://movian.tv/projects/movian/news.json",
FA_LOAD_FLAGS(FA_DISABLE_AUTH | FA_COMPRESSION),
FA_LOAD_RESPONSE_HEADERS(&response_headers),
FA_LOAD_ERRBUF(errbuf, sizeof(errbuf)),
NULL);
if(b == NULL) {
TRACE(TRACE_DEBUG, "News", "Unable to load news -- %s", errbuf);
return;
}
const char *dateheader = http_header_get(&response_headers, "date");
if(dateheader == NULL) {
buf_release(b);
http_headers_free(&response_headers);
return;
}
dateheader = mystrdupa(dateheader);
http_headers_free(&response_headers);
htsmsg_t *newsinfo = htsmsg_store_load("sitenews");
time_t no_news_before;
if(newsinfo == NULL)
newsinfo = htsmsg_create_map();
no_news_before = htsmsg_get_u32_or_default(newsinfo, "nothingbefore", 0);
if(no_news_before == 0) {
if(http_ctime(&no_news_before, dateheader)) {
buf_release(b);
htsmsg_release(newsinfo);
return;
}
htsmsg_add_u32(newsinfo, "nothingbefore", no_news_before);
htsmsg_store_save(newsinfo, "sitenews");
htsmsg_release(newsinfo);
}
htsmsg_t *doc = htsmsg_json_deserialize(buf_cstr(b));
buf_release(b);
if(doc == NULL) {
return;
}
hts_mutex_lock(&news_mutex);
htsmsg_t *news = htsmsg_get_list(doc, "news");
if(news != NULL) {
htsmsg_field_t *f;
HTSMSG_FOREACH(f, news) {
htsmsg_t *entry;
if((entry = htsmsg_get_map_by_field(f)) == NULL)
continue;
const char *title = htsmsg_get_str(entry, "title");
const char *created_on = htsmsg_get_str(entry, "created_on");
int id = htsmsg_get_u32_or_default(entry, "id", 0);
if(created_on == NULL || title == NULL || id == 0)
continue;
time_t t;
if(parse_created_on_time(&t, created_on))
continue;
if(t < no_news_before)
continue;
char idstr[64];
snprintf(idstr, sizeof(idstr), "sitenews:%d", id);
prop_t *p = add_news_locked(idstr, title, NULL, "Read more", idstr);
if(p != NULL) {
prop_subscribe(PROP_SUB_TRACK_DESTROY,
PROP_TAG_CALLBACK, open_news, p,
PROP_TAG_ROOT, prop_create(p, "eventSink"),
PROP_TAG_MUTEX, &news_mutex,
NULL);
}
}
int
js_plugin_load(const char *id, const char *url, char *errbuf, size_t errlen)
{
char *sbuf;
size_t size;
JSContext *cx;
js_plugin_t *jsp;
JSObject *pobj, *gobj;
JSScript *s;
char path[PATH_MAX];
jsval val;
fa_handle_t *ref;
ref = fa_reference(url);
if((sbuf = fa_load(url, &size, NULL, errbuf, errlen, NULL)) == NULL) {
fa_unreference(ref);
return -1;
}
cx = js_newctx(err_reporter);
JS_BeginRequest(cx);
/* Remove any plugin with same URL */
LIST_FOREACH(jsp, &js_plugins, jsp_link)
if(!strcmp(jsp->jsp_id, id))
break;
if(jsp != NULL)
js_plugin_unload0(cx, jsp);
jsp = calloc(1, sizeof(js_plugin_t));
jsp->jsp_url = strdup(url);
jsp->jsp_id = strdup(id);
jsp->jsp_ref = ref;
LIST_INSERT_HEAD(&js_plugins, jsp, jsp_link);
gobj = JS_NewObject(cx, &global_class, NULL, NULL);
JS_InitStandardClasses(cx, gobj);
JS_DefineProperty(cx, gobj, "showtime", OBJECT_TO_JSVAL(showtimeobj),
NULL, NULL, JSPROP_READONLY | JSPROP_PERMANENT);
/* Plugin object */
pobj = JS_NewObject(cx, &plugin_class, NULL, gobj);
JS_AddNamedRoot(cx, &pobj, "plugin");
JS_SetPrivate(cx, pobj, jsp);
JS_DefineFunctions(cx, pobj, plugin_functions);
val = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, url));
JS_SetProperty(cx, pobj, "url", &val);
if(!fa_parent(path, sizeof(path), url)) {
val = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, path));
JS_SetProperty(cx, pobj, "path", &val);
}
JS_DefineProperty(cx, pobj, "URIRouting", BOOLEAN_TO_JSVAL(1),
NULL, jsp_setEnableURIRoute, JSPROP_PERMANENT);
jsp->jsp_enable_uri_routing = 1;
JS_DefineProperty(cx, pobj, "search", BOOLEAN_TO_JSVAL(1),
NULL, jsp_setEnableSearch, JSPROP_PERMANENT);
jsp->jsp_enable_search = 1;
jsp->jsp_protect_object = 1;
s = JS_CompileScript(cx, pobj, sbuf, size, url, 1);
free(sbuf);
if(s != NULL) {
JSObject *sobj = JS_NewScriptObject(cx, s);
jsval result;
JS_AddNamedRoot(cx, &sobj, "script");
JS_ExecuteScript(cx, pobj, s, &result);
JS_RemoveRoot(cx, &sobj);
}
JS_RemoveRoot(cx, &pobj);
JS_EndRequest(cx);
JS_GC(cx);
JS_DestroyContext(cx);
return 0;
}
static void
check_upgrade(int set_news)
{
char url[1024];
char *result;
htsmsg_t *json;
char errbuf[1024];
if(inhibit_checks)
return;
if(upgrade_track == NULL) {
prop_set_string(upgrade_error, "No release track specified");
goto err;
}
prop_set_string(upgrade_status, "checking");
TRACE(TRACE_DEBUG, "Upgrade", "Checking upgrades for %s-%s",
upgrade_track, archname);
snprintf(url, sizeof(url), "%s/%s-%s.json", ctrlbase, upgrade_track,
archname);
result = fa_load(url, NULL, NULL, errbuf, sizeof(errbuf),
NULL, 0, NULL, NULL);
if(result == NULL) {
prop_set_string(upgrade_error, errbuf);
err:
prop_set_string(upgrade_status, "checkError");
return;
}
json = htsmsg_json_deserialize(result);
free(result);
if(json == NULL) {
prop_set_string(upgrade_error, "Malformed JSON in repository");
goto err;
}
// Find an artifact for us
const char *dlurl = NULL;
const char *sha1 = NULL;
int dlsize = 0;
const char *ver;
htsmsg_t *artifacts = htsmsg_get_list(json, "artifacts");
if(artifacts != NULL) {
htsmsg_field_t *f;
HTSMSG_FOREACH(f, artifacts) {
htsmsg_t *a;
if((a = htsmsg_get_map_by_field(f)) == NULL)
continue;
const char *type = htsmsg_get_str(a, "type");
if(type == NULL || strcmp(artifact_type, type))
continue;
dlurl = htsmsg_get_str(a, "url");
sha1 = htsmsg_get_str(a, "sha1");
dlsize = htsmsg_get_u32_or_default(a, "size", 0);
break;
}
static int
gmefile_scandir(fa_dir_t *fd, const char *url, char *errbuf, size_t errlen)
{
char *p, *fpath = mystrdupa(url);
char name[32];
char turl[URL_MAX];
int tracks, i;
fa_dir_entry_t *fde;
const char *title;
Music_Emu *emu;
gme_info_t *info;
gme_err_t err;
if((p = strrchr(fpath, '/')) == NULL) {
snprintf(errbuf, errlen, "Invalid filename");
return -1;
}
*p = 0;
buf_t *b;
if((b = fa_load(fpath, NULL, errbuf, errlen, NULL,
0, NULL, NULL)) == NULL)
return -1;
err = gme_open_data(b->b_ptr, b->b_size, &emu, gme_info_only);
buf_release(b);
if(err != NULL)
return 0;
tracks = gme_track_count(emu);
for(i = 0; i < tracks; i++) {
snprintf(turl, sizeof(turl), "gmeplayer:%s/%d", fpath, i + 1);
err = gme_track_info(emu, &info, i);
if(err == NULL && info->song[0]) {
title = info->song;
} else {
snprintf(name, sizeof(name), "Track %02d", i + 1);
title = name;
}
fde = fa_dir_add(fd, turl, title, CONTENT_AUDIO);
fde->fde_probestatus = FDE_PROBE_DEEP;
fde->fde_metadata = prop_create_root("metadata");
prop_set_string(prop_create(fde->fde_metadata, "title"), title);
if(err == NULL) {
if(info->game[0])
prop_set_string(prop_create(fde->fde_metadata, "album"), info->game);
if(info->author[0])
prop_set_string(prop_create(fde->fde_metadata, "artist"), info->author);
prop_set_float(prop_create(fde->fde_metadata, "duration"),
info->play_length / 1000.0);
gme_free_info(info);
}
}
gme_delete(emu);
return 0;
}
/**
* Load entire image into memory using fileaccess load method.
* Faster than open+read+close.
*/
static pixmap_t *
fa_imageloader2(const char *url, const char **vpaths,
char *errbuf, size_t errlen, int *cache_control,
fa_load_cb_t *cb, void *opaque)
{
uint8_t *p;
size_t size;
jpeg_meminfo_t mi;
pixmap_type_t fmt;
int width = -1, height = -1, orientation = 0;
p = fa_load(url, &size, vpaths, errbuf, errlen, cache_control, 0, cb, opaque);
if(p == NULL || p == NOT_MODIFIED)
return (pixmap_t *)p;
mi.data = p;
mi.size = size;
if(size < 16)
goto bad;
/* Probe format */
if((p[6] == 'J' && p[7] == 'F' && p[8] == 'I' && p[9] == 'F') ||
(p[6] == 'E' && p[7] == 'x' && p[8] == 'i' && p[9] == 'f')) {
jpeginfo_t ji;
if(jpeg_info(&ji, jpeginfo_mem_reader, &mi,
JPEG_INFO_DIMENSIONS | JPEG_INFO_ORIENTATION,
p, size, errbuf, errlen)) {
free(p);
return NULL;
}
fmt = PIXMAP_JPEG;
width = ji.ji_width;
height = ji.ji_height;
orientation = ji.ji_orientation;
jpeg_info_clear(&ji);
} else if(!memcmp(pngsig, p, 8)) {
fmt = PIXMAP_PNG;
} else if(!memcmp(gif87sig, p, sizeof(gif87sig)) ||
!memcmp(gif89sig, p, sizeof(gif89sig))) {
fmt = PIXMAP_GIF;
} else if(!memcmp(svgsig1, p, sizeof(svgsig1)) ||
!memcmp(svgsig2, p, sizeof(svgsig2))) {
fmt = PIXMAP_SVG;
} else {
bad:
snprintf(errbuf, errlen, "Unknown format");
free(p);
return NULL;
}
pixmap_t *pm = pixmap_alloc_coded(p, size, fmt);
if(pm != NULL) {
pm->pm_width = width;
pm->pm_height = height;
pm->pm_orientation = orientation;
} else {
snprintf(errbuf, errlen, "Out of memory");
}
free(p);
return pm;
}
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",
app_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;
RSX_TRACE("Loaded Vertex program %s", url);
RSX_TRACE(" input mask: %x",
realityVertexProgramGetInputMask(vp));
RSX_TRACE(" 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>";
RSX_TRACE(" 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>";
RSX_TRACE(" 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");
RSX_TRACE("%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");
RSX_TRACE("%d %d %d",
rvp->rvp_a_position, rvp->rvp_a_color, rvp->rvp_a_texcoord);
return rvp;
}
/**
* Load entire image into memory using fileaccess load method.
* Faster than open+read+close.
*/
static pixmap_t *
fa_imageloader2(const char *url, const char **vpaths,
char *errbuf, size_t errlen, int *cache_control,
cancellable_t *c)
{
buf_t *buf;
jpeg_meminfo_t mi;
pixmap_type_t fmt;
int width = -1, height = -1, orientation = 0;
buf = fa_load(url,
FA_LOAD_VPATHS(vpaths),
FA_LOAD_ERRBUF(errbuf, errlen),
FA_LOAD_CACHE_CONTROL(cache_control),
FA_LOAD_CANCELLABLE(c),
NULL);
if(buf == NULL || buf == NOT_MODIFIED)
return (pixmap_t *)buf;
const uint8_t *p = buf_c8(buf);
mi.data = p;
mi.size = buf->b_size;
if(buf->b_size < 16)
goto bad;
/* Probe format */
if((p[6] == 'J' && p[7] == 'F' && p[8] == 'I' && p[9] == 'F') ||
(p[6] == 'E' && p[7] == 'x' && p[8] == 'i' && p[9] == 'f')) {
jpeginfo_t ji;
if(jpeg_info(&ji, jpeginfo_mem_reader, &mi,
JPEG_INFO_DIMENSIONS | JPEG_INFO_ORIENTATION,
p, buf->b_size, errbuf, errlen)) {
buf_release(buf);
return NULL;
}
fmt = PIXMAP_JPEG;
width = ji.ji_width;
height = ji.ji_height;
orientation = ji.ji_orientation;
jpeg_info_clear(&ji);
} else if(!memcmp(pngsig, p, 8)) {
fmt = PIXMAP_PNG;
} else if(!memcmp(gif87sig, p, sizeof(gif87sig)) ||
!memcmp(gif89sig, p, sizeof(gif89sig))) {
fmt = PIXMAP_GIF;
} else if(!memcmp(svgsig1, p, sizeof(svgsig1)) ||
!memcmp(svgsig2, p, sizeof(svgsig2))) {
fmt = PIXMAP_SVG;
} else {
bad:
snprintf(errbuf, errlen, "Unknown format");
buf_release(buf);
return NULL;
}
pixmap_t *pm = pixmap_alloc_coded(p, buf->b_size, fmt);
if(pm != NULL) {
pm->pm_width = width;
pm->pm_height = height;
pm->pm_orientation = orientation;
} else {
snprintf(errbuf, errlen, "Out of memory");
}
buf_release(buf);
return pm;
}
/**
* Probe file by checking its header
*
* pb is guaranteed to point to at least 256 bytes of valid data
*/
static int
fa_probe_header(metadata_t *md, const char *url, fa_handle_t *fh,
const char *filename)
{
uint16_t flags;
uint8_t buf[256];
if(fa_read(fh, buf, sizeof(buf)) != sizeof(buf))
return 0;
if(!memcmp(buf, "SNES-SPC700 Sound File Data", 27)) {
fa_probe_spc(md, buf, filename);
md->md_contenttype = CONTENT_AUDIO;
return 1;
}
if(!memcmp(buf, "PSID", 4) || !memcmp(buf, "RSID", 4)) {
fa_probe_psid(md, buf);
md->md_contenttype = CONTENT_ALBUM;
metdata_set_redirect(md, "sidfile://%s/", url);
return 1;
}
if(buf[0] == 'R' && buf[1] == 'a' && buf[2] == 'r' && buf[3] == '!' &&
buf[4] == 0x1a && buf[5] == 0x07 && buf[6] == 0x0 && buf[9] == 0x73) {
flags = buf[10] | buf[11] << 8;
if((flags & 0x101) == 1) {
/* Don't include slave volumes */
md->md_contenttype = CONTENT_UNKNOWN;
return 1;
}
metdata_set_redirect(md, "rar://%s", url);
md->md_contenttype = CONTENT_ARCHIVE;
return 1;
}
if(buf[0] == 0x50 && buf[1] == 0x4b && buf[2] == 0x03 && buf[3] == 0x04) {
char path[256];
char *buf;
snprintf(path, sizeof(path), "zip://%s/plugin.json", url);
buf = fa_load(path, NULL, NULL, NULL, 0, NULL, 0, NULL, NULL);
if(buf != NULL) {
htsmsg_t *json = htsmsg_json_deserialize(buf);
free(buf);
if(json != NULL) {
const char *title = htsmsg_get_str(json, "title");
if(title != NULL && htsmsg_get_str(json, "id") != NULL &&
htsmsg_get_str(json, "type") != NULL) {
md->md_title = rstr_alloc(title);
md->md_contenttype = CONTENT_PLUGIN;
htsmsg_destroy(json);
return 1;
}
htsmsg_destroy(json);
}
}
metdata_set_redirect(md, "zip://%s", url);
md->md_contenttype = CONTENT_ARCHIVE;
return 1;
}
#if 0
if(!strncasecmp((char *)buf, "[playlist]", 10)) {
/* Playlist */
fa_probe_playlist(md, url, buf, sizeof(buf));
md->md_contenttype = CONTENT_PLAYLIST;
return 1;
}
#endif
if((buf[6] == 'J' && buf[7] == 'F' && buf[8] == 'I' && buf[9] == 'F') ||
(buf[6] == 'E' && buf[7] == 'x' && buf[8] == 'i' && buf[9] == 'f')) {
/* JPEG image */
md->md_contenttype = CONTENT_IMAGE;
fa_probe_exif(md, url, buf, fh); // Try to get more info
return 1;
}
if(!memcmp(buf, "<showtimeplaylist", strlen("<showtimeplaylist"))) {
/* Ugly playlist thing (see fa_video.c) */
md->md_contenttype = CONTENT_VIDEO;
return 1;
}
if(!memcmp(buf, pngsig, 8)) {
/* PNG */
md->md_contenttype = CONTENT_IMAGE;
return 1;
}
if(!memcmp(buf, gifsig, sizeof(gifsig))) {
/* GIF */
md->md_contenttype = CONTENT_IMAGE;
return 1;
}
if(buf[0] == '%' && buf[1] == 'P' && buf[2] == 'D' && buf[3] == 'F') {
md->md_contenttype = CONTENT_UNKNOWN;
return 1;
}
if(!memcmp(buf, ttfsig, sizeof(ttfsig)) ||
!memcmp(buf, otfsig, sizeof(otfsig))) {
/* TTF or OTF */
md->md_contenttype = CONTENT_FONT;
return 1;
}
return 0;
}
