Category : Music and Digitized Voice
Archive   : SDTK.ZIP
Filename : FM.ASM

; OPL-III Low Level Driver
;
; Marc Savary, 24-jan-91
;
;


INCLUDE MODEL2.MAC ; define memory model & macros


; Public functions defined in this module:

; InitFMDriver( ioAddr) Initialize OPL-III chip
; CloseFMDriver() Reset to original YM3812 mode
; Set4opMaskOpl3( msk) Enable/Disable 4-op voice mask
; SetPercModeOpl3( state) Enable/Disable perc mode
; SetGlobalOpl3( nSel, amD, vibD, pBRange) Change some globals of OPL-III
; PresetOpl3( voice, dP) Change preset of voice
; LevelOpl3( voice, level) Change volume of voice
; NoteOnOpl3( voice, note) Do a note-on on voice
; NoteOffOpl3( voice) Do a note-off on voice
; PitchBendOpl3( voice, pBend) Change pitch bend
; LeftRightOpl3( voice, lR) Change Left/Right/Center attribute of voice


; PRESET FORMAT:
;
; 4 times these first 6 bytes (for slot 0 to 3)
; byte 0: a v e k m m m m ; a=AM, v=VIB, e=EG-TYP, k=KSR, m=MULTI
; byte 1: k k l l l l l l ; k=KSL, l=LEVEL
; byte 2: a a a a d d d d ; a=AR, d=DR
; byte 3: s s s s r r r r ; s=SL, r=RR
; byte 4: d - - - - w w w ; d=slot defined, w=WAVE-SELECT
; byte 5: - - - - - - - - ; unused, == 0
;
; plus the following bytes:
; byte 24: c4 - - - f f f c ; c4=second bit for CONNECT,
; ; f=FEED-BACK, c=first bit for CONNECT
; byte 25: - - p 2 4 n n n ; p= perc preset; 2= 2-op preset,
; ; 4= 4-op preset, n= perc # (BD=0,
; ; SD=1, TOM=2, CYMB=3, HH=4)
; byte 26: t t t t t t t t ; t= sign integer transposition in half-tone
; byte 27: - - - - - - - - ; unused, == 0
; total = 28 bytes


; voice numbers
; bank 4-op <-> 2-op percs
;-------------------------------------------------
; 0 0 0, 1 -
; 0 2 2, 3 -
; 0 4 4, 5 -
;-------------------------------------------------
; 1 6 6, 7 -
; 1 8 8, 9 -
; 1 10 10, 11 -
;-------------------------------------------------
; 1 - 12 -
; 1 - 13 -
; 1 - 14 -
;-------------------------------------------------
; 0 - 15 15 (BD)
; 0 - 16 16 (HH), 17 (SD)
; 0 - 18 18 (TOM), 19 (CYMB)



PRESET_OPR_SIZE equ 6 ; 6 bytes per operators, 4 op.
PRESET_CONNECT equ 24 ; offset in preset data of Feed-Back & connect
PRESET_TYPE equ 25
PRESET_TRANSP equ 26 ; .... transposition
PRESET_SPARE equ 27 ; dernier byte libre du preset


; field description of 25th byte (PRESET_TYPE) of a preset array...
PERC_BIT equ 32 ; ON if percussion preset
TWO_OP_BIT equ 16 ; ON if 2 op. (melodic) preset
FOUR_OP_BIT equ 8 ; ON if 4 op. preset
PERC_NUM_MSK equ 7 ; mask of bit field for percussion # (0 - 4)

FIRST_PERC equ 15
BD equ 15
HH equ 16
SD equ 17
TOM equ 18
CYMB equ 19
LAST_PERC equ 19
LAST_VC equ 19

TYPE_DISABLE equ 80h ; values for 'typeVc' array ... voice disable
TYPE_4OP equ 8 ; ... voice 4-op
TYPE_2OP equ 16 ; ... voice 2-op
TYPE_PERC equ 32 ; ... voice perc

MAX_LOG_VOL equ 3fh ; maximum volume (attenuation), logarithmic

nb_notes equ 96
octave equ 12
nb_table_demi_ton equ octave
nb_step_pitch equ 16
log_nb_step_pitch equ 4
table_size equ (nb_step_pitch * nb_table_demi_ton)
log_pitch equ 8
DELTA_PITCH equ -12 ; convertion factor from MIDI C4 = 60 to internal C4 = 48
TOM_PITCH equ (60-24) ; two octave below MIDI C4 is the best!!
TOM_TO_HH equ 7 ; 7 half-tone between TOM & HH ... 19 ?




; initialized data segment:
DATAS

IF 0
; temporaire... pour le code de debug:
COMM NEAR _map0: BYTE: 256 ; accessible to C environment
COMM NEAR _map1: BYTE: 256 ; ...
ENDIF


; slots offset for each voices: 2 slots per voices, -1 means 'not used';
; 4-op voices use two lines:
vcToSlot db 00h, 03h ; #0 4-op, 2-op
db 08h, 0bh ; #1 2-op
db 01h, 04h ; #2 4-op, 2-op
db 09h, 0ch ; #3 2-op
db 02h, 05h ; #4 4-op, 2-op
db 0ah, 0dh ; #5 2-op
db 20h, 23h ; #6 4-op, 2-op
db 28h, 2bh ; #7 2-op
db 21h, 24h ; #8 4-op, 2-op
db 29h, 2ch ; #9 2-op
db 22h, 25h ; #10 4-op, 2-op
db 2ah, 2dh ; #11 2-op

db 30h, 33h ; #12 2-op
db 31h, 34h ; #13 2-op
db 32h, 35h ; #14 2-op

db 10h, 13h ; #15 2-op, BD
db 11h, 14h ; #16 2-op, HH
db 14h, -1 ; #17 SD
db 12h, 15h ; #18 2-op, TOM
db 15h, -1 ; #19 CYMB


; channel offset for each voices; -1 means 'not used',
; 4-op voices use two lines:
vcToChannel db 00h ; #0 4-op, 2-op
db 03h ; #1 2-op
db 01h ; #2 4-op, 2-op
db 04h ; #3 2-op
db 02h ; #4 4-op, 2-op
db 05h ; #5 2-op
db 20h ; #6 4-op, 2-op
db 23h ; #7 2-op
db 21h ; #8 4-op, 2-op
db 24h ; #9 2-op
db 22h ; #10 4-op, 2-op
db 25h ; #11 2-op

