home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
AmigActive 6
/
AACD06.ISO
/
AACD
/
Emulation
/
Atari800
/
pokey11.c
< prev
next >
Wrap
C/C++ Source or Header
|
1998-02-17
|
33KB
|
1,012 lines
/*****************************************************************************/
/* */
/* Module: POKEY Chip Simulator, V1.2 */
/* Purpose: To emulate the sound generation hardware of the Atari POKEY chip.*/
/* Author: Ron Fries */
/* Thomas Richter */
/* Date: September 22, 1996 */
/* February 17,1998 */
/* */
/*****************************************************************************/
/* */
/* License Information and Copyright Notice */
/* ======================================== */
/* */
/* PokeySound is Copyright(c) 1996 by Ron Fries */
/* */
/* This library is free software; you can redistribute it and/or modify it */
/* under the terms of version 2 of the GNU Library General Public License */
/* as published by the Free Software Foundation. */
/* */
/* This library is distributed in the hope that it will be useful, but */
/* WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library */
/* General Public License for more details. */
/* To obtain a copy of the GNU Library General Public License, write to the */
/* Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* */
/* Any permitted reproduction of these routines, in whole or in part, must */
/* bear this legend. */
/* */
/*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "pokey.h"
#include "pokey11.h"
#include "sio.h"
#include "mem.h"
#include "cpu.h"
#include "platform.h"
/* CONSTANT DEFINITIONS */
/* definitions for AUDCx (D201, D203, D205, D207) */
#define NOTPOLY5 0x80 /* selects POLY5 or direct CLOCK */
#define POLY4 0x40 /* selects POLY4 or POLY17 */
#define PURE 0x20 /* selects POLY4/17 or PURE tone */
#define VOL_ONLY 0x10 /* selects VOLUME OUTPUT ONLY */
#define VOLUME_MASK 0x0f /* volume mask */
/* definitions for AUDCTL (D208) */
#define POLY9 0x80 /* selects POLY9 or POLY17 */
#define CH1_179 0x40 /* selects 1.78979 MHz for Ch 1 */
#define CH3_179 0x20 /* selects 1.78979 MHz for Ch 3 */
#define CH1_CH2 0x10 /* clocks channel 1 w/channel 2 */
#define CH3_CH4 0x08 /* clocks channel 3 w/channel 4 */
#define CH1_FILTER 0x04 /* selects channel 1 high pass filter */
#define CH2_FILTER 0x02 /* selects channel 2 high pass filter */
#define CLOCK_15 0x01 /* selects 15.6999kHz or 63.9210kHz */
/* for accuracy, the 64kHz and 15kHz clocks are exact divisions of
the 1.79MHz clock */
#define DIV_64 28 /* divisor for 1.79MHz clock to 64 kHz */
#define DIV_15 114 /* divisor for 1.79MHz clock to 15 kHz */
/* the size (in entries) of the 4 polynomial tables */
#define POLY4_SIZE 0x000f
#define POLY5_SIZE 0x001f
#define POLY9_SIZE 0x01ff
#ifdef COMP16 /* if 16-bit compiler */
#define POLY17_SIZE 0x00007fffL /* reduced to 15 bits for simplicity */
#else
#define POLY17_SIZE 0x0001ffffL /* else use the full 17 bits */
#endif
#define FALSE 0
#define TRUE 1
/* GLOBAL VARIABLE DEFINITIONS */
/* structures to hold the 9 pokey control bytes */
UBYTE AUDF[4]; /* AUDFx (D200, D202, D204, D206) */
UBYTE AUDC[4]; /* AUDCx (D201, D203, D205, D207) */
UBYTE AUDCTL; /* AUDCTL (D208) */
static UBYTE Outbit[4]; /* current state of the output (high or low) */
static UBYTE Outvol[4]; /* last output volume for each channel */
int DELAYED_SERIN_IRQ;
int DELAYED_SEROUT_IRQ;
int DELAYED_XMTDONE_IRQ;
/* Initialze the bit patterns for the polynomials. */
/* The 4bit and 5bit patterns are the identical ones used in the pokey chip. */
/* Though the patterns could be packed with 8 bits per byte, using only a */
/* single bit per byte keeps the math simple, which is important for */
/* efficient processing. */
static UBYTE bit4[POLY4_SIZE] =
{ 1,1,0,1,1,1,0,0,0,0,1,0,1,0,0 };
static UBYTE bit5[POLY5_SIZE] =
{ 0,0,1,1,0,0,0,1,1,1,1,0,0,1,0,1,0,1,1,0,1,1,1,0,1,0,0,0,0,0,1 };
static UBYTE bit17[POLY17_SIZE]; /* Rather than have a table with 131071 */
/* entries, I use a random number generator. */
/* It shouldn't make much difference since */
/* the pattern rarely repeats anyway. */
static ULONG Poly17_size; /* global for the poly 17 size, since it can */
/* be changed from 17 bit to 9 bit */
static ULONG Poly_adjust; /* the amount that the polynomial will need */
/* to be adjusted to process the next bit */
static ULONG P4=0, /* Global position pointer for the 4-bit POLY array */
P5=0, /* Global position pointer for the 5-bit POLY array */
P17=0; /* Global position pointer for the 17-bit POLY array */
ULONG Div_n_cnt[4], /* Divide by n counter. one for each channel */
Div_n_max[4], /* Divide by n maximum, one for each channel */
Div_n_irq[4]; /* Just the same counter, but used for IRQ */
static ULONG Samp_n_max, /* Sample max. For accuracy, it is *256 */
Samp_n_cnt[2]; /* Sample cnt. */
static ULONG Base_mult; /* selects either 64Khz or 15Khz clock mult */
UBYTE KBCODE;
UBYTE IRQST;
UBYTE IRQEN;
UBYTE SKSTAT;
static char *rcsid = "$Id: pokey11.c,v 1.2 1998/02/17 Ron Fries,thor";
extern UWORD regPC;
void Update_Sound(int chan_mask);
/*****************************************************************************/
/* In my routines, I treat the sample output as another divide by N counter */
/* For better accuracy, the Samp_n_cnt has a fixed binary decimal point */
/* which has 8 binary digits to the right of the decimal point. I use a two */
/* byte array to give me a minimum of 40 bits, and then use pointer math to */
/* reference either the 24.8 whole/fraction combination or the 32-bit whole */
/* only number. This is mainly used to keep the math simple for */
/* optimization. See below: */
/* */
/* xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx | xxxxxxxx xxxxxxxx xxxxxxxx.xxxxxxxx */
/* unused unused unused whole whole whole whole fraction */
/* */
/* Samp_n_cnt[0] gives me a 32-bit int 24 whole bits with 8 fractional bits, */
/* while (ULONG *)((UBYTE *)(&Samp_n_cnt[0])+1) gives me the 32-bit whole */
/* number only. */
/*****************************************************************************/
/* Register GET routines */
mtype POKEY_KBCODE_GET(void)
{
return KBCODE;
}
mtype POKEY_IRQST_GET(void)
{
return IRQST;
}
mtype POKEY_POT0_GET(void)
{
return Atari_POT(0);
}
mtype POKEY_POT1_GET(void)
{
return Atari_POT(1);
}
mtype POKEY_POT2_GET(void)
{
return Atari_POT(2);
}
mtype POKEY_POT3_GET(void)
{
return Atari_POT(3);
}
mtype POKEY_POT4_GET(void)
{
return Atari_POT(4);
}
mtype POKEY_POT5_GET(void)
{
return Atari_POT(5);
}
mtype POKEY_POT6_GET(void)
{
return Atari_POT(6);
}
mtype POKEY_POT7_GET(void)
{
return Atari_POT(7);
}
mtype POKEY_RANDOM_GET(void)
{
static int rand_init = 0;
if (!rand_init) {
srand((int) time((time_t *) NULL));
rand_init = 1;
}
return rand();
}
mtype POKEY_SERIN_GET(void)
{
return SIO_GetByte();
}
mtype POKEY_SKSTAT_GET(void)
{
#ifdef BASIC
return 0xff;
#else
return Atari_Keyboard_State();
#endif
}
/* IO Put routines */
int POKEY_AUDF1_PUT(mtype val)
{
AUDF[CHAN1] = val;
Update_Sound((AUDCTL & CH1_CH2)?((1<<CHAN2)|(1<<CHAN1)):(1<<CHAN1));
return FALSE;
}
int POKEY_AUDC1_PUT(mtype val)
{
AUDC[CHAN1] = val;
Update_Sound(1<<CHAN1);
return FALSE;
}
int POKEY_AUDF2_PUT(mtype val)
{
AUDF[CHAN2] = val;
Update_Sound(1<<CHAN2);
return FALSE;
}
int POKEY_AUDC2_PUT(mtype val)
{
AUDC[CHAN2] = val;
Update_Sound(1<<CHAN2);
return FALSE;
}
int POKEY_AUDF3_PUT(mtype val)
{
AUDF[CHAN3] = val;
Update_Sound((AUDCTL & CH3_CH4)?((1<<CHAN4)|(1<<CHAN3)):(1<<CHAN3));
return FALSE;
}
int POKEY_AUDC3_PUT(mtype val)
{
AUDC[CHAN3] = val;
Update_Sound(1<<CHAN3);
return FALSE;
}
int POKEY_AUDF4_PUT(mtype val)
{
AUDF[CHAN4] = val;
Update_Sound(1<<CHAN4);
return FALSE;
}
int POKEY_AUDC4_PUT(mtype val)
{
AUDC[CHAN4] = val;
Update_Sound(1<<CHAN4);
return FALSE;
}
int POKEY_AUDCTL_PUT(mtype val)
{
AUDCTL = val;
if (AUDCTL & POLY9)
Poly17_size = POLY9_SIZE;
else
Poly17_size = POLY17_SIZE;
/* determine the base multiplier for the 'div by n' calculations */
if (AUDCTL & CLOCK_15)
Base_mult = DIV_15;
else
Base_mult = DIV_64;
Update_Sound((1<<CHAN1)|(1<<CHAN2)|(1<<CHAN3)|(1<<CHAN4));
return FALSE;
}
int POKEY_IRQEN_PUT(mtype val)
{
IRQEN = val;
IRQST |= ~val;
return FALSE;
}
int POKEY_SEROUT_PUT(mtype val)
{
if ((SKSTAT & 0x70) == 0x20) {
if ((AUDF[CHAN3] == 0x28) && (AUDF[CHAN4] == 0x00) && (AUDCTL & 0x28)==0x28)
SIO_PutByte(val);
}
return FALSE;
}
int POKEY_STIMER_PUT(mtype val)
{
Div_n_cnt[CHAN1]=Div_n_irq[CHAN1]=0;
Div_n_cnt[CHAN2]=Div_n_irq[CHAN2]=0;
Div_n_cnt[CHAN3]=Div_n_irq[CHAN3]=0;
Div_n_cnt[CHAN4]=Div_n_irq[CHAN4]=0;
return FALSE;
}
int POKEY_SKSTAT_PUT(mtype val)
{
SKSTAT = val;
return FALSE;
}
/*****************************************************************************/
/* Module: Pokey_sound_init() */
/* Purpose: to handle the power-up initialization functions */
/* these functions should only be executed on a cold-restart */
/* */
/* Author: Ron Fries */
/* Date: September 22, 1996 */
/* */
/* Inputs: freq17 - the value for the '1.79MHz' Pokey audio clock */
/* playback_freq - the playback frequency in samples per second */
/* */
/* Outputs: Adjusts local globals - no return value */
/* */
/*****************************************************************************/
void Init_Pokey(int *argc,char **argv,int base)
{
int chan;
long n;
/* fill the 17bit polynomial with random bits */
for (n=0; n<POLY17_SIZE; n++)
{
bit17[n] = rand() & 0x01; /* fill poly 17 with random bits */
}
/* start all of the polynomial counters at zero */
Poly_adjust = 0;
P4 = 0;
P5 = 0;
P17 = 0;
Samp_n_cnt[0] = 0; /* initialize all bits of the sample */
Samp_n_cnt[1] = 0; /* 'divide by N' counter */
Poly17_size = POLY17_SIZE;
for (chan = CHAN1; chan <= CHAN4; chan++)
{
Outvol[chan] = 0;
Outbit[chan] = 0;
Div_n_cnt[chan] = 0;
Div_n_irq[chan] = 0;
Div_n_max[chan] = 0x7fffffffL;
AUDC[chan] = 0;
AUDF[chan] = 0;
}
AUDCTL = 0;
IRQST = 0xff;
IRQEN = 0x00;
Base_mult = DIV_64;
/*
* Initialise Serial Port Interrupts
*/
DELAYED_SERIN_IRQ = 0;
DELAYED_SEROUT_IRQ = 0;
DELAYED_XMTDONE_IRQ = 0;
if (argc)
Samp_n_max = 1; /* provide some meaningfull default if hard reset */
SetHW(base+_AUDF1,0xff0f,&POKEY_POT0_GET,&POKEY_AUDF1_PUT);
SetHW(base+_AUDC1,0xff0f,&POKEY_POT1_GET,&POKEY_AUDC1_PUT);
SetHW(base+_AUDF2,0xff0f,&POKEY_POT2_GET,&POKEY_AUDF2_PUT);
SetHW(base+_AUDC2,0xff0f,&POKEY_POT3_GET,&POKEY_AUDC2_PUT);
SetHW(base+_AUDF3,0xff0f,&POKEY_POT4_GET,&POKEY_AUDF3_PUT);
SetHW(base+_AUDC3,0xff0f,&POKEY_POT5_GET,&POKEY_AUDC3_PUT);
SetHW(base+_AUDF4,0xff0f,&POKEY_POT6_GET,&POKEY_AUDF4_PUT);
SetHW(base+_AUDC4,0xff0f,&POKEY_POT7_GET,&POKEY_AUDC4_PUT);
SetHW(base+_AUDCTL,0xff0f,NULL,&POKEY_AUDCTL_PUT);
SetHW(base+_STIMER,0xff0f,&POKEY_KBCODE_GET,&POKEY_STIMER_PUT);
SetHW(base+_SKRES,0xff0f,&POKEY_RANDOM_GET,NULL);
SetHW(base+_POTGO,0xff0f,NULL,NULL);
SetHW(base+_SEROUT,0xff0f,&POKEY_SERIN_GET,&POKEY_SEROUT_PUT);
SetHW(base+_IRQEN,0xff0f,&POKEY_IRQST_GET,&POKEY_IRQEN_PUT);
SetHW(base+_SKCTLS,0xff0f,&POKEY_SKSTAT_GET,&POKEY_SKSTAT_PUT);
}
void Pokey_sound_init (ULONG freq17, UWORD playback_freq)
{
Samp_n_max = ((ULONG)freq17 << 8) / playback_freq;
}
/*****************************************************************************/
/* Module: Update_Sound() */
/* Purpose: To process the latest control values stored in the AUDF, AUDC, */
/* and AUDCTL registers. It pre-calculates as much information as */
/* possible for better performance. This routine has not been */
/* optimized. */
/* */
/* Author: Ron Fries */
/* Date: September 22, 1996 */
/* */
/* Inputs: addr - the address of the parameter to be changed */
/* val - the new value to be placed in the specified address */
/* */
/* Outputs: Adjusts local globals - no return value */
/* */
/*****************************************************************************/
void Update_Sound(int chan_mask)
{
ULONG new_val = 0;
int chan;
/************************************************************/
/* As defined in the manual, the exact Div_n_cnt values are */
/* different depending on the frequency and resolution: */
/* 64 kHz or 15 kHz - AUDF + 1 */
/* 1 MHz, 8-bit - AUDF + 4 */
/* 1 MHz, 16-bit - AUDF[CHAN1]+256*AUDF[CHAN2] + 7 */
/************************************************************/
/* only reset the channels that have changed */
if (chan_mask & (1 << CHAN1))
{
/* process channel 1 frequency */
if (AUDCTL & CH1_179)
new_val = AUDF[CHAN1] + 4;
else
new_val = (AUDF[CHAN1] + 1) * Base_mult;
if (new_val != Div_n_max[CHAN1])
{
Div_n_max[CHAN1] = new_val;
Div_n_cnt[CHAN1] = 0;
Div_n_irq[CHAN1] = 0;
}
}
if (chan_mask & (1 << CHAN2))
{
/* process channel 2 frequency */
if (AUDCTL & CH1_CH2)
if (AUDCTL & CH1_179)
new_val = AUDF[CHAN2] * 256 + AUDF[CHAN1] + 7;
else
new_val = (AUDF[CHAN2] * 256 + AUDF[CHAN1] + 1) * Base_mult;
else
new_val = (AUDF[CHAN2] + 1) * Base_mult;
if (new_val != Div_n_max[CHAN2])
{
Div_n_max[CHAN2] = new_val;
Div_n_cnt[CHAN2] = 0;
Div_n_irq[CHAN2] = 0;
}
}
if (chan_mask & (1 << CHAN3))
{
/* process channel 3 frequency */
if (AUDCTL & CH3_179)
new_val = AUDF[CHAN3] + 4;
else
new_val= (AUDF[CHAN3] + 1) * Base_mult;
if (new_val!= Div_n_max[CHAN3])
{
Div_n_max[CHAN3] = new_val;
Div_n_cnt[CHAN3] = 0;
Div_n_irq[CHAN3] = 0;
}
}
if (chan_mask & (1 << CHAN4))
{
/* process channel 4 frequency */
if (AUDCTL & CH3_CH4)
if (AUDCTL & CH3_179)
new_val = AUDF[CHAN4] * 256 + AUDF[CHAN3] + 7;
else
new_val = (AUDF[CHAN4] * 256 + AUDF[CHAN3] + 1) * Base_mult;
else
new_val = (AUDF[CHAN4] + 1) * Base_mult;
if (new_val != Div_n_max[CHAN4])
{
Div_n_max[CHAN4] = new_val;
Div_n_cnt[CHAN4] = 0;
Div_n_irq[CHAN4] = 0;
}
}
/* if channel is volume only, set current output */
for (chan = CHAN1; chan <= CHAN4; chan++)
{
if (chan_mask & (1 << chan))
{
/* I've disabled any frequencies that exceed the sampling
frequency. There isn't much point in processing frequencies
that the hardware can't reproduce. I've also disabled
processing if the volume is zero. */
/* if the channel is volume only */
/* or the channel is off (volume == 0) */
/* or the channel freq is greater than the playback freq */
if ((AUDC[chan] & VOL_ONLY) ||
((AUDC[chan] & VOLUME_MASK) == 0) ||
(Div_n_max[chan] < (Samp_n_max >> 8)))
{
/* then set the channel to the selected volume */
Outvol[chan] = AUDC[chan] & VOLUME_MASK;
/* and set channel freq to max to reduce processing */
/* Div_n_max[chan] = 0x7fffffffL;
Removed. Conflicts with POKEY-IRQs */
}
}
}
}
/*****************************************************************************/
/* Module: Pokey_process_2() */
/* Purpose: To fill the output buffer with the sound output based on the */
/* pokey chip parameters. This routine has not been optimized. */
/* Though it is not used by the program, I've left it for reference.*/
/* */
/* Author: Ron Fries */
/* Date: September 22, 1996 */
/* */
/* Inputs: *buffer - pointer to the buffer where the audio output will */
/* be placed */
/* n - size of the playback buffer */
/* */
/* Outputs: the buffer will be filled with n bytes of audio - no return val */
/* */
/*****************************************************************************/
void Pokey_process_2 (register unsigned char *buffer, register UWORD n)
{
#ifdef VOXWARE
register ULONG *samp_cnt_w_ptr;
register ULONG event_min;
register UBYTE next_event;
register UBYTE cur_val;
register UBYTE chan;
/* set a pointer to the whole portion of the samp_n_cnt */
samp_cnt_w_ptr = (ULONG *)((UBYTE *)(&Samp_n_cnt[0])+1);
/* loop until the buffer is filled */
while (n)
{
/* Normally the routine would simply decrement the 'div by N' */
/* counters and react when they reach zero. Since we normally */
/* won't be processing except once every 80 or so counts, */
/* I've optimized by finding the smallest count and then */
/* 'accelerated' time by adjusting all pointers by that amount. */
/* find next smallest event (either sample or chan 1-4) */
next_event = SAMPLE;
event_min = *samp_cnt_w_ptr;
for (chan = CHAN1; chan <= CHAN4; chan++)
{
if (Div_n_cnt[chan] <= event_min)
{
event_min = Div_n_cnt[chan];
next_event = chan;
}
}
/* decrement all counters by the smallest count found */
for (chan = CHAN1; chan <= CHAN4; chan++)
{
Div_n_cnt[chan] -= event_min;
}
*samp_cnt_w_ptr -= event_min;
/* since the polynomials require a mod (%) function which is
division, I don't adjust the polynomials on the SAMPLE events,
only the CHAN events. I have to keep track of the change,
though. */
Poly_adjust += event_min;
/* if the next event is a channel change */
if (next_event != SAMPLE)
{
/* shift the polynomial counters */
P4 = (P4 + Poly_adjust) % POLY4_SIZE;
P5 = (P5 + Poly_adjust) % POLY5_SIZE;
P17 = (P17 + Poly_adjust) % Poly17_size;
/* reset the polynomial adjust counter to zero */
Poly_adjust = 0;
/* adjust channel counter */
Div_n_cnt[next_event] += Div_n_max[next_event];
/* From here, a good understanding of the hardware is required */
/* to understand what is happening. I won't be able to provide */
/* much description to explain it here. */
/* if the output is pure or the output is poly5 and the poly5 bit */
/* is set */
if ((AUDC[next_event] & NOTPOLY5) || bit5[P5])
{
/* if the PURE bit is set */
if (AUDC[next_event] & PURE)
{
/* then simply toggle the output */
Outbit[next_event] = !Outbit[next_event];
}
/* otherwise if POLY4 is selected */
else if (AUDC[next_event] & POLY4)
{
/* then use the poly4 bit */
Outbit[next_event] = bit4[P4];
}
else
{
/* otherwise use the poly17 bit */
Outbit[next_event] = bit17[P17];
}
}
/* At this point I haven't emulated the filters. Though I don't
expect it to be complicated, I don't believe this feature is
used much anyway. I'll work on it later. */
if ((next_event == CHAN1) || (next_event == CHAN3))
{
/* INSERT FILTER HERE */
}
/* if the current output bit is set */
if (Outbit[next_event])
{
/* then set to the current volume */
Outvol[next_event] = AUDC[next_event] & VOLUME_MASK;
}
else
{
/* set the volume to zero */
Outvol[next_event] = 0;
}
}
else /* otherwise we're processing a sample */
{
/* adjust the sample counter - note we're using the 24.8 integer
which includes an 8 bit fraction for accuracy */
*Samp_n_cnt += Samp_n_max;
cur_val = 0;
/* add the output values of all 4 channels */
for (chan = CHAN1; chan <= CHAN4; chan++)
{
cur_val += Outvol[chan];
}
/* multiply the volume by 4 and add 8 to center around 128 */
/* NOTE: this statement could be eliminated for efficiency, */
/* though the volume would be lower. */
cur_val = (cur_val << 2) + 8;
/* add the current value to the output buffer */
*buffer++ = cur_val;
/* and indicate one less byte in the buffer */
n--;
}
}
#endif
}
/*****************************************************************************/
/* Module: Pokey_process() */
/* Purpose: To fill the output buffer with the sound output based on the */
/* pokey chip parameters. This routine has not been optimized. */
/* Though it is not used by the program, I've left it for reference.*/
/* */
/* Author: Ron Fries */
/* Date: September 22, 1996 */
/* */
/* Inputs: *buffer - pointer to the buffer where the audio output will */
/* be placed */
/* n - size of the playback buffer */
/* */
/* Outputs: the buffer will be filled with n bytes of audio - no return val */
/* */
/*****************************************************************************/
void Pokey_process (register unsigned char *buffer, register UWORD n)
{
#ifdef VOXWARE
register ULONG *div_n_ptr;
register ULONG *samp_cnt_w_ptr;
register ULONG event_min;
register UBYTE next_event;
register UBYTE cur_val;
register UBYTE *out_ptr;
register UBYTE audc;
register UBYTE toggle;
/* set a pointer to the whole portion of the samp_n_cnt */
samp_cnt_w_ptr = (ULONG *)((UBYTE *)(&Samp_n_cnt[0])+1);
/* set a pointer for optimization */
out_ptr = Outvol;
/* The current output is pre-determined and then adjusted based on each */
/* output change for increased performance (less over-all math). */
/* add the output values of all 4 channels */
cur_val = 2; /* start with a small offset */
cur_val += *out_ptr++;
cur_val += *out_ptr++;
cur_val += *out_ptr++;
cur_val += *out_ptr++;
/* loop until the buffer is filled */
while (n)
{
/* Normally the routine would simply decrement the 'div by N' */
/* counters and react when they reach zero. Since we normally */
/* won't be processing except once every 80 or so counts, */
/* I've optimized by finding the smallest count and then */
/* 'accelerated' time by adjusting all pointers by that amount. */
/* find next smallest event (either sample or chan 1-4) */
next_event = SAMPLE;
event_min = *samp_cnt_w_ptr;
/* Though I could have used a loop here, this is faster */
div_n_ptr = Div_n_cnt;
if (*div_n_ptr <= event_min)
{
event_min = *div_n_ptr;
next_event = CHAN1;
}
div_n_ptr++;
if (*div_n_ptr <= event_min)
{
event_min = *div_n_ptr;
next_event = CHAN2;
}
div_n_ptr++;
if (*div_n_ptr <= event_min)
{
event_min = *div_n_ptr;
next_event = CHAN3;
}
div_n_ptr++;
if (*div_n_ptr <= event_min)
{
event_min = *div_n_ptr;
next_event = CHAN4;
}
/* decrement all counters by the smallest count found */
/* again, no loop for efficiency */
*div_n_ptr -= event_min;
div_n_ptr--;
*div_n_ptr -= event_min;
div_n_ptr--;
*div_n_ptr -= event_min;
div_n_ptr--;
*div_n_ptr -= event_min;
*samp_cnt_w_ptr -= event_min;
/* since the polynomials require a mod (%) function which is
division, I don't adjust the polynomials on the SAMPLE events,
only the CHAN events. I have to keep track of the change,
though. */
Poly_adjust += event_min;
/* if the next event is a channel change */
if (next_event != SAMPLE)
{
/* shift the polynomial counters */
P4 = (P4 + Poly_adjust) % POLY4_SIZE;
P5 = (P5 + Poly_adjust) % POLY5_SIZE;
P17 = (P17 + Poly_adjust) % Poly17_size;
/* reset the polynomial adjust counter to zero */
Poly_adjust = 0;
/* adjust channel counter */
Div_n_cnt[next_event] += Div_n_max[next_event];
/* get the current AUDC into a register (for optimization) */
audc = AUDC[next_event];
/* set a pointer to the current output (for opt...) */
out_ptr = &Outvol[next_event];
/* assume no changes to the output */
toggle = FALSE;
/* From here, a good understanding of the hardware is required */
/* to understand what is happening. I won't be able to provide */
/* much description to explain it here. */
/* if the output is pure or the output is poly5 and the poly5 bit */
/* is set */
if ((audc & NOTPOLY5) || bit5[P5])
{
/* if the PURE bit is set */
if (audc & PURE)
{
/* then simply toggle the output */
toggle = TRUE;
}
/* otherwise if POLY4 is selected */
else if (audc & POLY4)
{
/* then compare to the poly4 bit */
toggle = (bit4[P4] == !(*out_ptr));
}
else
{
/* otherwise compare to the poly17 bit */
toggle = (bit17[P17] == !(*out_ptr));
}
}
/* At this point I haven't emulated the filters. Though I don't
expect it to be complicated, I don't believe this feature is
used much anyway. I'll work on it later. */
if ((next_event == CHAN1) || (next_event == CHAN3))
{
/* INSERT FILTER HERE */
}
/* if the current output bit has changed */
if (toggle)
{
if (*out_ptr)
{
/* remove this channel from the signal */
cur_val -= *out_ptr;
/* and turn the output off */
*out_ptr = 0;
}
else
{
/* turn the output on */
*out_ptr = audc & VOLUME_MASK;
/* and add it to the output signal */
cur_val += *out_ptr;
}
}
}
else /* otherwise we're processing a sample */
{
/* adjust the sample counter - note we're using the 24.8 integer
which includes an 8 bit fraction for accuracy */
*Samp_n_cnt += Samp_n_max;
/* add the current value to the output buffer */
*buffer++ = cur_val << 2;
/* and indicate one less byte in the buffer */
n--;
}
}
#endif
}
/***************************************************************************
** Generate POKEY Timer IRQs if required **
** called on a per-scanline basis, not very precise, but good enough **
** for most applications **
***************************************************************************/
void POKEY_Scanline(void)
{
if (DELAYED_SERIN_IRQ > 0) {
if (--DELAYED_SERIN_IRQ == 0 ) {
IRQST &= 0xdf;
if (IRQEN & 0x20)
GenerateIRQ();
/* else printf("SerIn missing.\n"); */
}
}
if (DELAYED_SEROUT_IRQ > 0) {
if (--DELAYED_SEROUT_IRQ == 0 ) {
IRQST &= 0xef;
if (IRQEN & 0x10)
GenerateIRQ();
/* else printf("SerOut missing.\n"); */
DELAYED_XMTDONE_IRQ += XMTDONE_INTERVAL;
}
}
if (DELAYED_XMTDONE_IRQ > 0) {
if (--DELAYED_XMTDONE_IRQ == 0) {
IRQST &= 0xf7;
if (IRQEN & 0x08)
GenerateIRQ();
/* else printf("XMTDone missing.\n"); */
}
}
/* one scanline is 15Khz for an ordinary TV */
if ((Div_n_irq[CHAN1] += DIV_15)>Div_n_max[CHAN1]) {
Div_n_irq[CHAN1] = 0;
if (IRQEN & 0x01) {
IRQST &= 0xfe;
GenerateIRQ();
}
}
if ((Div_n_irq[CHAN2] += DIV_15)>Div_n_max[CHAN2]) {
Div_n_irq[CHAN2] = 0;
if (IRQEN & 0x02) {
IRQST &= 0xfd;
GenerateIRQ();
}
}
if ((Div_n_irq[CHAN3] += DIV_15)>Div_n_max[CHAN3]) {
Div_n_irq[CHAN3] = 0;
}
if ((Div_n_irq[CHAN4] += DIV_15)>Div_n_max[CHAN4]) {
Div_n_irq[CHAN4] = 0;
if (IRQEN & 0x04) {
IRQST &= 0xfb;
GenerateIRQ();
}
}
}
void SendKey(UBYTE key)
{
KBCODE = key;
IRQST &= 0xbf;
if (IRQEN & 0x40)
GenerateIRQ();
}
void SendBRK(void)
{
IRQST &= 0x7f;
if (IRQEN & 0x80)
GenerateIRQ();
}