SPC 700 Documentation

Written by Gau of the Veldt
For the general Famidev community

OVERVIEW

Uwaoo! Hi. I'm Gau. Me have a shiny thing. Very shiny... shiny... shiny... A little *shiny* box inside my SNES. It's called an SPC-700. This little shiny thing makes noise when told to do so by code inside the SNES. This little gizmo is the key to making any sound whatsoever with your SNES program.

WHAT IS THE SPC

The SPC-700 is a co-processor. This means it is a separate CPU inside the SNES with its own memory and instruction set. The SNES communicates with the SPC through four 8-bit I/O ports. When the appropriate information is sent on the I/O ports, the program in the SPC will recognize the signals and perform some action (it might be nothing at all).

The SPC has its own memory, instruction set, etc. You cannot put a program into the SPC simply by storing it into RAM. The SPC must be sent the program via it's I/O locations. When you first turn on the SNES, the SPC has an internal kernal of sorts that gives it the ability to bootstrap to a program sent over the I/O port. Provided you have such a program, you can send it to the SPC. When the SPC recieves your code it will jump to the execution address in its memory that you specify (it's not required to be the start of code). This is where your program gets control of the SPC, DSP and I/O ports.

The memory on the SPC is 64K (kilobytes that is, not kilobits) in size. The DSP is 16-bit and supports eight stereo channels, each independantly pannable Left to Right. Samples sent into the DSP aren't the normal raw smapling used on an Amiga or PC. The samples in the SPC are encoded in a compressed format (I will get more to that later). The designers only placed 32K of RAM into the SPC however, so the upper 32K is unusable.

GETTING A PROGRAM INTO THE SPC

When the SPC starts, it waits for a startup value to appear in location 2141, This is hexadecimal $CC. However, you must do this last or else the kernal will get incorrect location and size information. Before I go too much further with this, I should indicate the block structure the SPC recognizes as part of the transfer protocol:

     WORD  Length
     WORD  Location
     BYTES Data

The SPC kernal will let you send any number of these blocks (ie: a MIDI implementation might use this to load appropriate patches for a song about to be played and then send the song).

When you've sent all blocks and want to start running code in the SPC, you send a zero-length block. There won't be any data. This block which contains only a 0 for length and a location will tell the kernal in the SPC that you're done sending and that it should jump to the program you just sent. The section below refers to this as the terminator block.

SENDING THE BLOCKS

The transfer protocol is fairly straightforward.

Get the length and place it into a counter
Get the location and store it to $2142-3 (a 16-bit operation will work fine).
If this is the first chunk, place $CC into $2140 and start an 8-bit sent-count at zero.
Send $01 to $2140 unless this is the terminator block, in which case you store a zero here.
You send the rest of the block one byte at a time. Store the byte into $2140.
To tell the SPC you've sent it the next value, you tell it the curent location. The SPC will set it to one less than the number of the curent byte sent (SPC starts this location at $FF and will wait for this location to go zero). Use the 8-bit sent-count. Store the sent-count to $2141
Wait for $2140 to mimic the value you just put into $2141. Please compare this with your counter and NOT the I/O port.
Bump the sent-count
Go back to step 5 until all bytes are sent.
Add 3 to your sent-count
If this makes the count 0, add 3 again.
If this wasn't a terminator block, go back to step 4 to continue sending blocks.

You are done and the SPC should now be doing your code. Final notes:

If speed is important, you'll want to move your blocks into RAM before sending.
To enusre reliability during tranfers, disable the NMI while transferring blocks to the SPC.

ONCE YOUR PROGRAM IS IN

Okay, so you've got an SPC program in the SPC, now what? First your program should have some means of accepting input from the SNES when it wants to change game music or play a sound effect. To do this, you need to be able to read or write values from or onto the I/O port from the SPC. On the SNES 65816 side, the I/O ports $2140-$2143. Inside the SPC, they're zero page locations $f4-$f7. Location $f4 is $2140, $f5 is $2141, etc.

