JITT64 (Java Ice Team Tracker) cheat sheet

Chord arpeggio (the 0 3 7 trick) › JITT64 (2010) #

Pattern command 05: the parameter byte packs a speed in bits 7–6 (0–3 ticks between steps), a first offset in bits 5–3 and a second offset in bits 2–0 that is added to the first arpeggio note, not to the root — so $23 (offsets 4 and 3) gives root, +4, +7, a major triad; the player cycles root → note 1 → note 2, a new note in the pattern clears the command, and 00 with bit 0 stops it. Chords of more than three notes, or offsets above 7 semitones, need the instrument's relative-note column instead (sources: s-sidin13-inside-jitt64, s-sidin13-jitt64-tracker).

• matt-gray-player, the 2015 readings: in V4.2 the plex is a pattern command, $FD ci — c notes from table i, so $FD,$36 plays table 6 as a three-note chord and $FD,$40 the first four entries of table 0 — and it persists until the next instrument or slide; Tognon's empty template offers 16 tables (nine of three notes, four of four, three of two: "95% of arpeggio are based into 3 values") (source: s-sidin14-dominator-player). The earlier Serpent Demo build keeps the arpeggio in instrument byte 5 and lists eight four-note chords with the octave on top — $00,$03,$07,$0C, $00,$04,$07,$0C, $00,$05,$07,$0C, $00,$04,$09,$0C, $00,$03,$08,$0C, $00,$05,$09,$0C, $00,$07,$0A,$0C — and one running downward, $13,$0C,$07,$00 (source: s-sidin15-serpent-demo-player).

Filter programming on the SID › JITT64 (2010), two tiny players, and an 8580 trick #

