NeoGeo Development Wiki - User contributions [en]

User talk:Eaglesoftware777

2026-09-29T23:45:47Z

Eaglesoftware777:

'''Welcome to ''NeoGeo Development Wiki''!'''
We hope you will contribute much and well.
You will probably want to read the [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents help pages].
Again, welcome and have fun! [[User:Furrtek|Furrtek]] ([[User talk:Furrtek|talk]]) 11:42, 23 September 2026 (CEST)

Hello. I need to know if your edits are AI-generated, and/or if you allow AI agents to make edits on your behalf through your account.

Hello, yes we did use AI to correct text and improve organization/language and layout manually ..no automated tool or direct connection via AI using our account.
The model we use is Gemini.

We would like to thank you for your works Furrtek on the neo geo documentation and the wiki great work that was very usefull for us druing first days around 2015 to develop some basic parts of the Eagle software Neogeosdk

User talk:Eaglesoftware777

2026-09-29T23:43:21Z

Eaglesoftware777:

'''Welcome to ''NeoGeo Development Wiki''!'''
We hope you will contribute much and well.
You will probably want to read the [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents help pages].
Again, welcome and have fun! [[User:Furrtek|Furrtek]] ([[User talk:Furrtek|talk]]) 11:42, 23 September 2026 (CEST)

Hello. I need to know if your edits are AI-generated, and/or if you allow AI agents to make edits on your behalf through your account.

Hello, yes we did use AI to correct text and improve organization/language and layout manually ..no automated tool or direct connection via AI usisng our account.
The model we use is Gemini.

We would like to thank you for your works Furrtek on the neo geo documentation and the wiki great work that was very usefull for us druing first days around 2015 to develop some basic parts of the Eagle software Neogeosdk

User talk:Eaglesoftware777

2026-09-29T23:42:52Z

Eaglesoftware777:

'''Welcome to ''NeoGeo Development Wiki''!'''
We hope you will contribute much and well.
You will probably want to read the [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents help pages].
Again, welcome and have fun! [[User:Furrtek|Furrtek]] ([[User talk:Furrtek|talk]]) 11:42, 23 September 2026 (CEST)

Hello. I need to know if your edits are AI-generated, and/or if you allow AI agents to make edits on your behalf through your account.

Hello, yes we did use AI to correct text and improve organization/language and layout manually ..no automated tool or direct connection via AI usisng our account.
The model we use is Gemini.

We would like to thank you for your works Furrtek on the neo geo documentation and the wiki great work that was very usefull for us druing first days to develop some basic parts of the Eagle software Neogeosdk

User talk:Eaglesoftware777

2026-09-29T23:40:33Z

Eaglesoftware777:

Making scrollable backgrounds

2026-09-27T12:50:25Z

Eaglesoftware777:

Scrolling backgrounds are formed using a set of [[sprites]] positioned directly next to each other. A sprite is only 16 pixels wide, so many are needed to fill the screen horizontally. The [[Sticky bit]] makes this simpler: once a set of sprites is chained, the whole layer is moved by changing the position of its first sprite only.

The screen is 320 pixels wide. 20 sprites cover it exactly, but a layer that scrolls by less than 16 pixels at a time also shows part of a 21st sprite at the right edge. A set of 21 chained sprites is therefore the minimum for a single full-screen scrolling background layer.

==How a chained layer works==
A layer is made of one '''driving sprite''' followed by any number of '''chained sprites''' in the next sprite slots.

* The driving sprite holds the position of the whole layer: its [[SCB3]] word gives the Y position and height, and its [[SCB4]] word gives the X position.
* Each chained sprite has the sticky bit (bit 6) set in its SCB3 word. It takes its Y position, height and vertical shrink from the previous sprite, and is placed 16 pixels to the right of it (less when the previous sprite is horizontally shrunk). The rest of its SCB3 word and its SCB4 word are ignored.
* Each sprite has its own column of tiles in [[SCB1]], so every 16-pixel column of the layer can show different graphics.

Moving the layer only takes one VRAM write (SCB4 of the driving sprite) for horizontal scrolling, and one more (SCB3 of the driving sprite) for vertical scrolling.

===Wrap-around at 512 pixels===
The X position in SCB4 is 9 bits wide, so sprite positions wrap around every 512 pixels: a sprite at X = 500 is drawn 12 pixels to the left of the screen, partly visible. A chain of '''32''' sprites is exactly 512 pixels wide, so it covers every possible X position. Whatever value is written to the driving sprite's X, the screen is always fully covered, and the layer repeats every 512 pixels.

This gives two ways to build a scrolling layer:

* '''Looping layer''': 32 chained sprites showing a 512-pixel-wide picture whose left and right edges join seamlessly. The tiles are written once. Scrolling is only X = -camera, which wraps by itself. This is enough for skies, distant mountains, and repeating ground.
* '''Streamed layer''': the same 32 chained sprites, but the tile column of each sprite is replaced as the camera moves, with columns read from a level map in ROM. The level can then be any width, with no repetition. Only the columns that come into view are written.

===Parallax===
Several layers can move at different speeds by using a fraction of the camera position for each one: for example the full camera X for the ground, half of it for hills, and a quarter for clouds. Each layer is a separate chain, and each only needs its own driving sprite updated. Sprites in higher slots are drawn in front of sprites in lower slots, so the farthest layer uses the lowest slots.

===Sprites per line===
The hardware draws at most 96 sprites on a line. A sprite counts towards that limit on every line it covers vertically, whatever its X position, so a 32-sprite layer costs 32 sprites on every line it covers, even though only 21 of them are on screen. Keep this in mind when stacking several full-height layers: three of them already use every sprite a line can show.

==Updating VRAM==
VRAM is accessed through three registers:

{|class="wikitable"
!Register !! Address !! Use
|-
| REG_VRAMADDR || $3C0000 || VRAM word address for the next access
|-
| REG_VRAMRW || $3C0002 || Data to write (or data read) at that address
|-
| REG_VRAMMOD || $3C0004 || Value added to the address after each access
|}

