SID (javamod 2.2 API)

java.lang.Object
- de.quippy.sidplay.resid_builder.resid.SID

```
public class SID
extends Object
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class SID.CycleCount

static class SID.FCPoints

static class SID.State
Read/Write State.

Nested Classes
Modifier and Type	Class and Description
`static class`	`SID.CycleCount`
`static class`	`SID.FCPoints`
`static class`	`SID.State` Read/Write State.

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean`	`ANTTI_LANKILA_PATCH` This is a patch against ReSID engine in libsidplay2-2.1.1 to make its sound closer to 6581R4 chip.
`protected int`	`bus_value`
`protected int`	`bus_value_ttl`
`protected double`	`clock_frequency`
`protected int`	`cycles_per_sample` Sampling variables.
`protected int`	`ext_in` External audio input.
`protected ExternalFilter`	`extfilt`
`Filter`	`filter`
`protected short[]`	`fir` FIR_RES filter tables (FIR_N*FIR_RES).
`protected int`	`fir_N` Sampling variables.
`protected static int`	`FIR_N` Resampling constants.
`protected int`	`fir_RES` Sampling variables.
`protected static int`	`FIR_RES_FAST` Resampling constants.
`protected static int`	`FIR_RES_INTERPOLATE` Resampling constants.
`protected static int`	`FIR_SHIFT` Resampling constants.
`protected static int`	`FIXP_MASK` Fixpoint constants (16.16 bits).
`protected static int`	`FIXP_SHIFT` Fixpoint constants (16.16 bits).
`protected Potentiometer`	`potx`
`protected Potentiometer`	`poty`
`protected static int`	`RINGSIZE` Resampling constants.
`protected short[]`	`sample` Ring buffer with overflow for contiguous storage of RINGSIZE samples.
`protected int`	`sample_index` Sampling variables.
`protected int`	`sample_offset` Sampling variables.
`protected short`	`sample_prev` Sampling variables.
`protected ISIDDefs.sampling_method`	`sampling` Sampling variables.
`protected Voice[]`	`voice`

Constructor Summary

Constructors
Constructor and Description

SID()
Constructor.