db 26h ; #12 2-op
db 27h ; #13 2-op
db 28h ; #14 2-op

db 06h ; #15 BD
db 07h ; #16 HH
db -1 ; #17 SD
db 08h ; #18 TOM
db -1 ; #19 CYMB



; mask des slots carrier: 1: 1 iere slot, 2: 2 ieme slot, 4: 3 ieme slot,
; 8: 4 ieme slot
carMsk4op db 8, 1+8, 2+8, 1+4+8 ; for 4-op voices only
carMsk2op db 2, 1+2, 2, 1+2 ; for 2-op melodic & perc voices

leftRightBits db 30h, 20h, 10h ; bits for center, left & right
percBits db 10h, 1, 8, 4, 2 ; BD, HH, SD, TOM, CYMB


; Table de convertion lineaire -> logarithmique (attenuation), 128 valeurs
; f(0) = 63
; f(A) = (-20 * log10( A/128)) / 0.75 ==> [1 <= A <= 127]
linToLog db 63, 56, 48, 43, 40, 37, 35, 33
db 32, 30, 29, 28, 27, 26, 25, 24, 24
db 23, 22, 22, 21, 20, 20, 19, 19, 18
db 18, 18, 17, 17, 16, 16, 16, 15, 15
db 15, 14, 14, 14, 13, 13, 13, 12, 12
db 12, 12, 11, 11, 11, 11, 10, 10, 10
db 10, 9, 9, 9, 9, 9, 8, 8, 8
db 8, 8, 8, 7, 7, 7, 7, 7, 6
db 6, 6, 6, 6, 6, 6, 5, 5, 5
db 5, 5, 5, 5, 4, 4, 4, 4, 4
db 4, 4, 3, 3, 3, 3, 3, 3, 3
db 3, 2, 2, 2, 2, 2, 2, 2, 2
db 2, 1, 1, 1, 1, 1, 1, 1, 1
db 1, 1, 0, 0, 0, 0, 0, 0, 0
db 0, 0, 0


; 10 bits F-Num table for Adlib board
; containing 12 notes (from 32.8 Hz to 65.6 Hz), with 16 steps between each note.
; If the sign bit is on, 1 must be added to the block octave information
;
; each value is compute by the formula:
; fN = (2**20 x Fmus) / (3.58e6 / 72)
; fN is shift right until is below 1024 (10 bits)
;
; here is the C code to generate table:

;#define CLOCK 3579545L /* 14.31818e6 /4 */
;#define F_SAMPL (CLOCK /72) /* chip sampling freq */
;#define NB_NOTES 96
;#define OCTAVE 12
;#define NB_TABLE_DEMI_TON OCTAVE
;#define NB_STEP_PITCH 16 /* 16 pas d'un ton a l'autre */
;#define LOG_NB_STEP_PITCH 4 /* LOG2( NB_STEP_PITCH) */
;#define TABLE_SIZE (NB_STEP_PITCH * NB_TABLE_DEMI_TON)
;#define LOG_PITCH 8 /* LOG2( TABLE_SIZE) */
;#define FREQ_DO (double)261.6256 /* reference C4 */
;
;#define xexpy( x, y) (exp( y * log( x))) /* return x**y */
;
;GenTable()
; {
; double freq;
; double range;
; long fNum, fN10;
; int block;
; int i, value;
;
; range = 2.0;
; for( i = 0; i < TABLE_SIZE; i++) {
; freq = xexpy( range, (double)i / TABLE_SIZE);
; freq *= FREQ_DO;
; fNum = ((long)((long)1 << 20) * freq) /F_SAMPL;
; for( block = 0, fN10 = fNum; fN10 >= 1024; fN10 >>= 1, block++)
; ;
; /* block range from 3 to 4 */
; fN10 = (fNum + (1 << block -1)) >> block; /* round to 0.5 */
; block = 3 - block;
; value = fN10 | (block << 10);
; printf( "%05xH, ", value);
; if( i % 10 == 9)
; printf( "\n");
; }
; printf( "\n\n");
; }


fNumTbl dw 02b2H, 02b4H, 02b7H, 02b9H, 02bcH, 02beH, 02c1H, 02c3H, 02c6H, 02c9H
dw 02cbH, 02ceH, 02d0H, 02d3H, 02d6H, 02d8H, 02dbH, 02ddH, 02e0H, 02e3H
dw 02e5H, 02e8H, 02ebH, 02edH, 02f0H, 02f3H, 02f6H, 02f8H, 02fbH, 02feH
dw 0301H, 0303H, 0306H, 0309H, 030cH, 030fH, 0311H, 0314H, 0317H, 031aH
dw 031dH, 0320H, 0323H, 0326H, 0329H, 032bH, 032eH, 0331H, 0334H, 0337H
dw 033aH, 033dH, 0340H, 0343H, 0346H, 0349H, 034cH, 034fH, 0352H, 0356H
dw 0359H, 035cH, 035fH, 0362H, 0365H, 0368H, 036bH, 036fH, 0372H, 0375H
dw 0378H, 037bH, 037fH, 0382H, 0385H, 0388H, 038cH, 038fH, 0392H, 0395H
dw 0399H, 039cH, 039fH, 03a3H, 03a6H, 03a9H, 03adH, 03b0H, 03b4H, 03b7H
dw 03bbH, 03beH, 03c1H, 03c5H, 03c8H, 03ccH, 03cfH, 03d3H, 03d7H, 03daH
dw 03deH, 03e1H, 03e5H, 03e8H, 03ecH, 03f0H, 03f3H, 03f7H, 03fbH, 03feH
dw 0fe01H, 0fe03H, 0fe05H, 0fe07H, 0fe08H, 0fe0aH, 0fe0cH, 0fe0eH, 0fe10H, 0fe12H
dw 0fe14H, 0fe16H, 0fe18H, 0fe1aH, 0fe1cH, 0fe1eH, 0fe20H, 0fe21H, 0fe23H, 0fe25H
dw 0fe27H, 0fe29H, 0fe2bH, 0fe2dH, 0fe2fH, 0fe31H, 0fe34H, 0fe36H, 0fe38H, 0fe3aH
dw 0fe3cH, 0fe3eH, 0fe40H, 0fe42H, 0fe44H, 0fe46H, 0fe48H, 0fe4aH, 0fe4cH, 0fe4fH
dw 0fe51H, 0fe53H, 0fe55H, 0fe57H, 0fe59H, 0fe5cH, 0fe5eH, 0fe60H, 0fe62H, 0fe64H
dw 0fe67H, 0fe69H, 0fe6bH, 0fe6dH, 0fe6fH, 0fe72H, 0fe74H, 0fe76H, 0fe79H, 0fe7bH
dw 0fe7dH, 0fe7fH, 0fe82H, 0fe84H, 0fe86H, 0fe89H, 0fe8bH, 0fe8dH, 0fe90H, 0fe92H
dw 0fe95H, 0fe97H, 0fe99H, 0fe9cH, 0fe9eH, 0fea1H, 0fea3H, 0fea5H, 0fea8H, 0feaaH
dw 0feadH, 0feafH