Your code will want to check these ports. Your SPC program should detect values by writing a sentinel value to the port and wait for it to change. Then call the appropriate routine or effect the appropriate change. The reciever should have the task of using the sentinel to detect a change. If all the values are important, use two ports, send the byte out both ports and wait for the exclusive-or complement of the value sent to show up at one of the ports. This will be the reciever telling you it has recieved the next byte ok. The reciever should wait for both locations to become equivalent before attempting to get the next byte. This will ensure the reciever that the sender has placed a value onto the port.

Next, your program will want to make some noise to tell the world (and you) that it's there. To do this, you need to know about the SPC's samples and registers. I'll start with the registers, then talk about the samples.

THE SPC-700 REGISTERS

These registers are directly accessible from your SPC code. They are the zeropage locations $f1-$ff.

     $F1       SPCCON1   bits 0-2 timer enables (1=on), bits 4-5
                         are I/O port clear bits (11=clear all)

     $F2       SPCDRGA   DSP Register Address latch.  Write a value
                         here to select a DSP register to read or
                         modify.  This register itself is write-
                         only.

     $F3       SPCDDAT   DSP Register Data register.  Read or write
                         this register to read/write the DSP register
                         currently referred to in SPCDRGA.

     $FA-$FC   SPCTMLT   Timer latches - place a value into the
                         registers.  The timer counts up to your
                         time from 0.  When it hits, the associated
                         SPCTMCT register will advance.

     $FD-$FF   SPCTMCT   4-bit counters count timer hits on each
                         timer respectively

     Note: Timer 2 ($FC,$FF) counts at 64 kHz while the other two
	   count at 8 kHz.

THE SPC-700 DSP REGISTERS

To store a DSP setting, you set $F2 to the DSP register address to modify and then set $F3 to the value this register is to recieve.

These registers repeat for each voice (00v0), where v is a voice number from 0 to 7.

     
     0000            Volume left
     0001            Volume right
     0002            Pitch low
     0003            Pitch high         (The total 14 bits of pitch 
                                        height)
     0004            SRCN               Designates source number from 0-
                                        255 (sample number)
     0005            ADSR 1
     0006            ADSR 2
     0007            GAIN               Envelope can be freely designated by 
                                        your code ($1f here: ignore ADSR
                                        and just output using the volume
                                        settings)

     000F            FILTER             Filter deisgnation for this voice

The remaining registers affect everything:

     0008            ENVX               Present val of envelope with DSP 
                                        rewrites
     0009            VALX               Present wave height val

     000C            MASTVOLL           Master volume ($7f is maximum),
                                        left channel

     000D            ECHO               Echo feedback bits (1 for each
                                        voice)

     001C            MASTVOLR           Master volume ($7f is maximum),
                                        right channel

     002C            ECHOVOLL           Echo volume, left

     002D            PTCHMOD            Pitch modulation enable bits

     003C            ECHOVOLR           Echo volume, right

     003D            NOISEN             Noise enable bits

     004C            KEYON              Key-on (enable voice) bits

     004D            ECHOEN             Echo enable bits

     005C            KEYOFF             Key-off (mute voice) bits

     005D            SAMLOC             Hi-byte of mem address for the
                                        sample directory table (contains
                                        start-address and loop-start
                                        offset)

     006C            VOXCON             Misc voice control
                                           Bit 7: Reset (0=off)
                                           Bit 6: Mute  (0=off)
                                           Bit 5: Echo  (1=off)

     006D            ECHOLOC            Echo waveform directory location
                                        (Same as $5d)

     007D            ECHODLY            Echo delay enable bits

SPC-700 SAMPLES

The samples for the SPC are stored in a compressed format known as BRR. Unlike raw samples, the SPC samples are divided into 9-byte blocks. Each block encodes the equivalent of 16 raw 16-bit samples. The block format is as follows:

     rrrrffle 01 23 45 67 89 ab cd ef

          rrrr - granularity (known in SPC dox as "range"), 0-12
            ff - filter designation

These are normally zero but have significance on the LAST block:

             l - loop flagbit
             e - last chunk of sample

To convert a raw sample, it must first be padded to a multple of 16 and converted to a 16-bit signed waveform.

The granularity indicates the quantization level used for this block. Higher granularity values indicate SMALLER shifts in amplitude for the BRR nybbles in this block. Since a nybble only has a dynamic range from -8 to 7, the granularity is used to expand this:

Granulirity Nybbles produce dynamic range:

00 -00008 to 00007, in steps of 0001 01 -00016 to 00014, in steps of 0002 02 -00032 to 00028, in steps of 0004 03 -00064 to 00056, in steps of 0008 04 -00128 to 00112, in steps of 0016 05 -00256 to 00224, in steps of 0032 06 -00512 to 00448, in steps of 0064 07 -01024 to 00896, in steps of 0128 08 -02048 to 01792, in steos of 0256 09 -04096 to 03584, in steps of 0512 10 -08192 to 07168, in steps of 1024 11 -16384 to 14336, in steps of 2048 12 -32768 to 28672, in steps of 4096

As you can see, the SPC uses 16-bit waveforms. There is enough space in 32K to store 58,240 samples using this compression method about 4 seconds at 14.4 KHz (sorry, there's not quite enough space to do a real good CD quality sound track), ah, but then there's always the cartridge memory (24 MBits would hold 5.5 million samples - since the transfer gets a speed faster than playback you could double buffer and send stuff this way - this would give you about 6.5 minutes of digitized sound at CD quality in monaural recording. Stereo would halve these times).

To convert you look at the raw sample 16 samples at a time. For all waveform points in this sample you find a range (above) that fits in all the points. This is your granularity. You then use the step value to quantize each point down to one nybble. Then string these nybbles together, left to right. When this is done, you just create the header byte and append the eight additional bytes from the nybbles you just obtained. This has just converted 16 bytes of your sample to BRR format (Yay hoo!). Repeat the above procedure for the rest of the raw sample.

When recording for music, keep the recording rate at about 30 Khz to ensure that using the pitch value will give you a broad tonal range when using that sample as an instrument. You can forgo (skip) this rule if you're using multiple patching of the instrument to counter envelope and timbre distortion (but you still have to keep this in mind however) [BTW: multiple patching means recording the instrument several times, playing the instrument at different octaves for each recording] you then match the right patch to the playback octave when performing music (ie: on the SPC).

A higher recording rate gives better results after BRR conversion, as does using 16-bit samples as opposed to 8-bit samples.

SPC-700 CODING

The SPC-700 is a processor. That means that, just like the 68000, the SPC follows a program placed in its memory. This means to do music, you must either use a predefined routine from someone else or learn SPC-700 machine code. The latter isn't all that bad (the SPC instructions set kicks butt over the 65816's). There are functions for testing individual bits, changing individual bits, doing 16-bit BCD, multiplying and dividing. Additionally, there are also 16-bit instructions and the accumulator and Y register combine to form a 16-bit register (much like H and L on the Z80).

The easiest way to do SPC700 coding is with an assembler. However, there is a distinct lack of SPC-700 assemblers (as compared to 65816 assemblers which are all over the place). However the Famidev site has one good shareware assembler called TASM which is a table-based assembler (you can change the instruction set it assembles for). If you place my instruction set (called TASM07.TAB) into TASM, you can assemble SPC-700 code. The list follows. It is beyond the scope of this overview to go into detail about the SPC 700 assembly. Maybe in another document I will do exactly that.

Anyhoo, here's the SPC-700 TASM table:

