summaryrefslogblamecommitdiffstatshomepage
path: root/src/devices/sound/hc55516.cpp
blob: 99cc782dc20f2ee1570b83808baf2a72c852411b (plain) (tree)
1
2
3
4
5
6
7
8
9

                                



                                                                              

                                                                              
                
                    

 
                     
                                           
 





                                       

 
 
 
                                                                  
 
                                                                                                               
                                                             

 


                                                                                                                                 
                                                       
                                   















                                      
 
                                                   

                                                   
 
                                   
 
                                 

 


                                                   
 
                                   
 

                               
 
                                                             
 
                                                                                                             
                                                            
 

 


                                                   
 
                                  
 
                                  


 
                                                             
 
                                                                                                             
                                                            
 

 


                                                   
 
                                  
 
                                  


 
                                                                               
 



                                                                      
 


                                             
 
                               
                                                                             










                                            
 
                                                   
 
                            


 
                                                                      
 

                                                                                     


 
                                                
 
                                                                             


 
                                    
 
                                               
 
                                                   
                                                 
 
                                                                   

                                       
            
                                       

                              
                             

                                                                               

                                                                    
         
                                                                             
 

                                              




                            
                                    
 

                                              



                                                 
                                  


                                                                      
                                                                              
            
                                                                             

 
                                       
 
                                                   
 
                                                                      
                                          
 
                                    
                                                    
         
                                                                            
                                    

                                            
                                   
 
                                
         

                              
                                         


 
                                       
 
                                     
         

                                        

            
                                    


 
                                   
 
                                                                     
                                         
 
                            
 
                                     

 






                                                                                                                                

                                             
                              
 


                               
 









                                                                          
 

                                             
                                                            
                                      
 




                                                              
                                            
 
                                           
 
                                         
 
                                                            
 



                                                                                     
 

                                                
 


                                                         
 




                                                              
 
                                                                                                                               
 
                                                                              

 

                                                                                                                               
                                                                              
 
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/*****************************************************************************

    Harris HC-55516 (and related) emulator

*****************************************************************************/

#include "emu.h"
#include "hc55516.h"


/* 4x oversampling */
#define SAMPLE_RATE             (48000 * 4)

#define INTEGRATOR_LEAK_TC      0.001
#define FILTER_DECAY_TC         0.004
#define FILTER_CHARGE_TC        0.004
#define FILTER_MIN              0.0416
#define FILTER_MAX              1.0954
#define SAMPLE_GAIN             10000.0




DEFINE_DEVICE_TYPE(HC55516, hc55516_device, "hc55516", "HC-55516")

hc55516_device::hc55516_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
	: hc55516_device(mconfig, HC55516, tag, owner, clock)
{
}

hc55516_device::hc55516_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock)
	: device_t(mconfig, type, tag, owner, clock),
		device_sound_interface(mconfig, *this),
		m_channel(nullptr),
		m_active_clock_hi(0),
		m_shiftreg_mask(0),
		m_last_clock_state(0),
		m_digit(0),
		m_new_digit(0),
		m_shiftreg(0),
		m_curr_sample(0),
		m_next_sample(0),
		m_update_count(0),
		m_filter(0),
		m_integrator(0),
		m_charge(0),
		m_decay(0),
		m_leak(0)
{
}

//-------------------------------------------------
//  device_start - device-specific startup
//-------------------------------------------------

void hc55516_device::device_start()
{
	start_common(0x07, true);
}

//-------------------------------------------------
//  device_reset - device-specific reset
//-------------------------------------------------

void hc55516_device::device_reset()
{
	m_last_clock_state = 0;
}

DEFINE_DEVICE_TYPE(MC3417, mc3417_device, "mc3417", "MC3417")

mc3417_device::mc3417_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
	: hc55516_device(mconfig, MC3417, tag, owner, clock)
{
}

//-------------------------------------------------
//  device_start - device-specific startup
//-------------------------------------------------

void mc3417_device::device_start()
{
	start_common(0x07, false);
}


DEFINE_DEVICE_TYPE(MC3418, mc3418_device, "mc3418", "MC3418")

mc3418_device::mc3418_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
	: hc55516_device(mconfig, MC3418, tag, owner, clock)
{
}

//-------------------------------------------------
//  device_start - device-specific startup
//-------------------------------------------------

void mc3418_device::device_start()
{
	start_common(0x0f, false);
}