Constructors
Constructor and Description
`SID()` Constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`adjust_sampling_frequency(double sample_freq)` Adjustment of SID sampling frequency.
`protected int`	`clock_fast(SID.CycleCount delta_t, short[] buf, int n, int interleave)` SID clocking with audio sampling - delta clocking picking nearest sample.
`protected int`	`clock_interpolate(SID.CycleCount delta_t, short[] buf, int n, int interleave)` SID clocking with audio sampling - cycle based with linear sample interpolation.
`protected int`	`clock_resample_fast(SID.CycleCount delta_t, short[] buf, int n, int interleave)` SID clocking with audio sampling - cycle based with audio resampling.
`protected int`	`clock_resample_interpolate(SID.CycleCount delta_t, short[] buf, int n, int interleave)` SID clocking with audio sampling - cycle based with audio resampling.
`void`	`clock()` SID clocking - 1 cycle.
`void`	`clock(int delta_t)` SID clocking - delta_t cycles.
`int`	`clock(SID.CycleCount delta_t, short[] buf, int n, int interleave)` SID clocking with audio sampling.
`void`	`enable_external_filter(boolean enable)` Enable external filter.
`void`	`enable_filter(boolean enable)` Enable filter.
`void`	`fc_default(SID.FCPoints fcp)`
`PointPlotter`	`fc_plotter()` Return FC spline plotter object.
`protected double`	`I0(double x)` I0() computes the 0th order modified Bessel function of the first kind.
`void`	`input(int sample)` 16-bit input (EXT IN).
`void`	`mute(int channel, boolean enable)` SID voice muting.
`int`	`output()` 16-bit output (AUDIO OUT).
`int`	`output(int bits)` n-bit output.
`SID.State`	`read_state()` Read state.
`int`	`read(int offset)` Read registers.
`void`	`reset()` SID reset.
`void`	`set_chip_model(ISIDDefs.chip_model model)` Set chip model.
`void`	`set_distortion_properties(int Lt, int Ls, int Ll, int Lb, int Lh, int Ht, int Hs, int Hl, int Hb, int Hh)`
`boolean`	`set_sampling_parameters(double clock_freq, ISIDDefs.sampling_method method, double sample_freq, double pass_freq, double filter_scale)` Setting of SID sampling parameters.
`void`	`write_state(SID.State state)` Write state.
`void`	`write(int offset, int value)` Write registers.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - ANTTI_LANKILA_PATCH
```
public static boolean ANTTI_LANKILA_PATCH
```
    This is a patch against ReSID engine in libsidplay2-2.1.1 to make its sound closer to 6581R4 chip.
    http://bel.fi/~alankila/c64-sw/
    Good simulation of strong lead and bass distortion. Tel's leads, Jeff's bass, Mechanicus's extreme distortion: it all seems to reproduce quite nicely.
    Good simulation of advanced effects peculiar to 6581, especially on Jeff's songs that target 6581R4.
    Parameters are now in sidplay2.ini file. No recompile is necessary when testing alternative parameters.
    Bugs in some songs, especially related to lowpass filter output. The middle part of Spaceman Salutes Commodore and intro for Snake Disco are incorrectly rendered. (ReSID's linear filter is totally wrong with them too.) Vendetta probably gets too much edge in the bass, too. It seems that some kind of additional low-pass filtering needs to happen during so far unknown filter conditions.
    - 8.12.2007 Separate parameters for band-pass (high) and low-pass (low) distortion. This doubles the number of tunables, but seems like a necessary step to open experimentation on this front.
    - 6.12.2007 New distortion algorithm. After I scratched the whole model of substracting filter states from each other. The new model simply calculates distortion by mixing in the filter state terms and input in linear combination. The following rules seem to apply:
      
      vlp term must be about 0.9. More than that, and Jeff's bass sounds lose their edge. Too little, and pretty much everything distorts wrong.
      vbp term be something negative like -0.5 or -1 or Vendetta and Meanwhile The Planet doesn't work.
      vhp must be small or the distortion loses its "edge".
      The new model has one important property above the previous one: it only distorts the other half-wave, the same which can be seen distorted in SID samplings, too. Therefore it makes for more complicated distorted sounds, and better replicates the effects in f.e. Mechanicus.
    - 5.12.2007 Nearly doubled the impact of the bp-hp term. This improves Elite and Shades quite a bit, without seeming to negatively impact other songs.
    - 4.12.2007 Made tunables out of the rest of the distortion parameters, save from one that I just added: low-pass filtering for my crude w0_eff term. This seems to reduce the artifacts on Robocop 3, and generally doesn't seem to harm the songs.
    - 3.12.2007 A new distortion algorithm. A lot of time has passed. I made some improvements that force more distortion out of the model. I feel that this reinstates some of my LEADDIST effects and should be closer to correct model. I'm reasonably happy about how it turned out. This is definitely the best all-around emulation to date. I also made the distortion tunable via config file, so the thing is sane and doesn't trash 8580 any more.
    - 18.4.2007 Oops, a few months passed as I was busy at work. I've got rid of the LEADDIST effect, simply accepted that things will not work with it. I hope to be able to replace it with another trick up my sleeve, but so far the new songs and patch probably constitute a step backwards. Maybe.
    - 13.2.2007 Defeat with the masterful TBB songs such as 0_N_0 and Meanwhile The Planet. The 0_N_0 makes a lot of snapping because in a real chip the distortion terms are "filtered" by the other filter components, while mine are filtered by a static ad-hoc estimate. So, the snapping here comes from the LEADDIST term and it doesn't make the right kind of effect. Meanwhile The Planet makes masterfully precise use of the filter, and there isn't enough distortion for ReSID rendition to be palatable. Thanks to Grue for digging these songs up. Also fixed invalid sidplay2.ini configuration file (was not using 6581R4 curve). This, too, was spotted by Grue. I suspect Snake Disco might be fixed by accounting for the loss of intensity of sound with the vbp op-amp distortion. I made some measurements last night and discovered that level of lp and hp outputs dropped dramatically when bp was driven to distortion. I observed loss of up to 20 dB. I probably have to make many more measurements to allow mapping an estimate for this behaviour.
    - 12.2.2007 I added a minor tweak, adding an estimate of the resonance term in the op-amp loading measurement. I also made the bass distortion slightly more prominent, although it still isn't so harsh as the real chip produces.
    - 11.2.2007 I decided the price for fixing RoboCop 3 on 10.2. changes was too high to pay. It put a few dB of distortion back and migrated the distortion back to later time. Other changes in frequency drift implementation however helped a lot even with RoboCop 3, although I do think it still distorts too much. I think overall I'm now better off. I also moved the distortion term computation into the filter clocking function, so that if output is being requested at some different rate than the filter is clocked, the lowpass filtering would still be computed similarly. This bit me because I had this stupid OptimiseLevel PerformanceHacks accidentally enabled.
    - 10.2.2007 I made the distortion term to start earlier but also more delicate. (Reduced distortion by 6 dB.) This fixed RoboCop_3, SYS4096 and improved locutox's cover of Purple Shades. (Not included on sample set.) I also set bass level to -4.4 dB, because it comes about 1.5 dB louder than treble or bandpass. This is in full contrast to comments in ReSID that claim no level difference exists. Strange, but I can see it plain as day on FFT.
    - 3.2.2007 - 9.2.2007 Creation and tuning the model...
  - voice
```
protected Voice[] voice
```
  - filter
```
public Filter filter
```
  - extfilt
```
protected ExternalFilter extfilt
```
  - potx
```
protected Potentiometer potx
```
  - poty
```
protected Potentiometer poty
```
  - bus_value
```
protected int bus_value
```
  - bus_value_ttl
```
protected int bus_value_ttl
```
  - clock_frequency
```
protected double clock_frequency
```
  - ext_in
```
protected int ext_in
```
    External audio input.
  - FIR_N
```
protected static final int FIR_N
```
    Resampling constants. The error in interpolated lookup is bounded by 1.234/L^2, while the error in non-interpolated lookup is bounded by 0.7854/L + 0.4113/L^2, see http://www-ccrma.stanford.edu/~jos/resample/Choice_Table_Size.html For a resolution of 16 bits this yields L >= 285 and L >= 51473, respectively.
    
    See Also:
    Constant Field Values
  - FIR_RES_INTERPOLATE
```
protected static final int FIR_RES_INTERPOLATE
```
    Resampling constants. The error in interpolated lookup is bounded by 1.234/L^2, while the error in non-interpolated lookup is bounded by 0.7854/L + 0.4113/L^2, see http://www-ccrma.stanford.edu/~jos/resample/Choice_Table_Size.html For a resolution of 16 bits this yields L >= 285 and L >= 51473, respectively.
    
    See Also:
    Constant Field Values
  - FIR_RES_FAST
```
protected static final int FIR_RES_FAST
```
    Resampling constants. The error in interpolated lookup is bounded by 1.234/L^2, while the error in non-interpolated lookup is bounded by 0.7854/L + 0.4113/L^2, see http://www-ccrma.stanford.edu/~jos/resample/Choice_Table_Size.html For a resolution of 16 bits this yields L >= 285 and L >= 51473, respectively.
    
    See Also:
    Constant Field Values
  - FIR_SHIFT
```
protected static final int FIR_SHIFT
```
    Resampling constants. The error in interpolated lookup is bounded by 1.234/L^2, while the error in non-interpolated lookup is bounded by 0.7854/L + 0.4113/L^2, see http://www-ccrma.stanford.edu/~jos/resample/Choice_Table_Size.html For a resolution of 16 bits this yields L >= 285 and L >= 51473, respectively.
    
    See Also:
    Constant Field Values
  - RINGSIZE
```
protected static final int RINGSIZE
```
    Resampling constants. The error in interpolated lookup is bounded by 1.234/L^2, while the error in non-interpolated lookup is bounded by 0.7854/L + 0.4113/L^2, see http://www-ccrma.stanford.edu/~jos/resample/Choice_Table_Size.html For a resolution of 16 bits this yields L >= 285 and L >= 51473, respectively.
    
    See Also:
    Constant Field Values
  - FIXP_SHIFT
```
protected static final int FIXP_SHIFT
```
    Fixpoint constants (16.16 bits).
    
    See Also:
    Constant Field Values
  - FIXP_MASK
```
protected static final int FIXP_MASK
```
    Fixpoint constants (16.16 bits).
    
    See Also:
    Constant Field Values
  - sampling
```
protected ISIDDefs.sampling_method sampling
```
    Sampling variables.
  - cycles_per_sample
```
protected int cycles_per_sample
```
    Sampling variables.
  - sample_offset
```
protected int sample_offset
```
    Sampling variables.
  - sample_index
```
protected int sample_index
```
    Sampling variables.
  - sample_prev
```
protected short sample_prev
```
    Sampling variables.
  - fir_N
```
protected int fir_N
```
    Sampling variables.
  - fir_RES
```
protected int fir_RES
```
    Sampling variables.
  - sample
```
protected short[] sample
```
    Ring buffer with overflow for contiguous storage of RINGSIZE samples.
  - fir
```
protected short[] fir
```
    FIR_RES filter tables (FIR_N*FIR_RES).
- Constructor Detail
  - SID
```
public SID()
```
    Constructor.
- Method Detail
  - set_chip_model
```
public void set_chip_model(ISIDDefs.chip_model model)
```
    Set chip model.
    
    Parameters:
    model -
  - set_distortion_properties
```
public void set_distortion_properties(int Lt,
                             int Ls,
                             int Ll,
                             int Lb,
                             int Lh,
                             int Ht,
                             int Hs,
                             int Hl,
                             int Hb,
                             int Hh)
```
  - reset
```
public void reset()
```
    SID reset.
  - input
```
public void input(int sample)
```
    16-bit input (EXT IN). Write 16-bit sample to audio input. NB! The caller is responsible for keeping the value within 16 bits. Note that to mix in an external audio signal, the signal should be resampled to 1MHz first to avoid sampling noise.
    
    Parameters:
    sample -
  - output
```
public int output()
```
    16-bit output (AUDIO OUT). Read sample from audio output. Both 16-bit and n-bit output is provided.
    
    Returns:
  - output
```
public int output(int bits)
```
    n-bit output.
    
    Parameters:
    bits -
    
    Returns:
  - read
```
public int read(int offset)
```
    Read registers.
    Reading a write only register returns the last byte written to any SID register. The individual bits in this value start to fade down towards zero after a few cycles. All bits reach zero within approximately $2000 - $4000 cycles. It has been claimed that this fading happens in an orderly fashion, however sampling of write only registers reveals that this is not the case. NB! This is not correctly modeled. The actual use of write only registers has largely been made in the belief that all SID registers are readable. To support this belief the read would have to be done immediately after a write to the same register (remember that an intermediate write to another register would yield that value instead). With this in mind we return the last value written to any SID register for $2000 cycles without modeling the bit fading.
    
    Parameters:
    offset -
    
    Returns:
  - write
```
public void write(int offset,
         int value)
```
    Write registers.
    
    Parameters:
    offset -
    value -
  - mute
```
public void mute(int channel,
        boolean enable)
```
    SID voice muting.
    
    Parameters:
    channel -
    enable -
  - read_state
```
public SID.State read_state()
```
    Read state.
    
    Returns:
  - write_state
```
public void write_state(SID.State state)
```
    Write state.
    
    Parameters:
    state -
  - enable_filter
```
public void enable_filter(boolean enable)
```
    Enable filter.
    
    Parameters:
    enable -
  - enable_external_filter
```
public void enable_external_filter(boolean enable)
```
    Enable external filter.
    
    Parameters:
    enable -
  - I0
```
protected double I0(double x)
```
    I0() computes the 0th order modified Bessel function of the first kind. This function is originally from resample-1.5/filterkit.c by J. O. Smith.
    
    Parameters:
    x -
    
    Returns:
  - set_sampling_parameters
```
public boolean set_sampling_parameters(double clock_freq,
                              ISIDDefs.sampling_method method,
                              double sample_freq,
                              double pass_freq,
                              double filter_scale)
```
    Setting of SID sampling parameters.
    Use a clock freqency of 985248Hz for PAL C64, 1022730Hz for NTSC C64. The default end of passband frequency is pass_freq = 0.9*sample_freq/2 for sample frequencies up to ~ 44.1kHz, and 20kHz for higher sample frequencies.
    For resampling, the ratio between the clock frequency and the sample frequency is limited as follows: 125*clock_freq/sample_freq < 16384 E.g. provided a clock frequency of ~ 1MHz, the sample frequency can not be set lower than ~ 8kHz. A lower sample frequency would make the resampling code overfill its 16k sample ring buffer.
    The end of passband frequency is also limited: pass_freq <= 0.9*sample_freq/2
    E.g. for a 44.1kHz sampling rate the end of passband frequency is limited to slightly below 20kHz. This constraint ensures that the FIR table is not overfilled.
    
    Parameters:
    clock_freq -
    method -
    sample_freq -
    pass_freq -
    filter_scale -
    
    Returns:
  - adjust_sampling_frequency
```
public void adjust_sampling_frequency(double sample_freq)
```
    Adjustment of SID sampling frequency.
    In some applications, e.g. a C64 emulator, it can be desirable to synchronize sound with a timer source. This is supported by adjustment of the SID sampling frequency.
    NB! Adjustment of the sampling frequency may lead to noticeable shifts in frequency, and should only be used for interactive applications. Note also that any adjustment of the sampling frequency will change the characteristics of the resampling filter, since the filter is not rebuilt.
    
    Parameters:
    sample_freq -
  - fc_default
```
public void fc_default(SID.FCPoints fcp)
```
  - fc_plotter
```
public PointPlotter fc_plotter()
```
    Return FC spline plotter object.
    
    Returns:
  - clock
```
public void clock()
```
    SID clocking - 1 cycle.
  - clock
```
public void clock(int delta_t)
```
    SID clocking - delta_t cycles.
    
    Parameters:
    delta_t -
  - clock
```
public int clock(SID.CycleCount delta_t,
        short[] buf,
        int n,
        int interleave)
```
    SID clocking with audio sampling. Fixpoint arithmetics is used.
    The example below shows how to clock the SID a specified amount of cycles while producing audio output:
```
 while (delta_t) {
        bufindex += sid.clock(delta_t, buf + bufindex, buflength - bufindex);
        write(dsp, buf, bufindex * 2);
        bufindex = 0;
 }
 
```
    Returns:
  - clock_fast
```
protected int clock_fast(SID.CycleCount delta_t,
             short[] buf,
             int n,
             int interleave)
```
    SID clocking with audio sampling - delta clocking picking nearest sample.
    
    Returns:
  - clock_interpolate
```
protected int clock_interpolate(SID.CycleCount delta_t,
                    short[] buf,
                    int n,
                    int interleave)
```
    SID clocking with audio sampling - cycle based with linear sample interpolation.
    Here the chip is clocked every cycle. This yields higher quality sound since the samples are linearly interpolated, and since the external filter attenuates frequencies above 16kHz, thus reducing sampling noise.
    
    Returns:
  - clock_resample_interpolate
```
protected int clock_resample_interpolate(SID.CycleCount delta_t,
                             short[] buf,
                             int n,
                             int interleave)
```
    SID clocking with audio sampling - cycle based with audio resampling.
    This is the theoretically correct (and computationally intensive) audio sample generation. The samples are generated by resampling to the specified sampling frequency. The work rate is inversely proportional to the percentage of the bandwidth allocated to the filter transition band.
    This implementation is based on the paper "A Flexible Sampling-Rate Conversion Method", by J. O. Smith and P. Gosset, or rather on the expanded tutorial on the "Digital Audio Resampling Home Page": http://www-ccrma.stanford.edu/~jos/resample/
    By building shifted FIR tables with samples according to the sampling frequency, this implementation dramatically reduces the computational effort in the filter convolutions, without any loss of accuracy. The filter convolutions are also vectorizable on current hardware.
    Further possible optimizations are: * An equiripple filter design could yield a lower filter order, see http://www.mwrf.com/Articles/ArticleID/7229/7229.html * The Convolution Theorem could be used to bring the complexity of convolution down from O(n*n) to O(n*log(n)) using the Fast Fourier Transform, see http://en.wikipedia.org/wiki/Convolution_theorem * Simply resampling in two steps can also yield computational savings, since the transition band will be wider in the first step and the required filter order is thus lower in this step. Laurent Ganier has found the optimal intermediate sampling frequency to be (via derivation of sum of two steps): 2 * pass_freq + sqrt [ 2 * pass_freq * orig_sample_freq * (dest_sample_freq - 2 * pass_freq) / dest_sample_freq ]
    
    Returns:
  - clock_resample_fast
```
protected int clock_resample_fast(SID.CycleCount delta_t,
                      short[] buf,
                      int n,
                      int interleave)
```
    SID clocking with audio sampling - cycle based with audio resampling.
    
    Returns:

Class SID

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ANTTI_LANKILA_PATCH

voice

filter

extfilt

potx

poty

bus_value

bus_value_ttl

clock_frequency

ext_in

FIR_N

FIR_RES_INTERPOLATE

FIR_RES_FAST

FIR_SHIFT

RINGSIZE

FIXP_SHIFT

FIXP_MASK

sampling

cycles_per_sample

sample_offset

sample_index

sample_prev

fir_N

fir_RES

sample

fir

Constructor Detail

SID

Method Detail

set_chip_model

set_distortion_properties

reset

input

output

output

read

write

mute

read_state

write_state

enable_filter

enable_external_filter

I0

set_sampling_parameters

adjust_sampling_frequency

fc_default

fc_plotter

clock

clock

clock

clock_fast

clock_interpolate

clock_resample_interpolate

clock_resample_fast