// search for specified scene file and load it
// return 1 on success, 0 on failure
u8 files_load_scene_name(const char* name) {
char path[64] = "";
FILE* f;
u8 ret = 1;
// strcpy(path, workingDir);
strcat(path, name);
printf("\r\n attempting to open scene file; path: %s", path);
f = fopen(path, "r");
if(f == NULL) {
printf("\r\n couldn't find scene file; path: %s", path);
return 0;
}
fread(sceneData, sizeof(sceneData_t), 1, f);
fclose(f);
scene_read_buf();
printf("\r\n loaded scene buffer, search DSP:");
ret = files_load_dsp_name(sceneData->desc.moduleName);
return ret;
}
/* // not used
static void fake_fseek(void* fp, u32 loc) {
u32 n = 0;
u8 dum;
while(n < loc) {
dum = fl_fgetc(fp);
n++;
}
}
*/
// fread: no size arg
static void fake_fread(volatile u8* dst, u32 size, void* fp) {
u32 n = 0;
while(n < size) {
*dst = fl_fgetc(fp);
n++;
dst++;
}
}
// strip space from the end of a string
static void strip_space(char* str, u8 len) {
u8 i;
for( i=(len-1); i>0; i-- ) {
if(str[i] == '\0') { continue; }
else if(str[i] == ' ') { str[i] = '\0'; }
else { break; }
}
}
// strip extension from the end of a string
static void strip_ext(char* str) {
int i;
int dotpos = -1;
i = strlen(str);
while(i > 0) {
--i;
if(str[i] == '.') {
dotpos = i;
break;
}
}
if(dotpos >= 0) {
str[dotpos] = '\0';
}
}
//---------------------------
//------------- extern defs
void files_init(void) {
// scan directories
print_dbg("\r\n BEES file_init, scanning directories..");
list_scan(&dspList, DSP_PATH);
list_scan(&sceneList, SCENES_PATH);
list_scan(&scalerList, SCALERS_PATH);
}
////////////////////////
//// modules
// return filename for DSP given index in list
const volatile char* files_get_dsp_name(u8 idx) {
return list_get_name(&dspList, idx);
}
// load a blacfkin executable by index */
u8 files_load_dsp(u8 idx) {
// app_notify("loading dsp...");
return files_load_dsp_name((const char*)files_get_dsp_name(idx));
}
// set current state of system from global RAM buffer
void scene_read_buf(void) {
/// pointer to serial blob
const u8* src = (u8*)&(sceneData->pickle);
int i;
// param count reported from dsp
// u32 paramsReported;
//// TEST
char moduleName[MODULE_NAME_LEN];
ModuleVersion moduleVersion;
////
app_pause();
// store current mod name in scene desc
// memcpy(modName, sceneData->desc.moduleName, MODULE_NAME_LEN);
// read scene name
for(i=0; i<SCENE_NAME_LEN; i++) {
sceneData->desc.sceneName[i] = *src;
src++;
}
// read bees version
sceneData->desc.beesVersion.min = *src;
src++;
sceneData->desc.beesVersion.maj = *src;
src++;
src = unpickle_16(src, &(sceneData->desc.beesVersion.rev));
// read module name
// target is temp module name buffer, so we can run a comparison
for(i=0; i<MODULE_NAME_LEN; i++) {
moduleName[i] = *src;
src++;
}
print_dbg("\r\n unpickled module name: ");
print_dbg(moduleName);
// read module version
sceneData->desc.moduleVersion.min = *src;
src++;
sceneData->desc.moduleVersion.maj = *src;
src++;
src = unpickle_16(src, &(sceneData->desc.moduleVersion.rev));
print_dbg("\r\n unpickled module version: ");
print_dbg_ulong(sceneData->desc.moduleVersion.maj);
print_dbg(".");
print_dbg_ulong(sceneData->desc.moduleVersion.min);
print_dbg(".");
print_dbg_ulong(sceneData->desc.moduleVersion.rev);
print_dbg("\r\n checking against module name from scene data: ");
print_dbg(sceneData->desc.moduleName);
if(strcmp(moduleName, sceneData->desc.moduleName) == 0) {
print_dbg("\r\n requested module name is already loaded; skip DSP reboot.");
// skip DSP load
/// FIXME: should check module version too
} else {
strcpy(sceneData->desc.moduleName, moduleName);
render_boot("loading DSP module:");
render_boot(sceneData->desc.moduleName);
///// load the DSP now!
render_boot("loading module from sdcard");
print_dbg("\r\n loading module from card, filename: ");
print_dbg(sceneData->desc.moduleName);
files_load_dsp_name(sceneData->desc.moduleName);
render_boot("waiting for module init");
print_dbg("\r\n waiting for DSP init...");
bfin_wait_ready();
#if RELEASEBUILD==1
#else
// query module name / version
render_boot("querying module");
print_dbg("\r\n querying module name...");
bfin_get_module_name(moduleName);
print_dbg("\r\n querying module version...");
bfin_get_module_version(&moduleVersion);
print_dbg("\r\n received module name: ");
print_dbg((char*)moduleName);
print_dbg("\r\n received module version: ");
print_dbg_ulong(moduleVersion.maj);
print_dbg(".");
print_dbg_ulong(moduleVersion.min);
print_dbg(".");
print_dbg_ulong(moduleVersion.rev);
#ifdef BEEKEEP
#else
// store in scene data
render_boot("storing module version");
sceneData->desc.moduleVersion.maj = moduleVersion.maj;
sceneData->desc.moduleVersion.min = moduleVersion.min;
sceneData->desc.moduleVersion.rev = moduleVersion.rev;
strcpy(sceneData->desc.moduleName, (const char*)moduleName);
#endif
#endif
} // load-module case
app_pause();
/// don't have to do this b/c net_unpickle will deinit anyways
/*
print_dbg("\r\n clearing operator list...");
net_clear_user_ops();
*/
//// FIXME: use .dsc
/*
print_dbg("\r\n reporting DSP parameters...");
paramsReported = net_report_params();
*/
/// FIXME:
/// check the module version and warn if different!
// there could also be a check here for mismatched parameter list.
// unpickle network
render_boot("reading network");
print_dbg("\r\n unpickling network for scene recall...");
src = net_unpickle(src);
// unpickle presets
render_boot("reading presets");
print_dbg("\r\n unpickling presets for scene recall...");
src = presets_unpickle(src);
render_boot("scene data stored in RAM");
print_dbg("\r\n copied stored network and presets to RAM ");
/* for(i=0; i<net->numParams; i++) { */
/* print_dbg("\r\n param "); */
/* print_dbg_ulong(i); */
/* print_dbg(" : "); */
/* print_dbg(net->params[i].desc.label); */
/* print_dbg(" ; val "); */
/* print_dbg_hex((u32)net->params[i].data.value); */
/* } */
render_boot("waiting for DSP");
bfin_wait_ready();
// update bfin parameters
// if(net->numParams != paramsReported) {
// print_dbg("\r\n !!!!!! WARNING ! param count from scene does not match reported count from DSP");
// render_boot("warning: param count mismatch!");
// } else {
#ifdef BEEKEEP
#else
render_boot("sending param values");
net_send_params();
#endif
// }
print_dbg("\r\n sent new parameter values");
delay_ms(5);
render_boot("enabling audio"); // enable audio processing
bfin_enable();
app_resume();
}
// this is called from main event handler
u8 app_launch(u8 firstrun) {
print_dbg("\r\n launching app with firstrun: ");
print_dbg_ulong(firstrun);
// net_print();
render_boot("BEES");
render_boot(versionString);
if(firstrun) {
render_boot("launching app, first run");
print_dbg("\r\n first run, writing nonvolatile data...");
///... write param scaler data
// this is done at firstrun instead of being linked statically,
// so that users can tune scaler data offline without recompiling
render_boot("init param scaling data...");
flash_init_scaler_data();
print_dbg("\r\n first run, try and load default DSP");
render_boot("launching default DSP...");
files_load_dsp_name("aleph-waves.ldr");
render_boot("waiting for DSP init...");
bfin_wait_ready();
// print_dbg(" requesting param report...");
render_boot("requesting DSP params");
net_report_params();
// print_dbg("\r\n enable DSP audio...");
render_boot("enabling audio");
bfin_enable();
render_boot("writing default dsp to flash...");
// files_store_default_dsp_name("aleph-waves.ldr");
} else {
app_pause();
print_dbg("\r\n booting default ldr from flash... ");
render_boot("booting DSP from flash");
// flash_read_ldr();
bfin_load_buf();
print_dbg("\r\n DSP booted, waiting to query params...");
render_boot("waiting for DSP init...");
/// blackfin should clear ready pin ASAP on boot.
/// but give it a moment to accomplish that.
delay_ms(2);
bfin_wait_ready();
print_dbg(" requesting param report...");
render_boot("requesting DSP params");
net_report_params();
print_dbg("\r\n enable DSP audio...");
render_boot("enabling audio");
bfin_enable();
print_dbg("\r\n reading default scene... ");
render_boot("reading default scene");
scene_read_default();
app_resume();
}
// init pages (fill graphics buffers)
print_dbg("\r\n pages_init...");
pages_init();
print_dbg("\r\n play_init...");
play_init();
// enable timers
print_dbg("\r\n enable app timers...");
render_boot("enabling app timers...");
init_app_timers();
// pull up power control pin, enabling soft-powerdown
gpio_set_gpio_pin(POWER_CTL_PIN);
// assign app event handlers
print_dbg("\r\n assigning handlers ");
render_boot("assigning UI handlers...");
assign_bees_event_handlers();
// update page rendering and handlers
pages_reselect();
// start in play mode
pages_toggle_play();
return 1;
}
// set current state of system from global RAM buffer
void scene_read_buf(void) {
s8 modName[MODULE_NAME_LEN];
const u8* src = (u8*)&(sceneData->pickle);
/// FIXME: we really should be using this comparison
// s8 neq = 0;
// u32 i;
app_pause();
// store current mod name in scene desc
memcpy(modName, sceneData->desc.moduleName, MODULE_NAME_LEN);
///// always load:
print_dbg("\r\n loading module name: ");
print_dbg(sceneData->desc.moduleName);
files_load_dsp_name(sceneData->desc.moduleName);
// }
bfin_wait_ready();
net_clear_user_ops();
net_report_params();
// unpickle network
print_dbg("\r\n unpickling network for scene recall...");
src = net_unpickle(src);
// unpickle presets
print_dbg("\r\n unpickling presets for scene recall...");
src = presets_unpickle(src);
print_dbg("\r\n copied stored network and presets to RAM ");
/* for(i=0; i<net->numParams; i++) { */
/* print_dbg("\r\n param "); */
/* print_dbg_ulong(i); */
/* print_dbg(" : "); */
/* print_dbg(net->params[i].desc.label); */
/* print_dbg(" ; val "); */
/* print_dbg_hex((u32)net->params[i].data.value); */
/* } */
// compare module name
//// is strncmp f*****g with us??
/// neq = strncmp((const char*)modName, (const char*)sceneData->desc.moduleName, MODULE_NAME_LEN);
// if(neq) {
// load bfin module if it doesn't match the current scene desc
//...
bfin_wait_ready();
//// well let's try it, actually that would explain some things..
// delay_ms(10);
// update bfin parameters
net_send_params();
print_dbg("\r\n sent new params");
delay_ms(5);
// enable audio processing
bfin_enable();
app_resume();
}
// this is called from main event handler
u8 app_launch(u8 firstrun) {
print_dbg("\r\n launching app with firstrun: ");
print_dbg_ulong(firstrun);
// net_print();
render_boot("BEES");
render_boot(versionString);
while (!sd_mmc_spi_mem_check()) {
render_boot("waiting for SD card...");
}
if(firstrun) {
render_boot("launching app, first run");
print_dbg("\r\n first run, writing nonvolatile data...");
///... write param scaler data
// this is done at firstrun instead of being linked statically,
// so that users can tune scaler data offline without recompiling
render_boot("init param scaling data...");
flash_init_scaler_data();
print_dbg("\r\n first run, try and load default DSP");
render_boot("launching default DSP");
//// startup using default DSP name
files_load_dsp_name(DEFAULT_LDR);
render_boot("waiting for DSP init...");
bfin_wait_ready();
// print_dbg("\r\n enable DSP audio...");
render_boot("enabling audio");
bfin_enable();
} else {
app_pause();
/// blackfin should clear ready pin ASAP on boot.
/// but give it a moment to accomplish that.
delay_ms(2);
/// read the default scene from sd card
/// this also attempts to load associated .ldr
render_boot("reading default scene");
print_dbg("\r\n loading default scene. current module name from sceneData: ");
print_dbg(sceneData->desc.moduleName);
scene_read_default();
delay_ms(2);
app_resume();
}
// init pages (fill graphics buffers)
render_boot("initializing gfx");
print_dbg("\r\n pages_init...");
pages_init();
print_dbg("\r\n play_init...");
play_init();
// enable timers
print_dbg("\r\n enable app timers...");
render_boot("enabling app timers");
init_app_timers();
// pull up power control pin, enabling soft-powerdown
// gpio_set_gpio_pin(POWER_CTL_PIN);
// assign app event handlers
print_dbg("\r\n assigning handlers... ");
render_boot("assigning UI handlers");
assign_bees_event_handlers();
// update page rendering and handlers...
pages_reselect();
// start in play mode if not firstrun
if(!firstrun) pages_toggle_play();
return 1;
}