With REG_VRAMMOD set to 1, consecutive writes to REG_VRAMRW fill consecutive VRAM words, so a whole tile column or a run of SCB entries is written with one address setup. REG_VRAMRW must always be written as a word: a long write would also write REG_VRAMMOD.

The sprite control blocks are laid out as follows:

{|class="wikitable"
!Block !! VRAM address !! Content per sprite
|-
| [[SCB1]] || $0000 + sprite × 64 || 32 pairs of words: tile number (bits 0-15), then attributes: palette (bits 15-8), tile number bits 16-19 (bits 7-4), auto-animation (bits 3-2), V flip (bit 1), H flip (bit 0)
|-
| [[SCB2]] || $8000 + sprite || Shrink: horizontal (bits 11-8), vertical (bits 7-0). $0FFF = full size
|-
| [[SCB3]] || $8200 + sprite || Y position as 496 - Y (bits 15-7), sticky bit (bit 6), height in tiles (bits 5-0)
|-
| [[SCB4]] || $8400 + sprite || X position (bits 15-7)
|}

All scroll updates should be done during vertical blank. Writing the position in the middle of a frame moves the layer part-way down the screen, which shows as a visible tear.

==Example code==
The code below builds a 32-sprite chained layer, scrolls it, and streams tile columns from a level map in ROM. The same routines also give a looping layer: skip the streaming step and load 32 columns of a 512-pixel picture once.

The level map is stored column by column. Each column holds 32 tiles as pairs of words (tile number, attributes), so every column is 128 bytes long and column n starts at LevelMap + n × 128. Rows below the layer height are never read by the hardware and can be left empty.

===Definitions===
<syntaxhighlight lang="asm">
REG_VRAMADDR equ $3C0000
REG_VRAMRW equ $3C0002
REG_VRAMMOD equ $3C0004

SCB1 equ $0000 ;tile maps, 64 words per sprite
SCB2 equ $8000 ;shrink
SCB3 equ $8200 ;Y, sticky bit, height
SCB4 equ $8400 ;X

LAYER_FIRST equ 33 ;first sprite slot of the layer (in front of a far layer at 1-32)
LAYER_STRIPS equ 32 ;32 x 16 = 512 pixels: covers every X position
LAYER_ROWS equ 14 ;height in tiles (14 x 16 = 224 pixels)
LAYER_Y equ 0 ;screen Y of the top of the layer

;in work RAM
LastCol ds.w 1 ;first column visible on the last update
</syntaxhighlight>

===Writing one column===
Copies world column d0 from the level map into the sprite that shows it. Column n always goes to sprite LAYER_FIRST + (n mod 32), which is exactly where the chain places it on screen.

<syntaxhighlight lang="asm">
;In: d0.w = world column
;Uses d0-d1/a0-a1. REG_VRAMMOD must be 1.
WriteColumn:
lea REG_VRAMRW,a1
move.w d0,d1
and.w #LAYER_STRIPS-1,d1 ;sprite = first + column mod 32
add.w #LAYER_FIRST,d1
lsl.w #6,d1 ;x 64 words: its SCB1 address
move.w d1,REG_VRAMADDR

lea LevelMap,a0
moveq #0,d1
move.w d0,d1
lsl.l #7,d1 ;column x 128 bytes
adda.l d1,a0

moveq #LAYER_ROWS*2-1,d1 ;tile word + attribute word per row
.copy:
move.w (a0)+,(a1)
dbra d1,.copy
rts
</syntaxhighlight>

===Setting up the layer===
Writes the shrink, height, sticky bits and position of all 32 sprites, then loads the 21 columns visible at camera X = 0.

<syntaxhighlight lang="asm">
InitLayer:
move.w #1,REG_VRAMMOD
lea REG_VRAMRW,a1

;SCB2: full size for every sprite
move.w #SCB2+LAYER_FIRST,REG_VRAMADDR
moveq #LAYER_STRIPS-1,d1
.scb2:
move.w #$0FFF,(a1)
dbra d1,.scb2

;SCB3: the driving sprite has Y and height, the others are chained to it
move.w #SCB3+LAYER_FIRST,REG_VRAMADDR
move.w #((496-LAYER_Y)<<7)|LAYER_ROWS,(a1)
moveq #LAYER_STRIPS-2,d1
.scb3:
move.w #$0040|LAYER_ROWS,(a1) ;sticky bit + height
dbra d1,.scb3

;SCB4: X of the driving sprite (chained sprites ignore theirs)
move.w #SCB4+LAYER_FIRST,REG_VRAMADDR
move.w #0,(a1)

;tiles for the columns on screen at camera X = 0
moveq #0,d0
.cols:
move.w d0,-(sp)
bsr WriteColumn
move.w (sp)+,d0
addq.w #1,d0
cmp.w #21,d0
bne.s .cols

clr.w LastCol
rts
</syntaxhighlight>

===Scrolling and streaming===
Called once per frame during vertical blank, with the camera position in world pixels. The visible columns are always c to c + 20, where c = camera X / 16.

* When the camera enters column c from the left, column c + 20 is about to appear at the right edge: it is written now, while it is still just off-screen.
* When the camera enters column c from the right, column c is appearing at the left edge and is written.

Each step writes one column, and a camera that moves less than 16 pixels per frame needs at most one step. The other 11 sprites of the chain are off-screen at all times, so the old tiles they hold are never seen. Finally the driving sprite is moved to X = -camera; the wrap-around at 512 keeps every column at its correct screen position.

<syntaxhighlight lang="asm">
;In: d0.w = camera X in world pixels (0 to level width - 320)
;Uses d0-d3/a0-a1
ScrollLayer:
move.w d0,d3 ;keep the camera position
move.w d0,d2
lsr.w #4,d2 ;c = first visible column

.right: ;camera moved right: bring in columns on the right
cmp.w LastCol,d2
ble.s .left
addq.w #1,LastCol
move.w LastCol,d0
add.w #20,d0
bsr WriteColumn
bra.s .right

.left: ;camera moved left: bring in columns on the left
cmp.w LastCol,d2
bge.s .move
subq.w #1,LastCol
move.w LastCol,d0
bsr WriteColumn
bra.s .left

