de.quippy.sidplay.resid_builder.resid

Class WaveformGenerator

java.lang.Object

de.quippy.sidplay.resid_builder.resid.WaveformGenerator

public class WaveformGenerator
extends Object

A 24 bit accumulator is the basis for waveform generation. FREQ is added to the lower 16 bits of the accumulator each cycle. The accumulator is set to zero when TEST is set, and starts counting when TEST is cleared. The noise waveform is taken from intermediate bits of a 23 bit shift register. This register is clocked by bit 19 of the accumulator.

Author:

Ken H�ndel

Field Summary

Fields

Modifier and Type	Field and Description
protected int	accumulator
protected int	freq Fout = (Fn*Fclk/16777216)Hz
protected boolean	msb_rising Tell whether the accumulator MSB was set high on this cycle.
protected int	pw PWout = (PWn/40.95)%
protected int	ring_mod The remaining control register bits.
protected int	shift_register
protected int	sync The remaining control register bits.
protected WaveformGenerator	sync_dest
protected WaveformGenerator	sync_source
protected int	test The remaining control register bits.
protected int	waveform The control register right-shifted 4 bits; used for output function table lookup.

Constructor Summary

Constructors

Constructor and Description
WaveformGenerator() Constructor.

Method Summary

Methods

Modifier and Type	Method and Description
void	clock() SID clocking - 1 cycle.
void	clock(int delta_t) SID clocking - delta_t cycles.
protected int	output____() No waveform: Zero output.
protected int	output___T() Triangle: The upper 12 bits of the accumulator are used.
protected int	output__S_() Sawtooth: The output is identical to the upper 12 bits of the accumulator.
protected int	output__ST() Combined waveforms: By combining waveforms, the bits of each waveform are effectively short circuited.
protected int	output_P__() Pulse: The upper 12 bits of the accumulator are used.
protected int	output_P_T() Combined waveforms: By combining waveforms, the bits of each waveform are effectively short circuited.
protected int	output_PS_() Combined waveforms: By combining waveforms, the bits of each waveform are effectively short circuited.
protected int	output_PST() Combined waveforms: By combining waveforms, the bits of each waveform are effectively short circuited.
int	output() 12-bit waveform output.
protected int	outputN___() Noise: The noise output is taken from intermediate bits of a 23-bit shift register which is clocked by bit 19 of the accumulator.
protected int	outputN__T() Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.
protected int	outputN_S_() Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.
protected int	outputN_ST() Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.
protected int	outputNP__() Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.
protected int	outputNP_T() Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.
protected int	outputNPS_() Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.
protected int	outputNPST() Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.
int	readOSC()
void	reset() SID reset.
void	set_chip_model(ISIDDefs.chip_model model) Set chip model.
void	set_sync_source(WaveformGenerator source) Set sync source.
void	synchronize() Synchronize oscillators.
void	writeCONTROL_REG(int control) Register functions.
void	writeFREQ_HI(int freq_hi) Register functions.
void	writeFREQ_LO(int freq_lo) Register functions.
void	writePW_HI(int pw_hi) Register functions.
void	writePW_LO(int pw_lo) Register functions.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

sync_source

protected WaveformGenerator sync_source

sync_dest

protected WaveformGenerator sync_dest

msb_rising

protected boolean msb_rising

Tell whether the accumulator MSB was set high on this cycle.

accumulator

protected int accumulator

shift_register

protected int shift_register

freq

protected int freq

Fout = (Fn*Fclk/16777216)Hz

pw

protected int pw

PWout = (PWn/40.95)%

waveform

protected int waveform

The control register right-shifted 4 bits; used for output function table lookup.

test

protected int test

The remaining control register bits.

ring_mod

protected int ring_mod

The remaining control register bits.

sync

protected int sync

The remaining control register bits.

Constructor Detail

WaveformGenerator

public WaveformGenerator()

Constructor.

Method Detail

set_sync_source

public void set_sync_source(WaveformGenerator source)

Set sync source.

Parameters:

source - sync source

set_chip_model

public void set_chip_model(ISIDDefs.chip_model model)

Set chip model.

Parameters:

model - chip model

writeFREQ_LO

public void writeFREQ_LO(int freq_lo)

Register functions.

Parameters:

freq_lo -

writeFREQ_HI

public void writeFREQ_HI(int freq_hi)

Register functions.

Parameters:

freq_hi -

writePW_LO

public void writePW_LO(int pw_lo)

Register functions.

Parameters:

pw_lo -

writePW_HI

