nullsound: FM vibrato effect

This commit includes a fairly big refactoring to share common parts
of the vibrato algo between FM and SSG.
It also includes updates to simplify the FM codebase.

Author: dciabrin

.gitignore

@@ -6,6 +6,8 @@
 *.lst
 *.rst
 *.lib
+*.map
+*.sym
 
 # Libraries
 *.a

nullsound/Makefile.in

@@ -19,7 +19,7 @@ all: nullsound.lib linkcheck.map
 -include ../Makefile.config
 
 INCLUDE_FILES=helpers ports ym2610
-OBJS=entrypoint bios-commands adpcm ym2610 stream timer nss-fm nss-adpcm nss-ssg
+OBJS=entrypoint bios-commands adpcm ym2610 stream timer nss-fm nss-adpcm nss-ssg fx-vibrato
 LIB=nullsound.lib
 
 VERSION=@version@
@@ -39,7 +39,7 @@ $(LIB): $(OBJS:%=%.rel)
 	cat $^ > $@
 
 %.rel: %.s
-	$(NGSDAS) -g -l -p -u -o $@ $<
+	$(NGSDAS) -a -g -l -p -s -u -o $@ $<
 
 install: install-nullsound install-include
 

nullsound/ssg-vibrato.s renamed to nullsound/fx-vibrato.s

@@ -16,32 +16,110 @@
 ;;; You should have received a copy of the GNU Lesser General Public License
 ;;; along with ngdevkit.  If not, see <http://www.gnu.org/licenses/>.
 
-;;; SSG vibrato effect. This file is included by nss-ssg.s
+;;; Vibrato effect, common functions for FM and SSG
 ;;;
 
-        .equ    VIBRATO_SPEED,(state_vibrato_speed-state_mirrored_ssg)
-        .equ    VIBRATO_DEPTH,(state_vibrato_depth-state_mirrored_ssg)
-        .equ    VIBRATO_POS,(state_vibrato_pos-state_mirrored_ssg)
-        .equ    VIBRATO_PREV,(state_vibrato_prev-state_mirrored_ssg)
-        .equ    VIBRATO_NEXT,(state_vibrato_next-state_mirrored_ssg)
+        .module nullsound
 
+        .include "ym2610.inc"
+        .include "struct-fx.inc"
 
-;;; Update the vibrato for the current SSG channel
-;;; Vibrato oscillates the current note's frequency between the previou
+        .area  CODE
+
+
+;;; Setup prev and next increments for vibrato
+;;; ------
+;;; IN:
+;;;   ix  : fm state for channel
+;;;         the note semitone must be already configured
+;;; [ hl ]: prev semitone distance
+;;; [hl+1]: next semitone distance
+;;; OUT:
+;;;    de : prev increment (fixed-point)
+;;;    hl : prev increment (fixed-point)
+;;; bc, de, hl modified
+vibrato_setup_increments::
+        ;; bc: prev distance from current note
+        push    hl              ; +(prev distance)
+        ld      b, (hl)
+        ;; de: output prev increment, scaled by depth (a)
+        ld      a, VIBRATO_DEPTH(ix)
+        call    vibrato_scale_increment
+        ld      e, l
+        ld      d, h
+
+        ;; bc: next distance from current note
+        pop     hl              ; (prev distance)
+        inc     hl
+        ld      b, (hl)
+        ;; hl: output next increment, scaled by depth (a)
+        ld      a, VIBRATO_DEPTH(ix)
+        call    vibrato_scale_increment
+
+        ret
+
+
+;;; Scale a fixed point 16bit value into x/16 fraction
+;;; ------
+;;; IN:
+;;;   bc : distance
+;;;    a : scale factor [1..16]
+;;; OUT:
+;;;   hl : scaled base increment
+;;; bc, hl modified
+vibrato_scale_increment:
+        ;; bc: base increment (fixed point)
+        ;; there are 8 possible levels, so bc = fixed point distance / 8
+        ld      c, #0
+        srl     b
+        rr      c
+        srl     b
+        rr      c
+        srl     b
+        rr      c
+
+        ;; scale the base increment based on the vibrato depth
+        ;; depth has 16 possible levels [1..16], so parse 4 bits
+        ld      h, #0
+        ld      l, h
+        bit     4, a
+        jr      z, _post_bit4
+        add     hl, bc
+_post_bit4:
+        ;; shift bc 1 bit to the right
+        srl     b
+        rr      c
+        bit     3, a
+        jr      z, _post_bit3
+        add     hl, bc
+_post_bit3:
+        srl     b
+        rr      c
+        bit     2, a
+        jr      z, _post_bit2
+        add     hl, bc
+_post_bit2:
+        srl     b
+        rr      c
+        bit     1, a
+        jr      z, _post_bit1
+        add     hl, bc
+_post_bit1:
+        ret
+
+
+;;; Update the vibrato for the current channel
+;;; Vibrato oscillates the current note's frequency between the previous
 ;;; and the next semitones of the current note, and follows a sine wave.
 ;;; This function update the frequency by one step among the 64 steps
 ;;; defined in the sine wave.
 ;;; ------
