// license:BSD-3-Clause // copyright-holders:Charles MacDonald /* Hudson PSG emulator by Charles MacDonald E-mail: cgfm2@hotmail.com WWW: http://cgfm2.emuviews.com Thanks to: - Paul Clifford for his PSG documentation. - Richard Bannister for the TGEmu-specific sound updating code. - http://www.uspto.gov for the PSG patents. - All contributors to the tghack-list. Changes: (03/30/2003) - Removed TGEmu specific code and added support functions for MAME. - Modified setup code to handle multiple chips with different clock and volume settings. Missing features / things to do: - Verify LFO frequency from real hardware. - Add shared index for waveform playback and sample writes. Almost every game will reset the index prior to playback so this isn't an issue. - While the noise emulation is complete, the data for the pseudo-random bitstream is calculated by machine().rand() and is not a representation of what the actual hardware does. For some background on Hudson Soft's C62 chipset: - http://www.hudsonsoft.net/ww/about/about.html - http://www.hudson.co.jp/corp/eng/coinfo/history.html Integrated on: HuC6280 CPU (PC Engine/TurboGrafx 16) HuC6230 Sound Chip (PC-FX, with OKI ADPCM) */ #include "emu.h" #include "c6280.h" void c6280_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples) { static const int scale_tab[] = { 0x00, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F, 0x10, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F }; int lmal = (m_balance >> 4) & 0x0F; int rmal = (m_balance >> 0) & 0x0F; lmal = scale_tab[lmal]; rmal = scale_tab[rmal]; /* Clear buffer */ for (int i = 0; i < samples; i++) { outputs[0][i] = 0; outputs[1][i] = 0; } for (int ch = 0; ch < 6; ch++) { /* Only look at enabled channels */ if(m_channel[ch].m_control & 0x80) { int lal = (m_channel[ch].m_balance >> 4) & 0x0F; int ral = (m_channel[ch].m_balance >> 0) & 0x0F; int al = m_channel[ch].m_control & 0x1F; lal = scale_tab[lal]; ral = scale_tab[ral]; /* Calculate volume just as the patent says */ int vll = (0x1F - lal) + (0x1F - al) + (0x1F - lmal); if(vll > 0x1F) vll = 0x1F; int vlr = (0x1F - ral) + (0x1F - al) + (0x1F - rmal); if(vlr > 0x1F) vlr = 0x1F; vll = m_volume_table[vll]; vlr = m_volume_table[vlr]; /* Check channel mode */ if((ch >= 4) && (m_channel[ch].m_noise_control & 0x80)) { /* Noise mode */ uint32_t step = (m_channel[ch].m_noise_control & 0x1F) ^ 0x1F; for (int i = 0; i < samples; i += 1) { static int data = 0; if(m_channel[ch].m_noise_counter <= 0) { m_channel[ch].m_noise_counter = step << 2; data = (machine().rand() & 1) ? 0x1F : 0; } m_channel[ch].m_noise_counter--; outputs[0][i] += (int16_t)(vll * (data - 16)); outputs[1][i] += (int16_t)(vlr * (data - 16)); } } else if(m_channel[ch].m_control & 0x40) { /* DDA mode */ for (int i = 0; i < samples; i++) { outputs[0][i] += (int16_t)(vll * (m_channel[ch].m_dda - 16)); outputs[1][i] += (int16_t)(vlr * (m_channel[ch].m_dda - 16)); } } else { if ((m_lfo_control & 3) && (ch < 2)) { if (ch == 0) // CH 0 only, CH 1 is muted { /* Waveform mode with LFO */ uint16_t lfo_step = m_channel[1].m_frequency ? m_channel[1].m_frequency : 0x1000; for (int i = 0; i < samples; i += 1) { int32_t step = m_channel[0].m_frequency ? m_channel[0].m_frequency : 0x1000; if (m_lfo_control & 0x80) // reset LFO { m_channel[1].m_tick = lfo_step * m_lfo_frequency; m_channel[1].m_counter = 0; } else { int lfooffset = m_channel[1].m_counter; m_channel[1].m_tick--; if (m_channel[1].m_tick <= 0) { m_channel[1].m_tick = lfo_step * m_lfo_frequency; // TODO : multiply? verify this from real hardware. m_channel[1].m_counter = (m_channel[1].m_counter + 1) & 0x1f; } int16_t lfo_data = m_channel[1].m_waveform[lfooffset]; step += ((lfo_data - 16) << (((m_lfo_control & 3)-1)<<1)); // verified from patent, TODO : same in real hardware? } int offset = m_channel[0].m_counter; m_channel[0].m_tick--; if (m_channel[0].m_tick <= 0) { m_channel[0].m_tick = step; m_channel[0].m_counter = (m_channel[0].m_counter + 1) & 0x1f; } int16_t data = m_channel[0].m_waveform[offset]; outputs[0][i] += (int16_t)(vll * (data - 16)); outputs[1][i] += (int16_t)(vlr * (data - 16)); } } } else { /* Waveform mode */ uint32_t step = m_channel[ch].m_frequency ? m_channel[ch].m_frequency : 0x1000; for (int i = 0; i < samples; i += 1) { int offset = m_channel[ch].m_counter; m_channel[ch].m_tick--; if (m_channel[ch].m_tick <= 0) { m_channel[ch].m_tick = step; m_channel[ch].m_counter = (m_channel[ch].m_counter + 1) & 0x1f; } int16_t data = m_channel[ch].m_waveform[offset]; outputs[0][i] += (int16_t)(vll * (data - 16)); outputs[1][i] += (int16_t)(vlr * (data - 16)); } } } } } } /*--------------------------------------------------------------------------*/ /* MAME specific code */ /*--------------------------------------------------------------------------*/ WRITE8_MEMBER( c6280_device::c6280_w ) { channel *chan = &m_channel[m_select]; /* Update stream */ m_stream->update(); switch(offset & 0x0F) { case 0x00: /* Channel select */ m_select = data & 0x07; break; case 0x01: /* Global balance */ m_balance = data; break; case 0x02: /* Channel frequency (LSB) */ chan->m_frequency = (chan->m_frequency & 0x0F00) | data; chan->m_frequency &= 0x0FFF; break; case 0x03: /* Channel frequency (MSB) */ chan->m_frequency = (chan->m_frequency & 0x00FF) | (data << 8); chan->m_frequency &= 0x0FFF; break; case 0x04: /* Channel control (key-on, DDA mode, volume) */ /* 1-to-0 transition of DDA bit resets waveform index */ if((chan->m_control & 0x40) && ((data & 0x40) == 0)) { chan->m_index = 0; } if(((chan->m_control & 0x80) == 0) && (data & 0x80)) { chan->m_tick = chan->m_frequency; } chan->m_control = data; break; case 0x05: /* Channel balance */ chan->m_balance = data; break; case 0x06: /* Channel waveform data */ switch(chan->m_control & 0xC0) { case 0x00: chan->m_waveform[chan->m_index & 0x1F] = data & 0x1F; chan->m_index = (chan->m_index + 1) & 0x1F; break; case 0x40: break; case 0x80: chan->m_waveform[chan->m_index & 0x1F] = data & 0x1F; chan->m_index = (chan->m_index + 1) & 0x1F; break; case 0xC0: chan->m_dda = data & 0x1F; break; } break; case 0x07: /* Noise control (enable, frequency) */ chan->m_noise_control = data; break; case 0x08: /* LFO frequency */ m_lfo_frequency = data; break; case 0x09: /* LFO control (enable, mode) */ m_lfo_control = data; break; default: break; } } DEFINE_DEVICE_TYPE(C6280, c6280_device, "c6280", "Hudson Soft HuC6280 PSG") c6280_device::c6280_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) : device_t(mconfig, C6280, tag, owner, clock) , device_sound_interface(mconfig, *this) { } void c6280_device::device_clock_changed() { m_stream->set_sample_rate(clock()); } //------------------------------------------------- // device_start - device-specific startup //------------------------------------------------- void c6280_device::device_start() { /* Loudest volume level for table */ double level = 65535.0 / 6.0 / 32.0; /* Clear context */ m_select = 0; m_balance = 0; m_lfo_frequency = 0; m_lfo_control = 0; memset(m_channel, 0, sizeof(channel) * 8); m_stream = machine().sound().stream_alloc(*this, 0, 2, clock()); /* Make volume table */ /* PSG has 48dB volume range spread over 32 steps */ double step = 48.0 / 32.0; for (int i = 0; i < 31; i++) { m_volume_table[i] = (uint16_t)level; level /= pow(10.0, step / 20.0); } m_volume_table[31] = 0; save_item(NAME(m_select)); save_item(NAME(m_balance)); save_item(NAME(m_lfo_frequency)); save_item(NAME(m_lfo_control)); for (int chan = 0; chan < 8; chan++) { save_item(NAME(m_channel[chan].m_frequency), chan); save_item(NAME(m_channel[chan].m_control), chan); save_item(NAME(m_channel[chan].m_balance), chan); save_item(NAME(m_channel[chan].m_waveform), chan); save_item(NAME(m_channel[chan].m_index), chan); save_item(NAME(m_channel[chan].m_dda), chan); save_item(NAME(m_channel[chan].m_noise_control), chan); save_item(NAME(m_channel[chan].m_noise_counter), chan); save_item(NAME(m_channel[chan].m_counter), chan); save_item(NAME(m_channel[chan].m_tick), chan); } }