static void change_subsong(int subsong)
{
song.cur_subsong = subsong;
uade_put_long(SCORE_SUBSONG, subsong);
uade_send_amiga_message(AMIGAMSG_SETSUBSONG);
flush_sound();
}
/* this is called for each played song from newcpu.c/m68k_reset() */
void uade_reset(void)
{
/* don't load anything under 0x1000 (execbase top at $1000) */
const int modnameaddr = 0x00400;
const int scoreaddr = 0x01000;
const int userstack = 0x08500;
const int superstack = 0x08f00;
const int playeraddr = 0x09000;
int relocaddr;
int modaddr;
int len;
FILE *file;
int bytesread;
uint8_t command[UADE_MAX_MESSAGE_SIZE];
struct uade_msg *um = (struct uade_msg *) command;
int ret;
nextsong:
/* IMPORTANT:
It seems that certain players don't work totally reliably if memory
contains trash from previous songs. To be certain that each song is
played from the same initial state of emulator we clear the memory
from 0x400 to 'uade_highmem' each time a new song is played */
uade_highmem = 0;
while (uade_highmem < 0x800000) {
if (!valid_address(0, uade_highmem + 0x10000))
break;
uade_highmem += 0x10000;
}
if (uade_highmem < 0x80000) {
fprintf(stderr, "uadecore: There must be at least 512 KiB of amiga memory (%d bytes found).\n", uade_highmem);
exit(-1);
}
if (uade_highmem < 0x200000) {
fprintf(stderr, "uadecore: Warning: highmem == 0x%x (< 0x200000)!\n", uade_highmem);
}
memset(get_real_address(0), 0, uade_highmem);
song.cur_subsong = song.min_subsong = song.max_subsong = 0;
ret = uade_receive_string(song.scorename, UADE_COMMAND_SCORE, sizeof(song.scorename), &uadeipc);
if (ret == 0) {
fprintf(stderr, "uadecore: No more songs to play.\n");
exit(0);
} else if (ret < 0) {
fprintf(stderr, "uadecore: Invalid input. Expected score name.\n");
exit(-1);
}
// printf("got scorename %s\n",song.scorename);
ret = uade_receive_string(song.playername, UADE_COMMAND_PLAYER, sizeof(song.playername), &uadeipc);
if (ret == 0) {
printf("uadecore: Expected player name. Got nothing.\n");
exit(-1);
} else if (ret < 0) {
printf( "uadecore: Invalid input. Expected player name.\n");
exit(-1);
}
// printf("got playername %s\n",song.playername);
if (uade_dirname(uade_player_dir, song.playername, sizeof(uade_player_dir)) == NULL) {
printf( "uadecore: Invalid dirname with player: %s\n", song.playername);
exit(-1);
}
ret = uade_receive_message(um, sizeof command, &uadeipc);
if (ret == 0) {
printf("uadecore: Expected module name. Got nothing.\n");
exit(-1);
} else if (ret < 0) {
printf( "uadecore: Invalid input. Expected module name.\n");
exit(-1);
}
assert(um->msgtype == UADE_COMMAND_MODULE);
if (um->size == 0) {
song.modulename[0] = 0;
} else {
assert(um->size == (strlen((char *) um->data) + 1));
strlcpy(song.modulename, (char *) um->data, sizeof(song.modulename));
}
// printf("got modulename %s\n",song.modulename);
uade_set_automatic_song_end(1);
uade_put_long(SCORE_EXEC_DEBUG, uade_execdebugboolean ? 0x12345678 : 0);
uade_put_long(SCORE_VOLUME_TEST, voltestboolean);
uade_put_long(SCORE_DMA_WAIT, uade_dmawait);
uade_put_long(SCORE_MODULECHANGE, disable_modulechange);
bytesread = uade_safe_load_name(playeraddr, song.playername, "player", uade_highmem - playeraddr);
if (bytesread > (uade_highmem - playeraddr)) {
fprintf (stderr, "uadecore: Player %s too big a file (%d bytes).\n", song.playername, bytesread);
goto skiptonextsong;
}
if (bytesread == 0) {
goto skiptonextsong;
}
/* fprintf(stderr, "uadecore: player '%s' (%d bytes)\n", song.playername, bytesread); */
/* set player executable address for relocator */
uade_put_long(SCORE_PLAYER_ADDR, playeraddr);
len = uade_calc_reloc_size((uae_u32 *) get_real_address(playeraddr),
(uae_u32 *) get_real_address(playeraddr + bytesread));
if (!len) {
fprintf(stderr, "uadecore: Problem with reloc calculation.\n");
goto skiptonextsong;
}
relocaddr = ((playeraddr + bytesread) & 0x7FFFF000) + 0x4000;
/* + 0x4000 for hippel coso (wasseremu) */
modaddr = ((relocaddr + len) & 0x7FFFF000) + 0x2000;
if (modaddr <= relocaddr) {
/* this is very bad because sound core memory allocation will fail */
fprintf(stderr, "uadecore: Warning: modaddr <= relocaddr: 0x%x <= 0x%x\n", modaddr, relocaddr);
}
uade_put_long(SCORE_RELOC_ADDR, relocaddr); /*address for relocated player*/
uade_put_long(SCORE_MODULE_ADDR, modaddr); /* set module address */
uade_put_long(SCORE_MODULE_LEN, 0); /* set module size to zero */
uade_put_long(SCORE_MODULE_NAME_ADDR, 0); /* mod name address pointer */
/* load the module if available */
if (song.modulename[0]) {
bytesread = uade_safe_load_name(modaddr, song.modulename, "module", uade_highmem - modaddr);
if (bytesread > (uade_highmem - playeraddr)) {
fprintf (stderr, "uadecore: Module %s too big a file (%d bytes).\n", song.modulename, bytesread);
goto skiptonextsong;
}
if (bytesread == 0) {
goto skiptonextsong;
}
uade_put_long(SCORE_MODULE_LEN, bytesread);
if (!valid_address(modnameaddr, strlen(song.modulename) + 1)) {
fprintf(stderr, "uadecore: Invalid address for modulename.\n");
goto skiptonextsong;
}
strlcpy((char *) get_real_address(modnameaddr), song.modulename, 1024);
uade_put_long(SCORE_MODULE_NAME_ADDR, modnameaddr);
} else {
if (!valid_address(modnameaddr, strlen(song.playername) + 1)) {
fprintf(stderr, "uadecore: Invalid address for playername.\n");
goto skiptonextsong;
}
strlcpy((char *) get_real_address(modnameaddr), song.playername, 1024);
uade_put_long(SCORE_MODULE_NAME_ADDR, modnameaddr);
bytesread = 0;
}
/* load sound core (score) */
if ((file = fopen(song.scorename, "rb"))) {
bytesread = uade_safe_load(scoreaddr, file, uade_highmem - scoreaddr);
fclose(file);
} else {
fprintf (stderr, "uadecore: Can not load score (%s).\n", song.scorename);
goto skiptonextsong;
}
m68k_areg(regs,7) = scoreaddr;
m68k_setpc(scoreaddr);
/* obey player format checking */
uade_put_long(SCORE_FORCE, 0);
/* set default subsong */
uade_put_long(SCORE_SET_SUBSONG, 0);
uade_put_long(SCORE_SUBSONG, 0);
/* set PAL mode */
uade_set_ntsc(0);
/* pause bits (don't care!), for debugging purposes only */
uade_put_long(SCORE_PREPAUSE, 0);
uade_put_long(SCORE_POSTPAUSE, 0);
/* set user and supervisor stack pointers */
uade_put_long(SCORE_USER_STACK, userstack);
uade_put_long(SCORE_SUPER_STACK, superstack);
/* no message for score */
uade_put_long(SCORE_OUTPUT_MSG, 0);
if ((userstack - (scoreaddr + bytesread)) < 0x1000)
fprintf(stderr, "uadecore: Amiga stack overrun warning.\n");
flush_sound();
/* note that uade_speed_hack can be negative (meaning that uade never uses
speed hack, even if it's requested by the amiga player)! */
uade_time_critical = 0;
if (uade_speed_hack > 0) {
uade_time_critical = 1;
}
uade_reboot = 0;
uade_audio_output = 0;
uade_audio_skip = 0;
old_ledstate = gui_ledstate;
if (uade_receive_short_message(UADE_COMMAND_TOKEN, &uadeipc)) {
fprintf(stderr, "uadecore: Can not receive token in uade_reset().\n");
exit(-1);
}
if (uade_send_short_message(UADE_REPLY_CAN_PLAY, &uadeipc)) {
fprintf(stderr, "uadecore: Can not send 'CAN_PLAY' reply.\n");
exit(-1);
}
if (uade_send_short_message(UADE_COMMAND_TOKEN, &uadeipc)) {
fprintf(stderr, "uadecore: Can not send token from uade_reset().\n");
exit(-1);
}
set_sound_freq(UADE_DEFAULT_FREQUENCY);
epoptionsize = 0;
return;
skiptonextsong:
fprintf(stderr, "uadecore: Can not play. Reboot.\n");
if (uade_receive_short_message(UADE_COMMAND_TOKEN, &uadeipc)) {
fprintf(stderr, "uadecore: Can not receive token in uade_reset().\n");
exit(-1);
}
if (uade_send_short_message(UADE_REPLY_CANT_PLAY, &uadeipc)) {
fprintf(stderr, "uadecore: Can not send 'CANT_PLAY' reply.\n");
exit(-1);
}
if (uade_send_short_message(UADE_COMMAND_TOKEN, &uadeipc)) {
fprintf(stderr, "uadecore: Can not send token from uade_reset().\n");
exit(-1);
}
goto nextsong;
}
void uade_handle_r_state(void)
{
uint8_t space[UADE_MAX_MESSAGE_SIZE];
struct uade_msg *um = (struct uade_msg *) space;
int ret;
uint32_t x, y;
while (1) {
ret = uade_receive_message(um, sizeof(space), &uadeipc);
if (ret == 0) {
fprintf(stderr, "uadecore: No more input. Exiting succesfully.\n");
exit(0);
} else if (ret < 0) {
fprintf(stderr, "uadecore: Error on input. Exiting with error.\n");
exit(-1);
}
if (um->msgtype == UADE_COMMAND_TOKEN)break;
switch (um->msgtype) {
case UADE_EXIT:
//uade_reboot = 1;
quit_program=1;
break;
case UADE_COMMAND_ACTIVATE_DEBUGGER:
fprintf(stderr, "uadecore: Received activate debugger message.\n");
activate_debugger();
uade_debug = 1;
break;
case UADE_COMMAND_CHANGE_SUBSONG:
if (uade_parse_u32_message(&x, um)) {
fprintf(stderr, "uadecore: Invalid size with change subsong.\n");
exit(-1);
}
change_subsong(x);
break;
case UADE_COMMAND_FILTER:
if (uade_parse_two_u32s_message(&x, &y, um)) {
fprintf(stderr, "uadecore: Invalid size with filter command\n");
exit(-1);
}
audio_set_filter(x, y);
break;
case UADE_COMMAND_IGNORE_CHECK:
/* override bit for sound format checking */
uade_put_long(SCORE_FORCE, 1);
break;
case UADE_COMMAND_SET_FREQUENCY:
if (uade_parse_u32_message(&x, um)) {
fprintf(stderr, "Invalid frequency message size: %u\n", um->size);
exit(-1);
}
set_sound_freq(x);
break;
case UADE_COMMAND_SET_PLAYER_OPTION:
uade_check_fix_string(um, 256);
add_ep_option((char *) um->data);
break;
case UADE_COMMAND_SET_RESAMPLING_MODE:
uade_check_fix_string(um, 16);
audio_set_resampler((char *) um->data);
break;
case UADE_COMMAND_SPEED_HACK:
uade_time_critical = 1;
break;
case UADE_COMMAND_READ:
if (uade_read_size != 0) {
fprintf(stderr, "uadecore: Read not allowed when uade_read_size > 0.\n");
exit(-1);
}
if (uade_parse_u32_message(&x, um)) {
fprintf(stderr, "uadecore: Invalid size on read command.\n");
exit(-1);
}
uade_read_size = x;
if (uade_read_size == 0 || uade_read_size > MAX_SOUND_BUF_SIZE || (uade_read_size & 3) != 0) {
fprintf(stderr, "uadecore: Invalid read size: %d\n", uade_read_size);
exit(-1);
}
break;
case UADE_COMMAND_REBOOT:
uade_reboot = 1;
break;
case UADE_COMMAND_SET_NTSC:
fprintf(stderr, "\nuadecore: Changing to NTSC mode.\n");
uade_set_ntsc(1);
break;
case UADE_COMMAND_SONG_END_NOT_POSSIBLE:
uade_set_automatic_song_end(0);
break;
case UADE_COMMAND_SET_SUBSONG:
if (uade_parse_u32_message(&x, um)) {
fprintf(stderr, "uadecore: Invalid size on set subsong command.\n");
exit(-1);
}
uade_put_long(SCORE_SET_SUBSONG, 1);
uade_put_long(SCORE_SUBSONG, x);
break;
case UADE_COMMAND_USE_TEXT_SCOPE:
audio_use_text_scope();
break;
default:
fprintf(stderr, "uadecore: Received invalid command %d\n", um->msgtype);
exit(-1);
}
}
}
void uade_get_amiga_message(void)
{
uae_u8 *ptr;
uae_u8 *nameptr;
FILE *file;
int x;
unsigned int mins, maxs, curs;
int status;
int src, dst, off, len;
char tmpstr[256];
char *srcstr, *dststr;
uint32_t *u32ptr;
uint8_t space[256];
struct uade_msg *um = (struct uade_msg *) space;
x = uade_get_u32(SCORE_INPUT_MSG); /* message type from amiga */
switch (x) {
case AMIGAMSG_SONG_END:
uade_song_end("player", 0);
break;
case AMIGAMSG_SUBSINFO:
mins = uade_get_u32(SCORE_MIN_SUBSONG);
maxs = uade_get_u32(SCORE_MAX_SUBSONG);
curs = uade_get_u32(SCORE_CUR_SUBSONG);
/* Brain damage in TFMX BC Kid Despair */
if (maxs < mins) {
uade_send_debug("Odd subsongs. Eagleplayer reported (min, cur, max) == (%u, %u, %u)", mins, curs, maxs);
maxs = mins;
}
/* Brain damage in Bubble bobble custom */
if (curs > maxs) {
uade_send_debug("Odd subsongs. Eagleplayer reported (min, cur, max) == (%u, %u, %u)", mins, curs, maxs);
maxs = curs;
}
um->msgtype = UADE_REPLY_SUBSONG_INFO;
um->size = 12;
u32ptr = (uint32_t *) um->data;
u32ptr[0] = htonl(mins);
u32ptr[1] = htonl(maxs);
u32ptr[2] = htonl(curs);
if (uade_send_message(um, &uadeipc)) {
fprintf(stderr, "uadecore: Could not send subsong info message.\n");
exit(-1);
}
break;
case AMIGAMSG_PLAYERNAME:
strlcpy(tmpstr, (char *) get_real_address(0x204), sizeof tmpstr);
uade_send_string(UADE_REPLY_PLAYERNAME, tmpstr, &uadeipc);
break;
case AMIGAMSG_MODULENAME:
strlcpy(tmpstr, (char *) get_real_address(0x204), sizeof tmpstr);
uade_send_string(UADE_REPLY_MODULENAME, tmpstr, &uadeipc);
break;
case AMIGAMSG_FORMATNAME:
strlcpy(tmpstr, (char *) get_real_address(0x204), sizeof tmpstr);
uade_send_string(UADE_REPLY_FORMATNAME, tmpstr, &uadeipc);
break;
case AMIGAMSG_GENERALMSG:
uade_send_debug((char *) get_real_address(0x204));
break;
case AMIGAMSG_CHECKERROR:
uade_song_end("module check failed", 1);
break;
case AMIGAMSG_SCORECRASH:
if (uade_debug) {
fprintf(stderr, "uadecore: Score crashed.\n");
activate_debugger();
break;
}
uade_song_end("score crashed", 1);
break;
case AMIGAMSG_SCOREDEAD:
if (uade_debug) {
fprintf(stderr, "uadecore: Score is dead.\n");
activate_debugger();
break;
}
uade_song_end("score died", 1);
break;
case AMIGAMSG_LOADFILE:
/* load a file named at 0x204 (name pointer) to address pointed by
0x208 and insert the length to 0x20C */
src = uade_get_u32(0x204);
if (!uade_valid_string(src)) {
fprintf(stderr, "uadecore: Load name in invalid address range.\n");
break;
}
nameptr = get_real_address(src);
if ((file = uade_open_amiga_file((char *) nameptr, uade_player_dir))) {
dst = uade_get_u32(0x208);
len = uade_safe_load(dst, file, uade_highmem - dst);
fclose(file); file = NULL;
uade_put_long(0x20C, len);
uade_send_debug("load success: %s ptr 0x%x size 0x%x", nameptr, dst, len);
} else {
uade_send_debug("load: file not found: %s", nameptr);
}
break;
case AMIGAMSG_READ:
src = uade_get_u32(0x204);
if (!uade_valid_string(src)) {
fprintf(stderr, "uadecore: Read name in invalid address range.\n");
break;
}
nameptr = get_real_address(src);
dst = uade_get_u32(0x208);
off = uade_get_u32(0x20C);
len = uade_get_u32(0x210);
if ((file = uade_open_amiga_file((char *) nameptr, uade_player_dir))) {
if (fseek(file, off, SEEK_SET)) {
perror("can not fseek to position");
x = 0;
} else {
x = uade_safe_load(dst, file, len);
if (x > len)
x = len;
}
fclose(file);
uade_send_debug("read %s dst 0x%x off 0x%x len 0x%x res 0x%x", nameptr, dst, off, len, x);
uade_put_long(0x214, x);
} else {
uade_send_debug("read: file not found: %s", nameptr);
uade_put_long(0x214, 0);
}
break;
case AMIGAMSG_FILESIZE:
src = uade_get_u32(0x204);
if (!uade_valid_string(src)) {
fprintf(stderr, "uadecore: Filesize name in invalid address range.\n");
break;
}
nameptr = get_real_address(src);
if ((file = uade_open_amiga_file((char *) nameptr, uade_player_dir))) {
fseek(file, 0, SEEK_END);
len = ftell(file);
fclose(file);
uade_put_long(0x208, len);
uade_put_long(0x20C, -1);
uade_send_debug("filesize: file %s res 0x%x", nameptr, len);
} else {
uade_put_long(0x208, 0);
uade_put_long(0x20C, 0);
uade_send_debug("filesize: file not found: %s", nameptr);
}
break;
case AMIGAMSG_TIME_CRITICAL:
uade_time_critical = uade_get_u32(0x204) ? 1 : 0;
if (uade_speed_hack < 0) {
/* a negative value forbids use of speed hack */
uade_time_critical = 0;
}
break;
case AMIGAMSG_GET_INFO:
src = uade_get_u32(0x204);
dst = uade_get_u32(0x208);
len = uade_get_u32(0x20C);
if (!uade_valid_string(src)) {
fprintf(stderr, "uadecore: get info: Invalid src: 0x%x\n", src);
break;
}
if (len <= 0) {
fprintf(stderr, "uadecore: get info: len = %d\n", len);
break;
}
if (!valid_address(dst, len)) {
fprintf(stderr, "uadecore: get info: Invalid dst: 0x%x\n", dst);
break;
}
srcstr = (char *) get_real_address(src);
dststr = (char *) get_real_address(dst);
uade_send_debug("score issued an info request: %s (maxlen %d)\n", srcstr, len);
len = get_info_for_ep(dststr, srcstr, len);
/* Send printable debug */
do {
size_t i;
size_t maxspace = sizeof space;
if (len <= 0) {
maxspace = 1;
} else {
if (len < maxspace)
maxspace = len;
}
for (i = 0; i < maxspace; i++) {
space[i] = dststr[i];
if (space[i] == 0)
space[i] = ' ';
}
if (i < maxspace) {
space[i] = 0;
} else {
space[maxspace - 1] = 0;
}
uade_send_debug("reply to score: %s (total len %d)\n", space, len);
} while (0);
uade_put_long(0x20C, len);
break;
case AMIGAMSG_START_OUTPUT:
uade_audio_output = 1;
uade_send_debug("Starting audio output at %d", uade_audio_skip);
break;
default:
fprintf(stderr,"uadecore: Unknown message from score (%d)\n", x);
break;
}
}
void uade_set_automatic_song_end(int song_end_possible)
{
uade_put_long(SCORE_HAVE_SONGEND, song_end_possible);
}
void uade_set_ntsc(int usentsc)
{
uade_put_long(SCORE_NTSC, usentsc);
}
void uade_send_amiga_message(int msgtype)
{
uade_put_long(SCORE_OUTPUT_MSG, msgtype);
}
void uadecore_get_amiga_message(void)
{
uae_u8 *ptr;
uae_u8 *nameptr;
int x;
unsigned int mins, maxs, curs;
int status;
int src, dst, len;
size_t off;
char tmpstr[256];
char *srcstr, *dststr;
struct uade_file *f;
uint32_t *u32ptr;
uint8_t space[256];
struct uade_msg *um = (struct uade_msg *) space;
x = amiga_get_u32(SCORE_INPUT_MSG); /* message type from amiga */
switch (x) {
case AMIGAMSG_SONG_END:
uadecore_song_end("player", 0);
break;
case AMIGAMSG_SUBSINFO:
mins = amiga_get_u32(SCORE_MIN_SUBSONG);
maxs = amiga_get_u32(SCORE_MAX_SUBSONG);
curs = amiga_get_u32(SCORE_CUR_SUBSONG);
/* Brain damage in TFMX BC Kid Despair */
if (maxs < mins) {
uadecore_send_debug("Odd subsongs. Eagleplayer reported (min, cur, max) == (%u, %u, %u)", mins, curs, maxs);
maxs = mins;
}
/* Brain damage in Bubble bobble custom */
if (curs > maxs) {
uadecore_send_debug("Odd subsongs. Eagleplayer reported (min, cur, max) == (%u, %u, %u)", mins, curs, maxs);
maxs = curs;
}
um->msgtype = UADE_REPLY_SUBSONG_INFO;
um->size = 12;
u32ptr = (uint32_t *) um->data;
u32ptr[0] = htonl(mins);
u32ptr[1] = htonl(maxs);
u32ptr[2] = htonl(curs);
if (uade_send_message(um, &uadecore_ipc)) {
fprintf(stderr, "uadecore: Could not send subsong info message.\n");
exit(1);
}
break;
case AMIGAMSG_PLAYERNAME:
strlcpy(tmpstr, (char *) get_real_address(0x204), sizeof tmpstr);
uade_send_string(UADE_REPLY_PLAYERNAME, tmpstr, &uadecore_ipc);
break;
case AMIGAMSG_MODULENAME:
strlcpy(tmpstr, (char *) get_real_address(0x204), sizeof tmpstr);
uade_send_string(UADE_REPLY_MODULENAME, tmpstr, &uadecore_ipc);
break;
case AMIGAMSG_FORMATNAME:
strlcpy(tmpstr, (char *) get_real_address(0x204), sizeof tmpstr);
uade_send_string(UADE_REPLY_FORMATNAME, tmpstr, &uadecore_ipc);
break;
case AMIGAMSG_GENERALMSG:
uadecore_send_debug((char *) get_real_address(0x204));
break;
case AMIGAMSG_CHECKERROR:
uadecore_song_end("module check failed", 1);
break;
case AMIGAMSG_SCORECRASH:
if (uadecore_debug) {
fprintf(stderr, "uadecore: Score crashed.\n");
activate_debugger();
break;
}
uadecore_song_end("score crashed", 1);
break;
case AMIGAMSG_SCOREDEAD:
if (uadecore_debug) {
fprintf(stderr, "uadecore: Score is dead.\n");
activate_debugger();
break;
}
uadecore_song_end("score died", 1);
break;
case AMIGAMSG_LOADFILE:
/*
* Load a file named at 0x204 (name pointer) to address pointed by
* 0x208 and insert the length to 0x20C.
* For example, R-Type (TFMX format) uses this.
*/
src = amiga_get_u32(0x204);
if (!uade_valid_string(src)) {
fprintf(stderr, "uadecore: Load name in invalid address range.\n");
break;
}
nameptr = get_real_address(src);
f = lookup_amiga_file_cache((const char *) nameptr);
if (f == NULL) {
uadecore_send_debug("load: request error: %s", nameptr);
exit(1);
}
if (f->data == NULL) {
/* File not found */
uadecore_send_debug("load: file not found: %s", nameptr);
break;
}
dst = amiga_get_u32(0x208);
len = uade_safe_copy(dst, f->data, f->size);
if (len == 0 && f->size > 0)
uadecore_send_debug("load: too long a file to copy");
uade_put_long(0x20C, len);
uadecore_send_debug("load: %s ptr 0x%x size 0x%x", nameptr, dst, len);
break;
case AMIGAMSG_READ:
/* Used by "mdat.Crystal_Palace-1", for example */
src = amiga_get_u32(0x204);
if (!uade_valid_string(src)) {
fprintf(stderr, "uadecore: Read name in invalid address range.\n");
break;
}
nameptr = get_real_address(src);
f = lookup_amiga_file_cache((const char *) nameptr);
if (f == NULL) {
uadecore_send_debug("read: request error: %s", nameptr);
exit(1);
}
x = 0;
if (f->data != NULL) {
dst = amiga_get_u32(0x208);
off = amiga_get_u32(0x20C);
len = amiga_get_u32(0x210);
if (off >= f->size) {
uadecore_send_debug("read: file offset over the file end");
} else {
size_t endpos = off + ((size_t) len);
size_t tocopy = len;
if (endpos > f->size)
tocopy = f->size - off;
x = uade_safe_copy(dst, f->data + off, tocopy);
}
uadecore_send_debug("read: %s dst 0x%x off 0x%x len 0x%x bytesread 0x%x", nameptr, dst, off, len, x);
} else {
uadecore_send_debug("read: file not found: %s", nameptr);
}
uade_put_long(0x214, x);
break;
case AMIGAMSG_FILESIZE:
/* Used by "mdat.Crystal_Palace-1", for example */
src = amiga_get_u32(0x204);
if (!uade_valid_string(src)) {
fprintf(stderr, "uadecore: Filesize name in invalid address range.\n");
break;
}
nameptr = get_real_address(src);
f = lookup_amiga_file_cache((const char *) nameptr);
if (f == NULL) {
uadecore_send_debug("filesize: request error: %s", nameptr);
exit(1);
}
len = 0;
x = 0;
if (f->data != NULL) {
len = f->size;
x = -1;
uadecore_send_debug("filesize: file %s res 0x%x", nameptr, len);
} else {
/* Note, f->size == -1 if file does not exist */
uadecore_send_debug("filesize: file not found: %s", nameptr);
}
uade_put_long(0x208, len);
uade_put_long(0x20C, x);
break;
case AMIGAMSG_TIME_CRITICAL:
uadecore_time_critical = amiga_get_u32(0x204) ? 1 : 0;
if (speed_hack < 0) {
/* a negative value forbids use of speed hack */
uadecore_time_critical = 0;
}
break;
case AMIGAMSG_GET_INFO:
src = amiga_get_u32(0x204);
dst = amiga_get_u32(0x208);
len = amiga_get_u32(0x20C);
if (!uade_valid_string(src)) {
fprintf(stderr, "uadecore: get info: Invalid src: 0x%x\n", src);
break;
}
if (len <= 0) {
fprintf(stderr, "uadecore: get info: len = %d\n", len);
break;
}
if (!valid_address(dst, len)) {
fprintf(stderr, "uadecore: get info: Invalid dst: 0x%x\n", dst);
break;
}
srcstr = (char *) get_real_address(src);
dststr = (char *) get_real_address(dst);
uadecore_send_debug("score issued an info request: %s (maxlen %d)", srcstr, len);
len = get_info_for_ep(dststr, srcstr, len);
/* Send printable debug */
do {
size_t i;
size_t maxspace = sizeof space;
if (len <= 0) {
maxspace = 1;
} else {
if (len < maxspace)
maxspace = len;
}
for (i = 0; i < maxspace; i++) {
space[i] = dststr[i];
if (space[i] == 0)
space[i] = ' ';
}
if (i < maxspace) {
space[i] = 0;
} else {
space[maxspace - 1] = 0;
}
uadecore_send_debug("reply to score: %s (total len %d)", space, len);
} while (0);
uade_put_long(0x20C, len);
break;
case AMIGAMSG_START_OUTPUT:
uadecore_audio_output = 1;
break;
default:
fprintf(stderr,"uadecore: Unknown message from score (%d)\n", x);
break;
}
}