; integer division & modulo 12 table (0 - 95)
divMod12 db 00, 01, 02h, 03h, 04h, 05h, 06h, 07h, 08h, 09h, 0ah, 0bh
db 10h, 11h, 12h, 13h, 14h, 15h, 16h, 17h, 18h, 19h, 1ah, 1bh
db 20h, 21h, 22h, 23h, 24h, 25h, 26h, 27h, 28h, 29h, 2ah, 2bh
db 30h, 31h, 32h, 33h, 34h, 35h, 36h, 37h, 38h, 39h, 3ah, 3bh
db 40h, 41h, 42h, 43h, 44h, 45h, 46h, 47h, 48h, 49h, 4ah, 4bh
db 50h, 51h, 52h, 53h, 54h, 55h, 56h, 57h, 58h, 59h, 5ah, 5bh
db 60h, 61h, 62h, 63h, 64h, 65h, 66h, 67h, 68h, 69h, 6ah, 6bh
db 70h, 71h, 72h, 73h, 74h, 75h, 76h, 77h, 78h, 79h, 7ah, 7bh

EDATAS



; uninitialized data segment:
DATA?S

typeVc db 20 DUP (?) ; 80h: disable; 8: 4op, 16: 2op, 32: perc
nbOpVc db 20 DUP (?) ; nb opr per voice: 4, 2, 1
levelVc db 20 DUP (?) ; voice level, log. attenuation
transpVc db 20 DUP (?) ; voice transpose, +/- half-tones
noteVc db 20 DUP (?) ; voice note #, 12 - 107
pitchBendVc dw 20 DUP (?) ; voice pitch bend, 0 - 3fff, 2000 = normal

carMaskVc db 20 DUP (?) ; carrier mask of each voices
c0RegVc db 20 DUP (?) ; [EXT-OUT, STEREO, FB, Connect], [Connect]
b0RegVc db 20 DUP (?) ; Bx register for for each voices
bdReg db (?) ; AM-D, VIB-D, RHY, BD, SD, TOM, CY, HH
mask4op db (?) ; bits for 4-op connection register
kslLevSlots db (20h+16h) DUP (?) ; values of each KSL-LEVEL regs

pitchRange dw (?) ; pitch bend range 1 - 12
opl3_io dw (?) ; OPL3 I/O address

EDATA?S




EXTERN _CtGetRelocationAddress

DGROUP GROUP _BSS, _DATA

ASSUME DS: DGROUP



CODES opl3



