etc/furnace
0
0
Fork 0
mirror of https://github.com/tildearrow/furnace.git synced 2024-11-26 14:33:01 +00:00
Code Issues Projects Releases Packages Wiki Activity

no more global variables!

Browse source
This commit is contained in:
AArt1256 2024-09-01 16:11:42 +03:00
parent 5599ee327b
commit f415e4c9a1
8 changed files with 236 additions and 229 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

252
src/engine/platform/sound/supervision.c
View file

@ -3,98 +3,60 @@
#include "supervision.h" #include "supervision.h"
enum {FALSE, TRUE};
#include <string.h> #include <string.h>
uint32 UNSCALED_CLOCK = 4000000; #define SV_SAMPLE_RATE ((svision->UNSCALED_CLOCK)/64)
#define SV_SAMPLE_RATE ((UNSCALED_CLOCK)/64)
#define SV_DEC_TICK ((SV_SAMPLE_RATE)/60) #define SV_DEC_TICK ((SV_SAMPLE_RATE)/60)
uint32 decrement_tick = 0; void supervision_sound_set_clock(struct svision_t *svision, uint32 clock) {
svision->UNSCALED_CLOCK = clock;
uint8 supervision_dma_mem[65536];
void supervision_sound_set_clock(uint32 clock) {
UNSCALED_CLOCK = clock;
} }
void supervision_memorymap_registers_write(uint32 Addr, uint8 Value) void supervision_memorymap_registers_write(struct svision_t *svision, uint32 Addr, uint8 Value)
{ {
switch (Addr & 0x1fff) { switch (Addr & 0x1fff) {
case 0x10: case 0x11: case 0x12: case 0x13: case 0x10: case 0x11: case 0x12: case 0x13:
case 0x14: case 0x15: case 0x16: case 0x17: case 0x14: case 0x15: case 0x16: case 0x17:
supervision_sound_wave_write(((Addr & 0x4) >> 2), Addr & 3, Value); supervision_sound_wave_write(svision, ((Addr & 0x4) >> 2), Addr & 3, Value);
break; break;
case 0x18: case 0x18:
case 0x19: case 0x19:
case 0x1a: case 0x1a:
case 0x1b: case 0x1b:
case 0x1c: case 0x1c:
supervision_sound_dma_write(Addr & 0x07, Value); supervision_sound_dma_write(svision, Addr & 0x07, Value);
break; break;
case 0x28: case 0x28:
case 0x29: case 0x29:
case 0x2a: case 0x2a:
supervision_sound_noise_write(Addr & 0x07, Value); supervision_sound_noise_write(svision, Addr & 0x07, Value);
break; break;
} }
} }
uint32 ch_mask = 15; void supervision_set_mute_mask(struct svision_t *svision, uint8 mask) {
uint32 flags = 0b00000001; svision->ch_mask = mask;
void supervision_set_mute_mask(uint32 mask) {
ch_mask = mask;
} }
void supervision_sound_set_flags(uint32 flags_set) void supervision_sound_set_flags(struct svision_t *svision, uint8 flags_set)
{ {
flags = flags_set; svision->flags = flags_set;
} }
typedef struct { void supervision_sound_reset(struct svision_t *svision)
uint8 reg[4];
int on;
uint8 waveform, volume;
uint16 pos, size;
uint16 count;
} SVISION_CHANNEL;
SVISION_CHANNEL m_channel[2];
// For clear sound (no grating), sync with m_channel
SVISION_CHANNEL ch[2];
typedef struct {
uint8 reg[3];
int on, right, left, play;
uint8 type; // 6 - 7-Bit, 14 - 15-Bit
uint16 state;
uint8 value, volume;
uint16 count;
real pos, step;
} SVISION_NOISE;
SVISION_NOISE m_noise;
typedef struct {
uint8 reg[5];
int on, right, left;
uint32 ca14to16;
uint16 start;
uint16 size;
real pos, step;
} SVISION_DMA;
SVISION_DMA m_dma;
void supervision_sound_reset(void)
{ {
memset(m_channel, 0, sizeof(m_channel)); memset(svision->m_channel, 0, sizeof(svision->m_channel));
memset(&m_noise, 0, sizeof(m_noise) ); memset(&svision->m_noise, 0, sizeof(svision->m_noise) );
memset(&m_dma, 0, sizeof(m_dma) ); memset(&svision->m_dma, 0, sizeof(svision->m_dma) );
memset(ch, 0, sizeof(ch) ); memset(svision->ch, 0, sizeof(svision->ch) );
decrement_tick = 0; svision->decrement_tick = 0;
ch_mask = 15; svision->ch_mask = 15;
} }
void supervision_sound_stream_update(uint8 *stream, uint32 len) void supervision_sound_stream_update(struct svision_t *svision, uint8 *stream, uint32 len)
{ {
size_t i, j; size_t i, j;
SVISION_CHANNEL *channel; SVISION_CHANNEL *channel;
@ -105,29 +67,29 @@ void supervision_sound_stream_update(uint8 *stream, uint32 len)
for (i = 0; i < len >> 1; i++, left += 2, right += 2) { for (i = 0; i < len >> 1; i++, left += 2, right += 2) {
*left = *right = 0; *left = *right = 0;
for (channel = m_channel, j = 0; j < 2; j++, channel++) { for (channel = svision->m_channel, j = 0; j < 2; j++, channel++) {
chout[j] = 0; chout[j] = 0;
if (ch[j].size != 0) { if (svision->ch[j].size != 0) {
if (ch[j].on || channel->count != 0) { if (svision->ch[j].on || channel->count != 0) {
BOOL on = FALSE; BOOL on = FALSE;
switch (ch[j].waveform) { switch (svision->ch[j].waveform) {
case 0: // 12.5% case 0: // 12.5%
on = ch[j].pos < (28 * ch[j].size) >> 5; on = svision->ch[j].pos < (28 * svision->ch[j].size) >> 5;
break; break;
case 1: // 25% case 1: // 25%
on = ch[j].pos < (24 * ch[j].size) >> 5; on = svision->ch[j].pos < (24 * svision->ch[j].size) >> 5;
break; break;
case 2: // 50% case 2: // 50%
on = ch[j].pos < ch[j].size / 2; on = svision->ch[j].pos < svision->ch[j].size / 2;
break; break;
case 3: // 75% case 3: // 75%
on = ch[j].pos < ch[j].size / 4; on = svision->ch[j].pos < svision->ch[j].size / 4;
// MESS/MAME: <= (9 * ch[j].size) >> 5; // MESS/MAME: <= (9 * svision->ch[j].size) >> 5;
break; break;
} }
s = on ? (ch[j].volume)<<2 : 0; s = on ? (svision->ch[j].volume)<<2 : 0;
s = ((ch_mask>>(3-j))&1)?s:0; s = ((svision->ch_mask>>(3-j))&1)?s:0;
if (flags&1) { if (svision->flags&1) {
if (j == 0) if (j == 0)
*right += s; *right += s;
else else
@ -138,91 +100,91 @@ void supervision_sound_stream_update(uint8 *stream, uint32 len)
} }
chout[j] = s; chout[j] = s;
} }
ch[j].pos++; svision->ch[j].pos++;
if (ch[j].pos >= ch[j].size) { if (svision->ch[j].pos >= svision->ch[j].size) {
ch[j].pos = 0; svision->ch[j].pos = 0;
// Transition from off to on // Transition from off to on
if (channel->on) { if (channel->on) {
memcpy(&ch[j], channel, sizeof(ch[j])); memcpy(&svision->ch[j], channel, sizeof(svision->ch[j]));
channel->on = FALSE; channel->on = FALSE;
} }
} }
} }
} }
if (m_noise.on && (m_noise.play || m_noise.count != 0)) { if (svision->m_noise.on && (svision->m_noise.play || svision->m_noise.count != 0)) {
s = (m_noise.value * m_noise.volume) << 2; s = (svision->m_noise.value * svision->m_noise.volume) << 2;
s = ch_mask&1?s:0; s = svision->ch_mask&1?s:0;
chout[3] = 0; chout[3] = 0;
if (m_noise.left) { if (svision->m_noise.left) {
*left += s; *left += s;
chout[3] = s; chout[3] = s;
} }
if (m_noise.right) { if (svision->m_noise.right) {
*right += s; *right += s;
chout[3] = s; chout[3] = s;
} }
m_noise.pos += m_noise.step; svision->m_noise.pos += svision->m_noise.step;
while (m_noise.pos >= 1.0) { // if/while difference - Pacific Battle while (svision->m_noise.pos >= 1.0) { // if/while difference - Pacific Battle
// LFSR: x^2 + x + 1 // LFSR: x^2 + x + 1
uint16 feedback; uint16 feedback;
m_noise.value = m_noise.state & 1; svision->m_noise.value = svision->m_noise.state & 1;
feedback = ((m_noise.state >> 1) ^ m_noise.state) & 0x0001; feedback = ((svision->m_noise.state >> 1) ^ svision->m_noise.state) & 0x0001;
feedback <<= m_noise.type; feedback <<= svision->m_noise.type;
m_noise.state = (m_noise.state >> 1) | feedback; svision->m_noise.state = (svision->m_noise.state >> 1) | feedback;
m_noise.pos -= 1.0; svision->m_noise.pos -= 1.0;
} }
} }
chout[2] = 0; chout[2] = 0;
if (m_dma.on) { if (svision->m_dma.on) {
uint8 sample; uint8 sample;
uint16 addr = m_dma.start + (uint16)m_dma.pos / 2; uint16 addr = svision->m_dma.start + (uint16)svision->m_dma.pos / 2;
if (addr >= 0x8000 && addr < 0xc000) { if (addr >= 0x8000 && addr < 0xc000) {
sample = supervision_dma_mem[(addr & 0x3fff) | m_dma.ca14to16]; sample = svision->supervision_dma_mem[(addr & 0x3fff) | svision->m_dma.ca14to16];
} }
if (((uint16)m_dma.pos) & 1) if (((uint16)svision->m_dma.pos) & 1)
s = (sample & 0xf); s = (sample & 0xf);
else else
s = (sample & 0xf0) >> 4; s = (sample & 0xf0) >> 4;
s <<= 2; s <<= 2;
s = ((ch_mask>>1)&1)?s:0; s = ((svision->ch_mask>>1)&1)?s:0;
chout[2] = 0; chout[2] = 0;
if (m_dma.left) { if (svision->m_dma.left) {
*left += s; *left += s;
chout[2] = s; chout[2] = s;
} }
if (m_dma.right) { if (svision->m_dma.right) {
*right += s; *right += s;
chout[2] = s; chout[2] = s;
} }
m_dma.pos += m_dma.step; svision->m_dma.pos += svision->m_dma.step;
if (m_dma.pos >= m_dma.size) { if (svision->m_dma.pos >= svision->m_dma.size) {
m_dma.on = FALSE; svision->m_dma.on = FALSE;
} }
} }
if (decrement_tick > SV_DEC_TICK) { if (svision->decrement_tick > SV_DEC_TICK) {
decrement_tick = 0; svision->decrement_tick = 0;
supervision_sound_decrement(); supervision_sound_decrement(svision);
} }
decrement_tick++; svision->decrement_tick++;
} }
} }
void supervision_sound_decrement(void) void supervision_sound_decrement(struct svision_t *svision)
{ {
if (m_channel[0].count > 0) if (svision->m_channel[0].count > 0)
m_channel[0].count--; svision->m_channel[0].count--;
if (m_channel[1].count > 0) if (svision->m_channel[1].count > 0)
m_channel[1].count--; svision->m_channel[1].count--;
if (m_noise.count > 0) if (svision->m_noise.count > 0)
m_noise.count--; svision->m_noise.count--;
} }
void supervision_sound_wave_write(int which, int offset, uint8 data) void supervision_sound_wave_write(struct svision_t *svision, int which, int offset, uint8 data)
{ {
SVISION_CHANNEL *channel = &m_channel[which]; SVISION_CHANNEL *channel = &svision->m_channel[which];
channel->reg[offset] = data; channel->reg[offset] = data;
switch (offset) { switch (offset) {
@ -232,15 +194,15 @@ void supervision_sound_wave_write(int which, int offset, uint8 data)
size = channel->reg[0] | ((channel->reg[1] & 7) << 8); size = channel->reg[0] | ((channel->reg[1] & 7) << 8);
// if size == 0 then channel->size == 0 // if size == 0 then channel->size == 0
if (size) if (size)
channel->size = (uint16)(((real)SV_SAMPLE_RATE) * ((real)((size + 1) << 5)) / ((real)UNSCALED_CLOCK)); channel->size = (uint16)(((real)SV_SAMPLE_RATE) * ((real)((size + 1) << 5)) / ((real)svision->UNSCALED_CLOCK));
else else
channel->size = 0; channel->size = 0;
channel->pos = 0; channel->pos = 0;
// Popo Team // Popo Team
if (channel->count != 0 || ch[which].size == 0 || channel->size == 0) { if (channel->count != 0 || svision->ch[which].size == 0 || channel->size == 0) {
ch[which].size = channel->size; svision->ch[which].size = channel->size;
if (channel->count == 0) if (channel->count == 0)
ch[which].pos = 0; svision->ch[which].pos = 0;
} }
} }
break; break;
@ -248,75 +210,75 @@ void supervision_sound_wave_write(int which, int offset, uint8 data)
channel->on = data & 0x40; channel->on = data & 0x40;
channel->waveform = (data & 0x30) >> 4; channel->waveform = (data & 0x30) >> 4;
channel->volume = data & 0x0f; channel->volume = data & 0x0f;
if (!channel->on || ch[which].size == 0 || channel->size == 0) { if (!channel->on || svision->ch[which].size == 0 || channel->size == 0) {
uint16 pos = ch[which].pos; uint16 pos = svision->ch[which].pos;
memcpy(&ch[which], channel, sizeof(ch[which])); memcpy(&svision->ch[which], channel, sizeof(svision->ch[which]));
if (channel->count != 0) // Journey to the West if (channel->count != 0) // Journey to the West
ch[which].pos = pos; svision->ch[which].pos = pos;
} }
break; break;
case 3: case 3:
channel->count = data + 1; channel->count = data + 1;
ch[which].size = channel->size; // Sonny Xpress! svision->ch[which].size = channel->size; // Sonny Xpress!
break; break;
} }
} }
void supervision_sound_dma_write(int offset, uint8 data) void supervision_sound_dma_write(struct svision_t *svision, int offset, uint8 data)
{ {
m_dma.reg[offset] = data; svision->m_dma.reg[offset] = data;
switch (offset) { switch (offset) {
case 0: case 0:
case 1: case 1:
m_dma.start = (m_dma.reg[0] | (m_dma.reg[1] << 8)); svision->m_dma.start = (svision->m_dma.reg[0] | (svision->m_dma.reg[1] << 8));
break; break;
case 2: case 2:
m_dma.size = (data ? data : 0x100) * 32; // Number of 4-bit samples svision->m_dma.size = (data ? data : 0x100) * 32; // Number of 4-bit samples
break; break;
case 3: case 3:
// Test games: Classic Casino, SSSnake // Test games: Classic Casino, SSSnake
m_dma.step = ((real)UNSCALED_CLOCK) / ((real)SV_SAMPLE_RATE * (256 << (data & 3))); svision->m_dma.step = ((real)svision->UNSCALED_CLOCK) / ((real)SV_SAMPLE_RATE * (256 << (data & 3)));
// MESS/MAME. Wrong // MESS/MAME. Wrong
//m_dma.step = UNSCALED_CLOCK / (256.0 * SV_SAMPLE_RATE * (1 + (data & 3))); //svision->m_dma.step = svision->UNSCALED_CLOCK / (256.0 * SV_SAMPLE_RATE * (1 + (data & 3)));
m_dma.right = data & 4; svision->m_dma.right = data & 4;
m_dma.left = data & 8; svision->m_dma.left = data & 8;
m_dma.ca14to16 = ((data & 0x70) >> 4) << 14; svision->m_dma.ca14to16 = ((data & 0x70) >> 4) << 14;
break; break;
case 4: case 4:
m_dma.on = data & 0x80; svision->m_dma.on = data & 0x80;
if (m_dma.on) { if (svision->m_dma.on) {
m_dma.pos = 0.0; svision->m_dma.pos = 0.0;
} }
break; break;
} }
} }
void supervision_sound_noise_write(int offset, uint8 data) void supervision_sound_noise_write(struct svision_t *svision, int offset, uint8 data)
{ {
m_noise.reg[offset] = data; svision->m_noise.reg[offset] = data;
switch (offset) { switch (offset) {
case 0: { case 0: {
uint32 divisor = 8 << (data >> 4); uint32 divisor = 8 << (data >> 4);
if (divisor) if (divisor)
m_noise.step = ((real)UNSCALED_CLOCK) / ((real)SV_SAMPLE_RATE * divisor); svision->m_noise.step = ((real)svision->UNSCALED_CLOCK) / ((real)SV_SAMPLE_RATE * divisor);
else else
m_noise.step = 0; svision->m_noise.step = 0;
m_noise.step = ((real)UNSCALED_CLOCK) / ((real)SV_SAMPLE_RATE * divisor); svision->m_noise.step = ((real)svision->UNSCALED_CLOCK) / ((real)SV_SAMPLE_RATE * divisor);
m_noise.volume = data & 0xf; svision->m_noise.volume = data & 0xf;
} }
break; break;
case 1: case 1:
m_noise.count = data + 1; svision->m_noise.count = data + 1;
break; break;
case 2: case 2:
m_noise.type = (data & 1) ? 14 : 6; svision->m_noise.type = (data & 1) ? 14 : 6;
m_noise.play = data & 2; svision->m_noise.play = data & 2;
m_noise.right = data & 4; svision->m_noise.right = data & 4;
m_noise.left = data & 8; svision->m_noise.left = data & 8;
m_noise.on = data & 0x10; /* honey bee start */ svision->m_noise.on = data & 0x10; /* honey bee start */
m_noise.state = 1; svision->m_noise.state = 1;
break; break;
} }
m_noise.pos = 0.0; svision->m_noise.pos = 0.0;
} }

