summaryrefslogblamecommitdiffstatshomepage
path: root/src/devices/sound/c6280.cpp
blob: c0a91f3665158127ae2c76715cbc94466b62243b (plain) (tree)
1
2
                       
                                      





















                                                                           
                                              




                                                                            
                                                                                     






                                                          

  
                

                  
 
                                                                                                                              
 











































                                                                               
                                                                                                                








                                                                                         

                                                                                      







                                                                 

                                                                                                     



                                 
                                                                       
                                 













                                                                                                                                                                                            
                                                                                                                                                                           
























                                                                                                                



                                 


 









                                                                              
 

                                         
                                             
 

                           
 




                                               
 


                                               
 



                                                                                
 



                                                                                       
 
                                                                           
 






                                                                                
 


                                                
 
                                                      
 





                                                                                             
 

                                              
 



                                                                                             
 



                                                                  
 
                              
 


                                                                  
 


                                               
 


                                                           
 


                              

 
                                                                  
 
                                                                                                           
                                                     

                                                    



                                                   

                                                  

                                                   
                                     
 
                                
 



                                                                  
                                                                  





                                                              
                                                     

         




























                                                                             




                                                            
                                                    


                                                






                                            








                                                                       
         
 
// license:BSD-3-Clause
// copyright-holders:Charles MacDonald
/*
    HuC6280 sound chip 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

*/

#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_noise_freq_tab[(m_channel[ch].m_noise_control & 0x1F) ^ 0x1F];
				for (int i = 0; i < samples; i += 1)
				{
					static int data = 0;
					m_channel[ch].m_noise_counter += step;
					if(m_channel[ch].m_noise_counter >= 0x800)
					{
						data = (machine().rand() & 1) ? 0x1F : 0;
					}
					m_channel[ch].m_noise_counter &= 0x7FF;
					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 & 0x80) && (ch < 2))
				{
					if (ch == 0) // CH 0 only, CH 1 is muted
					{
						/* Waveform mode with LFO */
						uint32_t step = m_channel[0].m_frequency;
						uint16_t lfo_step = m_channel[1].m_frequency;
						for (int i = 0; i < samples; i += 1)
						{
							int offset, lfooffset;
							int16_t data, lfo_data;
							lfooffset = (m_channel[1].m_counter >> 12) & 0x1F;
							m_channel[1].m_counter += m_wave_freq_tab[(lfo_step * m_lfo_frequency) & 0xfff]; // TODO : multiply? verify this from real hardware.
							m_channel[1].m_counter &= 0x1FFFF;
							lfo_data = m_channel[1].m_waveform[lfooffset];
							if (m_lfo_control & 3)
								step += ((lfo_data - 16) << ((m_lfo_control-1)<<1)); // verified from patent, TODO : same in real hardware?

							offset = (m_channel[0].m_counter >> 12) & 0x1F;
							m_channel[0].m_counter += m_wave_freq_tab[step & 0xfff];
							m_channel[0].m_counter &= 0x1FFFF;
							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_wave_freq_tab[m_channel[ch].m_frequency];
					for (int i = 0; i < samples; i += 1)
					{
						int offset;
						int16_t data;
						offset = (m_channel[ch].m_counter >> 12) & 0x1F;
						m_channel[ch].m_counter += step;
						m_channel[ch].m_counter &= 0x1FFFF;
						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                                                       */
/*--------------------------------------------------------------------------*/

READ8_MEMBER( c6280_device::c6280_r )
{
	return m_cpudevice->io_get_buffer();
}

WRITE8_MEMBER( c6280_device::c6280_w )
{
	m_cpudevice->io_set_buffer(data);

	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;
			}
			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 HuC6280")

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)
	, m_cpudevice(*this, finder_base::DUMMY_TAG)
{
}

//-------------------------------------------------
//  calculate_clocks - (re)calculate clock-derived
//  members
//-------------------------------------------------

void c6280_device::calculate_clocks()
{
	int rate = clock() / 16;

	/* Make waveform frequency table */
	for (int i = 0; i < 4096; i += 1)
	{
		double step = ((clock() / rate) * 4096) / (i + 1);
		m_wave_freq_tab[(1 + i) & 0xFFF] = (uint32_t)step;
	}

	/* Make noise frequency table */
	for (int i = 0; i < 32; i += 1)
	{
		double step = ((clock() / rate) * 32) / (i+1);
		m_noise_freq_tab[i] = (uint32_t)step;
	}

	if (m_stream != nullptr)
		m_stream->set_sample_rate(rate);
	else
		m_stream = machine().sound().stream_alloc(*this, 0, 2, rate);
}

void c6280_device::device_clock_changed()
{
	calculate_clocks();
}

//-------------------------------------------------
//  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);

	calculate_clocks();

	/* 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);
	}
}