; !!!
; InitFMDriver( ioAddr)
; unsigned ioAddr; /* IO Base Addr of OPL-III
;
BEGIN _InitFMDriver
push bp
mov bp, sp

MCALL _CtGetRelocationAddress
mov opl3_io, ax

; Low-level init:
call LowLevelInit

; Enable perc mode:
mov ax, 1
push ax
MCALL _SetPercModeOpl3

; enable all 4-op voices:
mov ax, 03fh ; mask for all 4-op voices ON
push ax
MCALL _Set4opMaskOpl3
add sp, 4

pop bp
ret
_InitFMDriver ENDP




; CloseFMDriver()
;
; Set the OPL-III chip in YM3812 mode. To be called before
; quitting application
;
BEGIN _CloseFMDriver

call LowLevelInit

mov dx, opl3_io
add dx, 2
mov ax, 0005H ; reset NEW bit at addr 5
call OutOpl3
ret
_CloseFMDriver ENDP




; Low-level init...
LowLevelInit PROC NEAR
push si
push di

; clear some variables...
mov bx, 20-1
sm_loop:
mov levelVc[ bx], 0 ; max level
mov transpVc[ bx], 0 ; no transposition
mov b0RegVc[ bx], 0 ; all channel OFF
mov noteVc[ bx], 0 ; note value OFF
mov c0RegVc[ bx], 30H ; ext 1 & 0 OFF, left & right ON
dec bx
jge sm_loop

mov bx, (20-1)*2
sm_lp2:
mov pitchBendVc[ bx], 02000h ; normal pitch bend
sub bx, 2
jge sm_lp2



; clear all OPL-III registers, except register 5
mov dx, opl3_io
mov ch, 2
sm_lp4:
mov ax, 0105H ; set NEW bit of bank to 1
call OutOPL3
sm_suit1:
mov cl, 0f5h
sm_lp3:
xor ah, ah
mov al, cl
cmp al, 5 ; register 5 ?
jne sm_ok1
; register 5:
cmp ch, 1 ; test if second bank
jne sm_ok1 ; skip if not
inc ah ; set low bit (NEW) of second bank to 1
sm_ok1:
call OutOPL3
dec cl
jne sm_lp3
add dx, 2
dec ch
jne sm_lp4

; set output left and right;
mov dx, opl3_io
mov ax, 2001h ; wave-form enable, register 1 (3812 only)
call OutOPL3
mov ch, 2
sm_lp6:
mov cl, 9
sm_lp5:
mov ah, 030h ; ext-out 1, 0 OFF; Left & Right ON
mov al, cl
add al, 0c0h-1
call OutOPL3
dec cl
jne sm_lp5
add dx, 2
dec ch
jne sm_lp6


; set release-rate of each slots to 15:
mov dx, opl3_io ; first bank
mov ch, 2
re_lp7:
mov si, offset CS: slotOffsets
mov cl, 18
re_lp8:
mov ah, 15 ; release-rate = 15
mov al, cs:[si]
inc si
add al, 80H
call OutOPL3
dec cl
jne re_lp8
add dx, 2 ; next bank
dec ch
jne re_lp7


; perc-mode == OFF, 4-op voices disabled:
xor ax, ax
mov bdReg, al ; AM & VIB depth = 0, RHY = 0, perc bits = 0
mov dx, opl3_io
mov al, 0bdh
call OutOPL3
xor ah, ah
mov mask4op, ah ; disable all 4 op voices
mov al, 4
add dx, 2
call OutOPL3

; first 15 2-op melodic voices:
mov bx, 14
mov al, TYPE_2OP
mov ah, 2
re_lp1:
mov typeVc[ bx], al ; TYPE_2OP
mov nbOpVc[ bx], ah ; 2 op per voice
dec bx
jge re_lp1

; perc slots: melodic mode
mov typeVc+15, TYPE_2OP
mov nbOpVc+15, 2
mov typeVc+16, TYPE_2OP
mov nbOpVc+16, 2
mov typeVc+17, TYPE_PERC + TYPE_DISABLE ; SD
mov nbOpVc+17, 1
mov typeVc+18, TYPE_2OP
mov nbOpVc+18, 2
mov typeVc+19, TYPE_PERC + TYPE_DISABLE ; CYMB
mov nbOpVc+19, 1

pop di
pop si
ret

slotOffsets:
db 0, 1, 2, 3, 4, 5
db 8, 9, 0Ah, 0Bh, 0Ch, 0Dh
db 10h, 11h, 12h, 13h, 14h, 15h

LowLevelInit ENDP




; Disable/enable melodic voices 15, 16, 18; enable/disable percussive
; voices 15 - 19
;
; SetPercModeOpl3( state)
; int state;
;
SPM_ struc
dw (?) ; old bp
db CPSIZE DUP (?) ; return addr
spm_state dw (?) ; 0: melodic, else perc
SPM_ ends

BEGIN _SetPercModeOpl3
push bp
mov bp, sp
push si


cmp [ bp].spm_state, 0 ; test if perc. mode
jne spm_perc
; melodic mode:
mov typeVc+15, TYPE_2OP
mov typeVc+16, TYPE_2OP
mov nbOpVc+16, 2
mov typeVc+17, TYPE_PERC + TYPE_DISABLE ; SD
mov typeVc+18, TYPE_2OP
mov nbOpVc+18, 2
mov typeVc+19, TYPE_PERC + TYPE_DISABLE ; CYMB

xor ah, ah ; clear RHY bit
jmp spm_suit2

; percussif mode:
spm_perc:
mov typeVc+15, TYPE_PERC ; BD
mov typeVc+16, TYPE_PERC ; HH
mov nbOpVc+16, 1
mov typeVc+17, TYPE_PERC ; SD
mov typeVc+18, TYPE_PERC ; TOM
mov nbOpVc+18, 1
mov typeVc+19, TYPE_PERC ; CYMB

; preset frequency for TOM & HH (they control the last 4 perc)
mov al, TOM_PITCH ; TOM pitch is FIXED!!
mov noteVc+TOM, al
mov ax, TOM
push ax ; voice
call near ptr UpdateFreqOpl3
add sp, 2
mov al, TOM_PITCH +TOM_TO_HH ; HH pitch is FIXED too!!
mov noteVc+HH, al
mov ax, HH
push ax
call near ptr UpdateFreqOpl3
add sp, 2

; initialise MULTI of HH & CYMB perc voices to 1, because they influence
; the timbre of SD, TOM, HH, CYMB:
mov dx, opl3_io
mov ax, 0131h ; set MULTI of HH slot to 1
call OutOpl3
mov ax, 0135h ; set MULTI of CYMB slot to 1
call OutOpl3

mov ah, 32 ; set RHY bit

spm_suit2:
mov dx, opl3_io
mov al, bdReg
and al, 0c0h
or ah, al
mov bdReg, ah
mov al, 0bdH
call OutOPL3 ; and send to chip


pop si
pop bp
ret
_SetPercModeOpl3 ENDP





; Enable/disable 4-op voices. There is a maximum of 6 4-op voices.
; Each 4-op voice use 2 2-op voices. The 6 low bits of 'mask'
; specifies if corresponding voice (from bit-0 to bit 5) is enable or
; disable. Enabling one 4-op voice will automaticaly disable two 2-op voices.
;
; Set4opMaskOpl3( mask)
; unsigned mask;
;
BEGIN _Set4opMaskOpl3
s4_ struc
s4_local dw (?) ; old BP
db CPSIZE DUP (?) ; ret. addr
s4_mask dw (?) ; mask, 6 low bits
s4_ ends

push bp
IF s4_local NE 0
sub sp, s4_local
ENDIF
mov bp, sp
push si

mov ax, [ bp].s4_mask
and ax, 3fH ; keep low 6 bits
mov mask4op, al

mov cx, 6
xor si, si
s4_lp1:
shr al, 1 ; test low bit
jnc s4_off
; ON:
mov typeVc[ si], TYPE_4OP
mov nbOpVc[ si], 4
mov typeVc[ si +1], TYPE_2OP + TYPE_DISABLE
jmp s4_suit
s4_off:
mov typeVc[ si], TYPE_2OP
mov nbOpVc[ si], 2
mov typeVc[ si +1], TYPE_2OP

s4_suit:
add si, 2
loop s4_lp1


; send 4-op bits to OPL-III:
mov dx, opl3_io
add dx, 2
mov ah, mask4op
mov al, 4
call OutOPL3

pop si
IF s4_local
add sp, s4_local
ENDIF
pop bp
ret
_Set4opMaskOpl3 ENDP





; SetGlobalOpl3( nSel, amD, vibD, pBRange)
; int nSel, amD, vibD;
; int pBRange;
BEGIN _SetGlobalOpl3
sg_ struc
sg_local dw (?) ; old BP
db CPSIZE DUP (?) ; ret. addr
sg_nSel dw (?) ; Note-Sel
sg_amD dw (?) ; AM-Depth
sg_vibD dw (?) ; VIB-Depth
sg_pBR dw (?) ; pitch bend range 1 - 12
sg_ ends

push bp
IF sg_local NE 0
sub sp, sg_local
ENDIF
mov bp, sp

mov dx, opl3_io
mov ax, [bp].sg_nSel
or ax, ax
je sg_ok1
; noteSel ON:
mov ah, 040h
sg_ok1:
mov al, 8
call OutOPL3

xor ah, ah
mov cx, [bp].sg_amD
or cx, cx
je sg_ok2
; am-Depth ON
mov ah, 080h
sg_ok2:
mov cx, [bp].sg_vibD
or cx, cx
je sg_ok3
; vib-Depth ON
or ah, 040h
sg_ok3:
mov al, bdReg
and al, NOT 0c0h ; clear AM & VIB bits
or al, ah ; set AM & VIB bits value
mov bdReg, al
mov ah, al
mov al, 0bdh ; register addr
call OutOPL3


; set the new pitch bend range
mov ax, [ bp].sg_pBR
cmp ax, 12
jle sg_ok4
mov ax, 12
jmp sg_ok5
sg_ok4:
cmp ax, 1
jge sg_ok5
mov ax, 1
sg_ok5:
mov pitchRange, ax

IF sg_local NE 0
add sp, sg_local
ENDIF
pop bp
ret
_SetGlobalOpl3 ENDP




; PresetOpl3( voice, dP)
; 0 <= int voice <= 19
; char dP[ 28];
po3_ struc
po3_prmOff dw (?)
po3_count db (?)
db (?) ; filler
po3_local dw (?) ; old BP
db CPSIZE DUP (?) ; ret. addr
po3_voice dw (?)
po3_dP db DPSIZE DUP (?) ; far pointer to preset data
po3_ ends

BEGIN _PresetOpl3

push bp
IF po3_local NE 0
sub sp, po3_local
ENDIF
mov bp, sp
push si
push di

mov bx, [bp].po3_voice
cmp bx, LAST_VC
jbe po3_9
po3_10:
jmp po3_bad
po3_9:
mov al, typeVc[ bx]
test al, TYPE_DISABLE ; verify if voice is valid
jne po3_10

test al, TYPE_4OP
je po3_1
; voix 4op
mov si, offset DGROUP: carMsk4op
jmp po3_suite

po3_1:
; voix 2-op ou Perc
mov si, offset DGROUP: carMsk2op

po3_suite:
mov al, levelVc[ bx] ; get voice volume (log)
xor ah, ah
push ax

IF LDATA
les di, dword ptr [bp].po3_dP
ELSE
mov di, word ptr [bp].po3_dP
push ds
pop es
ENDIF

mov bl, es:[ di +PRESET_CONNECT] ; get first connection bit
mov bh, bl
mov cl, 1
and bl, cl
rol bh, cl
and bh, cl
rol bh, cl ; second connection bit
or bl, bh ; algo #
xor bh, bh
mov dh, [si+bx] ; get carrier mask value

mov bx, [bp].po3_voice
cmp nbOpVc[ bx], 1 ; test if HH to CYMB voice..
jne po3_2b
; > BD: one slot voice ==> carrier mask = 1
mov dh, 1
po3_2b:
mov carMaskVc[ bx], dh ; save mask to array


mov al, nbOpVc[ bx]
mov [bp].po3_count, al
xor cx, cx
mov [bp].po3_prmOff, cx
po3_loop:
mov bx, [bp].po3_prmOff
lea si, [di+bx]
mov al, es:[ si+4] ; get 'defined bit'
or al, al ; test sign bit
jns po3_nextSlot
push es
push si ; data pointer

mov al, dh
and ax, 1 ; test carrier bit
push ax

mov bx, [bp].po3_voice
shl bx, 1
mov si, offset DGROUP: vcToSlot
add si, cx ; + slot number
mov al, [ si +bx] ; get slot offset
xor ah, ah
push ax

call SendOper
add sp, 4*2

po3_nextSlot:
add byte ptr [bp].po3_prmOff, PRESET_OPR_SIZE
shr dh, 1
inc cx
dec [bp].po3_count
jg po3_loop

; all slots have been sent...
pop ax ; clean up stack

mov bx, [bp].po3_voice
mov al, es:[ di +PRESET_TRANSP] ; transposition
mov transpVc[ bx], al

mov dx, opl3_io
mov al, es:[ di +PRESET_CONNECT] ; get FB & connect
and al, 0fh
mov ah, c0RegVc[ bx]
and ah, 0f0h
or ah, al
mov c0RegVc[ bx], ah ; save to array
mov al, vcToChannel[ bx] ; get first offset for C0-C8 registers
or al, al ; test sign bit for validity
js po3_5 ; no channel...
cmp al, 020H
jl po3_4
; second bank
sub al, 020h
add dx, 2
po3_4:
add al, 0c0H
call OutOPL3

cmp nbOpVc[ bx], 4
jne po3_5 ; only one connect bit

mov al, es:[ di + PRESET_CONNECT] ; get second connect bit
rol al, 1
and al, 1
mov ah, c0RegVc[ bx +1]
and ah, 0f0h
or ah, al
mov c0RegVc[ bx +1], ah ; save to array
mov al, vcToChannel[ bx +1] ; get second offset for C0-C8 registers
or al, al
js po3_5
and al, NOT 020H ; clear first/second bank indicator
add al, 0c0H ; add offset of C0-C8 reg.
call OutOPL3
po3_5:

po3_bad:
pop di
pop si
IF po3_local NE 0
add sp, po3_local
ENDIF
pop bp
ret
_PresetOpl3 ENDP






; LevelOpl3( voice, level)
; 0 <= voice <= 19
; 0 <= level <= 127 (linear)
BEGIN _LevelOpl3
lev_s struc
lev_local dw (?) ; old bp
db CPSIZE DUP (?) ; return addr
lev_voice dw (?)
lev_level dw (?)
lev_s ends

push bp
IF lev_local NE 0
sub sp, lev_local
ENDIF
mov bp, sp
push si
push di

mov bx, [bp].lev_voice
cmp bx, LAST_VC
ja lev_bad
test typeVc[ bx], TYPE_DISABLE
jne lev_bad ; jump if voice is invalid
mov ch, levelVc[ bx]
shl bx, 1
lea di, vcToSlot[ bx]

mov bx, [bp].lev_level
cmp bx, 127 ; level is MIN( level, 127)
jbe lev_ok
; overflow:
mov bx, 127
lev_ok:
mov al, linToLog[ bx] ; convert volume to log. value
mov bx, [bp].lev_voice
mov levelVc[ bx], al ; set new voice level
mov ch, al ; preserve voice level

mov cl, carMaskVc[ bx] ; get voice carrier mask
mov bl, nbOpVc[ bx] ; get number of slots for this voice
mov si, bx ; loop counter
lev_lp:
mov bl, [di] ; get slot offset
inc di ; point to next slot
or bl, bl ; test if valid slot
js lev_next ; skip if not
shr cl, 1 ; test if carrier slot
jnc lev_next ; skip if not
xor bh, bh
mov al, kslLevSlots[ bx] ; get slot KSL-LEVEL
mov ah, al
and ah, 3fh ; keep Total-Level bits only
add ah, ch ; + logarithm voice volume
cmp ah, MAX_LOG_VOL ; test if overflow
jbe lev_ok2 ; skip if yes
; overflow
mov ah, MAX_LOG_VOL ; set maximum volume
lev_ok2:
and al, NOT 3fh ; keep KSL
or ah, al ; add to resulting level
mov dx, opl3_io
mov al, bl ; slot offset
and bl, 20h ; test if second bank
je lev_ok3 ; skip if not
; bank 2
and al, NOT 20h
add dx, 2 ; second bank
lev_ok3:
add al, 40h ; KSL, TOTAL-LEVEL register offset
call OutOPL3
lev_next:
dec si ; loop count --
jne lev_lp

lev_bad:
lev_ret:
pop di
pop si
IF lev_local NE 0
add sp, lev_local
ENDIF
pop bp
ret
_LevelOpl3 ENDP





; NoteOnOpl3( voice, note);
; 0 <= voice <= 19
; 12 <= note <= 107
;
BEGIN _NoteOnOpl3
nop3 struc
nop3_local dw (?) ; old bp
db CPSIZE DUP (?) ; return addr
nop3_voice dw (?)
nop3_note dw (?)
nop3 ends

push bp
IF nop3_local NE 0
sub sp, nop3_local
ENDIF
mov bp, sp

mov bx, [bp].nop3_voice
cmp bx, LAST_VC
ja nop3_bad
mov al, typeVc[ bx]
test al, TYPE_DISABLE ; voice valid ?
jne nop3_bad

test al, TYPE_PERC
jne nop3_perc ; it's a percussion voice
; melodic voice:
or b0RegVc[ bx], 20H ; set KON bit
mov ax, [bp].nop3_note
mov noteVc[ bx], al
push bx ; voice
call near ptr UpdateFreqOpl3
add sp, 2
jmp nop3_ret

nop3_perc:
cmp bx, BD ; Base Drum ??
jg nop3_others
nop3_bd:
mov al, byte ptr [bp].nop3_note
mov noteVc[ bx], al
push bx ; voice
call near ptr UpdateFreqOpl3
add sp, 2

nop3_others:
nop3_pbits:
; others (SD, CYMB, HH) + (BD, TOM)
mov ah, percBits[ bx - FIRST_PERC]
or ah, bdReg
mov bdReg, ah
mov al, 0bdh
mov dx, opl3_io
call OutOPL3

nop3_bad:
nop3_ret:
IF nop3_local NE 0
add sp, nop3_local
ENDIF
pop bp
ret
_NoteOnOpl3 ENDP




; NoteOffOpl3( voice);
; 0 <= voice <= 19
;
BEGIN _NoteOffOpl3
nfop3 struc
nfop3_local dw (?) ; old bp
db CPSIZE DUP (?) ; return addr
nfop3_voice dw (?)
nfop3 ends

push bp
IF nfop3_local NE 0
sub sp, nfop3_local
ENDIF
mov bp, sp

mov bx, [bp].nfop3_voice
cmp bx, LAST_VC
ja nfop3_bad
mov al, typeVc[ bx]
test al, TYPE_DISABLE ; voice valid ?
jne nfop3_bad

test al, TYPE_PERC
jne nfop3_perc ; it's a percussion voice
; melodic voice:
mov ah, b0RegVc[ bx]
and ah, NOT 20H ; reset KON bit
mov b0RegVc[ bx], ah
mov dx, opl3_io
mov al, vcToChannel[ bx] ; get offset of channel
test al, 20h ; test bank indicator
je nfop3_first
; second bank
and al, NOT 20h ; clear bank indicator
add dx, 2 ; point to next bank
nfop3_first:
add al, 0b0H
call OutOPL3 ; update B0-B8 register
jmp nfop3_ret

; others (BD, SD, TOM, CYMB, HH)
nfop3_perc:
mov ah, percBits[ bx - FIRST_PERC]
not ah
and ah, bdReg ; reset perc bit
mov bdReg, ah
mov al, 0bdh ; perc bits register offset
mov dx, opl3_io
call OutOPL3

nfop3_bad:
nfop3_ret:
IF nfop3_local NE 0
add sp, nfop3_local
ENDIF
pop bp
ret
_NoteOffOpl3 ENDP



; PitchBendOpl3( voice, pitchBend)
; 0 <= int voice <= BD
; 0 <= unsigned pitchBend <= 0x3fff
;
BEGIN _PitchBendOpl3
pb struc
pb_local dw (?) ; old bp
db CPSIZE DUP (?) ; return addr
pb_voice dw (?)
pb_pitchBend dw (?)
pb ends

push bp
IF pb_local NE 0
sub sp, pb_local
ENDIF
mov bp, sp

mov bx, [bp].pb_voice
cmp bx, LAST_VC
ja pb_bad
test typeVc[ bx], TYPE_DISABLE ; voice valid ?
jne pb_bad

cmp nbOpVc[ bx], 1
jle pb_ret ; no pitch bend for SD, TOM, CYMB & HH

; melodic voice or BD:
mov ax, [bp].pb_pitchBend
cmp ax, 03fffH
jbe pb_ok
; overflow
mov ax, 03fffH
pb_ok:
push bx ; voice
add bx, bx ; offste in pitchBendVc array
mov pitchBendVc[ bx], ax
call near ptr UpdateFreqOpl3
add sp, 2
pb_bad:
pb_ret:
IF pb_local NE 0
add sp, pb_local
ENDIF
pop bp
ret
_PitchBendOpl3 ENDP




; LeftRightOpl3( voice, lR)
; lR ==> 0: center, 1: left, 2: right
;
BEGIN _LeftRightOpl3
lr_ struc
lr_local dw (?) ; old bp
db CPSIZE DUP (?) ; return addr
lr_voice dw (?)
lr_lrbits dw (?)
lr_ ends

push bp
IF lr_local NE 0
sub sp, lr_local
ENDIF
mov bp, sp
push si

mov bx, [bp].lr_voice
cmp bx, LAST_VC
ja lr_bad
test typeVc[ bx], TYPE_DISABLE ; voice valid ?
jne lr_bad

mov si, [bp].lr_lrbits
cmp si, 2
jbe lr_ok
; overflow
xor si, si
lr_ok:
mov al, vcToChannel[ bx] ; get channel offset
or al, al
js lr_bad ; pas de correspondance
mov dx, opl3_io
test al, 20h ; second bank ?
je lr_ok2
; bank 2
add dx, 2
and al, NOT 20H
lr_ok2:
add al, 0c0h
mov ah, leftRightBits[ si]
mov cl, c0RegVc[ bx] ; get current C0-C8 register val.
and cl, NOT 30H ; clear stereo bits
or ah, cl
mov c0RegVc[ bx], ah ; save new value of reg.
call OutOPL3

; do the same thing for second group
cmp nbOpVc[ bx], 4 ; verify if 4-op voice
jne lr_ret

mov al, vcToChannel[ bx +1]
and al, NOT 20h ; clear bank indicator
add al, 0c0h
mov ah, leftRightBits[ si]
mov cl, byte ptr c0RegVc[ bx +1] ; get current C0-C8 register val.
and cl, NOT 30H ; clear stereo bits
or ah, cl
mov c0RegVc[ bx +1], ah ; save new value of register
call OutOPL3

lr_bad:
lr_ret:
pop si
IF lr_local NE 0
add sp, lr_local
ENDIF
pop bp
ret
_LeftRightOpl3 ENDP



;/*
; Set the frequency of voice 'voice' to note number noteVc[ vc] +transpVc[ vc],
; shifting the note by 'pitchBendVc[ vc]/0x2000' of 'pitchRange' (global, 1-12).
;*/
;
;static int UpdateFreqOpl3( voice)
; int voice; /* [0, 19]
; {
; int tblValue, tNote;
; unsigned t1, t2;
; unsigned tableOff;
; unsigned fNLow, fNHigh;
; int block;
; int signP;

UpdateFreqOpl3 PROC NEAR
SF_F struc
sf_note dw (?)
sf_local dw (?) ; old bp
dw (?) ; ret. addr.
voice dw (?)
SF_F ends

push bp
IF sf_local NE 0
sub sp, sf_local
ENDIF
mov bp, sp
push si
push di

mov bx, [bp].voice

mov al, DELTA_PITCH ; convert from MID_C = 60 to MID_C = 48
add al, transpVc[ bx] ; add transposition of voice timbre
add al, noteVc[ bx] ; add note value
mov byte ptr [bp].sf_note, al

; signP = (int)pitch - 0x2000;
add bx, bx ; offset in pitchBendVc array
mov ax, pitchBendVc[ bx]
sub ax, 2000H
je after_mul ; if 0, by-pass multiplication...

; t2 = signP >> (13 -LOG_PITCH);
IF log_pitch NE 8
*** code non prevu pour log_pitch != 8
ENDIF
sar ax, 1
sar ax, 1
sar ax, 1
sar ax, 1
sar ax, 1

; t2 *= pBRange; /* 8 bits apres le point */
IF 0
IF log_pitch NE 8
*** code non prevu pour log_pitch != 8: multiplication 8 bits
ENDIF
imul pitchRange ; t2 ... byte ptr ???