void hc55516_device::start_common(uint8_t _shiftreg_mask, int _active_clock_hi)
{
	/* compute the fixed charge, decay, and leak time constants */
	m_charge = pow(exp(-1.0), 1.0 / (FILTER_CHARGE_TC * 16000.0));
	m_decay = pow(exp(-1.0), 1.0 / (FILTER_DECAY_TC * 16000.0));
	m_leak = pow(exp(-1.0), 1.0 / (INTEGRATOR_LEAK_TC * 16000.0));

	m_shiftreg_mask = _shiftreg_mask;
	m_active_clock_hi = _active_clock_hi;
	m_last_clock_state = 0;

	/* create the stream */
	m_channel = machine().sound().stream_alloc(*this, 0, 1, SAMPLE_RATE);

	save_item(NAME(m_last_clock_state));
	save_item(NAME(m_digit));
	save_item(NAME(m_new_digit));
	save_item(NAME(m_shiftreg));
	save_item(NAME(m_curr_sample));
	save_item(NAME(m_next_sample));
	save_item(NAME(m_update_count));
	save_item(NAME(m_filter));
	save_item(NAME(m_integrator));
}

inline int hc55516_device::is_external_oscillator()
{
	return clock() != 0;
}


inline int hc55516_device::is_active_clock_transition(int clock_state)
{
	return (( m_active_clock_hi && !m_last_clock_state &&  clock_state) ||
			(!m_active_clock_hi &&  m_last_clock_state && !clock_state));
}


inline int hc55516_device::current_clock_state()
{
	return ((uint64_t)m_update_count * clock() * 2 / SAMPLE_RATE) & 0x01;
}


void hc55516_device::process_digit()
{
	double integrator = m_integrator, temp;

	/* shift the bit into the shift register */
	m_shiftreg = (m_shiftreg << 1) | m_digit;

	/* move the estimator up or down a step based on the bit */
	if (m_digit)
		integrator += m_filter;
	else
		integrator -= m_filter;

	/* simulate leakage */
	integrator *= m_leak;

	/* if we got all 0's or all 1's in the last n bits, bump the step up */
	if (((m_shiftreg & m_shiftreg_mask) == 0) ||
		((m_shiftreg & m_shiftreg_mask) == m_shiftreg_mask))
	{
		m_filter = FILTER_MAX - ((FILTER_MAX - m_filter) * m_charge);

		if (m_filter > FILTER_MAX)
			m_filter = FILTER_MAX;
	}

	/* simulate decay */
	else
	{
		m_filter *= m_decay;

		if (m_filter < FILTER_MIN)
			m_filter = FILTER_MIN;
	}

	/* compute the sample as a 32-bit word */
	temp = integrator * SAMPLE_GAIN;
	m_integrator = integrator;

	/* compress the sample range to fit better in a 16-bit word */
	if (temp < 0)
		m_next_sample = (int)(temp / (-temp * (1.0 / 32768.0) + 1.0));
	else
		m_next_sample = (int)(temp / (temp * (1.0 / 32768.0) + 1.0));
}

void hc55516_device::clock_w(int state)
{
	uint8_t clock_state = state ? true : false;

	/* only makes sense for setups with a software driven clock */
	assert(!is_external_oscillator());

	/* speech clock changing? */
	if (is_active_clock_transition(clock_state))
	{
		/* update the output buffer before changing the registers */
		m_channel->update();

		/* clear the update count */
		m_update_count = 0;

		process_digit();
	}

	/* update the clock */
	m_last_clock_state = clock_state;
}


void hc55516_device::digit_w(int digit)
{
	if (is_external_oscillator())
	{
		m_channel->update();
		m_new_digit = digit & 1;
	}
	else
		m_digit = digit & 1;
}


int hc55516_device::clock_state_r()
{
	/* only makes sense for setups with an external oscillator */
	assert(is_external_oscillator());

	m_channel->update();

	return current_clock_state();
}


//-------------------------------------------------
//  sound_stream_update - handle a stream update
//-------------------------------------------------

void hc55516_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
{
	stream_sample_t *buffer = outputs[0];
	int i;
	int32_t sample, slope;

	/* zero-length? bail */
	if (samples == 0)
		return;

	if (!is_external_oscillator())
	{
		/* track how many samples we've updated without a clock */
		m_update_count += samples;
		if (m_update_count > SAMPLE_RATE / 32)
		{
			m_update_count = SAMPLE_RATE;
			m_next_sample = 0;
		}
	}

	/* compute the interpolation slope */
	sample = m_curr_sample;
	slope = ((int32_t)m_next_sample - sample) / samples;
	m_curr_sample = m_next_sample;

	if (is_external_oscillator())
	{
		/* external oscillator */
		for (i = 0; i < samples; i++, sample += slope)
		{
			uint8_t clock_state;

			*buffer++ = sample;

			m_update_count++;

			clock_state = current_clock_state();

			/* pull in next digit on the appropriate edge of the clock */
			if (is_active_clock_transition(clock_state))
			{
				m_digit = m_new_digit;

				process_digit();
			}

			m_last_clock_state = clock_state;
		}
	}

	/* software driven clock */
	else
		for (i = 0; i < samples; i++, sample += slope)
			*buffer++ = sample;
}

void mc3417_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
{
	hc55516_device::sound_stream_update(stream, inputs, outputs, samples);
}

void mc3418_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
{
	hc55516_device::sound_stream_update(stream, inputs, outputs, samples);
}