/** * 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, FA_LOAD_ERRBUF(errbuf, errlen), 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; }
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; }
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; }
JSBool js_get_descriptor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { char pdesc[PATH_MAX]; char *pe; buf_t *b; 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"); b = fa_load(pdesc, FA_LOAD_ERRBUF(errbuf, sizeof(errbuf)), NULL); if (b == 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(buf_cstr(b), &json_to_jsapi, cx, errbuf, sizeof(errbuf)); buf_release(b); *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, 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; }
static int gmefile_scandir(fa_protocol_t *fap, 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, FA_LOAD_ERRBUF(errbuf, errlen), 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_PROBED_CONTENTS; 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; }
/** * 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, FA_LOAD_ERRBUF(errbuf, errlen), 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, "tracks"); 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 > PLAYINFO_AUDIO_PLAY_THRESHOLD) { registered_play = 1; playinfo_register_play(url0, 1); } 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; }
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); } }
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; }
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", 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; } realityFragmentProgram *fp = b->b_ptr; RSX_TRACE("Loaded fragment program %s", url); RSX_TRACE(" 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>"; RSX_TRACE(" 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>"; RSX_TRACE(" Attribute %s @ 0x%x", name, attributes[i].index); } int offset = rsx_alloc(fp->num_insn * 16, 256); uint32_t *buf = rsx_to_ppu(offset); RSX_TRACE(" 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); RSX_TRACE(" 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) RSX_TRACE(" Texture %d via unit %d", i, rfp->rfp_texunit[i]); } return rfp; }