ELSE
mov cx, ax
mov bx, pitchRange
shl bx, 1
neg bx
add bx, offset CS: add_table+2
jmp bx
EVEN
add ax, cx ; x 12
add ax, cx ; x 11
add ax, cx ; x 10
add ax, cx ; x 9
add ax, cx ; x 8
add ax, cx ; x 7
add ax, cx ; x 6
add ax, cx ; x 5
add ax, cx ; x 4
add ax, cx ; x 3
add ax, cx ; x 2
add_table: ; x 1
ENDIF

; t1 = note << LOG_PITCH;
; tNote = (t1 + t2);
after_mul:
IF log_pitch NE 8
*** code non defini pour log_pitch != 8
ENDIF
add ah, byte ptr [bp].sf_note

; /* arrondir a 0.5: */
; tNote += ( 1 << LOG_PITCH - LOG_NB_STEP_PITCH -1);
add ax, (1 SHL (log_pitch - log_nb_step_pitch -1))

; tNote >>= LOG_PITCH - LOG_NB_STEP_PITCH; /* 4 bits apres le point */
IF (log_pitch - log_nb_step_pitch) NE 4
*** code non prevu pour (log_pitch - log_nb_step_pitch) != 4
ENDIF
sar ax, 1
sar ax, 1
sar ax, 1
sar ax, 1

