# Instrument Properties

Instrument ▸ Instrument Properties… (**Alt+0**) edits one instrument slot. The
top of the window holds what every instrument has, whatever makes its sound;
the tabs below hold what depends on it: a sample, a synth, a HighLife program,
a plugin, or MIDI.

The window shows whichever instrument is selected, in the instrument list or
anywhere else, and stays open while you work. There are no SET buttons: a field
applies when you press **Enter** or leave it. The pattern editor's keys for
choosing an instrument and the octave work here too, and the note keys play the
instrument.

## Instrument, Name and Disabled

**Instrument** is the slot on show, in hex as the instrument list and the
pattern write it; the readout beside it gives the slot and the number of slots
in decimal. Type a slot number (hex; `$` and `0x` are accepted), drag the
slider, or use the arrows. Choosing a slot here selects that instrument
everywhere, as clicking it in the list does.

**Name** is up to 40 characters. MED stores it one byte per character, so it is
Latin-1 only: a character outside Latin-1 is refused when you apply the name,
rather than failing the save later.

**Disabled** silences the instrument without removing it: its notes are
skipped and make no sound. The flag is saved with the module.

## Sample

Shown for a sample instrument. Several slots can play one sample, each with
its own name, tuning, loop and slice.

The box is the **sample's own name**, up to 200 characters. It belongs to the
sample, not to the slot: every slot that plays the sample shares it, the
Library shows it, and it is kept in a .medz. Renaming it never renames the
instrument. **Show in library** opens the Library on *This module* with this
slot's sample selected.

The readout says:

- the sample's content id (the start of a hash of its audio; *hashing…* while
  it is worked out);
- which other slots play it, or, when this slot's audio has been edited away
  from a shared sample, which slots still play the original;
- whether the compressed file it was loaded from (an MP3 or FLAC, say) is kept
  in the .medz — the first edit that changes the audio lets it go;
- how many samples in the project no slot plays.

An edit that changes the audio — a sample-editor command, or a new depth,
channel count or clip — gives this slot its own copy when other slots share
the sample, and they keep playing the original. Changing the loop, the slice, a
name or the tuning never makes a copy.

## Volume, Hold and Decay

**Volume** is in hex, like the pattern's volume column, with the decimal
beside it. Each module keeps its own MED's scale: 0–40 hex (0–64) in an Amiga
module, 0–7F (0–127) in a Windows one.

**Hold** is how many ticks a note sounds before the decay starts; the readout
is that time at the song's current tempo. 0 turns hold and decay off: the note
plays on.

**Decay** is what happens when the hold runs out. For a sample it is a fade
speed, so a higher number fades faster, and 0 cuts the note. For a synth or a
hybrid it is the line of the volume sequence to jump to, and what happens next
is whatever that line says. No time is shown for Decay: a sample's fade lasts
as long as its starting volume makes it, and a synth's is not a time at all.

## Transpose, Finetune and Default pitch

**Transpose** is in semitones, −128 to 127, and adds to the song's Global
transpose (Song Properties) for every ordinary note.

**Finetune** is in cents, to a tenth. MED stores sixteen finetune steps, −8 to
+7, each about 12.8 cents; the readout says which step the value is, or
*≈* the nearest step and how far off it is. An MMD save rounds to that step; a
.medz keeps the exact value. Tick **MED steps** to work in the raw steps
instead.

Transpose and finetune are one tuning in two fields: the arrows carry into
Transpose past either end of the finetune, and so does a typed value beyond
about +88 or −106 cents, so the tuning can be moved continuously through
semitones. Eight steps come to 102.6 cents rather than 100; MED has the same
gap. The arrows step a cent, ten with **Shift** and a tenth with **Alt** or
**Ctrl**. Finetune is greyed for a MIDI instrument.

**Default pitch** is the note a **DEF** note in the pattern plays this
instrument at. Type a key (`C-3`, `F#4`, `Db3`) or a note number up to 127 —
or, as in MED, hold the mouse button on the box and play the key. **Delete**
blanks it, and blank means the reference note. The arrows step a semitone, or
an octave with **Shift**. Neither transpose applies to a DEF note.

