void
setfreq_and_q (goomf_synth_t * s, AnalogFilter * filter, float frequency,
float q_)
{
filter->q = q_;
setfreq (s, filter, frequency);
};
/*********************************************************************
Pass a note, in half steps relative to 400 Hz. The 12 step scale
is an exponential thing. The speaker control is at port 0x61.
Setting the lowest two bits enables timer 2 of the 8253/8254 timer
and turns on the speaker.
*********************************************************************/
void playnote(NOTE note)
{
_outp(0x61, _inp(0x61) | 0x03); // start speaker going
setfreq((int)(400 * pow(2, note.pitch / 12.0)));
Sleep(note.duration);
_outp(0x61, _inp(0x61) & ~0x03); // stop that racket!
}
/* open all available CatWeasel devices */
int catweaselmkiii_open(void)
{
static int atexitinitialized = 0;
int i, z = 0;
/* close any open handles */
for (i = 0; i < MAXCARDS; i++) {
if (sidhandle[i] != INVALID_HANDLE_VALUE) {
CloseHandle(sidhandle[i]), sidhandle[i] = INVALID_HANDLE_VALUE;
}
}
/* find up to four CatWeasel cards */
for (i = 0; i < MAXCARDS; i++) {
char buf[32];
sprintf(buf, "\\\\.\\SID6581_%u", i + 1);
sidhandle[z] = CreateFile(buf, GENERIC_READ, FILE_SHARE_WRITE | FILE_SHARE_READ, 0L, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0L);
if (sidhandle[z] != INVALID_HANDLE_VALUE) {
log_message(LOG_DEFAULT, "Found CatWeasel MK3 PCI #%i", z + 1);
z++;
}
}
/* if cards were found */
if (z > 0) {
log_message(LOG_DEFAULT, "Found and opened a CatWeasel MK3 PCI SID");
/* silent all found cards */
mutethem();
/* set frequeny of found cards */
setfreq(ntsc);
/* install exit handler, so devices are closed properly */
if (!atexitinitialized) {
atexitinitialized = 1;
atexit((voidfunc_t)catweaselmkiii_close);
}
cwmkiii_is_open = 1;
return 0;
}
/* no CatWeasels were found */
return -1;
}
/* open unix device */
int cw_device_open(void)
{
int i;
if (!sids_found) {
return -1;
}
if (sids_found > 0) {
return 0;
}
sids_found = 0;
log_message(LOG_DEFAULT, "Detecting driver based CatWeasel boards.");
/* if no device is currently opened */
if (sidfh < 0) {
sidfh = open("/dev/sid", O_RDWR);
if (sidfh < 0) {
sidfh = open("/dev/misc/sid", O_RDWR);
}
/* could not open at standard locations: error */
if (sidfh < 0) {
log_error(LOG_DEFAULT, "Could not open SID device /dev/sid or /dev/misc/sid");
return -1;
}
}
/* mute all sids */
lseek(sidfh, 0, SEEK_SET);
for (i = 0; i < 32; ++i) {
write(sidfh, 0, 1);
}
setfreq();
log_message(LOG_DEFAULT, "PCI CatWeasel driver SID: opened.");
sids_found = 1;
return 0;
}
void
setfreq_and_q (ZEq10ban_t * s, AnalogFilter *filter,float frequency, float q_)
{
filter->q = q_;
setfreq (s,filter,frequency);
};
void SVFilter::setfreq_and_q(float frequency, float q_)
{
q = q_;
setfreq(frequency);
}
/* set current main clock frequency, which gives us the possibilty to
choose between pal and ntsc frequencies */
void cw_device_set_machine_parameter(long cycles_per_sec)
{
setfreq();
}
void AnalogFilter::setfreq_and_q(REALTYPE frequency,REALTYPE q_){
q=q_;
setfreq(frequency);
};
/* set current main clock frequency, which gives us the possibilty to
choose between pal and ntsc frequencies */
void catweaselmkiii_set_machine_parameter(long cycles_per_sec)
{
ntsc = (BYTE)((cycles_per_sec <= 1000000) ? 0 : 1);
setfreq(ntsc);
}
bool ChscPlayer::update()
{
// general vars
unsigned char chan,pattnr,note,effect,eff_op,inst,vol,Okt,db;
unsigned short Fnr;
unsigned long pattoff;
del--; // player speed handling
if(del)
return !songend; // nothing done
if(fadein) // fade-in handling
fadein--;
pattnr = song[songpos];
// 0xff indicates song end, but this prevents a crash for some songs that
// use other weird values, like 0xbf
if(pattnr >= 0xb2) { // arrangement handling
songend = 1; // set end-flag
songpos = 0;
pattnr = song[songpos];
} else
if ((pattnr & 128) && (pattnr <= 0xb1)) { // goto pattern "nr"
songpos = song[songpos] & 127;
pattpos = 0;
pattnr = song[songpos];
songend = 1;
}
pattoff = pattpos*9;
for (chan=0;chan<9;chan++) { // handle all channels
note = patterns[pattnr][pattoff].note;
effect = patterns[pattnr][pattoff].effect;
pattoff++;
if(note & 128) { // set instrument
setinstr(chan,effect);
continue;
}
eff_op = effect & 0x0f;
inst = channel[chan].inst;
if(note)
channel[chan].slide = 0;
switch (effect & 0xf0) { // effect handling
case 0: // global effect
/* The following fx are unimplemented on purpose:
* 02 - Slide Mainvolume up
* 03 - Slide Mainvolume down (here: fade in)
* 04 - Set Mainvolume to 0
*
* This is because i've never seen any HSC modules using the fx this way.
* All modules use the fx the way, i've implemented it.
*/
switch(eff_op) {
case 1: pattbreak++; break; // jump to next pattern
case 3: fadein = 31; break; // fade in (divided by 2)
case 5: mode6 = 1; break; // 6 voice mode on
case 6: mode6 = 0; break; // 6 voice mode off
}
break;
case 0x20:
case 0x10: // manual slides
if (effect & 0x10) {
channel[chan].freq += eff_op;
channel[chan].slide += eff_op;
} else {
channel[chan].freq -= eff_op;
channel[chan].slide -= eff_op;
}
if(!note)
setfreq(chan,channel[chan].freq);
break;
case 0x50: // set percussion instrument (unimplemented)
break;
case 0x60: // set feedback
opl->write(0xc0 + chan, (instr[channel[chan].inst][8] & 1) + (eff_op << 1));
break;
case 0xa0: // set carrier volume
vol = eff_op << 2;
opl->write(0x43 + op_table[chan], vol | (instr[channel[chan].inst][2] & ~63));
break;
case 0xb0: // set modulator volume
vol = eff_op << 2;
if (instr[inst][8] & 1)
opl->write(0x40 + op_table[chan], vol | (instr[channel[chan].inst][3] & ~63));
else
opl->write(0x40 + op_table[chan],vol | (instr[inst][3] & ~63));
break;
case 0xc0: // set instrument volume
db = eff_op << 2;
opl->write(0x43 + op_table[chan], db | (instr[channel[chan].inst][2] & ~63));
if (instr[inst][8] & 1)
opl->write(0x40 + op_table[chan], db | (instr[channel[chan].inst][3] & ~63));
break;
case 0xd0: pattbreak++; songpos = eff_op; songend = 1; break; // position jump
case 0xf0: // set speed
speed = eff_op;
del = ++speed;
break;
}
if(fadein) // fade-in volume setting
setvolume(chan,fadein*2,fadein*2);
if(!note) // note handling
continue;
note--;
if ((note == 0x7f-1) || ((note/12) & ~7)) { // pause (7fh)
adl_freq[chan] &= ~32;
opl->write(0xb0 + chan,adl_freq[chan]);
continue;
}
// play the note
if(mtkmode) // imitate MPU-401 Trakker bug
note--;
Okt = ((note/12) & 7) << 2;
Fnr = note_table[(note % 12)] + instr[inst][11] + channel[chan].slide;
channel[chan].freq = Fnr;
if(!mode6 || chan < 6)
adl_freq[chan] = Okt | 32;
else
adl_freq[chan] = Okt; // never set key for drums
opl->write(0xb0 + chan, 0);
setfreq(chan,Fnr);
if(mode6) {
switch(chan) { // play drums
case 6: opl->write(0xbd,bd & ~16); bd |= 48; break; // bass drum
case 7: opl->write(0xbd,bd & ~1); bd |= 33; break; // hihat
case 8: opl->write(0xbd,bd & ~2); bd |= 34; break; // cymbal
}
opl->write(0xbd,bd);
}
}
del = speed; // player speed-timing
if(pattbreak) { // do post-effect handling
pattpos=0; // pattern break!
pattbreak=0;
songpos++;
songpos %= 50;
if(!songpos)
songend = 1;
} else {
pattpos++;
pattpos &= 63; // advance in pattern data
if (!pattpos) {
songpos++;
songpos %= 50;
if(!songpos)
songend = 1;
}
}
return !songend; // still playing
}
static void
runexciter (LADSPA_Handle instance, unsigned long sample_count,
snd_seq_event_t * events, unsigned long event_count)
{
exciter_t *exc = (exciter_t *) instance;
LADSPA_Data *const pinputl = exc->inputl;
LADSPA_Data *const pinputr = exc->inputr;
// LADSPA_Data dry = *(exc->dry);
LADSPA_Data vol = *(exc->outvolume);
LADSPA_Data pan = *(exc->panning);
LADSPA_Data mag_1 = *(exc->mag_1);
LADSPA_Data mag_2 = *(exc->mag_2);
LADSPA_Data mag_3 = *(exc->mag_3);
LADSPA_Data mag_4 = *(exc->mag_4);
LADSPA_Data mag_5 = *(exc->mag_5);
LADSPA_Data mag_6 = *(exc->mag_6);
LADSPA_Data mag_7 = *(exc->mag_7);
LADSPA_Data mag_8 = *(exc->mag_8);
LADSPA_Data mag_9 = *(exc->mag_9);
LADSPA_Data mag_10 = *(exc->mag_10);
LADSPA_Data ffreq = *(exc->ffreq);
unsigned long event_pos = 0;
unsigned long pos;
unsigned long count;
int i;
// memset (exc->efxoutl, 0, sizeof (LADSPA_Data) * sample_count);
// memset (exc->efxoutr, 0, sizeof (LADSPA_Data) * sample_count);
for (pos = 0, event_pos = 0; pos < sample_count; pos += STEP_SIZE)
{
while (event_pos < event_count)
{
switch (events[event_pos].type)
{
case SND_SEQ_EVENT_NOTEON:
for (i = 0; i < POLY; i++)
{
if (events[event_pos].data.note.velocity != 0)
{
if (exc->rc.note_active[i] == 0)
{
exc->rc.note_active[i] = 1;
exc->rc.rnote[i] = events[event_pos].data.note.note;
exc->rc.gate[i] = 1;
MiraChord (exc);
calcula_mag (exc);
if (exc->rc.cc)
{
lo_send (exc->m_host,
exc->osc_configure_path, "ss",
"schord", exc->rc.NombreAcorde);
exc->rc.cc = 0;
}
break;
}
}
if (events[event_pos].data.note.velocity == 0)
{
if ((exc->rc.note_active[i])
&& (exc->rc.rnote[i] ==
events[event_pos].data.note.note))
{
exc->rc.note_active[i] = 0;
exc->rc.gate[i] = 0;
break;
}
}
}
break;
case SND_SEQ_EVENT_NOTEOFF:
for (i = 0; i < POLY; i++)
{
if ((exc->rc.note_active[i])
&& (exc->rc.rnote[i] ==
events[event_pos].data.note.note))
{
exc->rc.note_active[i] = 0;
exc->rc.gate[i] = 0;
break;
}
}
break;
case SND_SEQ_EVENT_CONTROLLER:
if (events[event_pos].data.control.param == 10)
{
pan = (float) events[event_pos].data.control.value / 128.0;
break;
}
if (events[event_pos].data.control.param == 7)
{
vol = (float) events[event_pos].data.control.value / 128.0;
break;
}
if (events[event_pos].data.control.param == 48)
{
mag_1 =
(float) ((events[event_pos].data.control.value -
64.0) / 64.0);
break;
}
if (events[event_pos].data.control.param == 49)
{
mag_2 =
(float) ((events[event_pos].data.control.value -
64.0) / 64.0);
break;
}
if (events[event_pos].data.control.param == 50)
{
mag_3 =
(float) ((events[event_pos].data.control.value -
64.0) / 64.0);
break;
}
if (events[event_pos].data.control.param == 51)
{
mag_4 =
(float) ((events[event_pos].data.control.value -
64.0) / 64.0);
break;
}
if (events[event_pos].data.control.param == 52)
{
mag_5 =
(float) ((events[event_pos].data.control.value -
64.0) / 64.0);
break;
}
if (events[event_pos].data.control.param == 53)
{
mag_6 =
(float) ((events[event_pos].data.control.value -
64.0) / 64.0);
break;
}
if (events[event_pos].data.control.param == 54)
{
mag_7 =
(float) ((events[event_pos].data.control.value -
64.0) / 64.0);
break;
}
if (events[event_pos].data.control.param == 55)
{
mag_8 =
(float) ((events[event_pos].data.control.value -
64.0) / 64.0);
break;
}
if (events[event_pos].data.control.param == 56)
{
mag_9 =
(float) ((events[event_pos].data.control.value -
64.0) / 64.0);
break;
}
if (events[event_pos].data.control.param == 57)
{
mag_10 =
(float) ((events[event_pos].data.control.value -
64.0) / 64.0);
break;
}
if (events[event_pos].data.control.param == 58)
{
ffreq =
(float) 21.0 +
(float) (events[event_pos].data.control.value * 10000.0 /
127.0);
break;
}
}
event_pos++;
}
count =
(sample_count - pos) > STEP_SIZE ? STEP_SIZE : sample_count - pos;
if (exc->rmag_1 != mag_1)
{
exc->rmag_1 = mag_1;
calcula_mag (exc);
}
if (exc->rmag_2 != mag_2)
{
exc->rmag_2 = mag_2;
calcula_mag (exc);
}
if (exc->rmag_3 != mag_3)
{
exc->rmag_3 = mag_3;
calcula_mag (exc);
}
if (exc->rmag_4 != mag_4)
{
exc->rmag_4 = mag_4;
calcula_mag (exc);
}
if (exc->rmag_5 != mag_5)
{
exc->rmag_5 = mag_5;
calcula_mag (exc);
}
if (exc->rmag_6 != mag_6)
{
exc->rmag_6 = mag_6;
calcula_mag (exc);
}
if (exc->rmag_7 != mag_7)
{
exc->rmag_7 = mag_7;
calcula_mag (exc);
}
if (exc->rmag_8 != mag_8)
{
exc->rmag_8 = mag_8;
calcula_mag (exc);
}
if (exc->rmag_9 != mag_9)
{
exc->rmag_9 = mag_9;
calcula_mag (exc);
}
if (exc->rmag_10 != mag_10)
{
exc->rmag_10 = mag_10;
calcula_mag (exc);
}
if (exc->rfreq != ffreq)
{
exc->rfreq = ffreq;
setfreq (exc, &exc->lhpf, exc->rfreq);
setfreq (exc, &exc->rhpf, exc->rfreq);
}
out_exciter (exc, pinputl, pinputr, count);
}
}
void action_cpuperflevel4(void) {
disableucg();
setfreq(CPUFREQ_LEVEL_FOUR);
}
void action_cpuperflevel3(void) {
disableucg();
setfreq(CPUFREQ_LEVEL_THREE);
}
void action_cpuperflevel2(void) {
disableucg();
setfreq(CPUFREQ_LEVEL_TWO);
}
/* set's cpu at full and enables the use case governor
* to scale as needed */
void action_cpuperflevel1(void) {
setfreq(CPUFREQ_LEVEL_ONE);
enableucg();
}