; /* attention de ne pas deborder de [0,96[ ... */
; if( tNote < 0)
jge l3

; tNote = 0;
xor ax, ax
jmp l4

; if( tNote >= NB_NOTES << LOG_NB_STEP_PITCH)
l3: cmp ax, (nb_notes SHL log_nb_step_pitch)-1
jl l4

; tNote = (NB_NOTES << LOG_NB_STEP_PITCH) -1;
mov ax, (nb_notes SHL log_nb_step_pitch)-1

; tableOff = divMod12[ (tNote >> LOG_NB_STEP_PITCH)] & 0xf;
l4:
mov di, ax
IF log_nb_step_pitch NE 4
*** code non prevu pour log_nb_step_pitch != 8
ENDIF
shr di, 1
shr di, 1
shr di, 1
shr di, 1
mov dx, di ; tNote >> log_nb_step_pitch
mov bl, divMod12[ di]
and bl, 0fH ; keep modulo 12 part
xor bh, bh
mov di, bx

; tableOff <<= LOG_NB_STEP_PITCH +1;
IF log_nb_step_pitch NE 4
*** code non prevu pour log_nb_step_pitch != 4
ENDIF
shl di, 1
shl di, 1
shl di, 1
shl di, 1
shl di, 1

; tableOff += (tNote << 1) & (NB_STEP_PITCH *2 -1);
shl ax, 1
and ax, (nb_step_pitch *2 -1)
add di, ax

; tblValue = * (int *)((char *)fNumTbl +tableOff);
mov ax, fNumTbl[ di]

; block = (divMod12[ (tNote >> LOG_NB_STEP_PITCH)] >> 4) -1;
mov di, dx
mov bl, divMod12[ di]
shr bl, 1
shr bl, 1
shr bl, 1
shr bl, 1
dec bl

; block += tblValue < 0 ? 1 : 0;
or ax, ax
jge l5
inc bl

; if( block < 0) {
l5:
or bl, bl
jge l6

; block++;
inc bl

; tblValue >>= 1;
; }
sar ax, 1
l6:


; OutOPL3( 0xA0 +voice % 9, tblValue & 255);
push bx ; save block value

mov cx, ax ; save tblValue
mov dx, opl3_io ; io addr
mov bx, [bp].voice
mov si, offset DGROUP: vcToChannel
lea si, [si +bx]
mov al, [si] ; get channel offset (+20h if bank 2)
or al, al ; check if we can change freq. for this voice
js sf_ret ; jump if no...
test al, 020h ; check if bank 2
je sf_10
; bank 2
add dx, 2
and al, NOT 020h
sf_10:
add al, 0a0H ; F-Number(Low) offset
mov ah, cl ; f-num low value
call OutOPL3

; OutOPL3( 0xB0 +voice % 9, (block << 2) + (tblValue >> 8) & 3);
mov ah, b0RegVc[ bx] ; get current register value
and ah, NOT 01fH ; mask off block & f-num(h)
and ch, 3 ; keep only f-num(h) 2 low bits
or ah, ch
pop cx ; restore block #
and cl, 7 ; keep block field
add cl, cl
add cl, cl ; shift block two bits left
or ah, cl
mov b0RegVc[ bx], ah ; save new register value