public void writePW_HI(int pw_hi)

Register functions.

Parameters:

pw_hi -

writeCONTROL_REG

public void writeCONTROL_REG(int control)

Register functions.

Parameters:

control -

readOSC

public int readOSC()

reset

public void reset()

SID reset.

clock

public void clock()

SID clocking - 1 cycle.

clock

public void clock(int delta_t)

SID clocking - delta_t cycles.

synchronize

public void synchronize()

Synchronize oscillators. This must be done after all the oscillators have been clock()'ed since the oscillators operate in parallel. Note that the oscillators must be clocked exactly on the cycle when the MSB is set high for hard sync to operate correctly. See SID.clock().

output____

protected int output____()

No waveform: Zero output.

Returns:

zero

output___T

protected int output___T()

Triangle: The upper 12 bits of the accumulator are used. The MSB is used to create the falling edge of the triangle by inverting the lower 11 bits. The MSB is thrown away and the lower 11 bits are left-shifted (half the resolution, full amplitude). Ring modulation substitutes the MSB with MSB EOR sync_source MSB.

Returns:

triangle

output__S_

protected int output__S_()

Sawtooth: The output is identical to the upper 12 bits of the accumulator.

Returns:

sawtooth

output_P__

protected int output_P__()

Pulse: The upper 12 bits of the accumulator are used. These bits are compared to the pulse width register by a 12 bit digital comparator; output is either all one or all zero bits.

NB! The output is actually delayed one cycle after the compare. This is not modeled.

The test bit, when set to one, holds the pulse waveform output at 0xfff regardless of the pulse width setting.

Returns:

outputN___

protected int outputN___()

Noise: The noise output is taken from intermediate bits of a 23-bit shift register which is clocked by bit 19 of the accumulator. NB! The output is actually delayed 2 cycles after bit 19 is set high. This is not modeled.

Operation: Calculate EOR result, shift register, set bit 0 = result.

                         ------------------------>--------------------
                         |                                            |
                    ----EOR----                                       |
                    |         |                                       |
                    2 2 2 1 1 1 1 1 1 1 1 1 1                         |
  Register bits:    2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 <---
                    |   |       |     |   |       |     |   |
  OSC3 bits  :      7   6       5     4   3       2     1   0
 

Since waveform output is 12 bits the output is left-shifted 4 times.

output__ST

protected int output__ST()