.move:
move.w #SCB4+LAYER_FIRST,REG_VRAMADDR
neg.w d3 ;X = -camera
lsl.w #7,d3 ;into bits 15-7; bits above 511 fall off
move.w d3,REG_VRAMRW
rts
</syntaxhighlight>

The level map must have at least 21 columns past the rightmost camera position, so the camera bounds must keep it inside 0 to (level width - 320).

===Looping and parallax layers===
A looping layer needs no streaming: load all 32 columns once in InitLayer (loop to 32 instead of 21), then each frame only write its driving sprite's X. For a layer that moves at half the camera's speed:

<syntaxhighlight lang="asm">
FAR_FIRST equ 1 ;far layer in slots 1-32: drawn behind the main layer at 33-64

;In: d0.w = camera X
ScrollFarLayer:
asr.w #1,d0 ;half speed
neg.w d0
lsl.w #7,d0 ;wraps every 512 pixels by itself
move.w #SCB4+FAR_FIRST,REG_VRAMADDR
move.w d0,REG_VRAMRW
rts
</syntaxhighlight>

Use asr.w #2 for a quarter of the speed, or a multiply by a fixed-point factor for other ratios.

===Vertical scrolling===
The same principle applies vertically: write the Y position to the driving sprite's SCB3, keeping the sticky bit clear and the height unchanged. The chained sprites follow it.

<syntaxhighlight lang="asm">
;In: d0.w = screen Y of the top of the layer
SetLayerY:
move.w #496,d1
sub.w d0,d1 ;496 - Y
lsl.w #7,d1 ;into bits 15-7
or.w #LAYER_ROWS,d1 ;height
move.w #SCB3+LAYER_FIRST,REG_VRAMADDR
move.w d1,REG_VRAMRW
rts
</syntaxhighlight>