64
src/engine/platform/sound/supervision.h
View file

@ -13,22 +13,60 @@ typedef uint16_t uint16;
typedef uint32_t uint32; typedef uint32_t uint32;
typedef float real; typedef float real;
typedef uint8_t BOOL; typedef uint8_t BOOL;
enum {FALSE, TRUE};
void supervision_sound_reset(void);
void supervision_sound_set_clock(uint32 clock); typedef struct {
void supervision_sound_stream_update(uint8 *stream, uint32 len); uint8 reg[4];
void supervision_sound_decrement(void); int on;
void supervision_sound_wave_write(int which, int offset, uint8 data); uint8 waveform, volume;
void supervision_sound_dma_write(int offset, uint8 data); uint16 pos, size;
void supervision_sound_noise_write(int offset, uint8 data); uint16 count;
void supervision_sound_noise_write(int offset, uint8 data); } SVISION_CHANNEL;
void supervision_memorymap_registers_write(uint32 Addr, uint8 Value);
typedef struct {
uint8 reg[3];
int on, right, left, play;
uint8 type; // 6 - 7-Bit, 14 - 15-Bit
uint16 state;
uint8 value, volume;
uint16 count;
real pos, step;
} SVISION_NOISE;
typedef struct {
uint8 reg[5];
int on, right, left;
uint32 ca14to16;
uint16 start;
uint16 size;
real pos, step;
} SVISION_DMA;
struct svision_t {
SVISION_CHANNEL m_channel[2];
// For clear sound (no grating), sync with m_channel
SVISION_CHANNEL ch[2];
SVISION_NOISE m_noise;
SVISION_DMA m_dma;
uint8 supervision_dma_mem[65536];
uint32 decrement_tick;
uint32 UNSCALED_CLOCK;
uint8 ch_mask, flags;
};
void supervision_sound_reset(struct svision_t *svision);
void supervision_sound_set_clock(struct svision_t *svision, uint32 clock);
void supervision_sound_stream_update(struct svision_t *svision, uint8 *stream, uint32 len);
void supervision_sound_decrement(struct svision_t *svision);
void supervision_sound_wave_write(struct svision_t *svision, int which, int offset, uint8 data);
void supervision_sound_dma_write(struct svision_t *svision,int offset, uint8 data);
void supervision_sound_noise_write(struct svision_t *svision, int offset, uint8 data);
void supervision_sound_noise_write(struct svision_t *svision, int offset, uint8 data);
void supervision_memorymap_registers_write(struct svision_t *svision, uint32 Addr, uint8 Value);
// 12SN // 12SN
void supervision_set_mute_mask(uint32 mask); void supervision_set_mute_mask(struct svision_t *svision, uint8 mask);
void supervision_sound_set_flags(uint32 flags_set); void supervision_sound_set_flags(struct svision_t *svision, uint8 flags_set);
extern uint8 supervision_dma_mem[65536];
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" } // extern "C"