Combined waveforms: By combining waveforms, the bits of each waveform are effectively short circuited. A zero bit in one waveform will result in a zero output bit (thus the infamous claim that the waveforms are AND'ed). However, a zero bit in one waveform will also affect the neighboring bits in the output. The reason for this has not been determined.

Example:

  
              1 1
  Bit #       1 0 9 8 7 6 5 4 3 2 1 0
              -----------------------
  Sawtooth    0 0 0 1 1 1 1 1 1 0 0 0
 
  Triangle    0 0 1 1 1 1 1 1 0 0 0 0
 
  AND         0 0 0 1 1 1 1 1 0 0 0 0
 
  Output      0 0 0 0 1 1 1 0 0 0 0 0
 

This behavior would be quite difficult to model exactly, since the SID in this case does not act as a digital state machine. Tests show that minor (1 bit) differences can actually occur in the output from otherwise identical samples from OSC3 when waveforms are combined. To further complicate the situation the output changes slightly with time (more neighboring bits are successively set) when the 12-bit waveform registers are kept unchanged.

It is probably possible to come up with a valid model for the behavior, however this would be far too slow for practical use since it would have to be based on the mutual influence of individual bits.

The output is instead approximated by using the upper bits of the accumulator as an index to look up the combined output in a table containing actual combined waveform samples from OSC3. These samples are 8 bit, so 4 bits of waveform resolution is lost. All OSC3 samples are taken with FREQ=0x1000, adding a 1 to the upper 12 bits of the accumulator each cycle for a sample period of 4096 cycles.

Sawtooth+Triangle: The sawtooth output is used to look up an OSC3 sample.

Pulse+Triangle: The triangle output is right-shifted and used to look up an OSC3 sample. The sample is output if the pulse output is on. The reason for using the triangle output as the index is to handle ring modulation. Only the first half of the sample is used, which should be OK since the triangle waveform has half the resolution of the accumulator.

Pulse+Sawtooth: The sawtooth output is used to look up an OSC3 sample. The sample is output if the pulse output is on.

Pulse+Sawtooth+Triangle: The sawtooth output is used to look up an OSC3 sample. The sample is output if the pulse output is on.

output_P_T

protected int output_P_T()

Combined waveforms: By combining waveforms, the bits of each waveform are effectively short circuited. A zero bit in one waveform will result in a zero output bit (thus the infamous claim that the waveforms are AND'ed). However, a zero bit in one waveform will also affect the neighboring bits in the output. The reason for this has not been determined.

Example:

  
              1 1
  Bit #       1 0 9 8 7 6 5 4 3 2 1 0
              -----------------------
  Sawtooth    0 0 0 1 1 1 1 1 1 0 0 0
 
  Triangle    0 0 1 1 1 1 1 1 0 0 0 0
 
  AND         0 0 0 1 1 1 1 1 0 0 0 0
 
  Output      0 0 0 0 1 1 1 0 0 0 0 0
 

This behavior would be quite difficult to model exactly, since the SID in this case does not act as a digital state machine. Tests show that minor (1 bit) differences can actually occur in the output from otherwise identical samples from OSC3 when waveforms are combined. To further complicate the situation the output changes slightly with time (more neighboring bits are successively set) when the 12-bit waveform registers are kept unchanged.

It is probably possible to come up with a valid model for the behavior, however this would be far too slow for practical use since it would have to be based on the mutual influence of individual bits.

The output is instead approximated by using the upper bits of the accumulator as an index to look up the combined output in a table containing actual combined waveform samples from OSC3. These samples are 8 bit, so 4 bits of waveform resolution is lost. All OSC3 samples are taken with FREQ=0x1000, adding a 1 to the upper 12 bits of the accumulator each cycle for a sample period of 4096 cycles.

Sawtooth+Triangle: The sawtooth output is used to look up an OSC3 sample.

Pulse+Triangle: The triangle output is right-shifted and used to look up an OSC3 sample. The sample is output if the pulse output is on. The reason for using the triangle output as the index is to handle ring modulation. Only the first half of the sample is used, which should be OK since the triangle waveform has half the resolution of the accumulator.

Pulse+Sawtooth: The sawtooth output is used to look up an OSC3 sample. The sample is output if the pulse output is on.

Pulse+Sawtooth+Triangle: The sawtooth output is used to look up an OSC3 sample. The sample is output if the pulse output is on.

output_PS_

protected int output_PS_()

Combined waveforms: By combining waveforms, the bits of each waveform are effectively short circuited. A zero bit in one waveform will result in a zero output bit (thus the infamous claim that the waveforms are AND'ed). However, a zero bit in one waveform will also affect the neighboring bits in the output. The reason for this has not been determined.

Example:

  
              1 1
  Bit #       1 0 9 8 7 6 5 4 3 2 1 0
              -----------------------
  Sawtooth    0 0 0 1 1 1 1 1 1 0 0 0
 
  Triangle    0 0 1 1 1 1 1 1 0 0 0 0
 
  AND         0 0 0 1 1 1 1 1 0 0 0 0
 
  Output      0 0 0 0 1 1 1 0 0 0 0 0
 

This behavior would be quite difficult to model exactly, since the SID in this case does not act as a digital state machine. Tests show that minor (1 bit) differences can actually occur in the output from otherwise identical samples from OSC3 when waveforms are combined. To further complicate the situation the output changes slightly with time (more neighboring bits are successively set) when the 12-bit waveform registers are kept unchanged.

It is probably possible to come up with a valid model for the behavior, however this would be far too slow for practical use since it would have to be based on the mutual influence of individual bits.

The output is instead approximated by using the upper bits of the accumulator as an index to look up the combined output in a table containing actual combined waveform samples from OSC3. These samples are 8 bit, so 4 bits of waveform resolution is lost. All OSC3 samples are taken with FREQ=0x1000, adding a 1 to the upper 12 bits of the accumulator each cycle for a sample period of 4096 cycles.

Sawtooth+Triangle: The sawtooth output is used to look up an OSC3 sample.

Pulse+Triangle: The triangle output is right-shifted and used to look up an OSC3 sample. The sample is output if the pulse output is on. The reason for using the triangle output as the index is to handle ring modulation. Only the first half of the sample is used, which should be OK since the triangle waveform has half the resolution of the accumulator.

Pulse+Sawtooth: The sawtooth output is used to look up an OSC3 sample. The sample is output if the pulse output is on.

Pulse+Sawtooth+Triangle: The sawtooth output is used to look up an OSC3 sample. The sample is output if the pulse output is on.

output_PST

protected int output_PST()

Combined waveforms: By combining waveforms, the bits of each waveform are effectively short circuited. A zero bit in one waveform will result in a zero output bit (thus the infamous claim that the waveforms are AND'ed). However, a zero bit in one waveform will also affect the neighboring bits in the output. The reason for this has not been determined.

Example:

  
              1 1
  Bit #       1 0 9 8 7 6 5 4 3 2 1 0
              -----------------------
  Sawtooth    0 0 0 1 1 1 1 1 1 0 0 0
 
  Triangle    0 0 1 1 1 1 1 1 0 0 0 0
 
  AND         0 0 0 1 1 1 1 1 0 0 0 0
 
  Output      0 0 0 0 1 1 1 0 0 0 0 0
 

This behavior would be quite difficult to model exactly, since the SID in this case does not act as a digital state machine. Tests show that minor (1 bit) differences can actually occur in the output from otherwise identical samples from OSC3 when waveforms are combined. To further complicate the situation the output changes slightly with time (more neighboring bits are successively set) when the 12-bit waveform registers are kept unchanged.

It is probably possible to come up with a valid model for the behavior, however this would be far too slow for practical use since it would have to be based on the mutual influence of individual bits.

The output is instead approximated by using the upper bits of the accumulator as an index to look up the combined output in a table containing actual combined waveform samples from OSC3. These samples are 8 bit, so 4 bits of waveform resolution is lost. All OSC3 samples are taken with FREQ=0x1000, adding a 1 to the upper 12 bits of the accumulator each cycle for a sample period of 4096 cycles.

Sawtooth+Triangle: The sawtooth output is used to look up an OSC3 sample.

Pulse+Triangle: The triangle output is right-shifted and used to look up an OSC3 sample. The sample is output if the pulse output is on. The reason for using the triangle output as the index is to handle ring modulation. Only the first half of the sample is used, which should be OK since the triangle waveform has half the resolution of the accumulator.

Pulse+Sawtooth: The sawtooth output is used to look up an OSC3 sample. The sample is output if the pulse output is on.

Pulse+Sawtooth+Triangle: The sawtooth output is used to look up an OSC3 sample. The sample is output if the pulse output is on.

outputN__T

protected int outputN__T()

Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.

NB! The effects of such combinations are not fully explored. It is claimed that the shift register may be filled with zeroes and locked up, which seems to be true.

We have not attempted to model this behavior, suffice to say that there is very little audible output from waveform combinations including noise. We hope that nobody is actually using it.

outputN_S_

protected int outputN_S_()

Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.

NB! The effects of such combinations are not fully explored. It is claimed that the shift register may be filled with zeroes and locked up, which seems to be true.

We have not attempted to model this behavior, suffice to say that there is very little audible output from waveform combinations including noise. We hope that nobody is actually using it.

outputN_ST

protected int outputN_ST()

Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.

NB! The effects of such combinations are not fully explored. It is claimed that the shift register may be filled with zeroes and locked up, which seems to be true.

We have not attempted to model this behavior, suffice to say that there is very little audible output from waveform combinations including noise. We hope that nobody is actually using it.

outputNP__

protected int outputNP__()

Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.

NB! The effects of such combinations are not fully explored. It is claimed that the shift register may be filled with zeroes and locked up, which seems to be true.

We have not attempted to model this behavior, suffice to say that there is very little audible output from waveform combinations including noise. We hope that nobody is actually using it.

outputNP_T

protected int outputNP_T()

Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.

NB! The effects of such combinations are not fully explored. It is claimed that the shift register may be filled with zeroes and locked up, which seems to be true.

We have not attempted to model this behavior, suffice to say that there is very little audible output from waveform combinations including noise. We hope that nobody is actually using it.

outputNPS_

protected int outputNPS_()

Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.

NB! The effects of such combinations are not fully explored. It is claimed that the shift register may be filled with zeroes and locked up, which seems to be true.

We have not attempted to model this behavior, suffice to say that there is very little audible output from waveform combinations including noise. We hope that nobody is actually using it.

outputNPST

protected int outputNPST()

Combined waveforms including noise: All waveform combinations including noise output zero after a few cycles.

NB! The effects of such combinations are not fully explored. It is claimed that the shift register may be filled with zeroes and locked up, which seems to be true.

We have not attempted to model this behavior, suffice to say that there is very little audible output from waveform combinations including noise. We hope that nobody is actually using it.

output

public int output()

12-bit waveform output. Select one of 16 possible combinations of waveforms.

Returns: