Apple-2-Tools
/
kegs
mirror of https://github.com/aufflick/kegs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
kegs/src/sound.c

2024 lines
42 KiB
C
Raw Permalink Blame History

/************************************************************************/
/* KEGS: Apple //gs Emulator */
/* Copyright 2002 by Kent Dickey */
/* */
/* This code is covered by the GNU GPL */
/* */
/* The KEGS web page is kegs.sourceforge.net */
/* You may contact the author at: kadickey@alumni.princeton.edu */
/************************************************************************/
const char rcsid_sound_c[] = "@(#)$KmKId: sound.c,v 1.108 2004-10-31 00:56:07-04 kentd Exp $";
#include "defc.h"
#define INCLUDE_RCSID_C
#include "sound.h"
#undef INCLUDE_RCSID_C
#if 0
# define DO_DOC_LOG
#endif
extern int Verbose;
extern int g_use_shmem;
extern word32 g_vbl_count;
extern int g_preferred_rate;
extern int g_c03ef_doc_ptr;
extern double g_last_vbl_dcycs;
void U_STACK_TRACE();
byte doc_ram[0x10000 + 16];
word32 doc_sound_ctl = 0;
word32 doc_saved_val = 0;
int g_doc_num_osc_en = 1;
double g_dcycs_per_doc_update = 1.0;
double g_dupd_per_dcyc = 1.0;
double g_drecip_osc_en_plus_2 = 1.0 / (double)(1 + 2);
int g_doc_saved_ctl = 0;
int g_queued_samps = 0;
int g_queued_nonsamps = 0;
int g_num_osc_interrupting = 0;
#if defined(HPUX) || defined(__linux__) || defined(_WIN32) || defined(MAC)
int g_audio_enable = -1;
#else
# if defined(OSS)
/* default to off for now */
int g_audio_enable = 0;
# else
/* Default to sound off */
int g_audio_enable = 0;
# endif
#endif
Doc_reg g_doc_regs[32];
word32 doc_reg_e0 = 0xff;
/* local function prototypes */
void doc_write_ctl_reg(int osc, int val, double dsamps);
int g_audio_rate = 0;
double g_daudio_rate = 0.0;
double g_drecip_audio_rate = 0.0;
double g_dsamps_per_dcyc = 0.0;
double g_dcycs_per_samp = 0.0;
float g_fsamps_per_dcyc = 0.0;
int g_doc_vol = 2;
#define MAX_C030_TIMES 18000
double g_last_sound_play_dsamp = 0.0;
float c030_fsamps[MAX_C030_TIMES + 1];
int g_num_c030_fsamps = 0;
#define DOC_SCAN_RATE (DCYCS_28_MHZ/32.0)
int g_pipe_fd[2] = { -1, -1 };
int g_pipe2_fd[2] = { -1, -1 };
word32 *g_sound_shm_addr = 0;
int g_sound_shm_pos = 0;
#define LEN_DOC_LOG 128
STRUCT(Doc_log) {
char *msg;
int osc;
double dsamps;
double dtmp2;
int etc;
Doc_reg doc_reg;
};
Doc_log g_doc_log[LEN_DOC_LOG];
int g_doc_log_pos = 0;
#ifdef DO_DOC_LOG
# define DOC_LOG(a,b,c,d) doc_log_rout(a,b,c,d)
#else
# define DOC_LOG(a,b,c,d)
#endif
#define UPDATE_G_DCYCS_PER_DOC_UPDATE(osc_en) \
g_dcycs_per_doc_update = (double)((osc_en + 2) * DCYCS_1_MHZ) / \
DOC_SCAN_RATE; \
g_dupd_per_dcyc = 1.0 / g_dcycs_per_doc_update; \
g_drecip_osc_en_plus_2 = 1.0 / (double)(osc_en + 2);
#define SND_PTR_SHIFT 14
#define SND_PTR_SHIFT_DBL ((double)(1 << SND_PTR_SHIFT))
void
doc_log_rout(char *msg, int osc, double dsamps, int etc)
{
int pos;
pos = g_doc_log_pos;
g_doc_log[pos].msg = msg;
g_doc_log[pos].osc = osc;
g_doc_log[pos].dsamps = dsamps;
g_doc_log[pos].dtmp2 = g_last_sound_play_dsamp;
g_doc_log[pos].etc = etc;
if(osc >= 0 && osc < 32) {
g_doc_log[pos].doc_reg = g_doc_regs[osc];
}
pos++;
if(pos >= LEN_DOC_LOG) {
pos = 0;
}
doc_printf("log: %s, osc:%d dsamp:%f, etc:%d\n", msg, osc, dsamps, etc);
g_doc_log_pos = pos;
}
extern double g_cur_dcycs;
void
show_doc_log(void)
{
FILE *docfile;
Doc_reg *rptr;
double dsamp_start;
int osc, ctl, freq;
int pos;
int i;
docfile = fopen("doc_log_out", "w");
if(docfile == 0) {
printf("fopen failed, errno: %d\n", errno);
return;
}
pos = g_doc_log_pos;
fprintf(docfile, "DOC log pos: %d\n", pos);
dsamp_start = g_doc_log[pos].dsamps;
for(i = 0; i < LEN_DOC_LOG; i++) {
rptr = &(g_doc_log[pos].doc_reg);
osc = g_doc_log[pos].osc;
ctl = rptr->ctl;
freq = rptr->freq;
if(osc < 0) {
ctl = 0;
freq = 0;
}
fprintf(docfile, "%03x:%03x: %-11s ds:%11.1f dt2:%10.1f "
"etc:%08x o:%02x c:%02x fq:%04x\n",
i, pos, g_doc_log[pos].msg,
g_doc_log[pos].dsamps - dsamp_start,
g_doc_log[pos].dtmp2,
g_doc_log[pos].etc, osc & 0xff, ctl, freq);
if(osc >= 0) {
fprintf(docfile, " ire:%d,%d,%d ptr4:%08x "
"inc4:%08x comp_ds:%.1f left:%04x, vol:%02x "
"wptr:%02x, wsz:%02x, 4st:%08x, 4end:%08x\n",
rptr->has_irq_pending, rptr->running,
rptr->event, 4*rptr->cur_acc, 4*rptr->cur_inc,
rptr->complete_dsamp - dsamp_start,
rptr->samps_left, rptr->vol, rptr->waveptr,
rptr->wavesize, 4*rptr->cur_start,
4*rptr->cur_end);
}
pos++;
if(pos >= LEN_DOC_LOG) {
pos = 0;
}
}
fprintf(docfile, "cur_dcycs: %f\n", g_cur_dcycs);
fprintf(docfile, "dsamps_now: %f\n",
(g_cur_dcycs * g_dsamps_per_dcyc) - dsamp_start);
fprintf(docfile, "g_doc_num_osc_en: %d\n", g_doc_num_osc_en);
fclose(docfile);
}
void
sound_init()
{
Doc_reg *rptr;
int i;
for(i = 0; i < 32; i++) {
rptr = &(g_doc_regs[i]);
rptr->dsamp_ev = 0.0;
rptr->dsamp_ev2 = 0.0;
rptr->complete_dsamp = 0.0;
rptr->samps_left = 0;
rptr->cur_acc = 0;
rptr->cur_inc = 0;
rptr->cur_start = 0;
rptr->cur_end = 0;
rptr->cur_mask = 0;
rptr->size_bytes = 0;
rptr->event = 0;
rptr->running = 0;
rptr->has_irq_pending = 0;
rptr->freq = 0;
rptr->vol = 0;
rptr->waveptr = 0;
rptr->ctl = 1;
rptr->wavesize = 0;
rptr->last_samp_val = 0;
}
sound_init_general();
}
void
sound_init_general()
{
#if !defined(_WIN32) && !defined(__CYGWIN__) && !defined(MAC)
int pid;
int shmid;
int tmp;
int i;
#endif
word32 *shmaddr;
int size;
int ret;
#if !defined(_WIN32) && !defined(__CYGWIN__) && !defined(MAC)
if(!g_use_shmem) {
if(g_audio_enable < 0) {
printf("Defaulting audio off for slow X display\n");
g_audio_enable = 0;
}
}
#endif
ret = 0;
if(g_audio_enable == 0) {
set_audio_rate(g_preferred_rate);
return;
}
size = SOUND_SHM_SAMP_SIZE * SAMPLE_CHAN_SIZE;
#if !defined(_WIN32) && !defined(__CYGWIN__) && !defined(MAC)
shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | 0777);
if(shmid < 0) {
printf("sound_init: shmget ret: %d, errno: %d\n", shmid,
errno);
exit(2);
}
shmaddr = shmat(shmid, 0, 0);
tmp = (int)PTR2WORD(shmaddr);
if(tmp == -1) {
printf("sound_init: shmat ret: %p, errno: %d\n", shmaddr,
errno);
exit(3);
}
ret = shmctl(shmid, IPC_RMID, 0);
if(ret < 0) {
printf("sound_init: shmctl ret: %d, errno: %d\n", ret, errno);
exit(4);
}
#else
/* windows and mac */
shmaddr = malloc(size);
memset(shmaddr, 0, size);
#endif
g_sound_shm_addr = shmaddr;
fflush(stdout);
#if !defined(MAC) && !defined(_WIN32) && !defined(__CYGWIN__)
/* prepare pipe so parent can signal child each other */
/* pipe[0] = read side, pipe[1] = write end */
ret = pipe(&g_pipe_fd[0]);
if(ret < 0) {
printf("sound_init: pipe ret: %d, errno: %d\n", ret, errno);
exit(5);
}
ret = pipe(&g_pipe2_fd[0]);
if(ret < 0) {
printf("sound_init: pipe ret: %d, errno: %d\n", ret, errno);
exit(5);
}
printf("pipes: pipe_fd = %d, %d pipe2_fd: %d,%d\n",
g_pipe_fd[0], g_pipe_fd[1], g_pipe2_fd[0], g_pipe2_fd[1]);
fflush(stdout);
pid = fork();
switch(pid) {
case 0:
/* child */
/* close stdin and write-side of pipe */
close(0);
/* Close other fds to make sure X window fd is closed */
for(i = 3; i < 100; i++) {
if((i != g_pipe_fd[0]) && (i != g_pipe2_fd[1])) {
close(i);
}
}
close(g_pipe_fd[1]); /*make sure write pipe closed*/
close(g_pipe2_fd[0]); /*make sure read pipe closed*/
child_sound_loop(g_pipe_fd[0], g_pipe2_fd[1], g_sound_shm_addr);
printf("Child sound loop returned\n");
exit(0);
case -1:
/* error */
printf("sound_init: fork ret: -1, errno: %d\n", errno);
exit(6);
default:
/* parent */
/* close read-side of pipe1, and the write side of pipe2 */
close(g_pipe_fd[0]);
close(g_pipe2_fd[1]);
doc_printf("Child is pid: %d\n", pid);
}
parent_sound_get_sample_rate(g_pipe2_fd[0]);
#else
# ifdef MAC
macsnd_init(shmaddr);
# else
/* windows */
win32snd_init(shmaddr);
# endif
#endif /* _WIN32 */
}
void
parent_sound_get_sample_rate(int read_fd)
{
word32 tmp;
int ret;
ret = read(read_fd, &tmp, 4);
if(ret != 4) {
printf("parent dying, could not get sample rate from child\n");
printf("ret: %d, fd: %d errno:%d\n", ret, read_fd, errno);
exit(1);
}
close(read_fd);
set_audio_rate(tmp);
}
void
set_audio_rate(int rate)
{
g_audio_rate = rate;
g_daudio_rate = (rate)*1.0;
g_drecip_audio_rate = 1.0/(rate);
g_dsamps_per_dcyc = ((rate*1.0) / DCYCS_1_MHZ);
g_dcycs_per_samp = (DCYCS_1_MHZ / (rate*1.0));
g_fsamps_per_dcyc = (float)((rate*1.0) / DCYCS_1_MHZ);
}
void
sound_reset(double dcycs)
{
double dsamps;
int i;
dsamps = dcycs * g_dsamps_per_dcyc;
for(i = 0; i < 32; i++) {
doc_write_ctl_reg(i, g_doc_regs[i].ctl | 1, dsamps);
doc_reg_e0 = 0xff;
if(g_doc_regs[i].has_irq_pending) {
halt_printf("reset: has_irq[%02x] = %d\n", i,
g_doc_regs[i].has_irq_pending);
}
g_doc_regs[i].has_irq_pending = 0;
}
if(g_num_osc_interrupting) {
halt_printf("reset: num_osc_int:%d\n", g_num_osc_interrupting);
}
g_num_osc_interrupting = 0;
g_doc_num_osc_en = 1;
UPDATE_G_DCYCS_PER_DOC_UPDATE(1);
}
void
sound_shutdown()
{
#ifdef _WIN32
win32snd_shutdown();
#else
if((g_audio_enable != 0) && g_pipe_fd[1] != 0) {
close(g_pipe_fd[1]);
}
#endif
}
void
sound_update(double dcycs)
{
double dsamps;
/* Called every VBL time to update sound status */
/* "play" sounds for this vbl */
dsamps = dcycs * g_dsamps_per_dcyc;
DOC_LOG("do_snd_pl", -1, dsamps, 0);
sound_play(dsamps);
}
#define MAX_SND_BUF 65536
int g_samp_buf[2*MAX_SND_BUF];
word32 zero_buf[SOUND_SHM_SAMP_SIZE];
double g_doc_dsamps_extra = 0.0;
float g_fvoices = 0.0;
word32 g_cycs_in_sound1 = 0;
word32 g_cycs_in_sound2 = 0;
word32 g_cycs_in_sound3 = 0;
word32 g_cycs_in_sound4 = 0;
word32 g_cycs_in_start_sound = 0;
word32 g_cycs_in_est_sound = 0;
int g_num_snd_plays = 0;
int g_num_doc_events = 0;
int g_num_start_sounds = 0;
int g_num_scan_osc = 0;
int g_num_recalc_snd_parms = 0;
word32 g_last_c030_vbl_count = 0;
int g_c030_state = 0;
#define VAL_C030_RANGE (32768)
#define VAL_C030_BASE (-16384)
int g_sound_file_num = 0;
int g_sound_file_fd = -1;
int g_send_sound_to_file = 0;
int g_send_file_bytes = 0;
void
open_sound_file()
{
char name[256];
int fd;
sprintf(name, "snd.out.%d", g_sound_file_num);
fd = open(name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0x1ff);
if(fd < 0) {
printf("open_sound_file open ret: %d, errno: %d\n", fd, errno);
exit(1);
}
g_sound_file_fd = fd;
g_sound_file_num++;
g_send_file_bytes = 0;
}
void
close_sound_file()
{
if(g_sound_file_fd >= 0) {
close(g_sound_file_fd);
}
g_sound_file_fd = -1;
}
void
check_for_range(word32 *addr, int num_samps, int offset)
{
short *shortptr;
int i;
int left;
int right;
int max;
max = -32768;
if(num_samps > SOUND_SHM_SAMP_SIZE) {
halt_printf("num_samps: %d > %d!\n", num_samps,
SOUND_SHM_SAMP_SIZE);
}
for(i = 0; i < num_samps; i++) {
shortptr = (short *)&(addr[i]);
left = shortptr[0];
right = shortptr[1];
if((left > 0x3000) || (right > 0x3000)) {
halt_printf("Sample %d of %d at snd_buf: %p is: "
"%d/%d\n", i + offset, num_samps,
&addr[i], left, right);
return;
}
max = MAX(max, left);
max = MAX(max, right);
}
printf("check4 max: %d over %d\n", max, num_samps);
}
void
send_sound_to_file(word32 *addr, int shm_pos, int num_samps)
{
int size;
int ret;
if(g_sound_file_fd < 0) {
open_sound_file();
}
size = 0;
if((num_samps + shm_pos) > SOUND_SHM_SAMP_SIZE) {
size = SOUND_SHM_SAMP_SIZE - shm_pos;
g_send_file_bytes += (size * 4);
ret = write(g_sound_file_fd, &(addr[shm_pos]), 4*size);
if(ret != 4*size) {
halt_printf("wrote %d not %d\n", ret, 4*size);
}
if(g_doc_vol < 3) {
check_for_range(&(addr[shm_pos]), size, 0);
} else {
printf("Not checking %d bytes since vol: %d\n",
4*size, g_doc_vol);
}
shm_pos = 0;
num_samps -= size;
}
g_send_file_bytes += (num_samps * 4);
ret = write(g_sound_file_fd, &(addr[shm_pos]), 4*num_samps);
if(ret != 4*num_samps) {
halt_printf("wrote %d not %d\n", ret, 4*num_samps);
}
if(g_doc_vol < 3) {
check_for_range(&(addr[shm_pos]), num_samps, size);
} else {
printf("Not checking2 %d bytes since vol: %d\n",
4*num_samps, g_doc_vol);
}
}
void
send_sound(int real_samps, int size)
{
word32 tmp;
int ret;
if(g_audio_enable == 0) {
printf("Entered send_sound but audio off!\n");
exit(2);
}
if(real_samps) {
tmp = size + 0xa2000000;
} else {
tmp = size + 0xa1000000;
}
DOC_LOG("send_sound", -1, g_last_sound_play_dsamp,
(real_samps << 30) + size);
#if defined(MAC) || defined(_WIN32)
ret = 0;
child_sound_playit(tmp);
#else
/* Although this looks like a big/little-endian issue, since the */
/* child is also reading an int, it just works with no byte swap */
ret = write(g_pipe_fd[1], &tmp, 4);
if(ret != 4) {
halt_printf("send_sound, wr ret: %d, errno: %d\n", ret, errno);
}
#endif
}
void
show_c030_state()
{
show_c030_samps(&(g_samp_buf[0]), 100);
}
void
show_c030_samps(int *outptr, int num)
{
int i;
printf("c030_fsamps[]: %d\n", g_num_c030_fsamps);
for(i = 0; i < g_num_c030_fsamps+2; i++) {
printf("%3d: %5.3f\n", i, c030_fsamps[i]);
}
printf("Samples[] = %d\n", num);
for(i = 0; i < num+2; i++) {
printf("%4d: %d %d\n", i, outptr[0], outptr[1]);
outptr += 2;
}
}
int g_sound_play_depth = 0;
void
sound_play(double dsamps)
{
register word32 start_time1, start_time2, start_time3, start_time4;
register word32 end_time1, end_time2, end_time3;
Doc_reg *rptr;
int *outptr;
int *outptr_start;
word32 *sndptr;
double complete_dsamp;
double cur_dsamp;
double last_dsamp;
double dsamp_now;
double dnum_samps;
int val, val2;
int new_val;
float ftmp;
int imul;
int off;
int num;
float fsampnum;
float next_fsampnum;
int c030_lo_val, c030_hi_val;
float fc030_range;
float fc030_base;
int sampnum;
int next_sampnum;
float fpercent;
int c030_state;
int val0, val1;
word32 cur_acc;
word32 cur_pos;
word32 cur_mask;
word32 cur_inc;
word32 cur_end;
int ctl;
int num_osc_en;
int samps_left;
int samps_to_do;
int samps_played;
int samp_offset;
int snd_buf_init;
int pos;
int num_running;
int num_samps;
int osc;
int done;
int i, j;
GET_ITIMER(start_time1);
g_num_snd_plays++;
if(g_sound_play_depth) {
halt_printf("Nested sound_play!\n");
}
g_sound_play_depth++;
/* calc sample num */
last_dsamp = g_last_sound_play_dsamp;
num_samps = (int)(dsamps - g_last_sound_play_dsamp);
dnum_samps = (double)num_samps;
dsamp_now = last_dsamp + dnum_samps;
if(num_samps < 1) {
/* just say no */
g_sound_play_depth--;
return;
}
DOC_LOG("sound_play", -1, dsamp_now, num_samps);
if(num_samps > MAX_SND_BUF) {
printf("num_samps: %d, too big!\n", num_samps);
g_sound_play_depth--;
return;
}
GET_ITIMER(start_time4);
outptr_start = &(g_samp_buf[0]);
outptr = outptr_start;
snd_buf_init = 0;
samps_played = 0;
num = g_num_c030_fsamps;
if(num || ((g_vbl_count - g_last_c030_vbl_count) < 240)) {
if(num) {
g_last_c030_vbl_count = g_vbl_count;
}
pos = 0;
outptr = outptr_start;
c030_state = g_c030_state;
c030_hi_val = ((VAL_C030_BASE + VAL_C030_RANGE)*g_doc_vol) >> 4;
c030_lo_val = (VAL_C030_BASE * g_doc_vol) >> 4;
fc030_range = (float)(((VAL_C030_RANGE) * g_doc_vol) >> 4);
fc030_base = (float)(((VAL_C030_BASE) * g_doc_vol) >> 4);
val = c030_lo_val;
if(c030_state) {
val = c030_hi_val;
}
snd_buf_init++;
c030_fsamps[num] = (float)(num_samps);
c030_fsamps[num+1] = (float)(num_samps+1);
ftmp = (float)num_samps;
/* ensure that all samps are in range */
for(i = num - 1; i >= 0; i--) {
if(c030_fsamps[i] > ftmp) {
c030_fsamps[i] = ftmp;
}
}
num++;
fsampnum = c030_fsamps[0];
sampnum = (int)fsampnum;
fpercent = (float)0.0;
i = 0;
while(i < num) {
next_fsampnum = c030_fsamps[i+1];
next_sampnum = (int)next_fsampnum;
if(sampnum < 0 || sampnum > num_samps) {
halt_printf("play c030: [%d]:%f is %d, > %d\n",
i, fsampnum, sampnum, num_samps);
break;
}
/* write in samples to all samps < me */
new_val = c030_lo_val;
if(c030_state) {
new_val = c030_hi_val;
}
for(j = pos; j < sampnum; j++) {
outptr[0] = new_val;
outptr[1] = new_val;
outptr += 2;
pos++;
}
/* now, calculate me */
fpercent = (float)0.0;
if(c030_state) {
fpercent = (fsampnum - (float)sampnum);
}
c030_state = !c030_state;
while(next_sampnum == sampnum) {
if(c030_state) {
fpercent += (next_fsampnum - fsampnum);
}
i++;
fsampnum = next_fsampnum;
next_fsampnum = c030_fsamps[i+1];
next_sampnum = (int)next_fsampnum;
c030_state = !c030_state;
}
if(c030_state) {
/* add in fractional time */
ftmp = (int)(fsampnum + (float)1.0);
fpercent += (ftmp - fsampnum);
}
if((fpercent < (float)0.0) || (fpercent > (float)1.0)) {
halt_printf("fpercent: %d = %f\n", i, fpercent);
show_c030_samps(outptr_start, num_samps);
break;
}
val = (int)((fpercent * fc030_range) + fc030_base);
outptr[0] = val;
outptr[1] = val;
outptr += 2;
pos++;
i++;
sampnum = next_sampnum;
fsampnum = next_fsampnum;
}
samps_played += num_samps;
/* since we pretended to get one extra sample, we will */
/* have toggled the speaker one time too many. Fix it */
g_c030_state = !c030_state;
if(g_send_sound_to_file) {
show_c030_samps(outptr_start, num_samps);
}
}
g_num_c030_fsamps = 0;
GET_ITIMER(start_time2);
num_running = 0;
num_osc_en = g_doc_num_osc_en;
done = 0;
while(!done) {
done = 1;
for(j = 0; j < num_osc_en; j++) {
osc = j;
rptr = &(g_doc_regs[osc]);
complete_dsamp = rptr->complete_dsamp;
samps_left = rptr->samps_left;
cur_acc = rptr->cur_acc;
cur_mask = rptr->cur_mask;
cur_inc = rptr->cur_inc;
cur_end = rptr->cur_end;
if(!rptr->running || cur_inc == 0 ||
(complete_dsamp >= dsamp_now)) {
continue;
}
done = 0;
ctl = rptr->ctl;
samp_offset = 0;
if(complete_dsamp > last_dsamp) {
samp_offset = (int)(complete_dsamp- last_dsamp);
if(samp_offset > num_samps) {
rptr->complete_dsamp = dsamp_now;
continue;
}
}
outptr = outptr_start + 2 * samp_offset;
if(ctl & 0x10) {
/* other channel */
outptr += 1;
}
imul = (rptr->vol * g_doc_vol);
off = imul * 128;
samps_to_do = MIN(samps_left, num_samps - samp_offset);
if(imul == 0 || samps_to_do == 0) {
/* produce no sound */
samps_left = samps_left - samps_to_do;
cur_acc += cur_inc * samps_to_do;
rptr->samps_left = samps_left;
rptr->cur_acc = cur_acc;
cur_dsamp = last_dsamp +
(double)(samps_to_do + samp_offset);
DOC_LOG("nosnd", osc, cur_dsamp, samps_to_do);
rptr->complete_dsamp = dsamp_now;
cur_pos = rptr->cur_start+(cur_acc & cur_mask);
if(samps_left <= 0) {
doc_sound_end(osc, 1, cur_dsamp,
dsamp_now);
val = 0;
j--;
} else {
val = doc_ram[cur_pos >> SND_PTR_SHIFT];
}
rptr->last_samp_val = val;
continue;
}
if(snd_buf_init == 0) {
memset(outptr_start, 0,
2*sizeof(outptr_start[0])*num_samps);
snd_buf_init++;
}
val = 0;
rptr->complete_dsamp = dsamp_now;
cur_pos = rptr->cur_start + (cur_acc & cur_mask);
for(i = 0; i < samps_to_do; i++) {
pos = cur_pos >> SND_PTR_SHIFT;
cur_pos += cur_inc;
cur_acc += cur_inc;
val = doc_ram[pos];
val2 = (val * imul - off) >> 4;
if((val == 0) || (cur_pos >= cur_end)) {
cur_dsamp = last_dsamp +
(double)(samp_offset + i + 1);
rptr->cur_acc = cur_acc;
rptr->samps_left = 0;
DOC_LOG("end or 0", osc, cur_dsamp,
(pos << 16) + ((i &0xff) << 8) +
val);
doc_sound_end(osc, val, cur_dsamp,
dsamp_now);
val = 0;
break;
}
val2 = outptr[0] + val2;
samps_left--;
*outptr = val2;
outptr += 2;
}
rptr->last_samp_val = val;
if(val != 0) {
rptr->cur_acc = cur_acc;
rptr->samps_left = samps_left;
rptr->complete_dsamp = dsamp_now;
}
samps_played += samps_to_do;
DOC_LOG("splayed", osc, dsamp_now,
(samps_to_do << 16) + (pos & 0xffff));
}
}
GET_ITIMER(end_time2);
g_cycs_in_sound2 += (end_time2 - start_time2);
g_last_sound_play_dsamp = dsamp_now;
GET_ITIMER(start_time3);
outptr = outptr_start;
pos = g_sound_shm_pos;
sndptr = g_sound_shm_addr;
#if 0
printf("samps_left: %d, num_samps: %d\n", samps_left, num_samps);
#endif
if(g_audio_enable != 0) {
if(snd_buf_init) {
/* convert sound buf */
for(i = 0; i < num_samps; i++) {
val0 = outptr[0];
val1 = outptr[1];
val = val0;
if(val0 > 32767) {
val = 32767;
}
if(val0 < -32768) {
val = -32768;
}
val0 = val;
val = val1;
if(val1 > 32767) {
val = 32767;
}
if(val1 < -32768) {
val = -32768;
}
outptr += 2;
#if defined(__linux__) || defined(OSS)
/* Linux seems to expect little-endian */
/* samples always, even on PowerPC */
# ifdef KEGS_LITTLE_ENDIAN
sndptr[pos] = (val << 16) + (val0 & 0xffff);
# else
sndptr[pos] = ((val & 0xff) << 24) +
((val & 0xff00) << 8) +
((val0 & 0xff) << 8) +
((val0 >> 8) & 0xff);
# endif
#else
# ifdef KEGS_LITTLE_ENDIAN
sndptr[pos] = (val << 16) + (val0 & 0xffff);
# else
sndptr[pos] = (val0 << 16) + (val & 0xffff);
# endif
#endif
pos++;
if(pos >= SOUND_SHM_SAMP_SIZE) {
pos = 0;
}
}
if(g_queued_nonsamps) {
/* force out old 0 samps */
send_sound(0, g_queued_nonsamps);
g_queued_nonsamps = 0;
}
if(g_send_sound_to_file) {
send_sound_to_file(g_sound_shm_addr,
g_sound_shm_pos, num_samps);
}
g_queued_samps += num_samps;
} else {
/* move pos */
pos += num_samps;
while(pos >= SOUND_SHM_SAMP_SIZE) {
pos -= SOUND_SHM_SAMP_SIZE;
}
if(g_send_sound_to_file) {
send_sound_to_file(zero_buf, g_sound_shm_pos,
num_samps);
}
if(g_queued_samps) {
/* force out old non-0 samps */
send_sound(1, g_queued_samps);
g_queued_samps = 0;
}
g_queued_nonsamps += num_samps;
}
}
g_sound_shm_pos = pos;
GET_ITIMER(end_time3);
g_fvoices += ((float)(samps_played) * (float)(g_drecip_audio_rate));
if(g_audio_enable != 0) {
if(g_queued_samps >= (g_audio_rate/32)) {
send_sound(1, g_queued_samps);
g_queued_samps = 0;
}
if(g_queued_nonsamps >= (g_audio_rate/32)) {
send_sound(0, g_queued_nonsamps);
g_queued_nonsamps = 0;
}
}
GET_ITIMER(end_time1);
g_cycs_in_sound1 += (end_time1 - start_time1);
g_cycs_in_sound3 += (end_time3 - start_time3);
g_cycs_in_sound4 += (start_time2 - start_time4);
g_last_sound_play_dsamp = dsamp_now;
g_sound_play_depth--;
}
void
doc_handle_event(int osc, double dcycs)
{
double dsamps;
/* handle osc stopping and maybe interrupting */
g_num_doc_events++;
dsamps = dcycs * g_dsamps_per_dcyc;
DOC_LOG("doc_ev", osc, dcycs, 0);
g_doc_regs[osc].event = 0;
sound_play(dsamps);
}
void
doc_sound_end(int osc, int can_repeat, double eff_dsamps, double dsamps)
{
Doc_reg *rptr, *orptr;
int mode, omode;
int other_osc;
int one_shot_stop;
int ctl;
/* handle osc stopping and maybe interrupting */
if(osc < 0 || osc > 31) {
printf("doc_handle_event: osc: %d!\n", osc);
return;
}
rptr = &(g_doc_regs[osc]);
ctl = rptr->ctl;
if(rptr->event) {
remove_event_doc(osc);
}
rptr->event = 0;
rptr->cur_acc = 0; /* reset internal accumulator*/
/* check to make sure osc is running */
if(ctl & 0x01) {
/* Oscillator already stopped. */
halt_printf("Osc %d interrupt, but it was already stop!\n",osc);
#ifdef HPUX
U_STACK_TRACE();
#endif
return;
}
if(ctl & 0x08) {
if(rptr->has_irq_pending == 0) {
add_sound_irq(osc);
}
}
if(!rptr->running) {
halt_printf("Doc event for osc %d, but ! running\n", osc);
}
rptr->running = 0;
mode = (ctl >> 1) & 3;
other_osc = osc ^ 1;
orptr = &(g_doc_regs[other_osc]);
omode = (orptr->ctl >> 1) & 3;
/* If either this osc or it's partner is in swap mode, treat the */
/* pair as being in swap mode. This Ensoniq feature pointed out */
/* by Ian Schmidt */
if(mode == 0 && can_repeat) {
/* free-running mode with no 0 byte! */
/* start doing it again */
start_sound(osc, eff_dsamps, dsamps);
return;
} else if((mode == 3) || (omode == 3)) {
/* swap mode (even if we're one_shot and partner is swap)! */
/* unless we're one-shot and we hit a 0-byte--then */
/* Olivier Goguel says just stop */
rptr->ctl |= 1;
one_shot_stop = (mode == 1) && (!can_repeat);
if(!one_shot_stop && !orptr->running &&
(orptr->ctl & 0x1)) {
orptr->ctl = orptr->ctl & (~1);
start_sound(other_osc, eff_dsamps, dsamps);
}
return;
} else {
/* stop the oscillator */
rptr->ctl |= 1;
}
return;
}
void
add_sound_irq(int osc)
{
int num_osc_interrupting;
if(g_doc_regs[osc].has_irq_pending) {
halt_printf("Adding sound_irq for %02x, but irq_p: %d\n", osc,
g_doc_regs[osc].has_irq_pending);
}
num_osc_interrupting = g_num_osc_interrupting + 1;
g_doc_regs[osc].has_irq_pending = num_osc_interrupting;
g_num_osc_interrupting = num_osc_interrupting;
add_irq(IRQ_PENDING_DOC);
if(num_osc_interrupting == 1) {
doc_reg_e0 = 0x00 + (osc << 1);
}
DOC_LOG("add_irq", osc, g_cur_dcycs * g_dsamps_per_dcyc, 0);
}
void
remove_sound_irq(int osc, int must)
{
Doc_reg *rptr;
int num_osc_interrupt;
int has_irq_pending;
int first;
int i;
doc_printf("remove irq for osc: %d, has_irq: %d\n",
osc, g_doc_regs[osc].has_irq_pending);
num_osc_interrupt = g_doc_regs[osc].has_irq_pending;
first = 0;
if(num_osc_interrupt) {
g_num_osc_interrupting--;
g_doc_regs[osc].has_irq_pending = 0;
DOC_LOG("rem_irq", osc, g_cur_dcycs * g_dsamps_per_dcyc, 0);
if(g_num_osc_interrupting == 0) {
remove_irq(IRQ_PENDING_DOC);
}
first = 0x40 | (doc_reg_e0 >> 1);
/* if none found, then def = no ints */
for(i = 0; i < g_doc_num_osc_en; i++) {
rptr = &(g_doc_regs[i]);
has_irq_pending = rptr->has_irq_pending;
if(has_irq_pending > num_osc_interrupt) {
has_irq_pending--;
rptr->has_irq_pending = has_irq_pending;
}
if(has_irq_pending == 1) {
first = i;
}
}
if(num_osc_interrupt == 1) {
doc_reg_e0 = (first << 1);
} else {
#if 0
halt_printf("remove_sound_irq[%02x]=%d, first:%d\n",
osc, num_osc_interrupt, first);
#endif
}
} else {
#if 0
/* make sure no int pending */
if(doc_reg_e0 != 0xff) {
halt_printf("remove_sound_irq[%02x]=0, but e0: %02x\n",
osc, doc_reg_e0);
}
#endif
if(must) {
halt_printf("REMOVE_sound_irq[%02x]=0, but e0: %02x\n",
osc, doc_reg_e0);
}
}
if(doc_reg_e0 & 0x80) {
for(i = 0; i < 0x20; i++) {
has_irq_pending = g_doc_regs[i].has_irq_pending;
if(has_irq_pending) {
halt_printf("remove_sound_irq[%02x], but "
"[%02x]=%d!\n", osc,i,has_irq_pending);
printf("num_osc_int: %d, first: %02x\n",
num_osc_interrupt, first);
}
}
}
}
void
start_sound(int osc, double eff_dsamps, double dsamps)
{
register word32 start_time1;
register word32 end_time1;
Doc_reg *rptr;
int ctl;
int mode;
word32 sz;
word32 size;
word32 wave_size;
if(osc < 0 || osc > 31) {
halt_printf("start_sound: osc: %02x!\n", osc);
}
g_num_start_sounds++;
rptr = &(g_doc_regs[osc]);
if(osc >= g_doc_num_osc_en) {
rptr->ctl |= 1;
return;
}
GET_ITIMER(start_time1);
ctl = rptr->ctl;
mode = (ctl >> 1) & 3;
wave_size = rptr->wavesize;
sz = ((wave_size >> 3) & 7) + 8;
size = 1 << sz;
if(size < 0x100) {
halt_printf("size: %08x is too small, sz: %08x!\n", size, sz);
}
if(rptr->running) {
halt_printf("start_sound osc: %d, already running!\n", osc);
}
rptr->running = 1;
rptr->complete_dsamp = eff_dsamps;
doc_printf("Starting osc %02x, dsamp: %f\n", osc, dsamps);
doc_printf("size: %04x\n", size);
if((mode == 2) && ((osc & 1) == 0)) {
printf("Sync mode osc %d starting!\n", osc);
/* set_halt(1); */
/* see if we should start our odd partner */
if((rptr[1].ctl & 7) == 5) {
/* odd partner stopped in sync mode--start him */
rptr[1].ctl &= (~1);
start_sound(osc + 1, eff_dsamps, dsamps);
} else {
printf("Osc %d starting sync, but osc %d ctl: %02x\n",
osc, osc+1, rptr[1].ctl);
}
}
wave_end_estimate(osc, eff_dsamps, dsamps);
DOC_LOG("st playing", osc, eff_dsamps, size);
#if 0
if(rptr->cur_acc != 0) {
halt_printf("Start osc %02x, acc: %08x\n", osc, rptr->cur_acc);
}
#endif
GET_ITIMER(end_time1);
g_cycs_in_start_sound += (end_time1 - start_time1);
}
void
wave_end_estimate(int osc, double eff_dsamps, double dsamps)
{
register word32 start_time1;
register word32 end_time1;
Doc_reg *rptr;
byte *ptr1;
double event_dsamp;
double event_dcycs;
double dcycs_per_samp;
double dsamps_per_byte;
double num_dsamps;
double dcur_inc;
word32 tmp1;
word32 cur_inc;
word32 save_val;
int save_size;
int pos;
int size;
int estimate;
GET_ITIMER(start_time1);
dcycs_per_samp = g_dcycs_per_samp;
rptr = &(g_doc_regs[osc]);
cur_inc = rptr->cur_inc;
dcur_inc = (double)cur_inc;
dsamps_per_byte = 0.0;
if(cur_inc) {
dsamps_per_byte = SND_PTR_SHIFT_DBL / (double)dcur_inc;
}
/* see if there's a zero byte */
tmp1 = rptr->cur_start + (rptr->cur_acc & rptr->cur_mask);
pos = tmp1 >> SND_PTR_SHIFT;
size = ((rptr->cur_end) >> SND_PTR_SHIFT) - pos;
ptr1 = &doc_ram[pos];
estimate = 0;
if(rptr->ctl & 0x08 || g_doc_regs[osc ^ 1].ctl & 0x08) {
estimate = 1;
}
#if 0
estimate = 1;
#endif
if(estimate) {
save_size = size;
save_val = ptr1[size];
ptr1[size] = 0;
size = strlen((char *)ptr1);
ptr1[save_size] = save_val;
}
/* calc samples to play */
num_dsamps = (dsamps_per_byte * (double)size) + 1.0;
rptr->samps_left = (int)num_dsamps;
if(rptr->event) {
remove_event_doc(osc);
}
rptr->event = 0;
event_dsamp = eff_dsamps + num_dsamps;
if(estimate) {
rptr->event = 1;
rptr->dsamp_ev = event_dsamp;
rptr->dsamp_ev2 = dsamps;
event_dcycs = (event_dsamp * dcycs_per_samp) + 1.0;
add_event_doc(event_dcycs, osc);
}
GET_ITIMER(end_time1);
g_cycs_in_est_sound += (end_time1 - start_time1);
}
void
remove_sound_event(int osc)
{
if(g_doc_regs[osc].event) {
g_doc_regs[osc].event = 0;
remove_event_doc(osc);
}
}
void
doc_write_ctl_reg(int osc, int val, double dsamps)
{
Doc_reg *rptr;
double eff_dsamps;
word32 old_halt;
word32 new_halt;
int old_val;
int mode;
if(osc < 0 || osc >= 0x20) {
halt_printf("doc_write_ctl_reg: osc: %02x, val: %02x\n",
osc, val);
return;
}
eff_dsamps = dsamps;
rptr = &(g_doc_regs[osc]);
old_val = rptr->ctl;
g_doc_saved_ctl = old_val;
if(old_val == val) {
return;
}
DOC_LOG("ctl_reg", osc, dsamps, (old_val << 16) + val);
mode = (val >> 1) & 3;
old_halt = (old_val & 1);
new_halt = (val & 1);
/* bits are: 28: old int bit */
/* 29: old halt bit */
/* 30: new int bit */
/* 31: new halt bit */
#if 0
if(osc == 0x10) {
printf("osc %d new_ctl: %02x, old: %02x\n", osc, val, old_val);
}
#endif
/* no matter what, remove any pending IRQs on this osc */
remove_sound_irq(osc, 0);
#if 0
if(old_halt) {
printf("doc_write_ctl to osc %d, val: %02x, old: %02x\n",
osc, val, old_val);
}
#endif
if(new_halt != 0) {
/* make sure sound is stopped */
remove_sound_event(osc);
if(old_halt == 0) {
/* it was playing, finish it up */
#if 0
halt_printf("Aborted osc %d at eff_dsamps: %f, ctl: "
"%02x, oldctl: %02x\n", osc, eff_dsamps,
val, old_val);
#endif
sound_play(eff_dsamps);
}
if(((old_val >> 1) & 3) > 0) {
/* don't clear acc if free-running */
g_doc_regs[osc].cur_acc = 0;
}
g_doc_regs[osc].ctl = val;
g_doc_regs[osc].running = 0;
} else {
/* new halt == 0 = make sure sound is running */
if(old_halt != 0) {
/* start sound */
DOC_LOG("ctl_sound_play", osc, eff_dsamps, val);
sound_play(eff_dsamps);
g_doc_regs[osc].ctl = val;
start_sound(osc, eff_dsamps, dsamps);
} else {
/* was running, and something changed */
doc_printf("osc %d old ctl:%02x new:%02x!\n",
osc, old_val, val);
#if 0
sound_play(eff_dsamps);
/* HACK: fix this??? */
#endif
g_doc_regs[osc].ctl = val;
if((old_val ^ val) & val & 0x8) {
/* now has ints on */
wave_end_estimate(osc, dsamps, dsamps);
}
}
}
}
void
doc_recalc_sound_parms(int osc, double eff_dcycs, double dsamps)
{
Doc_reg *rptr;
double dfreq;
double dtmp1;
double dacc, dacc_recip;
word32 res;
word32 sz;
word32 size;
word32 wave_size;
word32 cur_start;
word32 shifted_size;
g_num_recalc_snd_parms++;
rptr = &(g_doc_regs[osc]);
wave_size = rptr->wavesize;
dfreq = (double)rptr->freq;
sz = ((wave_size >> 3) & 7) + 8;
size = 1 << sz;
rptr->size_bytes = size;
res = wave_size & 7;
shifted_size = size << SND_PTR_SHIFT;
cur_start = (rptr->waveptr << (8 + SND_PTR_SHIFT)) & (-shifted_size);
dtmp1 = dfreq * (DOC_SCAN_RATE * g_drecip_audio_rate);
dacc = (double)(1 << (20 - (17 - sz + res)));
dacc_recip = (SND_PTR_SHIFT_DBL) / ((double)(1 << 20));
dtmp1 = dtmp1 * g_drecip_osc_en_plus_2 * dacc * dacc_recip;
rptr->cur_inc = (int)(dtmp1);
rptr->cur_start = cur_start;
rptr->cur_end = cur_start + shifted_size;
rptr->cur_mask = (shifted_size - 1);
DOC_LOG("recalc", osc, dsamps, (rptr->waveptr << 16) + wave_size);
}
int
doc_read_c030(double dcycs)
{
int num;
num = g_num_c030_fsamps;
if(num >= MAX_C030_TIMES) {
halt_printf("Too many clicks per vbl: %d\n", num);
return 0;
}
c030_fsamps[num] = (float)(dcycs * g_dsamps_per_dcyc -
g_last_sound_play_dsamp);
g_num_c030_fsamps = num + 1;
doc_printf("read c030, num this vbl: %04x\n", num);
return 0;
}
int
doc_read_c03c(double dcycs)
{
return doc_sound_ctl;
}
int
doc_read_c03d(double dcycs)
{
double dsamps;
Doc_reg *rptr;
int osc;
int type;
int ret;
ret = doc_saved_val;
dsamps = dcycs * g_dsamps_per_dcyc;
if(doc_sound_ctl & 0x40) {
/* Read RAM */
doc_saved_val = doc_ram[g_c03ef_doc_ptr];
} else {
/* Read DOC */
doc_saved_val = 0;
osc = g_c03ef_doc_ptr & 0x1f;
type = (g_c03ef_doc_ptr >> 5) & 0x7;
rptr = &(g_doc_regs[osc]);
switch(type) {
case 0x0: /* freq lo */
doc_saved_val = rptr->freq & 0xff;
break;
case 0x1: /* freq hi */
doc_saved_val = rptr->freq >> 8;
break;
case 0x2: /* vol */
doc_saved_val = rptr->vol;
break;
case 0x3: /* data register */
/* HACK: make this call sound_play sometimes */
doc_saved_val = rptr->last_samp_val;
break;
case 0x4: /* wave ptr register */
doc_saved_val = rptr->waveptr;
break;
case 0x5: /* control register */
doc_saved_val = rptr->ctl;
break;
case 0x6: /* control register */
doc_saved_val = rptr->wavesize;
break;
case 0x7: /* 0xe0-0xff */
switch(osc) {
case 0x00: /* 0xe0 */
doc_saved_val = doc_reg_e0;
doc_printf("Reading doc 0xe0, ret: %02x\n",
doc_saved_val);
/* Clear IRQ on read of e0, if any irq pend */
if((doc_reg_e0 & 0x80) == 0) {
remove_sound_irq(doc_reg_e0 >> 1, 1);
}
break;
case 0x01: /* 0xe1 */
doc_saved_val = (g_doc_num_osc_en - 1) << 1;
break;
case 0x02: /* 0xe2 */
doc_saved_val = 0x80;
#if 0
halt_printf("Reading doc 0xe2, ret: %02x\n",
doc_saved_val);
#endif
break;
default:
doc_saved_val = 0;
halt_printf("Reading bad doc_reg[%04x]: %02x\n",
g_c03ef_doc_ptr, doc_saved_val);
}
break;
default:
doc_saved_val = 0;
halt_printf("Reading bad doc_reg[%04x]: %02x\n",
g_c03ef_doc_ptr, doc_saved_val);
}
}
doc_printf("read c03d, doc_ptr: %04x, ret: %02x, saved: %02x\n",
g_c03ef_doc_ptr, ret, doc_saved_val);
DOC_LOG("read c03d", -1, dsamps, (g_c03ef_doc_ptr << 16) +
(doc_saved_val << 8) + ret);
if(doc_sound_ctl & 0x20) {
g_c03ef_doc_ptr = (g_c03ef_doc_ptr + 1) & 0xffff;
}
return ret;
}
void
doc_write_c03c(int val, double dcycs)
{
int vol;
vol = val & 0xf;
if(g_doc_vol != vol) {
/* don't bother playing sound..wait till next update */
/* sound_play(dcycs); */
g_doc_vol = vol;
doc_printf("Setting doc vol to 0x%x at %f\n",
vol, dcycs);
}
DOC_LOG("c03c write", -1, dcycs * g_dsamps_per_dcyc, val);
doc_sound_ctl = val;
}
void
doc_write_c03d(int val, double dcycs)
{
double dsamps;
double eff_dsamps;
Doc_reg *rptr;
int osc;
int type;
int ctl;
int tmp;
int i;
val = val & 0xff;
dsamps = dcycs * g_dsamps_per_dcyc;
eff_dsamps = dsamps;
doc_printf("write c03d, doc_ptr: %04x, val: %02x\n",
g_c03ef_doc_ptr, val);
DOC_LOG("write c03d", -1, dsamps, (g_c03ef_doc_ptr << 16) + val);
if(doc_sound_ctl & 0x40) {
/* RAM */
doc_ram[g_c03ef_doc_ptr] = val;
} else {
/* DOC */
osc = g_c03ef_doc_ptr & 0x1f;
type = (g_c03ef_doc_ptr >> 5) & 0x7;
rptr = &(g_doc_regs[osc]);
ctl = rptr->ctl;
#if 0
if((ctl & 1) == 0) {
if(type < 2 || type == 4 || type == 6) {
halt_printf("Osc %d is running, old ctl: %02x, "
"but write reg %02x=%02x\n",
osc, ctl, g_c03ef_doc_ptr & 0xff, val);
}
}
#endif
switch(type) {
case 0x0: /* freq lo */
if((rptr->freq & 0xff) == (word32)val) {
break;
}
if((ctl & 1) == 0) {
/* play through current status */
DOC_LOG("flo_sound_play", osc, dsamps, val);
sound_play(dsamps);
}
rptr->freq = (rptr->freq & 0xff00) + val;
doc_recalc_sound_parms(osc, eff_dsamps, dsamps);
break;
case 0x1: /* freq hi */
if((rptr->freq >> 8) == (word32)val) {
break;
}
if((ctl & 1) == 0) {
/* play through current status */
DOC_LOG("fhi_sound_play", osc, dsamps, val);
sound_play(dsamps);
}
rptr->freq = (rptr->freq & 0xff) + (val << 8);
doc_recalc_sound_parms(osc, eff_dsamps, dsamps);
break;
case 0x2: /* vol */
if(rptr->vol == (word32)val) {
break;
}
if((ctl & 1) == 0) {
/* play through current status */
DOC_LOG("vol_sound_play", osc, dsamps, val);
sound_play(dsamps);
#if 0
halt_printf("vol_sound_play at %.1f osc:%d "
"val:%d\n", dsamps, osc, val);
#endif
}
rptr->vol = val;
break;
case 0x3: /* data register */
#if 0
printf("Writing %02x into doc_data_reg[%02x]!\n",
val, osc);
#endif
break;
case 0x4: /* wave ptr register */
if(rptr->waveptr == (word32)val) {
break;
}
if((ctl & 1) == 0) {
/* play through current status */
DOC_LOG("wptr_sound_play", osc, dsamps, val);
sound_play(dsamps);
}
rptr->waveptr = val;
doc_recalc_sound_parms(osc, eff_dsamps, dsamps);
break;
case 0x5: /* control register */
#if 0
printf("doc_write ctl osc %d, val: %02x\n", osc, val);
#endif
if(rptr->ctl == (word32)val) {
break;
}
doc_write_ctl_reg(osc, val, dsamps);
break;
case 0x6: /* wavesize register */
if(rptr->wavesize == (word32)val) {
break;
}
if((ctl & 1) == 0) {
/* play through current status */
DOC_LOG("wsz_sound_play", osc, dsamps, val);
sound_play(dsamps);
}
rptr->wavesize = val;
doc_recalc_sound_parms(osc, eff_dsamps, dsamps);
break;
case 0x7: /* 0xe0-0xff */
switch(osc) {
case 0x00: /* 0xe0 */
doc_printf("writing doc 0xe0 with %02x, "
"was:%02x\n", val, doc_reg_e0);
#if 0
if(val != doc_reg_e0) {
halt_printf("writing doc 0xe0 with "
"%02x, was:%02x\n", val,
doc_reg_e0);
}
#endif
break;
case 0x01: /* 0xe1 */
doc_printf("Writing doc 0xe1 with %02x\n", val);
tmp = val & 0x3e;
tmp = (tmp >> 1) + 1;
if(tmp < 1) {
tmp = 1;
}
if(tmp > 32) {
halt_printf("doc 0xe1: %02x!\n", val);
tmp = 32;
}
g_doc_num_osc_en = tmp;
UPDATE_G_DCYCS_PER_DOC_UPDATE(tmp);
/* Stop any oscs that were running but now */
/* are disabled */
for(i = g_doc_num_osc_en; i < 0x20; i++) {
doc_write_ctl_reg(i,
g_doc_regs[i].ctl | 1, dsamps);
}
break;
default:
/* this should be illegal, but Turkey Shoot */
/* and apparently TaskForce, OOTW, etc */
/* writes to e2-ff, for no apparent reason */
doc_printf("Writing doc 0x%x with %02x\n",
g_c03ef_doc_ptr, val);
break;
}
break;
default:
halt_printf("Writing %02x into bad doc_reg[%04x]\n",
val, g_c03ef_doc_ptr);
}
}
if(doc_sound_ctl & 0x20) {
g_c03ef_doc_ptr = (g_c03ef_doc_ptr + 1) & 0xffff;
}
doc_saved_val = val;
}
void
doc_show_ensoniq_state(int osc)
{
Doc_reg *rptr;
int i;
printf("Ensoniq state\n");
printf("c03c doc_sound_ctl: %02x, doc_saved_val: %02x\n",
doc_sound_ctl, doc_saved_val);
printf("doc_ptr: %04x, num_osc_en: %02x, e0: %02x\n",
g_c03ef_doc_ptr, g_doc_num_osc_en, doc_reg_e0);
for(i = 0; i < 32; i += 8) {
printf("irqp: %02x: %04x %04x %04x %04x %04x %04x %04x %04x\n",
i,
g_doc_regs[i].has_irq_pending,
g_doc_regs[i + 1].has_irq_pending,
g_doc_regs[i + 2].has_irq_pending,
g_doc_regs[i + 3].has_irq_pending,
g_doc_regs[i + 4].has_irq_pending,
g_doc_regs[i + 5].has_irq_pending,
g_doc_regs[i + 6].has_irq_pending,
g_doc_regs[i + 7].has_irq_pending);
}
for(i = 0; i < 32; i += 8) {
printf("freq: %02x: %04x %04x %04x %04x %04x %04x %04x %04x\n",
i,
g_doc_regs[i].freq, g_doc_regs[i + 1].freq,
g_doc_regs[i + 2].freq, g_doc_regs[i + 3].freq,
g_doc_regs[i + 4].freq, g_doc_regs[i + 5].freq,
g_doc_regs[i + 6].freq, g_doc_regs[i + 7].freq);
}
for(i = 0; i < 32; i += 8) {
printf("vol: %02x: %02x %02x %02x %02x %02x %02x %02x %02x\n",
i,
g_doc_regs[i].vol, g_doc_regs[i + 1].vol,
g_doc_regs[i + 2].vol, g_doc_regs[i + 3].vol,
g_doc_regs[i + 4].vol, g_doc_regs[i + 5].vol,
g_doc_regs[i + 6].vol, g_doc_regs[i + 6].vol);
}
for(i = 0; i < 32; i += 8) {
printf("wptr: %02x: %02x %02x %02x %02x %02x %02x %02x %02x\n",
i,
g_doc_regs[i].waveptr, g_doc_regs[i + 1].waveptr,
g_doc_regs[i + 2].waveptr, g_doc_regs[i + 3].waveptr,
g_doc_regs[i + 4].waveptr, g_doc_regs[i + 5].waveptr,
g_doc_regs[i + 6].waveptr, g_doc_regs[i + 7].waveptr);
}
for(i = 0; i < 32; i += 8) {
printf("ctl: %02x: %02x %02x %02x %02x %02x %02x %02x %02x\n",
i,
g_doc_regs[i].ctl, g_doc_regs[i + 1].ctl,
g_doc_regs[i + 2].ctl, g_doc_regs[i + 3].ctl,
g_doc_regs[i + 4].ctl, g_doc_regs[i + 5].ctl,
g_doc_regs[i + 6].ctl, g_doc_regs[i + 7].ctl);
}
for(i = 0; i < 32; i += 8) {
printf("wsize: %02x: %02x %02x %02x %02x %02x %02x %02x %02x\n",
i,
g_doc_regs[i].wavesize, g_doc_regs[i + 1].wavesize,
g_doc_regs[i + 2].wavesize, g_doc_regs[i + 3].wavesize,
g_doc_regs[i + 4].wavesize, g_doc_regs[i + 5].wavesize,
g_doc_regs[i + 6].wavesize, g_doc_regs[i + 7].wavesize);
}
show_doc_log();
for(i = 0; i < 32; i++) {
rptr = &(g_doc_regs[i]);
printf("%2d: ctl:%02x wp:%02x ws:%02x freq:%04x vol:%02x "
"ev:%d run:%d irq:%d sz:%04x\n", i,
rptr->ctl, rptr->waveptr, rptr->wavesize, rptr->freq,
rptr->vol, rptr->event, rptr->running,
rptr->has_irq_pending, rptr->size_bytes);
printf(" acc:%08x inc:%08x st:%08x end:%08x m:%08x\n",
rptr->cur_acc, rptr->cur_inc, rptr->cur_start,
rptr->cur_end, rptr->cur_mask);
printf(" compl_ds:%f samps_left:%d ev:%f ev2:%f\n",
rptr->complete_dsamp, rptr->samps_left,
rptr->dsamp_ev, rptr->dsamp_ev2);
}
#if 0
for(osc = 0; osc < 32; osc++) {
fmax = 0.0;
printf("osc %d has %d samps\n", osc, g_fsamp_num[osc]);
for(i = 0; i < g_fsamp_num[osc]; i++) {
printf("%4d: %f\n", i, g_fsamps[osc][i]);
fmax = MAX(fmax, g_fsamps[osc][i]);
}
printf("osc %d, fmax: %f\n", osc, fmax);
}
#endif
}
Reference in New Issue View Git Blame Copy Permalink