The box beside it is the same pitch as a **rate**, to a tenth of a hertz: what
DEF plays the sample at. Type a rate and Mediante sets the nearest key and the
finetune that makes the sample play at exactly that rate, in one undo step;
that finetune is usually between MED's steps, so only a .medz keeps it exact.
The arrows step 10 Hz, 100 with **Shift** and 1 with **Alt** or **Ctrl**.
*Recorded at* gives the sample's own rate when it is known — the rate of the
file it was loaded from, or one typed here — and a .medz keeps it.

## Sends

Shown only when the module has buses to send to. An instrument send takes
every voice playing this instrument, on whichever track, and sums it into a
bus.

Each send shows its bus (click it to open that bus in the Buses window), its
level in dB, **M** to mute it and **−** to remove it. At −60 dB the send is
off: it stays in the file but is not processed. **+ send…** adds a send; it
lists only the buses one can be added to.

Whether a send is pre- or post-fader is set in the Buses window, and the fader
it means is the one of the **track** each note plays on, not the instrument's:
move the notes to another track and the send follows that track's fader and
mute.

## The tabs

Sample and MIDI are always there; Synth, HighLife and Plugin appear only for
an instrument of that kind. The window opens on the tab the instrument is
about.

### Sample tab

**Slice start** and **Slice end** mark the part of the sample this slot plays,
in frames; the end is the frame after the last one. Both 0 means no slice: the
whole sample plays. A slice needs at least two frames. The strip along the top
of the waveform is the slice too: drag its bar to move it, or its ends to
resize it. A loop that falls outside the slice is pulled into it.

A slice is how one sample can sit in several slots, each playing a different
part. An MMD save trims the sample to the slice; a .medz keeps the whole sample
and the slice with it, so reopening the .medz gives both back.

The three dropdowns change how the sample is stored. Each is one undo step,
and each stops playback:

- **Depth** — 16-bit, 8-bit dithered or 8-bit rounded. Edits work on a
  floating-point copy of the sample (the master), and the stored bytes are made
  from it, so changing the depth loses nothing: 16 to 8 and back gives the
  16-bit sample again. Dither is added only where rounding would leave an
  error, so untouched audio stays exactly as it was.
- **Channels** — mono or stereo. Stereo from mono copies the one channel to
  both; mono from stereo averages the two. The loop and the slice stay where
  they are.
- **Clip** — where the master runs past full scale (after a boost, say), the
  stored sample is clamped (**hard clip**) or rounded off by a curve that
  starts at 87.5 % of full scale (**soft clip**). The master itself is never
  clamped; Normalise brings it back into range.

Under them is the [sample editor](sample-editor.md), and under that the loop:

- **On** turns the loop on. The loop fields stay editable with it off, as in
  MED.
- **Ping-pong** plays the loop forwards and backwards. It only takes effect
  while the loop is on; the flag is kept either way.
- **Start** and **Length** are in frames; together they cannot run past the
  end of the sample.
- **From selection** sets the loop to the waveform selection; **Clear** turns
  it off.

The loop is greyed for a MIDI instrument.

### Synth tab

For a synth or a hybrid. A MED synth is two small programs running side by
side, each at its own speed: a **volume sequence** and a **waveform
sequence**, each able to jump into the other.

**Vol speed** and **WF speed** are ticks per step, 1 to 127: MED tests the
counter as a signed byte, so 128–255 would step every tick.

In the two sequences, each row is one byte and the line number is its
position, which is what a jump command addresses. A row shows what that byte
is where the program reaches it — a command, a command's argument, or a value —
and the rows after an END or HLT are dimmed, because the program never reaches
them. A sequence can be 127 lines long.