=== "TASM07.TAB" === Cut me here ==============================================
"TASM SPC-700 Assembler, "
/*
/* Defines the SNES's SPC-700 Instruction set
/* Created by Gau of the Veldt
/*
/* There are no special instruction classes
/*
/* INSTR,ARGS,OPCODE,BYTES,MOD,CLASS,SHIFT,OR
/*
ADC     A,(X)   86 1 NOP 1
ADC     A,[*+X] 87 2 NOP 1
ADC     A,#*    88 2 NOP 1
ADC     A,*+X   95 3 NOP 1
ADCZ    A,*+X   94 2 NOP 1
ADC     A,*+Y   96 3 NOP 1
ADC     A,[*]+Y 97 2 NOP 1
ADC     A,*     85 3 NOP 1
ADCZ    A,*     84 2 NOP 1
ADC     *,#*    98 3 CSWAP 1
ADC     *,*     89 3 CSWAP 1

AND     A,(X)   26 1 NOP 1
AND     A,[*+X] 27 2 NOP 1
AND     A,#*    28 2 NOP 1
AND     A,*+X   35 3 NOP 1
ANDZ    A,*+X   34 2 NOP 1
AND     A,*+Y   36 3 NOP 1
AND     A,[*]+Y 37 2 NOP 1
AND     A,*     25 3 NOP 1
ANDZ    A,*     24 2 NOP 1
AND     (X),(Y) 39 1 NOP 1
AND     *,#*    38 3 CSWAP 1
AND     *,*     29 3 CSWAP 1

AND1    C,*     4A 3 NOP 1
AND1    C,/*    6A 3 NOP 1

ASL     A       1C 1 NOP 1
ASL     *,X     1B 2 NOP 1
ASL     *       0C 3 NOP 1
ASLZ    *       0B 2 NOP 1

LSR     A       5C 1 NOP 1
LSR     *,X     5B 2 NOP 1
LSR     *       4C 3 NOP 1
LSRZ    *       4B 2 NOP 1

ROL     A       3C 1 NOP 1
ROL     *,X     3B 2 NOP 1
ROL     *       2C 3 NOP 1
ROLZ    *       2B 2 NOP 1

ROR     A       7C 1 NOP 1
ROR     *,X     7B 2 NOP 1
ROR     *       6C 3 NOP 1
RORZ    *       6B 2 NOP 1

BBC0    *,*     13 3 CREL 1
BBC1    *,*     33 3 CREL 1
BBC2    *,*     53 3 CREL 1
BBC3    *,*     73 3 CREL 1
BBC4    *,*     93 3 CREL 1
BBC5    *,*     B3 3 CREL 1
BBC6    *,*     D3 3 CREL 1
BBC7    *,*     F3 3 CREL 1

BBS0    *,*     03 3 CREL 1
BBS1    *,*     23 3 CREL 1
BBS2    *,*     43 3 CREL 1
BBS3    *,*     63 3 CREL 1
BBS4    *,*     83 3 CREL 1
BBS5    *,*     A3 3 CREL 1
BBS6    *,*     C3 3 CREL 1
BBS7    *,*     E3 3 CREL 1

BPL     *       10 2 R1 1
BRA     *       2F 2 R1 1
BMI     *       30 2 R1 1
BVC     *       50 2 R1 1
BVS     *       70 2 R1 1
BCC     *       90 2 R1 1
BCS     *       B0 2 R1 1
BNE     *       D0 2 R1 1
BEQ     *       F0 2 R1 1

CLR0    *       02 2 NOP 1
CLR1    *       22 2 NOP 1
CLR2    *       42 2 NOP 1
CLR3    *       62 2 NOP 1
CLR4    *       82 2 NOP 1
CLR5    *       A2 2 NOP 1
CLR6    *       C2 2 NOP 1
CLR7    *       E2 2 NOP 1

SET0    *       12 2 NOP 1
SET1    *       32 2 NOP 1
SET2    *       52 2 NOP 1
SET3    *       72 2 NOP 1
SET4    *       92 2 NOP 1
SET5    *       B2 2 NOP 1
SET6    *       D2 2 NOP 1
SET7    *       F2 2 NOP 1

CMP     A,(X)   66 1 NOP 1
CMP     A,[*+X] 67 2 NOP 1
CMP     A,#*    68 2 NOP 1
CMP     A,*+X   75 3 NOP 1
CMPZ    A,*+X   74 2 NOP 1
CMP     A,*+Y   76 3 NOP 1
CMP     A,[*]+Y 77 2 NOP 1
CMP     A,*     65 3 NOP 1
CMPZ    A,*     64 2 NOP 1
CMP     X,#*    C8 2 NOP 1
CMP     X,*     1E 3 NOP 1
CMP     X,*     3E 2 NOP 1
CMP     Y,#*    AD 2 NOP 1
CMP     Y,*     5E 3 NOP 1
CMP     Y,*     7E 2 NOP 1
CMP     (X),(Y) 79 1 NOP 1
CMP     *,#*    78 3 CSWAP 1
CMP     *,*     69 3 CSWAP 1

CBNE    *+X,*   DE 3 CREL 1
CBNE    *,*     2E 3 CREL 1
DBNZ    Y,*     FE 2 R1 1
DBNZ    *,*     6E 3 CREL 1
DAA     YA      DF 1 NOP 1
DAS     YA      BE 1 NOP 1
NOT1    *       EA 3 NOP 1
XCN     A       9F 1 NOP 1
MOV1    C,*     AA 3 NOP 1
MOV1    *,C     CA 3 NOP 1

DECW    *       1A 2 NOP 1
INCW    *       3A 2 NOP 1
CLRW    *       5A 2 NOP 1
ADDW    YA,*    7A 2 NOP 1
SUBW    YA,*    9A 2 NOP 1
MOVW    YA,*    BA 2 NOP 1
MOVW    *,YA    DA 2 NOP 1
MUL     YA      CF 1 NOP 1
DIV     YA,X    9E 1 NOP 1

EOR     A,(X)   46 1 NOP 1
EOR     A,[*+X] 47 2 NOP 1
EOR     A,#*    48 2 NOP 1
EOR     A,*+X   55 3 NOP 1
EORZ    A,*+X   54 2 NOP 1
EOR     A,*+Y   56 3 NOP 1
EOR     A,[*]+Y 57 2 NOP 1
EOR     A,*     45 3 NOP 1
EORZ    A,*     44 2 NOP 1
EOR     (X),(Y) 59 1 NOP 1
EOR     *,#*    58 3 CSWAP 1
EOR     *,*     49 3 CSWAP 1

EOR1    C,*     8A 3 NOP 1

DEC     A       9C 1 NOP 1
DEC     X       1D 1 NOP 1
DEC     Y       DC 1 NOP 1
DEC     *,X     9B 2 NOP 1
DEC     *       8C 3 NOP 1
DECZ    *       8B 2 NOP 1

INC     A       BC 1 NOP 1
INC     X       3D 1 NOP 1
INC     Y       FC 1 NOP 1
INC     *,X     BB 2 NOP 1
INC     *       AC 3 NOP 1
INCZ    *       AB 2 NOP 1

MOV     X,A     5D 1 NOP 1
MOV     A,X     7D 1 NOP 1
MOV     X,SP    9D 1 NOP 1
MOV     SP,X    BD 1 NOP 1
MOV     A,Y     DD 1 NOP 1
MOV     Y,A     FD 1 NOP 1
MOV     (X),(Y) 99 1 NOP 1
MOV     (X)+,A  AF 1 NOP 1
MOV     A,(X)+  BF 1 NOP 1
MOV     (X),A   C6 1 NOP 1
MOV     A,(X)   E6 1 NOP 1
MOV     Y,#*    8D 2 NOP 1
MOV     X,#*    CD 2 NOP 1
MOV     A,#*    E8 2 NOP 1
MOV     [*+X],A C7 2 NOP 1
MOV     [*]+Y,A D7 2 NOP 1
MOV     A,[*+X] E7 2 NOP 1
MOV     A,[*]+Y F7 2 NOP 1
MOV     *+X,A   D5 3 NOP 1
MOVZ    *+X,A   D4 2 NOP 1
MOV     *+Y,A   D6 3 NOP 1
MOV     *+Y,X   D9 2 NOP 1
MOV     *+X,Y   DB 2 NOP 1
MOV     X,*+Y   F9 2 NOP 1
MOV     Y,*+X   FB 2 NOP 1
MOV     A,*+X   F5 3 NOP 1
MOVZ    A,*+X   F4 2 NOP 1
MOV     A,*+Y   F6 3 NOP 1
MOV     *,A     C5 3 NOP 1
MOVZ    *,A     C4 2 NOP 1
MOV     *,X     C9 3 NOP 1
MOV     *,X     D8 2 NOP 1
MOV     *,Y     CC 3 NOP 1
MOV     *,Y     CB 2 NOP 1
MOV     A,*     E5 3 NOP 1
MOVZ    A,*     E4 2 NOP 1
MOV     X,*     E9 3 NOP 1
MOV     X,*     F8 2 NOP 1
MOV     Y,*     EC 3 NOP 1
MOV     Y,*     EB 2 NOP 1
MOV     *,#*    8F 3 CSWAP 1
MOV     *,*     FA 3 CSWAP 1

OR      A,(X)   06 1 NOP 1
OR      A,[*+X] 07 2 NOP 1
OR      A,#*    08 2 NOP 1
OR      A,*+X   15 3 NOP 1
ORZ     A,*+X   14 2 NOP 1
OR      A,*+Y   16 3 NOP 1
OR      A,[*]+Y 17 2 NOP 1
OR      A,*     05 3 NOP 1
ORZ     A,*     04 2 NOP 1
OR      (X),(Y) 19 1 NOP 1
OR      *,#*    18 3 CSWAP 1
OR      *,*     09 3 CSWAP 1

OR1     C,*     0A 3 NOP 1
OR1     C,/*    2A 3 NOP 1

SBC     A,(X)   A6 1 NOP 1
SBC     A,[*+X] A7 2 NOP 1
SBC     A,#*    A8 2 NOP 1
SBC     A,*+X   B5 3 NOP 1
SBCZ    A,*+X   B4 2 NOP 1
SBC     A,*+Y   B6 3 NOP 1
SBC     A,[*]+Y B7 2 NOP 1
SBC     A,*     A5 3 NOP 1
SBCZ    A,*     A4 2 NOP 1
SBC     (X),(Y) B9 1 NOP 1
SBC     *,#*    B8 3 CSWAP 1
SBC     *,*     A9 3 CSWAP 1

TCALL   *       01 1 T1 1 4 F0
TSET1   *       0E 3 NOP 1
TCLR1   *       4E 3 NOP 1

CALL    *       3F 3 NOP 1
PCALL   *       4F 2 NOP 1
JMP     [*+X]   1F 3 NOP 1
JMP     *       5F 3 NOP 1

PUSH    PSW     0D 1 NOP 1
PUSH    A       2D 1 NOP 1
PUSH    X       4D 1 NOP 1
PUSH    Y       6D 1 NOP 1

POP     PSW     8E 1 NOP 1
POP     A       AE 1 NOP 1
POP     X       CE 1 NOP 1
POP     Y       EE 1 NOP 1

NOP     ""      00 1 NOP 1
BRK     ""      0F 1 NOP 1
RET     ""      6F 1 NOP 1
RETI    ""      7F 1 NOP 1
CLRP    ""      20 1 NOP 1
SETP    ""      40 1 NOP 1
CLRC    ""      60 1 NOP 1
SETC    ""      80 1 NOP 1
EI      ""      A0 1 NOP 1
DI      ""      C0 1 NOP 1
CLRV    ""      E0 1 NOP 1
NOTC    ""      ED 1 NOP 1
SLEEP   ""      EF 1 NOP 1
STOP    ""      FF 1 NOP 1
=== "TASM07.TAB" === Cut me here ==============================================

Anyways, enjoy this SPC-700 doc. It's been fun. If you want help or more info, you can either mail me via the Famidev (famidev@webcom.com) mailing list, or at my email location (gau@netbistro.com), or additionally through my mail gateway from my WWW page (http://www.netbistro.com/~gau).

E-Mail: gau@netbistro.com
WWW: http://www.netbistro.com/~gau