==Demos==
Interactive demos with source can be found [http://smkdan.eludevisibility.org/neo/scroll_02.zip here].

[[Category:Code]]
[[Category:Graphics Code]]

Using the SSG sound channels

2026-09-27T03:57:21Z

Eaglesoftware777:

==SSG==
The SSG part of the YM2610 is compatible with the AY-3-8910 (without its I/O ports). It has 3 square-wave tone channels (A, B, C), one noise generator that can be mixed into any channel, and one envelope generator (EG) shared by all channels. Each channel has a 4-bit volume, or can take its volume from the EG instead.

The SSG registers are on YM2610 '''port A''': the Z80 writes the register number to port '''$04''' and the value to port '''$05'''.

Definitions of [[YM2610_registers#SSG part|SSG registers]]:

<syntaxhighlight lang="z80">
;SSG register defines (YM2610 port A: address $04, data $05)
SSG_AFINE: EQU $00 ;channel A tone period, bits 0-7
SSG_ACOARSE: EQU $01 ;channel A tone period, bits 8-11
SSG_BFINE: EQU $02 ;channel B
SSG_BCOARSE: EQU $03
SSG_CFINE: EQU $04 ;channel C
SSG_CCOARSE: EQU $05
SSG_NOISE: EQU $06 ;noise period, 5 bits (0-$1F)
SSG_MIXER: EQU $07 ;bits 0-2: tone A/B/C off, bits 3-5: noise A/B/C off (1 = off)
SSG_AVOL: EQU $08 ;bits 0-3: volume 0-$F, bit 4: use EG instead
SSG_BVOL: EQU $09
SSG_CVOL: EQU $0A
SSG_EGFINE: EQU $0B ;EG period, bits 0-7
SSG_EGCOARSE: EQU $0C ;EG period, bits 8-15
SSG_EGSHAPE: EQU $0D ;bits 0-3: hold, alternate, attack, continue
</syntaxhighlight>

(Full list of defines [[YM2610 ASM defines|here]])

===Frequencies===
With the YM2610's 8 MHz clock:

Tone: f = 125000 / TP TP = 12-bit tone period (1-$FFF)
Noise: f = 125000 / NP NP = 5-bit noise period (1-$1F)
EG: f = 7812.5 / EP EP = 16-bit EG period; f is the repeat rate of one full ramp

For example, TP = $040 gives about 1953 Hz, and A4 (440 Hz) is TP = 284 ($11C). Going up one octave halves TP; going down one octave doubles it.

===Mixer register===
In register $07 a bit set to '''1''' turns the source '''off'''. Bits 0-2 control the tone of channels A, B and C, and bits 3-5 control the noise on channels A, B and C. So $3F silences all tone and noise, $3E enables only the tone of channel A, and $37 enables only noise on channel A.

The mixer controls all three channels at once. A driver that plays several channels independently should keep a copy of the register in RAM and change only its own bits (see the example below).

===Write routine===
The examples below use RST $08 to write register D with value E on port A. An RST slot is only 8 bytes long, and the write routine does not fit in it together with a RET, so the slot jumps to the routine instead. Polling the busy flag (bit 7 of port $04) before each write is the safe choice on real hardware.

<syntaxhighlight lang="z80">
.org $0008
jp WritePortA ;RST $08: set YM2610 port A register D to value E

;Write E to YM2610 port A register D
;Destroys: nothing
WritePortA:
push af
WPA_wait1:
in a,($04) ;status 0
rlca ;busy flag -> carry
jr c,WPA_wait1
ld a,d
out ($04),a ;register number
WPA_wait2:
in a,($04)
rlca
jr c,WPA_wait2
ld a,e
out ($05),a ;value
pop af
ret
</syntaxhighlight>

===Beep using the envelope generator===
Plays a 2 kHz tone on channel A whose volume repeatedly ramps down.

<syntaxhighlight lang="z80">
FastBeep:
ld de,$0040 ;Channel A tone period: $040 (about 2 kHz)
rst $08
ld de,$0100
rst $08

ld de,$0B0F ;EG period: $050F (about 6 Hz)
rst $08
ld de,$0C05
rst $08

ld de,$0810 ;Channel A volume is taken from the EG
rst $08
ld de,$0D08 ;EG shape: repeating ramp down
rst $08
ld de,$073E ;Only the tone of channel A is on
rst $08

ret
</syntaxhighlight>

Note: the mixer value is $3E, not $0E. $0E leaves the noise enabled on channels B and C.

Writing the EG shape register restarts the envelope, so write it last, when the sound should start.

===EG shapes===
{|class="wikitable"
!Value !! Shape
|-
| $00-$03, $09 || Single ramp down, then stay at 0
|-
| $04-$07, $0F || Single ramp up, then drop to 0 and stay there
|-
| $08 || Repeating ramp down (sawtooth)
|-
| $0A || Repeating down-up (triangle)
|-
| $0B || Single ramp down, then stay at maximum
|-
| $0C || Repeating ramp up (sawtooth)
|-
| $0D || Single ramp up, then stay at maximum
|-
| $0E || Repeating up-down (triangle)
|}

===Playing a note===
Sets channel C (0 = A, 1 = B, 2 = C) to note A (0-11 = C to B, octave 4). The table holds TP values; the fine and coarse registers of channel n are 2n and 2n+1.

<syntaxhighlight lang="z80">
;In: A = note 0-11, C = channel 0-2
SSG_SetNote:
push hl
ld hl,SSG_NoteTable
add a,a ;2 bytes per entry
add a,l
ld l,a
jr nc,SSG_SN_nc
inc h
SSG_SN_nc:
ld a,c
add a,a
ld d,a ;fine tune register
ld e,(hl)
rst $08
inc d ;coarse tune register
inc hl
ld e,(hl)
rst $08
pop hl
ret

SSG_NoteTable: ;octave 4, TP = 125000 / f
dw 478,451,426,402,379,358,338,319,301,284,268,253
; C C# D D# E F F# G G# A A# B
</syntaxhighlight>

For other octaves, shift the TP right (higher) or left (lower) once per octave before writing it.

===Enabling one channel without affecting the others===
Keeps a copy of the mixer register in RAM, so each channel can be switched on or off independently.

<syntaxhighlight lang="z80">
MixerCopy: EQU $F800 ;1 byte of Z80 RAM, initialised to $3F

;Enable the tone of channel C (0-2)
SSG_ToneOn:
ld a,c
call SSG_ChannelBit ;A = 1 << channel
cpl
ld b,a
ld a,(MixerCopy)
and b ;clear bit = tone on
jr SSG_WriteMixer

;Disable the tone of channel C (0-2)
SSG_ToneOff:
ld a,c
call SSG_ChannelBit
ld b,a
ld a,(MixerCopy)
or b ;set bit = tone off

SSG_WriteMixer:
ld (MixerCopy),a
ld d,SSG_MIXER
ld e,a
rst $08
ret

;A = channel 0-2 -> A = 1 << channel
SSG_ChannelBit:
ld b,a
ld a,1
inc b
SSG_CB_loop:
dec b
ret z
add a,a
jr SSG_CB_loop
</syntaxhighlight>

The same approach works for noise, using bits 3-5 (shift the channel bit left 3 times).

===Noise hit===
A short noise burst on channel C that decays by itself, usable as a snare or explosion.

<syntaxhighlight lang="z80">
NoiseHit:
ld de,$0608 ;Noise period: 8
rst $08
ld de,$0B00 ;EG period: $0800 (about 4 Hz: a decay of about 0.26 s)
rst $08
ld de,$0C08
rst $08
ld de,$0A10 ;Channel C volume is taken from the EG
rst $08
ld de,$071F ;Noise on channel C only (tone off everywhere)
rst $08
ld de,$0D00 ;EG shape: single ramp down, then silent
rst $08
ret
</syntaxhighlight>

A lower noise period gives a brighter, hissier sound; a higher one sounds rougher.

===Silence===
<syntaxhighlight lang="z80">
SSG_Silence:
ld de,$0800 ;Channel A volume = 0
rst $08
ld de,$0900 ;Channel B volume = 0
rst $08
ld de,$0A00 ;Channel C volume = 0
rst $08
ld de,$073F ;Disable tone and noise on all channels
rst $08
ret
</syntaxhighlight>

Note: the mixer value is $3F, not $0F. $0F only disables the three tones and the noise on channel A; noise on channels B and C stays enabled.

[[Category:Code]]
[[Category:Sound Code]]

Playing sound samples

2026-09-27T03:53:59Z

Eaglesoftware777: /* ADPCM-A */

==ADPCM-A==
The YM2610 has 6 ADPCM-A channels. They play 4-bit ADPCM samples from V ROM at a fixed rate of 18.5 kHz (8 MHz / 432); there is no pitch control. Each channel has its own start address, end address, pan and volume, and all six share a master volume.

The ADPCM-A registers are on YM2610 '''port B''': the Z80 writes the register number to port '''$06''' and the value to port '''$07'''.

Sample addresses are given in 256-byte units: the start and end registers hold bits 8-23 of the V ROM byte address. The end address is inclusive, so a sample occupying $000000-$00FFFF has start $0000 and end $00FF. A sample must not cross a 1 MB boundary, because the top 4 bits of the address counter are not incremented during playback.

Definitions of [[YM2610_registers#ADPCM-A part|ADPCM-A registers]]:

<syntaxhighlight lang="z80">
;ADPCM-A register defines (YM2610 port B: address $06, data $07)
PA_CTRL: EQU $00 ;bit 7: 0 = key on, 1 = dump (key off). Bits 0-5: channel mask
PA_MVOL: EQU $01 ;master volume, 0-$3F ($3F = loudest)
PA_CVOL: EQU $08 ;+channel: bit 7 = left, bit 6 = right, bits 0-4 = volume 0-$1F
PA_STARTL: EQU $10 ;+channel: start address bits 8-15
PA_STARTH: EQU $18 ;+channel: start address bits 16-23
PA_ENDL: EQU $20 ;+channel: end address bits 8-15
PA_ENDH: EQU $28 ;+channel: end address bits 16-23
</syntaxhighlight>

(Full list of defines [[YM2610 ASM defines|here]])

Registers marked "+channel" exist once per channel: add the channel number (0-5) to the base address. For example, the start address low register of CH3 is PA_STARTL+2 = $12. In PA_CTRL, bit 0 is CH1 and bit 5 is CH6, so several channels can be keyed on or off with a single write.

===Writing to the YM2610===
The YM2610 cannot accept a new write while it is busy. Bit 7 of the status register (read from port $04) is set while it is busy. Polling it before each write is the safe choice on real hardware; code that relies on fixed delays may work in an emulator and fail on a real board.

<syntaxhighlight lang="z80">
ORG $0018
jp WritePortB ;RST $18 vector (only 8 bytes available here, so jump)

;Write E to YM2610 port B register D (ADPCM-A, FM channels 3-4)
;Destroys: nothing
WritePortB:
push af
WPB_wait1:
in a,($04) ;status 0
rlca ;busy flag -> carry
jr c,WPB_wait1
ld a,d
out ($06),a ;register number
WPB_wait2:
in a,($04)
rlca
jr c,WPB_wait2
ld a,e
out ($07),a ;value
pop af
ret

;Write E to YM2610 port A register D (SSG, ADPCM-B, FM channels 1-2, flag control)
WritePortA:
push af
WPA_wait1:
in a,($04)
rlca
jr c,WPA_wait1
ld a,d
out ($04),a
WPA_wait2:
in a,($04)
rlca
jr c,WPA_wait2
ld a,e
out ($05),a
pop af
ret
</syntaxhighlight>

===Playing a sample===
Example: play V ROM $000000-$00FFFF on CH1, centred, at maximum volume. The start and end addresses must be written before the channel is keyed on. The master volume is global, so it usually only needs to be set once, at driver initialisation.

<syntaxhighlight lang="z80">
;playback parameters
CH: EQU 0 ;channel 0-5 (0 = CH1)
MVOL: EQU $3F ;master volume
CVOL: EQU $C0+$1F ;left + right, channel volume $1F
START_ADDR: EQU $000000 ;first byte of the sample in V ROM
END_ADDR: EQU $00FFFF ;last byte of the sample (inclusive)

PlayADPCMA:
ld de,(PA_MVOL<<8)+MVOL
rst $18
ld de,((PA_CVOL+CH)<<8)+CVOL
rst $18
ld de,((PA_STARTL+CH)<<8)+((START_ADDR>>8)&$FF)
rst $18
ld de,((PA_STARTH+CH)<<8)+((START_ADDR>>16)&$FF)
rst $18
ld de,((PA_ENDL+CH)<<8)+((END_ADDR>>8)&$FF)
rst $18
ld de,((PA_ENDH+CH)<<8)+((END_ADDR>>16)&$FF)
rst $18
ld de,(PA_CTRL<<8)+(1<<CH) ;key on
rst $18
ret
</syntaxhighlight>

Keying on a channel that is already playing restarts it from its start address. When the channel reaches its end address it stops on its own and sets its end flag; there is no looping.

===Stopping a sample===
Writing PA_CTRL with bit 7 set stops (dumps) the channels selected in bits 0-5:

<syntaxhighlight lang="z80">
StopADPCMA:
ld de,(PA_CTRL<<8)+$80+(1<<CH) ;dump CH
rst $18
ret
</syntaxhighlight>

Writing $BF stops all six channels.

===End flags===
The end flags of the ADPCM-A channels can be read in bits 0-5 of status 1 (port $06); bit 7 is the ADPCM-B end flag. A flag stays set until it is cleared through the flag control register $1C on port A. Writing 1 to a bit clears and masks that flag, and writing 0 unmasks it again so it can be set by the next sample end.

<syntaxhighlight lang="z80">
;Z flag clear on return if CH has finished playing
CheckADPCMAEnd:
in a,($06) ;status 1
and 1<<CH
ret

;Clear the end flag of CH
ClearADPCMAEnd:
ld de,($1C<<8)+(1<<CH) ;clear and mask
call WritePortA
ld de,($1C<<8)+$00 ;unmask
call WritePortA
ret
</syntaxhighlight>

==ADPCM-B==
The YM2610 has one ADPCM-B channel. It plays 4-bit ADPCM samples at a variable rate, from about 1.85 kHz to 55.5 kHz, and can loop. This makes it suited to music, longer ambience and voice. Like ADPCM-A, samples are addressed in 256-byte units with an inclusive end address. Depending on the cartridge board, ADPCM-B samples are read from the same V ROM as ADPCM-A or from a separate ROM.

The ADPCM-B registers are on YM2610 '''port A''': the Z80 writes the register number to port '''$04''' and the value to port '''$05''' (see WritePortA above).

Definitions of [[YM2610_registers#ADPCM-B part|ADPCM-B registers]]:

<syntaxhighlight lang="z80">
;ADPCM-B register defines (YM2610 port A: address $04, data $05)
PB_CTRL1: EQU $10 ;bit 7 = start, bit 4 = repeat, bit 0 = reset
PB_CTRL2: EQU $11 ;bit 7 = left, bit 6 = right
PB_STARTL: EQU $12 ;start address bits 8-15
PB_STARTH: EQU $13 ;start address bits 16-23
PB_ENDL: EQU $14 ;end address bits 8-15
PB_ENDH: EQU $15 ;end address bits 16-23
PB_DELTAL: EQU $19 ;Delta-N (playback rate) low byte
PB_DELTAH: EQU $1A ;Delta-N high byte
PB_VOL: EQU $1B ;volume, 0-$FF ($FF = loudest)
</syntaxhighlight>

===Playback rate===
The playback rate is set by the 16-bit Delta-N value:

rate = 55.5 kHz × Delta-N / 65536
Delta-N = rate × 65536 / 55555

For example, a sample recorded at 22050 Hz needs Delta-N = 26011 ($659B), and one at 11025 Hz needs 13006 ($32CE). Changing Delta-N while the sample plays changes its pitch, which can be used to play one sample at different notes.

===Playing a sample===
Example: play V ROM $100000-$13FFFF on ADPCM-B at 22050 Hz, centred, at maximum volume. All parameters must be written before the start bit is set. The pan bits in PB_CTRL2 must be set, otherwise nothing is heard.

<syntaxhighlight lang="z80">
;playback parameters
B_START: EQU $100000 ;first byte of the sample in V ROM
B_END: EQU $13FFFF ;last byte of the sample (inclusive)
B_DELTA: EQU $659B ;22050 Hz
B_VOL: EQU $FF
B_PAN: EQU $C0 ;left + right

PlayADPCMB:
ld de,(PB_CTRL1<<8)+$01 ;reset, in case a sample is playing
call WritePortA
ld de,(PB_CTRL1<<8)+$00
call WritePortA
ld de,(PB_CTRL2<<8)+B_PAN
call WritePortA
ld de,(PB_STARTL<<8)+((B_START>>8)&$FF)
call WritePortA
ld de,(PB_STARTH<<8)+((B_START>>16)&$FF)
call WritePortA
ld de,(PB_ENDL<<8)+((B_END>>8)&$FF)
call WritePortA
ld de,(PB_ENDH<<8)+((B_END>>16)&$FF)
call WritePortA
ld de,(PB_DELTAL<<8)+(B_DELTA&$FF)
call WritePortA
ld de,(PB_DELTAH<<8)+(B_DELTA>>8)
call WritePortA
ld de,(PB_VOL<<8)+B_VOL
call WritePortA
ld de,(PB_CTRL1<<8)+$80 ;start ($90 = start with repeat)
call WritePortA
ret
</syntaxhighlight>

With the repeat bit set ($90), the sample loops from its end address back to its start address until it is stopped. Only the whole start-to-end range can loop; there is no separate loop point.

===Stopping a sample===
<syntaxhighlight lang="z80">
StopADPCMB:
ld de,(PB_CTRL1<<8)+$01 ;reset
call WritePortA
ld de,(PB_CTRL1<<8)+$00
call WritePortA
ret
</syntaxhighlight>

===End flag===
The ADPCM-B end flag is bit 7 of status 1 (port $06), and it is cleared through bit 7 of the flag control register $1C on port A, the same way as the ADPCM-A flags:

<syntaxhighlight lang="z80">
;Z flag clear on return if ADPCM-B has finished playing
CheckADPCMBEnd:
in a,($06) ;status 1
and $80
ret

ClearADPCMBEnd:
ld de,($1C<<8)+$80 ;clear and mask
call WritePortA
ld de,($1C<<8)+$00 ;unmask
call WritePortA
ret
</syntaxhighlight>

==ADPCM-A demo==

An interactive demo with source files can be found [http://smkdan.eludevisibility.org/neo/adpcma_demo2.zip here].

[[Category:Code]]
[[Category:Sound Code]]

Development tools

2026-09-27T03:46:28Z

Eaglesoftware777:

__NOTOC__
==68000==
{|class="wikitable"
!colspan=6 style="background-color:#ccc"|Assemblers
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| [http://john.ccac.rwth-aachen.de:8000/as/ AS] || Alfred Arnold, et al || Multi-target assembler || (multiple) || Provided as source code and binaries (Windows, DOS) ||  
|-
| [http://sun.hasenbraten.de/vasm/ vasm] || Volker Barthelmann, et al || Multi-target assembler || (multiple) || Provided as source code "official" binaries are for older versions ||  
|-
| JAS || Charles Doty, Paul Lee, Michael Hope || Modified version of AS || Windows || (base AS version unknown; binary is circa 1999/12/30) || [[File:JAS.zip]]
|-
| Maccer || Michael Hope || Pre-processor for AS-series assemblers || (multiple) || Provided as source code and Windows binary ||  
|-
| [http://gendev.spritesmind.net/page-macX.html MaccerX] || Kaneda || Updated version of Maccer || (multiple) || Provided as source code and Windows binary; added support for XGCC (gcc) and comments ||  
|-
| SNASM68K || S.N. Systems || 680x0 assembler || Windows ||   || [http://segaretro.org/SNASM68K SNASM68K at Sega Retro] (Modified version by Nemesis)
|-
!colspan=6 style="background-color:#ccc"|Compilers
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| NeoDev kit || Fabrice Martinez, Jeff Kurtz, et al || GCC compiler and library || (multiple) ||   || [[File:NeoDev001.zip]]
|-
| [https://github.com/eaglesoftware777/neogeosdk/blob/main/docs/DEPENDENCIES.md NeoGeoSDK toolchain] || Eagle Software || m68k-unknown-elf GCC cross compiler (crosstool-NG build) with C and C++ support, plus cross-GDB || Linux, WSL, Windows || Part of [[NeoGeoSDK]]. Linux/WSL use the prebuilt <code>x-tools</code> bundle from the release page; Windows uses a SysGCC-style m68k-elf GCC via <code>MakefileWin32.mak</code> (<code>M68K_ELF_ROOT</code> selects the location). See also [https://github.com/eaglesoftware777/neogeosdk/blob/main/docs/GDB_GUIDE.md GDB guide] || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|-
!colspan=6 style="background-color:#ccc"|Disassemblers
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| IRA || Tim Ruehsen, ported by Antirad || Intelligent ReAssembler for M680x0 || (multiple) || PC port of an Amiga app; provided as source ("PC") and binary (Windows) || [[File:Ira.zip]]
|-
| unidasm || MAMEdev || Universal Disassembler || (multiple) || Included with the Windows MAME distribution; can be built from source ||  
|}

==Z80==
{|class="wikitable"
!colspan=6 style="background-color:#ccc"|Assemblers
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| [http://john.ccac.rwth-aachen.de:8000/as/ AS] || Alfred Arnold, et al || Multi-target assembler || (multiple) || Provided as source code and binaries (Windows, DOS) ||  
|-
| [http://sun.hasenbraten.de/vasm/ vasm] || Volker Barthelmann, et al || Multi-target assembler || (multiple) || Provided as source code "official" binaries are for older versions ||  
|-
| [https://github.com/vhelin/wla-dx WLA DX] || Ville Helin, et al || Multi-target assembler || (multiple) || Provided as source code. Used (wla-z80 / wlalink) to build the [[NeoGeoSDK]] sound driver || [http://www.niksula.cs.hut.fi/~tursas/wla/wladx_binaries_20040822.zip WLA-DX 9.2 Win32 binaries]
|-
| [http://www.nongnu.org/z80asm/ z80asm] || Bas Wijnen (and others?) || Z80 assembler || (multiple) || Provided as source code ||  
|-
!colspan=6 style="background-color:#ccc"|Compilers
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| ZCC || Ken Yap, et al || Z80 development package with C compiler || (multiple) || Provided as source code and binaries (Windows); circa January 1996 || [[File:zcc096.zip]]
|-
| [http://sdcc.sourceforge.net/ SDCC] || Sandeep Dutta, et al || "Small Device C Compiler" || (multiple) || Provided as source code and binaries (various platforms) || [http://sdcc.sourceforge.net/snap.php Snapshot Builds]
|-
| [http://www.z88dk.org/forum/ z88dk] || (many people) || z80 C cross compiler with assembler/linker || (multiple) || Provided as source code and binaries (Windows, Mac) || [http://nightly.z88dk.org/?C=M;O=D Nightly Builds] (Hit escape as soon as you see the links for "latest")
|-
| [https://github.com/eaglesoftware777/neogeosdk z80c-special] || Eagle Software || Experimental Z80 C compiler || (multiple) || Part of [[NeoGeoSDK]]; used for the experimental C port of the sound driver (<code>make m1rom-c</code>, <code>make compare-driver</code>). The assembler driver remains the release path || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|-
!colspan=6 style="background-color:#ccc"|Disassemblers
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| DASM || Charles Doty || Z80 disassembler || DOS || Source code and binary included. || [[File:dasmz80.zip]]
|-
| [http://www.inkland.org.uk/dz80/ DZ80] || Inkland || Z80 disassembler || (multiple) || Provided as source code (command line version) and binaries (DOS command line, Windows GUI) ||  
|-
| unidasm || MAMEdev || Universal Disassembler || (multiple) || Included with the Windows MAME distribution; can be built from source ||  
|-
| Z80DASM || ? || Z80 disassembler || Windows || Binary || http://trd.speccy.cz/sbor/Z80DASM.ZIP
|}

==Source Editors==
There are a lot of source code editors out there... Use whatever you're comfortable with (hopefully one with 68000 and Z80 syntax highlighting).

==Sound and Music==
{|class="wikitable"
|-
!colspan=6 style="background-color:#ccc"|Music Drivers and Tools
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| [[MVSTracker]] || Ivan Mackintosh || FM tracker || Windows || [http://www.archaic.fr/interviews/interview-jeff-kurtz-repond-a-nos-questions/3/ Z80 driver does not work on hardware] ||  
|-
| [http://gendev.spritesmind.net/page-mvst.html MVSTracker Suite] || Pascal Bosquet, Kaneda || Modified version of MVSTracker || Windows || supports Mega Drive as well. Neo-Geo driver still doesn't work on hardware. ||  
|-
| [https://github.com/eaglesoftware777/neogeosdk/blob/main/sound/SOUND_DRIVER_GUIDE.txt NeoGeoSDK sound driver] || Eagle Software || Z80 YM2610 sound driver (<code>sound/driver/driver.asm</code>): FM, SSG, ADPCM-A, ADPCM-B || (multiple) || Part of [[NeoGeoSDK]]; assembled with WLA DX. Real-time FM tempo, LFO, panning, noise and CSM control from the 68000; fade engine; recorded voice bank driven by <code>speakText()</code>. Written for real-hardware compatibility || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|-
| [https://github.com/eaglesoftware777/neogeosdk/blob/main/docs/SOUND_STUDIO_GUIDE.md Sound Studio] || Eagle Software || GUI for the audio pipeline (<code>sound/sound_studio.py</code>): FM patch editor, MML composer with piano roll, SSG preset editor, ADPCM sample manager with waveform view, YM2610 channel simulator, mix and ROM views || Linux, Windows || Part of [[NeoGeoSDK]]; Python 3 + PyQt6, numpy, scipy. Front end for the same scripts the Makefile calls || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|-
| [https://github.com/eaglesoftware777/neogeosdk/blob/main/sound/mml/readme NeoGeoSDK MML / FM / SSG compilers] || Eagle Software || Compile MML music, FM tracks and patch banks, and SSG tracks and presets into driver tables for the M1 ROM || (multiple) || Part of [[NeoGeoSDK]]; Python. Make targets <code>mml</code>, <code>fm</code>, <code>fmpatches</code>, <code>ssg</code>, <code>ssgconfig</code> || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|-
!colspan=6 style="background-color:#ccc"|Sound Editors
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| [http://www.goldwave.com/release.php GoldWave] || GoldWave Inc. || commercial sound editor || Windows ||   ||  
|-
| [http://www.sonycreativesoftware.com/soundforgesoftware Sound Forge] || Sony || commercial sound editor || Windows, Mac ||   ||  
|-
| [http://audacity.sourceforge.net/ Audacity] || Audacity developers || open-source sound editor || (multiple) ||   ||  
|-
!colspan=6 style="background-color:#ccc"|Sound Encoders
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| [https://github.com/freem/adpcma ADPCM-A encoder] || freem || Command-line ADPCM-A encoder || (multiple) || Provided as source code and binary (Windows) ||  
|-
| [http://www.smspower.org/forums/11965-VGMLoggingWithOtherEmulators?start=200#66597 ADPCM-B encoder] || ValleyBell and Fred/FRONT || Command-line ADPCM-B encoder || (multiple) || Provided as source code and binary (Windows) || [[File:ADPCM_Encode.zip]]
|-
| [[Neo Sound Builder]] || Jeff Kurtz/Neobitz || GUI V ROM/PCM file creator || Windows || ADPCM-A only || [https://www.facebook.com/Neobitz/photos/a.462349983789893.110879.221161891242038/1093044660720419/?type=3 announcement post]
|-
| [https://github.com/eaglesoftware777/neogeosdk/blob/main/sound/samples/readme NeoGeoSDK ADPCM encoder] || Eagle Software || WAV to ADPCM-A / ADPCM-B encoder and V ROM builder || (multiple) || Part of [[NeoGeoSDK]]; cross-platform Python, SoX optional. Pre-roll ramp reduces the click at sample start. Make targets <code>samples</code>, <code>vrom</code> || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|}

==Graphics==
{|class="wikitable"
|-
!colspan=6 style="background-color:#ccc"|Graphics Viewers and Editors
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| [[YY-CHR]] || YY || multi-format tile editor || Windows || FIX files require plugin (YY-CHR.NET only, see below); Sprites need conversion (see tools below) || [http://www.romhacking.net/utils/119/ YY-CHR 0.99]
|-
| NGFX || blastar || Fix, Sprite, TITLE_*.SYS viewer/editor; LOGO_*.SYS viewer || Windows || WIP; not yet released. || [https://www.romhacking.net/download/utilities/1175/]
|-
| neospriteviewer || Matt Greer || S and C ROM tile viewer || Web ||   || [https://neospriteviewer.mattgreer.dev site]
|-
| [https://github.com/eaglesoftware777/neogeosdk/blob/main/docs/ARTBOX_PIPELINE.md Artbox Studio] || Eagle Software || GUI for the graphics pipeline (<code>artbox/artbox_studio.py</code>): C ROM tile viewer, sprite designer with C export, hitbox editor, 16-colour paint editor, pipeline runner, movement and level designers, ROM inventory, asset-rule editor || Linux, Windows || Part of [[NeoGeoSDK]]; Python 3 + PyQt6. Front end for the Artbox scripts || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|-
| [https://github.com/eaglesoftware777/neogeosdk NeoGeoSDK GIMP plugins] || Eagle Software || GIMP plugins for preparing Neo Geo art || (multiple) || Part of [[NeoGeoSDK]] || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|-
!colspan=6 style="background-color:#ccc"|Graphics Converters and Tools
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| [[DATLib]] graphics tools || HPMAN || Tools used to process and display graphics on Neo-Geo. || Windows || Animator, BuildChar, CharSplit, Framer || [https://www.dropbox.com/s/wqviye5xxzktr6y/DATlib_0.3.rar?dl=0 download]
|-
| [[NGGTool|NeoGeo Graphics ToolSuite]] || evo || Tool to convert between SNES/SFC and Neo-Geo graphics. || Windows || Fix conversion is botched (see page for details) || [http://furrtek.free.fr/noclass/neogeo/nggts.zip NGGTS]
|-
| Sprite graphics converter || IQ || Converts MVS graphics (.c*) to CD graphics (.SPR). || Windows ||   || [http://furrtek.free.fr/noclass/neogeo/gfxmvstocd.zip MVS to CD sprite converter]
|-
| [https://github.com/freem/NeoSpriteConv Neo-Geo Sprite Converter] || freem || Convert 4BPP SMS/GG/WSC graphics to Neo-Geo format. || (multiple) || Provided as source code and binary (Windows) Further work required for converting to Cart (split files by words (2 bytes)) and CD (byteswap file)-usable files. || [http://ajworld.net/neogeodev/utils/neosprconv.zip main download]
|-
| [https://github.com/Kannagi/Neoconvert Neoconvert] || Kannagi || Convert PNG to rom Cx with map, palette and HiColor. || Windows,Linux ||   || [https://github.com/Kannagi/Neoconvert download]
|-
| [https://github.com/Kannagi/Neoextract Neoextract] || Kannagi || extract rom Cx or s1 to bmp. || Windows,Linux ||   || [https://github.com/Kannagi/Neoextract download]
|-
| [https://github.com/city41/sromcrom sromcrom] || Matt Greer || Generate S and C ROMs from images, generates corresponding source code as well || cross platform ||   || [https://github.com/city41/sromcrom download]
|-
| [https://neo-source.com/index.php?topic=4180.msg37936 buildobj] || iq_132 || Compress / Decompress NeoGeo CD OBJ files || Windows ||   || [https://neo-source.com/index.php?topic=4180.msg37936 buildobj]
|-
| [https://github.com/eaglesoftware777/neogeosdk/blob/main/docs/ARTBOX_PIPELINE.md Artbox] || Eagle Software || PNG to C ROM sprite converter (<code>artbox/img2neo.py</code>) with perceptual quantisation in CIE-Lab on the Neo Geo's 5-bit colour lattice; rule-driven through <code>artbox/assets.cfg</code> || (multiple) || Part of [[NeoGeoSDK]]; Python 3. Void-and-cluster blue-noise dithering, per-tile and master sprite palettes, sprite halo removal, content-preserving screen fit; generates <code>sprite_meta.h</code> for 68000 code || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|-
| [https://github.com/eaglesoftware777/neogeosdk/blob/main/docs/ARTBOX_PIPELINE.md NeoGeoSDK fixtiles] || Eagle Software || PNG to 128 KB S1 FIX ROM || (multiple) || Part of [[NeoGeoSDK]]; Python 3. Make target <code>sfix</code> || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|}

==Other Tools==
{|class="wikitable"
|-
!Name !! Author(s) !! Description !! Platform(s) !! Notes !! Download
|-
| MemCardTool || Fabrice Martinez || Memory card manager || Windows ||   || [[File:memcardtool.zip]]
|-
| [https://github.com/freem/romwak ROMwak] || Jeff Kurtz, ported by freem || Binary image manipulation tool || (multiple) || Provided as source code and binary (Windows) ||  
|-
| [https://github.com/eaglesoftware777/neogeosdk/blob/main/docs/MAKEFILE_INTEGRATION.md NeoGeoSDK ROM packaging] || Eagle Software || P1 ROM crop to 512 KB and byte-swap; MAME software-list (<code>hash_eagle/neogeo.xml</code>) regeneration with CRC/SHA1; <code>make dist</code> release packaging || (multiple) || Part of [[NeoGeoSDK]]; lets homebrew ROM sets load in MAME without hand-editing hash files || [https://github.com/eaglesoftware777/neogeosdk GitHub]
|}

[[Category:Code]]