• jitt64: three pattern commands — 0D filter type (high/band/low pass and the voices to filter), 0E resonance (0–15), 0F cut-off — and three instrument columns: cut-off relative or absolute (values from the instrument's own table), resonance fixed / add / subtract, and a type entry of six checkboxes (HP, BP, LP, voice 1, 2, 3), each with the D/N delay/repeat field; the player keeps them in shadow registers (shadow_FCH, shadow_RES, shadow_TYPE) written after the three voices. The example "filtered bass drum" moves the cut-off per tick (sources: s-sidin13-jitt64-tracker, s-sidin13-inside-jitt64).
• 512 and 256 bytes: Plaster sweeps the cut-off high byte between $3F and $FF one step per frame with $D417 = $F1 and $D418 = $3F; Back To Basics writes the same counter to $D416 that it uses for pulse width, with $D417 = $F4 and $D418 = $1F (source: s-sidin12-tiny-sid-2-part-3).
• freedom's reason to prefer the 8580: "when you change filter type you don't get an unwanted noise as noticeable as the one you hear in 6581. This makes it possible to change filter type on an instrument while a note is being played and you get more sophisticated sounds" — but "way too open filters"; tsm adds that every 8580 sounds the same, unlike the 6581 (source: s-sidin13-tsm-freedom-interview). hermit in 2008: the 6581 "has good bass-filter behavior for older compositions", the 8580 "is more accurate" (source: s-sidin12-hermit-interview).

• Two 1980s filter policies from the SIDin interviews: matt-gray wrote no filter code until after Dominator — "I only started using them post Dominator on Vendetta … I was well aware of the filter inconsistencies and wanted to avoid using them, but eventually I needed the extra palette of sounds" (source: s-sidin15-matt-gray-interview), and elsewhere: "Initially, like others I didn't use the filters because they often sounded very different on another machine, but eventually I simply had to just to move the sound on" (source: s-vandalism63-matt-gray-interview); scarzix's 6581 had "a very light filter", so when the programmer could not hear CombatZone's leads the game got a filter on/off option in its menu (1989/90) (source: s-sidin14-scarzix-interview).

Hard restart › JITT64 (2010): hard restart as five instrument fields #

Tognon's jitt64 makes every part of the restart an explicit per-instrument setting (sources: s-sidin13-jitt64-tracker, s-sidin13-inside-jitt64):

• Three choices: no action ("all is left to you for preventing ADSR bugs"), Gate off N ticks before the end of the note, or Hard Restart — N ticks before the end the player writes Attack/Decay HR, Sustain/Release HR and First Control HR, and on the last tick before the new note Second Control HR. N is capped by the pattern tempo (timing 3, ticks 4 → 3 effective).
• A per-instrument write order, Wave–ADSR or ADSR–Wave, "for letting you obtain good hardrestart (some one need accurate write timing to be achieved)" — the choice GoatTracker makes globally with its attack-F playroutine.
• Two test-bit recipes: (a) HR AD/SR set, first control with the gate released, second control $09 (test + gate), at least 2 ticks, order ADSR–Wave; (b) both HR controls gate-off, one tick, and the instrument table's first row sets ADSR and wave $09 before the real waveform, order ADSR–Wave.
• In the player the instrument record starts with an HR byte (low nibble = ticks, bit 7 = full HR rather than gate off) and AD, SR, CTRL1, CTRL2; the hard-restart block runs last in the interrupt so that it overrides every other command, and the SID is written from shadow registers at the start of the next interrupt so that all voices — and the HR frame — land together; Tognon restructured the routine because variable block timing "can cause some hard-restart of note problem too". A hard-restart pattern command was still on the to-do list.

And a hard restart in 512 bytes: GRG's Tiny Sid Compo II winner Plaster writes SR $01 and AD $0F when a note's remaining duration reaches 1 — the 0F01 value — and starts every control sequence with $09 then $81 (source: s-sidin12-tiny-sid-2-part-3); the same GRG is credited above with the "soft restart".

Pitch slides and tone portamento › JITT64 (2010) #

06 xx / 07 xx add or subtract xx twice per tick ("the amount (*2)") to the 16-bit frequency until 00 (bits 1–2) stops them; 08 xx is a tone portamento entered on the same row as the target note: the player takes the new note's frequency as the target, restores the previous frequency as the start, chooses the direction by a 16-bit compare, moves xx × 2 per tick and snaps to the target when it is passed, then clears the command. Portamento at instrument level uses the frequency column's relative-frequency entries; a note-independent "hifi portamento" was planned (sources: s-sidin13-inside-jitt64, s-sidin13-jitt64-tracker).

Pulse width modulation (PWM) › JITT64 (2010) and the 512/256-byte players #

• jitt64: pattern commands 0A xx / 0B xx add or subtract xx per tick to the 12-bit pulse value (carry into the high byte, no bounds) until 00 with bits 5–6 stops them; in the instrument table the Pulse column takes fixed values (0–2048, from the instrument's own value table) or relative steps, the D/N field setting how many ticks each step holds and repeats — that is how the example instruments do "a 'vibrato' to the pulse" (Emil's string, a Dane lead, Matt Gray's bass) and "a 'portamento' onto the pulse" (the filtered bass drum, the other Dane lead) (sources: s-sidin13-jitt64-tracker, s-sidin13-inside-jitt64).
• The 2005 512-byte entries are three variations on a free-running counter (source: s-sidin08-tiny-sid-512b): Crue Gurl steps the pulse high byte for voices 1 and 3 from pwmMin = 3 to pwmMax = 6 every four frames, wrapping — with the source's own warning that the step counter pwmSpeed = 3 ; must be (n^2)-1!!!! because the code masks rather than compares; laxity's Twone Five gives each voice a start high byte (pulsehi $08,$01,$04) and adds a per-voice constant (pulseadd $00,$10,$3d) to the low byte at every SID write, so voice 3 sweeps fast and voice 1 not at all; 4mat's Empty makes it an instrument parameter — one instadd byte per instrument ($1c,$0c,$00,$15,$00,$74,$a5) added to the pulse low byte each frame, with the pulse high byte packed into the low nibble of instpuls.
• In GRG's 512-byte Plaster the pulse low byte of each voice is simply incremented by $18 every frame from high bytes $08, $08, $04 — a free-running sweep with no bounds; in Jaymz Julian's 256-byte Back To Basics one counter, incremented every four loops, is written as the pulse high byte of all three voices with the voice offset added, and as the filter cut-off at the same time (source: s-sidin12-tiny-sid-2-part-3).

• matt-gray-player V4.2: the bounce limits became part of the instrument — byte 14 holds them as nibbles $LH, i.e. between $0Lxx and $0Hxx ($8E = the Driller $08–$0E; $33 keeps the width "around" $03xx; $35 = $0300–$0500); byte 0 is the start width as swapped nibbles ($23 → $0320), byte 4 the per-frame step. Tognon's worked example: start $0320, step $A0, limits $18 → 800, 960, 1120 … 2080, then down to $01xx and back (source: s-sidin14-dominator-player).

Vibrato and delayed vibrato › JITT64 (2010) #

Command 09 xy: y + 1 ticks per leg, and each tick adds or subtracts (x + 1) × 16 to the raw 16-bit frequency; the first leg lasts one speed count and the following ones two (plus the reload tick), so it starts with a half period — a triangle on the register value, deeper in cents at low pitch like the matt-gray-player's and unlike Bjerregaard's semitone-proportional one; 00 with bit 4 stops it, and a "hifi vibrato … independent from octave/note" was planned. Instrument-level vibrato goes in the frequency column as relative-frequency entries timed by the D/N delay field (sources: s-sidin13-inside-jitt64, s-sidin13-jitt64-tracker).

• matt-gray-player V4.2 adds a per-note vibrato delay: pattern byte $F9 nn counts down before the instrument's vibrato (step in row byte 8, length in byte 9, the same down / up / up / down / down triangle as Driller) starts (source: s-sidin14-dominator-player). Gray in 2015: "My vibrato routine was very different to his [Hubbard's] and Martin Galway's" (source: s-sidin15-matt-gray-interview).

Wavetable programming (waveform / arp tables) › Two more starts: Plaster's $09,$81 and JITT64's noise drums #

• GRG's 512-byte Plaster keeps its "wavetables" as three control-register sequences shared by five instruments — $09,$81,$41,$00, $09,$81,$11,$11,$11,$11,$11,$00, $09,$81,$41,$40,$40,$80 — every sound opening with a test-bit frame and a noise frame, and a parallel list supplying fixed high-frequency bytes ($8B,$89,$86,$84, $8E,$8C,$8A) for the drum steps (source: s-sidin12-tiny-sid-2-part-3).
• jitt64's wave column is one of eight per-instrument columns with a delay/repeat field per row (0 = keep the waveform); its example bank builds bass drums and Matt Gray's snares from "fixed notes" in the frequency column and noise in the wave column, a second bass drum with "more low pitch notes and less noise", and a sea effect from noise with a very long attack/decay and no sustain (source: s-sidin13-jitt64-tracker).