Click a row to select it. **Line** shows which one; type a byte in hex and
press **Enter**, and **↑**/**↓** move to the next line without leaving the
box. *Insert command…* lists only the commands that sequence has. Arguments
are held to what their command accepts: speeds 1–127; a volume-sequence wait
1–127 (above that MED waits a single step); a waveform-sequence wait 1–255; a
waveform number no higher than the last waveform; a jump no further than line
126. The line under the entry box says what the selected row is; hover it for
why a range stops where it does.

**Preview** plays the instrument with both sequences running and highlights
the line each one is on. It needs the song stopped.

Below the sequences is the waveform the sequence plays. **Show** picks one;
drag across the picture to draw it (it is 8-bit, and the middle line is zero).
**Clear**, **Rev**, **Invert** and the two arrows (rotate by one sample) act on
the whole waveform; **Paste sample** replaces it with a range copied from the
sample editor (its *Copy to synth editor* command).

### HighLife tab

A HighLife instrument is **read-only**. There is no encoder for the format, so
Mediante saves the instrument exactly as it came in, byte for byte; *Carried*
says whether it can, and a module holding one it cannot carry cannot be saved.
The tab shows the program's name, its zones and its play mode, and lists the
zones — the keys each covers, its root key, rate and loop. Click a zone to see
its waveform.

**Playback** is Mediante's own, and neither setting is written to the file:
both are gone when the module is closed. They take effect on the next note.

- **Play mode** is *From the file* unless you override it: *Mono* retriggers,
  *Legato* slurs from note to note, *Poly* lets notes overlap. The Program
  section still shows what the file asks for, and the note beside the choice
  says when it is being overridden.
- **Voices**, 1 to 16, only matters in Poly: how many of one track's notes may
  sound at once. At 1 the previous note only gets its release tail; at 8, seven
  earlier notes can ring on.

### Plugin tab

For an instrument slot that plays a plugin (a Web Audio Module).

- **Instrument** is the plugin. The slot runs one copy of it, shared by every
  track that plays the slot, and the plugin's own polyphony decides how many
  notes sound. A plugin this machine does not have keeps its name in the list,
  marked *not installed*.
- **Preset** applies one of the slot's own presets or, if it has none, the
  plugin's; it is applied at once and kept with the slot. **Test note** plays
  middle C through the plugin, once it is running.
- The line under them says whether the plugin is running. It starts when the
  module plays.
- **Level** (0–200 %) and **Pan** are this instrument's own trim: the level
  multiplies the track's volume and the pan is added to the track's.
- **Out group** says where the plugin's sound joins the mix. *Master (not
  routed)* joins after the mixer: the master plugin chain and the master
  volume act on it, but no group's filter, echo or reverb. A group joins that
  group's mix before its filter, echo, reverb and stereo separation, exactly
  where a sampled voice on that group joins, and a plugin chain on the group
  processes it too. It then shares the mix's headroom like a voice, so it can
  sit lower than it did unrouted, and 2× oversampling is off while any
  instrument is routed. A group the module does not have is marked *not in
  this module*, and the sound still reaches the master.
- **Controls** hosts the plugin's own controls while it is running.

Level, pan, preset and out group are kept in the .medz and are not undo steps.

What the tracker sends a plugin:

- notes and note-offs. A track plays one note at a time, so a new note on a
  track releases the one before it; a note cut and **Stop** release notes too.
  Muting a track silences the plugin without releasing its notes, so unmuting
  brings them back. Every note has the same velocity, because MED has no
  velocity column;
- the track's volume and pan, and the song's tempo;
- the instrument's finetune, vibrato and slides, as pitch bend of up to ±2
  semitones — a slide wider than that stops at the edge.

A **DEF**, **11k**, **22k** or **44k** note is not sent: those play a sample at
a rate, and a plugin has no sample. It releases the track's note instead.

### MIDI tab

**Transmit ch.** 0 means the instrument is not a MIDI one. In MED, any other
channel makes it one: its notes go out over MIDI instead of playing the
sampler, which is why the loop and the finetune are greyed while it is set.
Mediante does not send MIDI; these fields are kept in the module for MED.

The rest apply once Transmit ch. is not 0:

- **Preset** (0–255) and **Long preset** (0–65535) are two separate fields in
  the file. Each is saved as it is; neither is filled in from the other.
- **Extended preset** tells MED to use the Long preset.
- **Don't send Note Off** is saved for MED.
- **Bank** and **Output port** are Windows MED fields. An Amiga-format module
  has nowhere to store them, so they are greyed there.

Hover a greyed field for why it is greyed.