mov al, [si] ; get channel offset
and al, NOT 20h ; clear bank indicator
add al, 0b0h
call OutOPL3

; }
sf_ret:
pop di
pop si
IF sf_local NE 0
add sp, sf_local
ENDIF
pop bp
ret

UpdateFreqOpl3 ENDP






; send parameters of base addr 20h, 40h, 60h, 80h & 0e0h
;
sop_ struc
sop_local dw (?) ; old bp
dw (?) ; return addr
sop_slot dw (?) ; slot offset (+20H if second bank)
sop_carrier dw (?) ; != 0 if it's a carrier slot
sop_data dd (?)
sop_vcVol dw (?) ; voice number, [0 - 28]
sop_ ends

SendOper PROC NEAR
push bp
IF sop_local NE 0
sub sp, sop_local
ENDIF
mov bp, sp
push di
push es
push ax
push bx
push cx
push dx

mov dx, opl3_io
mov al, byte ptr [bp].sop_slot
or al, al ; test sign bit for validity
js sop_ret

cmp al, 020h ; first or second bank ?
jl sop_ok1
; bank #2
sub al, 020h
add dx, 2 ; point to second bank
sop_ok1:
mov cl, al
les di, dword ptr [bp].sop_data ; get pointer to preset data
add al, 020H ; AM VIB EG_TYPE KSR MULTI
mov ah, es:[ di]
inc di
call OutOPL3

mov ah, es:[ di]
inc di
mov bx, [bp].sop_slot
mov kslLevSlots[ bx], ah
cmp byte ptr [bp].sop_carrier, 0
je sop_ok2
; carrier:
mov al, ah
and al, 3fH ; mask off KSL
add al, byte ptr [bp].sop_vcVol
cmp al, 03fH
jle sop_ok3
; overflow:
mov al, 03fH
sop_ok3:
and ah, 0c0H
or ah, al
sop_ok2:
mov al, cl
add al, 040H
call OutOPL3

mov ah, es:[ di] ; AR DR
inc di
mov al, cl
add al, 060H
call OutOPL3

mov ah, es:[ di] ; SL RR
inc di
mov al, cl
add al, 080H
call OutOPL3

mov ah, es:[ di] ; WS
and ah, 07h
inc di
mov al, cl
add al, 0e0H
call OutOPL3

sop_ret:
pop dx
pop cx
pop bx
pop ax
pop es
pop di
IF sop_local NE 0
add sp, sop_local
ENDIF
pop bp
ret
SendOper ENDP



; Send data byte to OPL3
; input:
; DX: I/O base addr (bank 1 or 2)
; AL: register #
; AH: data
; lost:
; AL, AH
OutOPL3 PROC NEAR

pushf
cli

IF 0
; garder une copie des valeurs transferees au chip...
push bx
xor bh, bh
mov bl, al
test dx, 2
je o3_1
; second map
mov _map1[ bx], ah
jmp o3_2
; first map
o3_1:
mov _map0[ bx], ah
o3_2:
pop bx
ENDIF


out dx, al

if 0 ; pour que ca marche sur l'ancienne carte...
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
endif

; in al, dx ; delay (delay >= 280 ns) between addr and data write
in al, 20H ; delay ...
in al, 20H ; delay ... for 33 MHz machines
mov al, ah ; get data byte
inc dx ; point to data register
out dx, al
dec dx ; restore orginal address

if 0 ; pour que ca marche sur l'ancienne carte...
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx

in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx

in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx

in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
in al, dx

in al, dx
in al, dx
in al, dx
in al, dx
in al, dx
endif
popf

ret
OutOPL3 ENDP



ECODES opl3
END