-;;; hl: mirrored state of the current ssg channel
-eval_ssg_vibrato_step::
-        push    hl
-        push    de
-        push    bc
-
-        ;; ix: mirrored_ssg for current channel
-        push    hl
-        pop     ix
-
+;;; IN:
+;;;   ix: mirrored state of the current fm channel
+;;; OUT:
+;;;   hl: new note for step (FM: f-num, SSG: period)
+;;; bc, de, hl modified
+vibrato_eval_step::
         ;; e: next vibrato pos
         ld      a, VIBRATO_POS(ix)
         add     a, VIBRATO_SPEED(ix)
@@ -106,117 +184,4 @@ _post_mul_a0:
         ;; hl: new note
         add     hl, de
 
-        ;; configure SSG channel with new note
-        ;; TODO, update the mirror state only
-        ld      a, (state_ssg_channel)
-        sla     a
-        ld      b, a
-        ld      c, l
-        call    ym2610_write_port_a
-        inc     b
-        ld      c, h
-        call    ym2610_write_port_a
-
-        pop     bc
-        pop     de
-        pop     hl
-
-        ret 
-
-
-;;; Setup prev and next increments for vibrato
-;;; ------
-;;; ix : ssg state for channel
-;;;      the note semitone must be already configured
-ssg_vibrato_setup_increments::
-        push    bc
-        push    hl
-
-        ;; reset vibrato sine pos
-        ld      VIBRATO_POS(ix), #0
-
-        ;; bc: prev distance from current note, fix point
-        ld      hl, #ssg_semitone_distance
-        ld      l, NOTE_SEMITONE_OFFSET(ix)
-        push    hl              ; +prev distance
-        ld      b, (hl)
-        ld      c, #0
-        ;; a: vibrato depth
-        ld      a, VIBRATO_DEPTH(ix)
-        ;; hl: output prev increment, scaled by depth (a)
-        ld      h, #0
-        ld      l, h
-        call    ssg_vibrato_scale_increment
-        ld      VIBRATO_PREV(ix), l
-        ld      VIBRATO_PREV+1(ix), h
-
-        ;; bc: next distance
-        pop     hl              ; prev distance
-        inc     hl
-        ld      b, (hl)
-        ld      c, #0
-        ;; a: vibrato depth
-        ld      a, VIBRATO_DEPTH(ix)
-        ;; hl: output next increment, scaled by depth (a)
-        ld      h, #0
-        ld      l, h
-        call    ssg_vibrato_scale_increment
-        ;; hl: -hl (next increment is always negative)
-        xor     a
-        sub     l
-        ld      l, a
-        sbc     a, a
-        sub     h
-        ld      h, a
-        ld      VIBRATO_NEXT(ix), l
-        ld      VIBRATO_NEXT+1(ix), h
-
-        pop     hl
-        pop     bc
-        ret
-
-
-;;; Scale a fixed point 16bit value into x/16 fraction
-;;; ------
-;;; IN:
-;;;   bc : distance
-;;;    a : scale factor [1..16]
-;;; OUT:
-;;;   hl : scaled base increment
-;;; bc, hl modified
-ssg_vibrato_scale_increment:
-        ;; bc: get base increment
-        ;; there are 8 possible levels, so bc = distance / 8
-        srl     b
-        rr      c
-        srl     b
-        rr      c
-        srl     b
-        rr      c
-
-        ;; scale the base increment based on the vibrato depth
-        ;; depth has 16 possible levels [1..16], so parse 4 bits
-        bit     4, a
-        jr      z, _post_bit4
-        add     hl, bc
-_post_bit4:
-        ;; shift bc 1 bit to the right
-        srl     b
-        rr      c
-        bit     3, a
-        jr      z, _post_bit3
-        add     hl, bc
-_post_bit3:
-        srl     b
-        rr      c
-        bit     2, a
-        jr      z, _post_bit2
-        add     hl, bc
-_post_bit2:
-        srl     b
-        rr      c
-        bit     1, a
-        jr      z, _post_bit1
-        add     hl, bc
-_post_bit1:
         ret