102
src/engine/platform/sound/upd1771c.c
View file

@ -216,89 +216,79 @@ const unsigned char noise_tbl[8][256] = {
}; };
uint8_t upd1771c_packets[16]; void upd1771c_reset(struct upd1771c_t *scv) {
uint8_t upd1771c_mode; memset(scv->upd1771c_packets,0,16);
uint32_t upd1771c_pos; scv->upd1771c_mode = 0;
uint8_t upd1771c_off; scv->upd1771c_pos = 0;
uint8_t upd1771c_posc; scv->upd1771c_posc = 0;
uint8_t upd1771c_wave; scv->upd1771c_wave = 0;
uint8_t upd1771c_vol; scv->upd1771c_vol = 0;
uint8_t upd1771c_period; scv->upd1771c_period = 0;
uint8_t upd1771c_npos; scv->upd1771c_off = 0;
void upd1771c_reset() { scv->upd1771c_npos = 0;
memset(upd1771c_packets,0,16); //scv->upd1771c_repsamp = 0;
upd1771c_mode = 0;
upd1771c_pos = 0;
upd1771c_posc = 0;
upd1771c_wave = 0;
upd1771c_vol = 0;
upd1771c_period = 0;
upd1771c_off = 0;
upd1771c_npos = 0;
} }
void upd1771c_write_packet(uint8_t ind, uint8_t val) { void upd1771c_write_packet(struct upd1771c_t *scv, uint8_t ind, uint8_t val) {
upd1771c_packets[ind&15] = val; scv->upd1771c_packets[ind&15] = val;
switch (upd1771c_packets[0]) { switch (scv->upd1771c_packets[0]) {
case 1: case 1:
if (ind == 3) { if (ind == 3) {
upd1771c_mode = 1; scv->upd1771c_mode = 1;
upd1771c_wave = (upd1771c_packets[1]&0xe0)>>5; scv->upd1771c_wave = (scv->upd1771c_packets[1]&0xe0)>>5;
upd1771c_off = 0; //? scv->upd1771c_off = 0; //?
upd1771c_period = upd1771c_packets[2]; scv->upd1771c_period = scv->upd1771c_packets[2];
upd1771c_vol = upd1771c_packets[3]&0x1f; scv->upd1771c_vol = scv->upd1771c_packets[3]&0x1f;
} }
break; break;
case 2: case 2:
if (ind == 3) { if (ind == 3) {
upd1771c_mode = 2; scv->upd1771c_mode = 2;
upd1771c_wave = (upd1771c_packets[1]&0xe0)>>5; scv->upd1771c_wave = (scv->upd1771c_packets[1]&0xe0)>>5;
upd1771c_off = upd1771c_packets[1]&0x1f; scv->upd1771c_off = scv->upd1771c_packets[1]&0x1f;
upd1771c_period = upd1771c_packets[2]<0x20?0x20:upd1771c_packets[2]; scv->upd1771c_period = scv->upd1771c_packets[2]<0x20?0x20:scv->upd1771c_packets[2];
upd1771c_vol = upd1771c_packets[3]&0x1f; scv->upd1771c_vol = scv->upd1771c_packets[3]&0x1f;
} }
break; break;
default: default:
case 0: case 0:
upd1771c_mode = 0; scv->upd1771c_mode = 0;
break; break;
} }
} }
int upd1771c_repsamp = 0; void upd1771c_sound_set_clock(struct upd1771c_t *scv, unsigned int clock, unsigned int divi) {
scv->upd1771c_repsamp = divi;
void upd1771c_sound_set_clock(unsigned int clock, unsigned int divi) {
upd1771c_repsamp = divi;
} }
int16_t upd1771c_sound_stream_update() { int16_t upd1771c_sound_stream_update(struct upd1771c_t *scv) {
int16_t s = 0; int16_t s = 0;
for (int i = 0; i < upd1771c_repsamp; i++) { for (int i = 0; i < scv->upd1771c_repsamp; i++) {
s = 0; s = 0;
switch (upd1771c_mode) { switch (scv->upd1771c_mode) {
case 2: case 2:
s = ((int16_t)WAVEFORMS[upd1771c_wave][upd1771c_posc])*upd1771c_vol; s = ((int16_t)WAVEFORMS[scv->upd1771c_wave][scv->upd1771c_posc])*scv->upd1771c_vol;
upd1771c_pos++; scv->upd1771c_pos++;
if (upd1771c_pos >= upd1771c_period) { if (scv->upd1771c_pos >= scv->upd1771c_period) {
upd1771c_pos=0; scv->upd1771c_pos=0;
upd1771c_posc++; scv->upd1771c_posc++;
if (upd1771c_posc == 32) if (scv->upd1771c_posc == 32)
upd1771c_posc = upd1771c_off; scv->upd1771c_posc = scv->upd1771c_off;
} }
break; break;
case 1: case 1:
upd1771c_pos++; scv->upd1771c_pos++;
if (upd1771c_pos >= ((((uint32_t)upd1771c_period) + 1)*128)) { if (scv->upd1771c_pos >= ((((uint32_t)scv->upd1771c_period) + 1)*128)) {
upd1771c_pos=0; scv->upd1771c_pos=0;
upd1771c_posc++; scv->upd1771c_posc++;
if (upd1771c_posc == NOISE_SIZE) if (scv->upd1771c_posc == NOISE_SIZE)
upd1771c_posc = 0; scv->upd1771c_posc = 0;
} }
uint16_t p = upd1771c_posc; uint16_t p = scv->upd1771c_posc;
p = p>=254?253:p; p = p>=254?253:p;
s = ((int16_t)(noise_tbl[upd1771c_wave][p])-127)*upd1771c_vol; s = ((int16_t)(noise_tbl[scv->upd1771c_wave][p])-127)*scv->upd1771c_vol;
// inaccurate noise mixing :/ // inaccurate noise mixing :/
// s |= (upd1771c_npos&128)?127*upd1771c_vol:0; // s |= (scv->upd1771c_npos&128)?127*scv->upd1771c_vol:0;
break; break;
case 0: case 0:
default: default:

21
src/engine/platform/sound/upd1771c.h
View file

@ -8,10 +8,23 @@ extern "C"
#include <stdint.h> #include <stdint.h>
void upd1771c_reset(void); struct upd1771c_t {
void upd1771c_write_packet(uint8_t ind, uint8_t val); uint8_t upd1771c_packets[16];
int16_t upd1771c_sound_stream_update(void); uint8_t upd1771c_mode;
void upd1771c_sound_set_clock(unsigned int clock, unsigned int divi); uint32_t upd1771c_pos;
uint8_t upd1771c_off;
uint8_t upd1771c_posc;
uint8_t upd1771c_wave;
uint8_t upd1771c_vol;
uint8_t upd1771c_period;
uint8_t upd1771c_npos;
int upd1771c_repsamp;
};
void upd1771c_reset(struct upd1771c_t *scv);
void upd1771c_write_packet(struct upd1771c_t *scv, uint8_t ind, uint8_t val);
int16_t upd1771c_sound_stream_update(struct upd1771c_t *scv);
void upd1771c_sound_set_clock(struct upd1771c_t *scv, unsigned int clock, unsigned int divi);
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" } // extern "C"

16
src/engine/platform/supervision.cpp
View file

@ -61,17 +61,17 @@ void DivPlatformSupervision::acquire(short** buf, size_t len) {
int mask_bits=0; int mask_bits=0;
for (int i=0; i<4; i++) for (int i=0; i<4; i++)
mask_bits |= isMuted[i]?0:8>>i; mask_bits |= isMuted[i]?0:8>>i;
supervision_set_mute_mask(mask_bits); supervision_set_mute_mask(&svision,mask_bits);
while (!writes.empty()) { while (!writes.empty()) {
QueuedWrite w=writes.front(); QueuedWrite w=writes.front();
supervision_memorymap_registers_write(w.addr|0x2000,w.val); supervision_memorymap_registers_write(&svision,w.addr|0x2000,w.val);
regPool[w.addr&0x3f]=w.val; regPool[w.addr&0x3f]=w.val;
writes.pop(); writes.pop();
} }
unsigned char s[6]; unsigned char s[6];
supervision_sound_stream_update(s,2); supervision_sound_stream_update(&svision,s,2);
tempL[0]=(((int)s[0])-128)*256; tempL[0]=(((int)s[0])-128)*256;
tempR[0]=(((int)s[1])-128)*256; tempR[0]=(((int)s[1])-128)*256;
@ -441,7 +441,7 @@ void DivPlatformSupervision::reset() {
if (dumpWrites) { if (dumpWrites) {
addWrite(0xffffffff,0); addWrite(0xffffffff,0);
} }
supervision_sound_reset(); supervision_sound_reset(&svision);
memset(tempL,0,32*sizeof(int)); memset(tempL,0,32*sizeof(int));
memset(tempR,0,32*sizeof(int)); memset(tempR,0,32*sizeof(int));
memset(noiseReg,0,3*sizeof(unsigned char)); memset(noiseReg,0,3*sizeof(unsigned char));
@ -481,8 +481,8 @@ void DivPlatformSupervision::setFlags(const DivConfig& flags) {
for (int i=0; i<4; i++) { for (int i=0; i<4; i++) {
oscBuf[i]->rate=rate; oscBuf[i]->rate=rate;
} }
supervision_sound_set_clock((unsigned int)chipClock); supervision_sound_set_clock(&svision,(unsigned int)chipClock);
supervision_sound_set_flags((unsigned int)otherFlags); supervision_sound_set_flags(&svision,(unsigned int)otherFlags);
} }
void DivPlatformSupervision::poke(unsigned int addr, unsigned short val) { void DivPlatformSupervision::poke(unsigned int addr, unsigned short val) {
@ -574,12 +574,14 @@ int DivPlatformSupervision::init(DivEngine* p, int channels, int sugRate, const
isMuted[i]=false; isMuted[i]=false;
oscBuf[i]=new DivDispatchOscBuffer; oscBuf[i]=new DivDispatchOscBuffer;
} }
sampleMem=supervision_dma_mem; sampleMem=svision.supervision_dma_mem;
dutySwap=0; dutySwap=0;
otherFlags=0; otherFlags=0;
sampleOffset=0; sampleOffset=0;
sampleMemLen=0; sampleMemLen=0;
memset(sampleMem,0,65536); memset(sampleMem,0,65536);
svision.ch_mask=15;
svision.flags=1;
setFlags(flags); setFlags(flags);
reset(); reset();
return 4; return 4;

1
src/engine/platform/supervision.h
View file

@ -66,6 +66,7 @@ class DivPlatformSupervision: public DivDispatch {
unsigned char noiseReg[3]; unsigned char noiseReg[3];
unsigned char kon[4]; unsigned char kon[4];
unsigned char initWrite[4]; unsigned char initWrite[4];
struct svision_t svision;
friend void putDispatchChip(void*,int); friend void putDispatchChip(void*,int);
friend void putDispatchChan(void*,int,int); friend void putDispatchChan(void*,int,int);

8
src/engine/platform/upd1771c.cpp
View file

@ -47,12 +47,12 @@ void DivPlatformUPD1771c::acquire(short** buf, size_t len) {
while (!writes.empty()) { while (!writes.empty()) {
QueuedWrite w=writes.front(); QueuedWrite w=writes.front();
upd1771c_write_packet(w.addr&15,w.val); upd1771c_write_packet(&scv,w.addr&15,w.val);
regPool[w.addr&0xf]=w.val; regPool[w.addr&0xf]=w.val;
writes.pop(); writes.pop();
} }
signed short s = upd1771c_sound_stream_update()<<3; signed short s = (upd1771c_sound_stream_update(&scv)<<3)*((isMuted[0]&1)^1);
for (int i=0; i<1; i++) { for (int i=0; i<1; i++) {
oscBuf[i]->data[oscBuf[i]->needle++]=s; oscBuf[i]->data[oscBuf[i]->needle++]=s;
@ -314,7 +314,7 @@ void DivPlatformUPD1771c::reset() {
if (dumpWrites) { if (dumpWrites) {
addWrite(0xffffffff,0); addWrite(0xffffffff,0);
} }
//upd1771c_sound_reset(); upd1771c_reset(&scv);
memset(tempL,0,32*sizeof(int)); memset(tempL,0,32*sizeof(int));
memset(tempR,0,32*sizeof(int)); memset(tempR,0,32*sizeof(int));
memset(kon,0,1*sizeof(unsigned char)); memset(kon,0,1*sizeof(unsigned char));
@ -342,7 +342,7 @@ void DivPlatformUPD1771c::setFlags(const DivConfig& flags) {
for (int i=0; i<1; i++) { for (int i=0; i<1; i++) {
oscBuf[i]->rate=rate; oscBuf[i]->rate=rate;
} }
upd1771c_sound_set_clock((unsigned int)chipClock,8); upd1771c_sound_set_clock(&scv,(unsigned int)chipClock,8);
} }
void DivPlatformUPD1771c::poke(unsigned int addr, unsigned short val) { void DivPlatformUPD1771c::poke(unsigned int addr, unsigned short val) {

1
src/engine/platform/upd1771c.h
View file

@ -53,6 +53,7 @@ class DivPlatformUPD1771c: public DivDispatch {
// I may add the 3 square waves in noise mode later... // I may add the 3 square waves in noise mode later...
unsigned char kon[1]; unsigned char kon[1];
unsigned char initWrite[1]; unsigned char initWrite[1];
struct upd1771c_t scv;
friend void putDispatchChip(void*,int); friend void putDispatchChip(void*,int);