int fime_ship_init(void)
{
int err;
ship_obj = 0;
texid = -1;
MtxIdentity(mtx);
memset(&angle, 0, sizeof(angle));
ship_obj = (obj_driver_t *)driver_list_search(&obj_drivers,"bebop");
if (!ship_obj) {
ship_obj = (obj_driver_t *)driver_list_search(&obj_drivers,"spaceship1");
}
err = !ship_obj;
if (err) {
SDDEBUG("[fime] : No ship object\n");
}
texid = texture_get("fime_bordertile");
if (texid < 0) {
SDDEBUG("[fime] : No bordertex\n");
err = 1;
}
return -(!!err);
}
/* sndtstvorbis_stop()
*
* function to stop the current playback and set the thread back to
* STATUS_READY mode.
*/
static int sndtst_stop(void)
{
SDDEBUG(">> %s()\n", __FUNCTION__);
pcm_buffer_shutdown();
SDDEBUG("<< %s()\n", __FUNCTION__);
return 0;
}
static int specific_register(any_driver_t * driver)
{
int err = 0;
switch(driver->type) {
case INP_DRIVER:
{
inp_driver_t * d = (inp_driver_t *) driver;
d->id = filetype_add(filetype_major_add("music"),
driver->name, d->extensions);
SDDEBUG("Driver '%s' : filetype %d\n", driver->name, d->id);
} break;
case IMG_DRIVER:
{
img_driver_t * d = (img_driver_t *) driver;
/* Add to translator */
err = AddTranslator(d->translator);
if (!err) {
/* Add filetype. */
d->id = filetype_add(filetype_major_add("image"),
driver->name, d->extensions);
SDDEBUG("Driver '%s' : filetype %d\n", driver->name, d->id);
}
} break;
}
return err;
}
static int r_plugin_path_load(char *path, unsigned int level)
{
dirent_t *de;
int count = 0;
int fd = -1;
char *path_end = 0;
SDDEBUG(">> %s(%2d,[%s])\n", __FUNCTION__, level, path);
SDINDENT;
if (level == 0) {
goto error;
}
fd = fs_open(path, O_RDONLY | O_DIR);
if (fd<0) {
count = -1;
goto error;
}
path_end = path + strlen(path);
path_end[0] = '/';
path_end[1] = 0;
while (de = fs_readdir(fd), de) {
int type;
type = filetype_get(de->name, de->size);
/* SDDEBUG("[%s] : %04x\n", de->name, type); */
if (type == filetype_dir) {
int cnt;
strcpy(path_end+1, de->name);
cnt = r_plugin_path_load(path, level-1);
count += (cnt > 0) ? cnt : 0;
continue;
}
if (type != filetype_lef) {
continue;
}
strcpy(path_end+1, de->name);
count += plugin_load_and_register(path);
}
error:
if (fd>=0) {
fs_close(fd);
}
if (path_end) {
*path_end = 0;
}
SDUNINDENT;
SDDEBUG("<< %s(%2d,[%s]) = %d\n", __FUNCTION__, level, path, count);
return count;
}
static int shutdown(any_driver_t *d)
{
stop();
SDDEBUG("[sc68] : shutdown 68k\n");
shutdown_68K();
SDDEBUG("[sc68] : removing sc68 romdisk\n");
fs_rz_shutdown();
return 0;
}
int plugin_load_and_register(const char *fname)
{
lef_prog_t * lef;
any_driver_t *d, *driver, *nxt, *old;
int count = 0;
driver = plugin_load(fname);
if (!driver) {
return 0;
}
/* We can set the lef here since it is the same for all these drivers */
lef = (lef_prog_t *) driver->dll;
SDDEBUG("Scanning lef [%s] driver list\n", fname);
SDINDENT;
for (d=driver; d; d = nxt) {
driver_list_t *dl;
SDDEBUG("scan [%p %s]\n", d, d->name);
/* Save nxt here, It will be crashed by driver_list */
nxt = d->nxt;
dl = driver_list_which(d);
if (!dl) {
SDERROR("Unexpected plugin type !\n");
continue;
}
/* Remove driver with the same name if it exists. */
old = driver_list_search(dl, d->name);
if (old) {
SDDEBUG("Existing driver [%p %s %d]\n", old, old->name, old->count);
driver_list_unregister(dl, old);
SDDEBUG("List unregister [%p %s %d]\n", old, old->name, old->count);
driver_dereference(old); /* Becoz search add a reference. */
}
if (driver_list_register(dl, d)) {
SDERROR( "[%s] Init or Registration failed, removed\n", d->name);
/* $$$ Don't need anymore. */
/* remove_driver(dl, d); */
} else {
SDDEBUG("++ [%s] added to [%s]\n", d->name, dl->name);
++count;
}
}
SDUNINDENT;
/* Unreference original lef reference. */
lef_free(lef);
return count;
}
/** Shutdown driver list : $$$ ben : we need to do thing here !! */
void driver_list_shutdown(driver_list_t *dl)
{
if (dl) {
spinlock_lock(&dl->mutex);
SDDEBUG("[%s] : shutdown list [%s]\n", __FUNCTION__, dl->name);
if (dl->n) {
SDDEBUG("[%s] : %d remaining driver in [%s]\n",
__FUNCTION__, dl->n, dl->name);
}
}
}
/* Start playback (implies song load) */
static int sndtst_start(const char *fn, int track, playa_info_t *info)
{
int err = -1;
int i, frq;
float a, stp;
const float amp = 14000;
char tmp[128];
SDDEBUG("%s([%s])\n", fn);
SDINDENT;
frq = get_frq(fn);
pcm_current = 0;
pcm_count = 44100 / frq;
if (pcm_buffer_init(pcm_count, 0)) {
goto error;
}
for (i=0, a=0, stp=2.0*MF_PI/(float)pcm_count; i<pcm_count; i++, a += stp) {
pcm_buffer[i] = Sin(a) * amp;
}
playa_info_bits(info,16);
playa_info_stereo(info, 0); /* 1 = stereo ? BeN : yes that's it :) */
playa_info_frq(info,44100);
#if 0
playa_info_bps(info,4*44100);
playa_info_bytes(info,pcm_count*4); /* ? BeN: only for streaming,
but anyway if you want to set it :
x4 (x2:short x2:stereo */
playa_info_time(info, 100000);
#endif
playa_info_genre(info, "head-ache");
playa_info_comments(info, "What a nice sound , isn't it ?");
sprintf(tmp,"%dhz sinus generator", (int)frq);
playa_info_desc(info, tmp);
sprintf(tmp,"%dhz sinus", (int)frq);
playa_info_title(info, tmp);
/* sndtst_info(info, 0);*/
err = 0;
error:
if (err) {
pcm_buffer_shutdown();
}
SDUNINDENT;
SDDEBUG("%s() := [%d]\n", __FUNCTION__, err);
return err;
}
/** Remove a driver from the driver list */
int driver_list_unregister(driver_list_t *dl, any_driver_t * driver)
{
any_driver_t *d, *p=0;
if (!dl || !driver) {
return -1;
}
driver_list_lock(dl);
for (p=0, d=dl->drivers; d && d != driver; p=d, d=d->nxt)
;
if (d) {
if (p) {
p->nxt = d->nxt;
} else {
dl->drivers = d->nxt;
}
--dl->n;
SDDEBUG("Unregister [%s] from [%s] success\n", driver->name, dl->name);
specific_unregister(d);
driver_dereference(d);
} else {
SDERROR("Failed to unregister [%s] from [%s].\n", driver->name, dl->name);
}
driver_list_unlock(dl);
return d ? 0 : -1;
}
int driver_reference(any_driver_t * drv)
{
lef_prog_t * lef;
int result = 0;
if (!drv) return -1;
spinlock_lock((spinlock_t *) &drv->mutex);
drv->count++;
if (drv->count == 1) {
SDDEBUG("Calling init on driver '%s'\n", drv->name);
result = drv->init(drv);
if (!result) {
result = specific_register(drv);
} else {
SDERROR("[%s] : init failed [%d]\n", drv->name, result);
}
}
lef = drv->dll;
if (lef) {
lef->ref_count++;
}
spinlock_unlock((spinlock_t *) &drv->mutex);
if (result) {
driver_dereference(drv);
}
return result;
}
/** Init everything for the driver manager. */
int driver_lists_init(void)
{
int i, err = 0;
const int n = sizeof(registered_lists) / sizeof(*registered_lists);
spinlock_init(&driver_lists_mutex);
driver_lists = 0;
for (i=0; i<n; ++i) {
driver_list_reg_t * reg = registered_lists + i;
if (driver_lists_add(reg) < 0) {
SDERROR("[%s] : [%s,%08x] registration failed.\n",
__FUNCTION__, reg->name, reg->type);
++ err;
} else {
/* $$$ ben : careful ! driver list will not been initiliazed if
the registration failed. This couls be dangerous since we used
extern driver list. This could be ok as soon as these extern be
removed.
*/
list_init(reg->list, reg->name);
SDDEBUG("[%s] : [%s,%08x] initialized.\n",
__FUNCTION__, reg->name, reg->type);
}
}
return -err;
}
int driver_list_register(driver_list_t *dl, any_driver_t * driver)
{
const any_driver_t * d;
int err = 0;
if (!dl || !driver) {
return -1;
}
driver_list_lock(dl);
d = drv_list_search(dl, driver->name);
if (d) {
SDERROR("%s([%s], [%s]) : Driver already exists.\n",
__FUNCTION__, dl->name, driver->name);
err = -1;
} else {
err = driver_reference(driver);
if (!err) {
driver->nxt = dl->drivers;
dl->drivers = driver;
++dl->n;
}
}
driver_list_unlock(dl);
SDDEBUG("[%s] := [%d]\n",__FUNCTION__, err);
return err;
}
void driver_dereference(any_driver_t * drv)
{
lef_prog_t * lef;
if (!drv) return;
spinlock_lock((spinlock_t *) &drv->mutex);
drv->count--;
if (drv->count == 0) {
SDDEBUG("Calling shutdown on driver '%s'\n", drv->name);
drv->shutdown(drv);
}
lef = drv->dll;
if (lef) {
int count = drv->count;
lef_free(lef);
/* past this point, the driver may not exist anymore ... */
if (count == 0)
return; /* do not release mutex ON PURPOSE */
}
spinlock_unlock((spinlock_t *) &drv->mutex);
}
int driver_lists_add(driver_list_reg_t * reg)
{
int err = -1;
driver_list_reg_t * lists;
/* Check parameter */
if (!reg || !reg->type || !reg->name || !reg->shutdown || !reg->list) {
SDERROR("[%s] : bad parameters\n", __FUNCTION__);
return -1;
}
reg->next = 0;
SDDEBUG("[%s] : adding [%s,%08x] to registered driver type list.\n",
__FUNCTION__, reg->name, reg->type);
lists = driver_lists_lock();
if (lists == driver_lists) {
driver_list_reg_t * l, * p;
/* Cannot add a list with the same name or the same type. */
l = lists_search(lists,reg->type, reg->name);
if (l) {
SDERROR("[%s] : [%s,%08x] already exists as [%s,%08x].\n",
__FUNCTION__, reg->name, reg->type, l->name, l->type);
driver_list_unlock(l->list);
} else {
/* Find last. */
for (p=0,l=lists; l; p=l, l=l->next)
;
if (!p) {
driver_lists = lists = reg;
SDDEBUG("[%s] : [%s,%08x] has been registered as first\n",
__FUNCTION__, reg->name, reg->type);
} else {
p->next = reg;
SDDEBUG("[%s] : [%s,%08x] has been registered after [%s,%08x]\n",
__FUNCTION__, reg->name, reg->type, p->name, p->type);
}
err = 0;
}
}
driver_lists_unlock(lists);
return err;
}
/** Shutddown all driver list */
void driver_lists_shutdown(void)
{
driver_list_reg_t * reg, * next;
for (reg=driver_lists_lock(); reg; reg = next) {
next = reg->next;
driver_list_shutdown(reg->list);
}
driver_lists = 0;
SDDEBUG("[driver_list : all lists shutdowned\n");
}
/* Initialize the file system */
int fs_rz_init(const unsigned char * romdisk)
{
SDDEBUG("[%s] [%p]\n", __FUNCTION__, romdisk);
/* Could not create 2 ramdisks. */
if (root) {
SDERROR("[%s] : only one ROM disk is available.\n", __FUNCTION__);
return -1;
}
if (!romdisk) {
SDERROR("[%s] : bad pointer.\n", __FUNCTION__);
return -1;
}
if (memcmp(romdisk,"RD-BEN",6)) {
SDERROR("[%s] : invalid romdisk.\n", __FUNCTION__);
return -1;
}
root_entries = * (uint16 *) (romdisk + 6);
SDDEBUG("[%s] : %d entries\n",__FUNCTION__, root_entries);
/* Register with VFS */
if (nmmgr_handler_add(&vh.nmmgr)) {
SDERROR("-->fs_handler_add failed\n");
return -1;
}
root = romdisk;
cur_rd = 0;
cached_addr = 0;
cached_shadow = 0;
memset(&myrd,0,sizeof(myrd));
memset(&mydh,0,sizeof(mydh));
cur_dh = 0;
return 0;
}
int id3_info(playa_info_t * info, const char *fn)
{
struct id3_file * f;
int i;
SDDEBUG(">> %s(%s)\n", __FUNCTION__, fn);
memset(info, 0, sizeof(*info));
f = id3_file_open(fn, ID3_FILE_MODE_READONLY);
if (!f) {
SDERROR("id3 : open error\n");
return -1;
}
for (i=0; i<f->ntags; ++i) {
show_id3(info, f->tags[i].tag);
}
id3_file_close(f);
SDDEBUG("<< %s(%s) := [0]\n", __FUNCTION__, fn);
return 0;
}
static int init(any_driver_t *d)
{
int err = 0;
int frq;
/* SDDEBUG("sc68 : Init [%s]\n", d->name); */
/* check whether EMU68 is compiled without debug option */
if (EMU68_sizeof_reg68() != sizeof(reg68_t)) {
SC68error_add
("Internal : Bad EMU68 version : should not define SC68DEBUG ...");
err = __LINE__;
goto error;
}
/* Set default configuration */
set_sc68app_default(&app);
/* Copy config parameters to app */
SC68app_configure(&app);
frq = (int) app.mix.real_frq;
/* 68K & IO-Emulators init */
if (init_68K(&app.reg68, MEMORY68)) {
err = __LINE__;
goto error;
}
/* SDDEBUG("sc68: 68K emulator init : OK\n"); */
/* IO replay frequency init */
app.mix.real_frq = 44100;
YM_set_replay_frq(app.mix.real_frq);
MW_set_replay_frq((int) app.mix.real_frq);
PL_set_replay_frq((int) app.mix.real_frq);
app.mix.buf = YM_get_buffer();
SDDEBUG("[sc68] : create sc68 romdisk\n");
fs_rz_init(sc68newdisk);
error:
if (err) {
spool_error_message();
SDERROR("[%s] : error line [%d]\n", __FUNCTION__ , err);
shutdown_68K();
}
return -!!err;
}
static int set_visual(vis_driver_t * d)
{
if (d == visual) {
driver_dereference(&d->common);
return 0;
}
if (d) {
int err;
SDDEBUG("Start visual [%s,%p]\n", d->common.name, d);
EXPT_GUARD_BEGIN;
err = d->start();
EXPT_GUARD_CATCH;
err = -1;
EXPT_GUARD_END;
if (err) {
driver_dereference(&d->common);
return -1;
}
}
if (visual) {
SDDEBUG("Stop visual [%s,%p]\n",visual->common.name,visual);
EXPT_GUARD_BEGIN;
visual->stop();
EXPT_GUARD_CATCH;
EXPT_GUARD_END;
driver_dereference(&visual->common);
}
visual = d;
SDDEBUG("New visual [%s,%p]\n",
d ? d->common.name : "NONE", d);
return 0;
}
/* De-init the file system */
int fs_rz_shutdown(void)
{
SDDEBUG("%s\n", __FUNCTION__);
root = 0;
if (cached_addr) {
free(cached_addr);
cached_addr = 0;
}
cur_rd = 0;
cached_addr = 0;
cached_shadow = 0;
memset(&myrd,0,sizeof(myrd));
memset(&mydh,0,sizeof(mydh));
cur_dh = 0;
return nmmgr_handler_remove(&vh.nmmgr);
}
static int sndtst_init(any_driver_t * d)
{
SDDEBUG("%s([%s]) := [0]\n", __FUNCTION__, d->name);
return 0;
}
/* Shutdown the player */
static int sndtst_shutdown(any_driver_t * d)
{
SDDEBUG("%s(%s) := [0]\n", __FUNCTION__, d->name);
sndtst_stop();
return 0;
}
any_driver_t * plugin_load(const char *fname)
{
lef_prog_t * prog = 0;
any_driver_t *d = 0, *d2 = 0, *pd = 0, *d1 = 0;
SDDEBUG(">> %s(%s)\n", __FUNCTION__, fname);
SDINDENT;
d = 0;
prog = lef_load(fname);
if (!prog) {
SDERROR("Plugin [%s] load error\n", fname);
goto error;
}
SDDEBUG("Plugin load success [%s].\n", fname);
d = (any_driver_t *)prog->main(0, 0);
if (!d) {
SDWARNING("No driver found in plugin [%s].\n", fname);
goto error;
}
SDDEBUG("Driver list in [%s]\n", fname);
sysdbg_indent(1, 0);
for (d1 = pd = 0, d2 = d; d2; d2 = d2->nxt) {
driver_list_t *dl;
/* Attach dll to driver. */
d2->dll = prog;
dl = driver_list_which(d2);
if (dl) {
/* Have a valid driver. */
if (pd) {
/* Link it to previous valid driver. */
pd->nxt = d2;
} else {
/* Or set first valid. */
d1 = d2;
}
pd = d2;
/* Add a ref count to lef. */
/* ++prog->ref_count;*/
SDDEBUG("+ [%s] [%s] -> [%s]\n", (char *)&d2->type, d2->name, dl->name);
} else {
SDERROR("Bad driver type %08x [%c%c%c%c]\n",
d->type,
(d->type&255), (d->type>>8)&255,
(d->type>>16)&255, (d->type>>24)&255);
}
}
SDUNINDENT;
/* Close the list. */
if (pd) {
pd->nxt = 0;
}
error:
if (!d1) {
/* No valid driver has been found ! */
lef_free(prog);
}
sysdbg_indent(-1,0);
SDDEBUG("<< %s() = %s\n", __FUNCTION__, d1 ? "OK" : "FAILED");
return d1;
}
/**
* \ingroup sd_raw
* Reads raw data from the card.
*
* \param[in] offset The offset from which to read.
* \param[out] buffer The buffer into which to write the data.
* \param[in] length The number of bytes to read.
* \returns 0 on failure, 1 on success.
* \see sd_raw_read_interval, sd_raw_write, sd_raw_write_interval
*/
uint8_t sd_raw_read(offset_t offset, uint8_t* buffer, uintptr_t length)
{
offset_t block_address;
uint16_t block_offset;
uint16_t read_length;
while(length > 0)
{
/* determine byte count to read at once */
block_offset = offset & 0x01ff;
block_address = offset - block_offset;
read_length = 512 - block_offset; /* read up to block border */
if(read_length > length)
read_length = length;
#if !SD_RAW_SAVE_RAM
/* check if the requested data is cached */
if(block_address != raw_block_address)
#endif
{
#if SD_RAW_WRITE_BUFFERING
if(!sd_raw_sync())
return 0;
#endif
/* address card */
select_card();
/* send single block request */
#if SD_RAW_SDHC
if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, (sd_raw_card_type & (1 << SD_RAW_SPEC_SDHC) ? block_address / 512 : block_address)))
#else
if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, block_address))
#endif
{
unselect_card();
return 0;
}
/* wait for data block (start byte 0xfe) */
#ifdef SD_READ_TIMEOUT
uint16_t timeout = 20000;
while(sd_raw_rec_byte() != 0xfe && timeout > 0)
timeout --;
if (timeout == 0)
{
SDDEBUG ("read timeout reached!\n");
unselect_card();
return 0;
}
#else
while(sd_raw_rec_byte() != 0xfe);
#endif
#if SD_RAW_SAVE_RAM
/* read byte block */
uint16_t read_to = block_offset + read_length;
for(uint16_t i = 0; i < 512; ++i)
{
uint8_t b = sd_raw_rec_byte();
if(i >= block_offset && i < read_to)
*buffer++ = b;
}
#else
/* read byte block */
uint8_t* cache = raw_block;
for(uint16_t i = 0; i < 512; ++i)
*cache++ = sd_raw_rec_byte();
raw_block_address = block_address;
memcpy(buffer, raw_block + block_offset, read_length);
buffer += read_length;
#endif
/* read crc16 */
sd_raw_rec_byte();
sd_raw_rec_byte();
/* deaddress card */
unselect_card();
/* let card some time to finish */
sd_raw_rec_byte();
}
#if !SD_RAW_SAVE_RAM
else
{
/* use cached data */
memcpy(buffer, raw_block + block_offset, read_length);
buffer += read_length;
}
#endif
length -= read_length;
offset += read_length;
}
return 1;
}
/**
* \ingroup sd_raw
* Initializes memory card communication.
*
* \returns 0 on failure, 1 on success.
*/
uint8_t sd_raw_init(void)
{
/* enable inputs for reading card status */
configure_pin_available();
configure_pin_locked();
/* enable outputs for MOSI, SCK, SS, input for MISO */
#if 0
configure_pin_mosi();
configure_pin_sck();
#endif
configure_pin_ss();
#if 0
configure_pin_miso();
#endif
unselect_card();
/* initialize SPI with lowest frequency; max. 400kHz during identification mode of card */
SPCR = (0 << SPIE) | /* SPI Interrupt Enable */
(1 << SPE) | /* SPI Enable */
(0 << DORD) | /* Data Order: MSB first */
(1 << MSTR) | /* Master mode */
(0 << CPOL) | /* Clock Polarity: SCK low when idle */
(0 << CPHA) | /* Clock Phase: sample on rising SCK edge */
(1 << SPR1) | /* Clock Frequency: f_OSC / 128 */
(1 << SPR0);
SPSR &= ~(1 << SPI2X); /* No doubled clock frequency */
/* initialization procedure */
sd_raw_card_type = 0;
if(!sd_raw_available())
{
SDDEBUG ("sd-card not available, stop.\n");
return 0;
}
/* card needs 74 cycles minimum to start up */
for(uint8_t i = 0; i < 10; ++i)
{
/* wait 8 clock cycles */
sd_raw_rec_byte();
}
/* address card */
select_card();
/* reset card */
uint8_t response;
for(uint16_t i = 0; ; ++i)
{
response = sd_raw_send_command(CMD_GO_IDLE_STATE, 0);
if(response == (1 << R1_IDLE_STATE))
break;
if(i == 0x1ff)
{
unselect_card();
/* disabled, it's just flooding the console ...
SDDEBUG ("card reset failed, response=0x%04x.\n", response); */
return 0;
}
}
#if SD_RAW_SDHC
/* check for version of SD card specification */
response = sd_raw_send_command(CMD_SEND_IF_COND, 0x100 /* 2.7V - 3.6V */ | 0xaa /* test pattern */);
if((response & (1 << R1_ILL_COMMAND)) == 0)
{
sd_raw_rec_byte();
sd_raw_rec_byte();
if((sd_raw_rec_byte() & 0x01) == 0)
return 0; /* card operation voltage range doesn't match */
if(sd_raw_rec_byte() != 0xaa)
return 0; /* wrong test pattern */
/* card conforms to SD 2 card specification */
sd_raw_card_type |= (1 << SD_RAW_SPEC_2);
}
else
#endif
{
/* determine SD/MMC card type */
sd_raw_send_command(CMD_APP, 0);
response = sd_raw_send_command(CMD_SD_SEND_OP_COND, 0);
if((response & (1 << R1_ILL_COMMAND)) == 0)
{
/* card conforms to SD 1 card specification */
sd_raw_card_type |= (1 << SD_RAW_SPEC_1);
SDDEBUG ("found SD 1 card\n");
}
else
{
/* MMC card */
SDDEBUG ("found MMC card\n");
}
}
/* wait for card to get ready */
for(uint16_t i = 0; ; ++i)
{
if(sd_raw_card_type & ((1 << SD_RAW_SPEC_1) | (1 << SD_RAW_SPEC_2)))
{
uint32_t arg = 0;
#if SD_RAW_SDHC
if(sd_raw_card_type & (1 << SD_RAW_SPEC_2))
arg = 0x40000000;
#endif
sd_raw_send_command(CMD_APP, 0);
response = sd_raw_send_command(CMD_SD_SEND_OP_COND, arg);
}
else
{
response = sd_raw_send_command(CMD_SEND_OP_COND, 0);
}
if((response & (1 << R1_IDLE_STATE)) == 0)
break;
if(i == 0x7fff)
{
unselect_card();
return 0;
}
}
#if SD_RAW_SDHC
if(sd_raw_card_type & (1 << SD_RAW_SPEC_2))
{
if(sd_raw_send_command(CMD_READ_OCR, 0))
{
unselect_card();
return 0;
}
if(sd_raw_rec_byte() & 0x40)
sd_raw_card_type |= (1 << SD_RAW_SPEC_SDHC);
sd_raw_rec_byte();
sd_raw_rec_byte();
sd_raw_rec_byte();
}
#endif
/* set block size to 512 bytes */
if(sd_raw_send_command(CMD_SET_BLOCKLEN, 512))
{
unselect_card();
SDDEBUG ("failed to set block size to 512 bytes.\n");
return 0;
}
/* deaddress card */
unselect_card();
/* switch to highest SPI frequency possible */
SPCR &= ~((1 << SPR1) | (1 << SPR0)); /* Clock Frequency: f_OSC / 4 */
SPSR |= (1 << SPI2X); /* Doubled Clock Frequency: f_OSC / 2 */
#if !SD_RAW_SAVE_RAM
/* the first block is likely to be accessed first, so precache it here */
raw_block_address = (offset_t) -1;
#if SD_RAW_WRITE_BUFFERING
raw_block_written = 1;
#endif
if(!sd_raw_read(0, raw_block, sizeof(raw_block)))
return 0;
#endif
return 1;
}
fftbands_t * fftband_create(int n, int fft_size, int sampling,
const fftband_limit_t * limits)
{
int i;
fftbands_t * bands;
int size = sizeof(fftbands_t) + n * sizeof(fftband_t) - sizeof(bands->band);
SDDEBUG("[%s] n:%d fft:%d sampling:%d f0:%.2f\n",
__FUNCTION__, n, fft_size, sampling, (float)sampling/fft_size);
if (bands = malloc(size), !bands) {
return 0;
}
memset(bands,0,size);
bands->n = n;
bands->sampling = sampling;
bands->fftsize = fft_size;
bands->oof0 = (fft_size << FFT_BAND_FIX) / sampling;
if (limits) {
for (i=0; i<n; ++i) {
fftband_limit(bands->band+i, limits[i].fmin, limits[i].fmax);
}
} else {
float radix = radix_calc(fft_size/2,n);
float fmin, fmax, j, r;
float band_width = (float)sampling / (float)fft_size;
/* float V; */
/* float Fmax, Fmin; */
/* Fmax = (float)sampling/2; */
/* Fmin = band_width; */
/* V = log(Fmax - Fmin) / n; */
/* printf("Radix1:%f Radix2:%f\n", radix, V); */
if (1) {
for (i=0, j=0, r=radix, fmin=0; i<n; ++i) {
j += r;
r *= radix;
fmax = band_width * j;
fftband_limit(bands->band+i, fmin, fmax);
fmin = fmax;
}
} else {
/* 2nd version */
for (i=n-1, fmax=sampling/2; i>=0; --i) {
fftband_limit(bands->band+i, fmax/2, fmax);
fmax /= 2;
}
}
}
for (i=0; i<n; ++i) {
fftband_t * b = bands->band+i;
fftband_setup(b, bands->oof0, fft_size);
/* SDDEBUG("[%s] f[%d-%d] b[%x-%x] s[%x-%x/%x]\n", __FUNCTION__, */
/* b->fmin, b->fmax, b->bmin, b->bmax, */
/* b->bminscale, b->bmaxscale, b->bdivisor); */
}
return bands;
}
