forked from KolibriOS/kolibrios
3374 lines
73 KiB
NASM
3374 lines
73 KiB
NASM
; CORE.ASM
|
|
; --------
|
|
; uFMOD public source code release. Provided as-is.
|
|
|
|
if VIBRATO_OR_TREMOLO
|
|
sin127 db 00h,0Ch,19h,25h,31h,3Ch,47h,51h,5Ah,62h,6Ah,70h,75h,7Ah,7Dh,7Eh
|
|
db 7Fh,7Eh,7Dh,7Ah,75h,70h,6Ah,62h,5Ah,51h,47h,3Ch,31h,25h,19h,0Ch
|
|
endif
|
|
if INSTRUMENTVIBRATO_ON
|
|
sin64 db 00h,02h,03h,05h,06h,08h,09h,0Bh,0Ch,0Eh,10h,11h,13h,14h,16h,17h
|
|
db 18h,1Ah,1Bh,1Dh,1Eh,20h,21h,22h,24h,25h,26h,27h,29h,2Ah,2Bh,2Ch
|
|
db 2Dh,2Eh,2Fh,30h,31h,32h,33h,34h,35h,36h,37h,38h,38h,39h,3Ah,3Bh
|
|
db 3Bh,3Ch,3Ch,3Dh,3Dh,3Eh,3Eh,3Eh,3Fh,3Fh,3Fh,40h,40h,40h,40h,40h
|
|
endif
|
|
if AMIGAPERIODS_ON
|
|
f0_0833 dd 8.3333336e-2
|
|
f13_375 dd 1.3375e1
|
|
endif
|
|
f0_0013 dd 1.302083375e-3
|
|
f8363_0 dd 8.3630004275e3
|
|
|
|
; Mixer ramping
|
|
Ramp:
|
|
; [arg0] - ptr. to end of buffer
|
|
; ESI - _mod+36
|
|
; EDI - length
|
|
; EDX - buffer
|
|
; LOOP THROUGH CHANNELS
|
|
mov ecx,[esi+FMUSIC_MODULE.Channels-36]
|
|
push ebx
|
|
push ebp
|
|
loop_ch:
|
|
push esi
|
|
mov esi,[ecx+FSOUND_CHANNEL.fsptr] ; load the correct SAMPLE pointer for this channel
|
|
test esi,esi ; if(!fsptr) skip this channel!
|
|
jz MixExit_1
|
|
push edx ; mix buffer
|
|
push edx ; cur. mix buffer pointer
|
|
mov ebx,[ecx+FSOUND_CHANNEL.mixpos]
|
|
; Set up a mix counter. See what will happen first, will the output buffer
|
|
; end be reached first? or will the end of the sample be reached first? whatever
|
|
; is smallest will be the mixcount.
|
|
push edi
|
|
CalculateLoopCount:
|
|
cmp BYTE PTR [ecx+FSOUND_CHANNEL.speeddir],0
|
|
mov edx,[esi+FSOUND_SAMPLE.loopstart]
|
|
mov eax,[ecx+FSOUND_CHANNEL.mixposlo]
|
|
jne samplesleftbackwards
|
|
; work out how many samples left from mixpos to loop end
|
|
add edx,[esi+FSOUND_SAMPLE.looplen]
|
|
sub edx,ebx
|
|
ja submixpos
|
|
mov edx,[esi+FSOUND_SAMPLE._length]
|
|
sub edx,ebx
|
|
submixpos:
|
|
; edx : samples left (loopstart+looplen-mixpos)
|
|
neg edx
|
|
neg eax
|
|
adc edx,ebx
|
|
samplesleftbackwards:
|
|
; work out how many samples left from mixpos to loop start
|
|
neg edx
|
|
add edx,ebx
|
|
js MixExit
|
|
; edx:eax now contains number of samples left to mix
|
|
mov ebp,[ecx+FSOUND_CHANNEL.speedlo]
|
|
shrd eax,edx,5
|
|
mov ebx,[ecx+FSOUND_CHANNEL.speedhi]
|
|
shr edx,5
|
|
shrd ebp,ebx,5
|
|
jnz speedok ; divide by 0 check
|
|
mov ebp,FREQ_40HZ_p
|
|
mov DWORD PTR [ecx+FSOUND_CHANNEL.speedlo],FREQ_40HZ_f
|
|
speedok:
|
|
div ebp
|
|
xor ebp,ebp
|
|
neg edx
|
|
adc eax,ebp
|
|
jz DoOutputbuffEnd
|
|
mov ebx,OFFSET uFMOD_fopen
|
|
cmp eax,edi
|
|
; set a flag to say mix will end when end of output buffer is reached
|
|
seta [ebx-22] ; mix_endflag
|
|
jae staywithoutputbuffend
|
|
xchg eax,edi
|
|
staywithoutputbuffend:
|
|
if RAMP_NONE
|
|
else
|
|
movzx eax,WORD PTR [ecx+FSOUND_CHANNEL.ramp_count]
|
|
; VOLUME RAMP SETUP
|
|
; Reasons to ramp
|
|
; 1 volume change
|
|
; 2 sample starts (just treat as volume change - 0 to volume)
|
|
; 3 sample ends (ramp last n number of samples from volume to 0)
|
|
; now if the volume has changed, make end condition equal a volume ramp
|
|
test eax,eax
|
|
endif
|
|
mov edx,[ecx+FSOUND_CHANNEL.leftvolume]
|
|
mov ebp,[ecx+FSOUND_CHANNEL.rightvolume]
|
|
if RAMP_NONE
|
|
mov [ecx+FSOUND_CHANNEL.ramp_leftvolume],ebp
|
|
mov [ecx+FSOUND_CHANNEL.ramp_rightvolume],edx
|
|
else
|
|
mov [ebx-16],edi ; mmf+4 <- remember mix count before modifying it
|
|
jz volumerampstart
|
|
; if it tries to continue an old ramp, but the target has changed,
|
|
; set up a new ramp
|
|
cmp dx,[ecx+FSOUND_CHANNEL.ramp_lefttarget]
|
|
jne volumerampstart
|
|
cmp bp,[ecx+FSOUND_CHANNEL.ramp_righttarget]
|
|
je volumerampclamp ; restore old ramp
|
|
volumerampstart:
|
|
; SETUP NEW RAMP
|
|
mov [ecx+FSOUND_CHANNEL.ramp_lefttarget],dx
|
|
shl edx,volumeramps_pow
|
|
sub edx,[ecx+FSOUND_CHANNEL.ramp_leftvolume]
|
|
xor eax,eax
|
|
sar edx,volumeramps_pow
|
|
mov DWORD PTR [ecx+FSOUND_CHANNEL.ramp_leftspeed],edx
|
|
jz novolumerampL
|
|
mov al,volumerampsteps
|
|
novolumerampL:
|
|
mov [ecx+FSOUND_CHANNEL.ramp_righttarget],bp
|
|
shl ebp,volumeramps_pow
|
|
sub ebp,[ecx+FSOUND_CHANNEL.ramp_rightvolume]
|
|
sar ebp,volumeramps_pow
|
|
mov DWORD PTR [ecx+FSOUND_CHANNEL.ramp_rightspeed],ebp
|
|
jz novolumerampR
|
|
mov al,volumerampsteps
|
|
novolumerampR:
|
|
test eax,eax
|
|
mov [ecx+FSOUND_CHANNEL.ramp_count],ax
|
|
jz volumerampend
|
|
volumerampclamp:
|
|
cmp edi,eax
|
|
jbe volumerampend ; dont clamp mixcount
|
|
mov edi,eax
|
|
volumerampend:
|
|
mov eax,[ecx+FSOUND_CHANNEL.ramp_leftspeed]
|
|
mov [ebx],eax ; ramp_leftspeed
|
|
mov eax,[ecx+FSOUND_CHANNEL.ramp_rightspeed]
|
|
mov [ebx+4],eax ; ramp_rightspeed
|
|
endif
|
|
mov [ebx-20],edi ; mmf
|
|
; SET UP ALL OF THE REGISTERS HERE FOR THE INNER LOOP
|
|
; edx : speed
|
|
; ebx : mixpos
|
|
; ebp : speed low
|
|
; esi : destination pointer
|
|
; edi : counter
|
|
mov ebx,[ecx+FSOUND_CHANNEL.mixpos]
|
|
lea ebx,[ebx*2+esi+FSOUND_SAMPLE.buff]
|
|
push esi
|
|
cmp BYTE PTR [ecx+FSOUND_CHANNEL.speeddir],0
|
|
mov esi,[esp+8] ; <- cur. mix buffer
|
|
mov edx,[ecx+FSOUND_CHANNEL.speedhi]
|
|
mov ebp,[ecx+FSOUND_CHANNEL.speedlo]
|
|
je MixLoop16
|
|
; neg edx:ebp
|
|
neg ebp
|
|
not edx
|
|
sbb edx,-1
|
|
align 4
|
|
MixLoop16:
|
|
push edi
|
|
push edx
|
|
movsx edi,WORD PTR [ebx]
|
|
movsx eax,WORD PTR [ebx+2]
|
|
mov edx,[ecx+FSOUND_CHANNEL.mixposlo]
|
|
sub eax,edi
|
|
shr edx,1 ; force unsigned
|
|
imul edx
|
|
shl edi,volumeramps_pow-1
|
|
shld edx,eax,volumeramps_pow
|
|
add edx,edi
|
|
if RAMP_NONE
|
|
mov eax,edx
|
|
imul edx,[ecx+FSOUND_CHANNEL.ramp_rightvolume]
|
|
add [esi],edx
|
|
imul DWORD PTR [ecx+FSOUND_CHANNEL.ramp_leftvolume]
|
|
add [esi+4],eax
|
|
else
|
|
xchg eax,edx
|
|
mov edi,eax
|
|
imul DWORD PTR [ecx+FSOUND_CHANNEL.ramp_rightvolume]
|
|
shrd eax,edx,volumeramps_pow-1
|
|
rol edx,1
|
|
and edx,1
|
|
add eax,edx
|
|
sar eax,1
|
|
add [esi],eax
|
|
xchg eax,edi
|
|
imul DWORD PTR [ecx+FSOUND_CHANNEL.ramp_leftvolume]
|
|
shrd eax,edx,volumeramps_pow-1
|
|
rol edx,1
|
|
and edx,1
|
|
add eax,edx
|
|
mov edi,[uFMOD_fread]
|
|
sar eax,1
|
|
add [esi+4],eax
|
|
mov edx,[uFMOD_fopen]
|
|
add [ecx+FSOUND_CHANNEL.ramp_rightvolume],edi ; + cur_ramp_rightspeed
|
|
add [ecx+FSOUND_CHANNEL.ramp_leftvolume],edx ; + cur_ramp_leftspeed
|
|
endif
|
|
pop edx
|
|
xor eax,eax
|
|
add [ecx+FSOUND_CHANNEL.mixposlo],ebp
|
|
pop edi
|
|
adc eax,edx
|
|
add esi,8
|
|
dec edi
|
|
lea ebx,[ebx+eax*2]
|
|
jnz MixLoop16
|
|
mov edi,[esp+20h] ; find out how many OUTPUT samples left to mix
|
|
mov [esp+8],esi ; update cur. mix buffer
|
|
sub edi,esi
|
|
shr edi,3 ; edi <- # of samples left
|
|
pop esi ; esi <- sample pointer
|
|
lea eax,[esi+FSOUND_SAMPLE.buff]
|
|
sub ebx,eax
|
|
shr ebx,1
|
|
mov [ecx+FSOUND_CHANNEL.mixpos],ebx
|
|
if RAMP_NONE
|
|
xor edx,edx
|
|
else
|
|
; DID A VOLUME RAMP JUST HAPPEN?
|
|
movzx edx,WORD PTR [ecx+FSOUND_CHANNEL.ramp_count]
|
|
test edx,edx
|
|
jz DoOutputbuffEnd
|
|
mov eax,[mmf]
|
|
cdq
|
|
sub [ecx+FSOUND_CHANNEL.ramp_count],ax
|
|
; if(!rampcount) a ramp has FINISHED, so finish the rest of the mix
|
|
jnz DoOutputbuffEnd
|
|
sub eax,[mmf+4]
|
|
; clear out the ramp speeds
|
|
mov [ecx+FSOUND_CHANNEL.ramp_leftspeed],edx
|
|
neg eax
|
|
mov [ecx+FSOUND_CHANNEL.ramp_rightspeed],edx
|
|
; is it 0 because ramp ended only? or both ended together?
|
|
; if sample ended together with ramp... problems... loop isn't handled
|
|
sbb edx,edx
|
|
; start again and continue rest of mix
|
|
test edi,edx
|
|
jnz CalculateLoopCount ; dont start again if nothing left
|
|
xor edx,edx
|
|
endif
|
|
DoOutputbuffEnd:
|
|
cmp [mix_endflag],dl
|
|
jne MixExit
|
|
movzx eax,BYTE PTR [esi+FSOUND_SAMPLE.loopmode]
|
|
; SWITCH ON LOOP MODE TYPE
|
|
dec eax ; check for normal loop (FSOUND_LOOP_NORMAL = 1)
|
|
jnz CheckBidiLoop
|
|
mov eax,[esi+FSOUND_SAMPLE.loopstart]
|
|
mov ebp,[esi+FSOUND_SAMPLE.looplen]
|
|
add eax,ebp
|
|
cmp ebx,eax
|
|
jbe rewind_ok
|
|
sub ebx,eax
|
|
xchg eax,ebx
|
|
div ebp
|
|
rewind_ok:
|
|
sub ebp,edx
|
|
sub ebx,ebp
|
|
jmp ChkLoop_OK
|
|
CheckBidiLoop:
|
|
dec eax ; FSOUND_LOOP_BIDI = 2
|
|
neg eax
|
|
adc edx,-1
|
|
and [ecx+FSOUND_CHANNEL.mixposlo],edx
|
|
and [ecx+FSOUND_CHANNEL.mixpos],edx
|
|
and [ecx+FSOUND_CHANNEL.fsptr],edx
|
|
jz MixExit
|
|
cmp [ecx+FSOUND_CHANNEL.speeddir],al ; FSOUND_MIXDIR_FORWARDS
|
|
je BidiForward
|
|
BidiBackwards:
|
|
mov eax,[esi+FSOUND_SAMPLE.loopstart]
|
|
neg ebp
|
|
dec eax
|
|
sub ebp,1
|
|
dec BYTE PTR [ecx+FSOUND_CHANNEL.speeddir] ; set FSOUND_MIXDIR_FORWARDS
|
|
sbb eax,ebx
|
|
mov ebx,[esi+FSOUND_SAMPLE.loopstart]
|
|
add ebx,eax
|
|
cmp eax,[esi+FSOUND_SAMPLE.looplen]
|
|
jl BidiFinish
|
|
BidiForward:
|
|
mov eax,[esi+FSOUND_SAMPLE.loopstart]
|
|
add eax,[esi+FSOUND_SAMPLE.looplen]
|
|
lea edx,[eax-1]
|
|
sbb eax,ebx
|
|
neg ebp
|
|
xchg eax,ebx
|
|
sub ebp,1
|
|
adc ebx,edx
|
|
inc BYTE PTR [ecx+FSOUND_CHANNEL.speeddir] ; go backwards
|
|
cmp ebx,[esi+FSOUND_SAMPLE.loopstart]
|
|
jl BidiBackwards
|
|
BidiFinish:
|
|
mov [ecx+FSOUND_CHANNEL.mixposlo],ebp
|
|
ChkLoop_OK:
|
|
test edi,edi
|
|
mov [ecx+FSOUND_CHANNEL.mixpos],ebx
|
|
jnz CalculateLoopCount
|
|
MixExit:
|
|
pop edi
|
|
pop eax ; discard cur. mix buffer pointer
|
|
pop edx
|
|
MixExit_1:
|
|
add ecx,FSOUND_CHANNEL_size
|
|
pop esi
|
|
cmp ecx,[esi+FMUSIC_MODULE.uFMOD_Ch-36]
|
|
jl loop_ch
|
|
pop ebp
|
|
pop ebx
|
|
ret
|
|
|
|
if AMIGAPERIODS_ON
|
|
AmigaPeriod:
|
|
; [sptr] in ECX
|
|
; note in EAX
|
|
; ESI != 0
|
|
mov edx,132
|
|
push edi
|
|
sub edx,eax
|
|
push esi
|
|
test eax,eax
|
|
push edx
|
|
movsx eax,BYTE PTR [ecx+FSOUND_SAMPLE.finetune]
|
|
mov edi,edx
|
|
jz _do_inc
|
|
cdq
|
|
shl edx,1
|
|
_do_inc:
|
|
inc edx
|
|
exp2:
|
|
fild DWORD PTR [esp]
|
|
fmul DWORD PTR [f0_0833] ; /12.0f
|
|
fld st0
|
|
frndint
|
|
fsub st1,st0
|
|
fxch st1
|
|
f2xm1
|
|
fld1
|
|
faddp st1,st0
|
|
fscale
|
|
fstp st1
|
|
fmul DWORD PTR [f13_375] ; *13.375f
|
|
fistp DWORD PTR [esp]
|
|
test esi,esi
|
|
pop ecx
|
|
jz exp2_end
|
|
sub edi,edx
|
|
push edi
|
|
xor esi,esi
|
|
mov edi,ecx
|
|
jmp exp2
|
|
exp2_end:
|
|
sub ecx,edi
|
|
test edx,edx
|
|
jns _do_imul
|
|
neg ecx
|
|
_do_imul:
|
|
imul ecx
|
|
and edx,127 ; +2^7-1
|
|
add eax,edx
|
|
sar eax,7
|
|
pop esi
|
|
add eax,edi
|
|
pop edi
|
|
ret
|
|
endif ; AMIGAPERIODS_ON
|
|
|
|
; DESCRIPTION: To carry out a vibrato at a certain depth and speed
|
|
if VIBRATO_OR_VOLSLIDE
|
|
if TREMOLO_ON
|
|
VibratoOrTremolo:
|
|
; cptr+2 = ESI
|
|
movzx ecx,BYTE PTR [esi+FMUSIC_CHANNEL.vibpos-2]
|
|
mov al,[esi+FMUSIC_CHANNEL.wavecontrol-2]
|
|
mov edx,ecx
|
|
add dl,[esi+FMUSIC_CHANNEL.vibspeed-2]
|
|
and edx,3Fh
|
|
and eax,3 ; switch(cptr->wavecontrol&3)
|
|
mov [esi+FMUSIC_CHANNEL.vibpos-2],dl
|
|
jz vibrato_c0
|
|
; C2 : Sqare wave
|
|
rol ecx,27
|
|
sbb edx,edx
|
|
xor edx,7Fh
|
|
or edx,1
|
|
dec eax
|
|
jnz vibrato_default
|
|
; C1 : Triangle wave (ramp down)
|
|
shr edx,24
|
|
ror ecx,23
|
|
add edx,ecx
|
|
neg edx
|
|
jmp vibrato_default
|
|
vibrato_c0:
|
|
; C0 : Sine wave
|
|
; delta = 127 sin(2 Pi x/64)
|
|
mov eax,ecx
|
|
and ecx,1Fh
|
|
shr eax,6
|
|
movzx edx,BYTE PTR [OFFSET sin127+ecx]
|
|
sbb eax,eax
|
|
xor edx,eax
|
|
sub edx,eax
|
|
vibrato_default:
|
|
movsx eax,BYTE PTR [esi+FMUSIC_CHANNEL.vibdepth-2]
|
|
imul edx ; delta *= cptr->vibdepth
|
|
sar eax,5
|
|
ret
|
|
endif
|
|
|
|
Vibrato:
|
|
; cptr+2 = ESI
|
|
if TREMOLO_ON
|
|
call VibratoOrTremolo
|
|
sar eax,1
|
|
else
|
|
movzx ecx,BYTE PTR [esi+FMUSIC_CHANNEL.vibpos-2]
|
|
mov al,[esi+FMUSIC_CHANNEL.wavecontrol-2]
|
|
mov edx,ecx
|
|
add dl,[esi+FMUSIC_CHANNEL.vibspeed-2]
|
|
and edx,3Fh
|
|
and eax,3 ; switch(cptr->wavecontrol&3)
|
|
mov [esi+FMUSIC_CHANNEL.vibpos-2],dl
|
|
jz vibrato_c0
|
|
; C2 : Sqare wave
|
|
rol ecx,27
|
|
sbb edx,edx
|
|
xor edx,7Fh
|
|
or edx,1
|
|
dec eax
|
|
jnz vibrato_default
|
|
; C1 : Triangle wave (ramp down)
|
|
shr edx,24
|
|
ror ecx,23
|
|
add edx,ecx
|
|
neg edx
|
|
jmp vibrato_default
|
|
vibrato_c0:
|
|
; C0 : Sine wave
|
|
; delta = 127 sin(2 Pi x/64)
|
|
mov eax,ecx
|
|
and ecx,1Fh
|
|
shr eax,6
|
|
movzx edx,BYTE PTR [OFFSET sin127+ecx]
|
|
sbb eax,eax
|
|
xor edx,eax
|
|
sub edx,eax
|
|
vibrato_default:
|
|
movsx eax,BYTE PTR [esi+FMUSIC_CHANNEL.vibdepth-2]
|
|
imul edx ; delta *= cptr->vibdepth
|
|
sar eax,6
|
|
endif
|
|
mov [esi+FMUSIC_CHANNEL.freqdelta-2],eax
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_FREQ
|
|
ret
|
|
endif ; VIBRATO_OR_VOLSLIDE
|
|
|
|
if TREMOLO_ON
|
|
Tremolo:
|
|
; cptr+2 = ESI
|
|
if VIBRATO_OR_VOLSLIDE
|
|
push esi
|
|
add esi,FMUSIC_CHANNEL.tremolopos-FMUSIC_CHANNEL.vibpos
|
|
call VibratoOrTremolo
|
|
pop esi
|
|
else
|
|
movzx ecx,BYTE PTR [esi+FMUSIC_CHANNEL.tremolopos-2]
|
|
mov al,[esi+FMUSIC_CHANNEL.wavecontrol-2]
|
|
mov edx,ecx
|
|
add dl,[esi+FMUSIC_CHANNEL.tremolospeed-2]
|
|
and edx,3Fh
|
|
and eax,3 ; switch(cptr->wavecontrol&3)
|
|
mov [esi+FMUSIC_CHANNEL.tremolopos-2],dl
|
|
jz tremolo_c0
|
|
; C2 : Sqare wave
|
|
rol ecx,27
|
|
sbb edx,edx
|
|
xor edx,7Fh
|
|
or edx,1
|
|
dec eax
|
|
jnz tremolo_default
|
|
; C1 : Triangle wave (ramp down)
|
|
shr edx,24
|
|
ror ecx,23
|
|
add edx,ecx
|
|
neg edx
|
|
jmp tremolo_default
|
|
tremolo_c0:
|
|
; C0 : Sine wave
|
|
; delta = 127 sin(2 Pi x/64)
|
|
mov eax,ecx
|
|
and ecx,1Fh
|
|
shr eax,6
|
|
movzx edx,BYTE PTR [OFFSET sin127+ecx]
|
|
sbb eax,eax
|
|
xor edx,eax
|
|
sub edx,eax
|
|
tremolo_default:
|
|
movsx eax,BYTE PTR [esi+FMUSIC_CHANNEL.tremolodepth-2]
|
|
imul edx
|
|
sar eax,5
|
|
endif
|
|
mov [esi+FMUSIC_CHANNEL.voldelta-2],eax
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME
|
|
ret
|
|
endif ; TREMOLO_ON
|
|
|
|
if PORTATO_OR_VOLSLIDE
|
|
Portamento:
|
|
; cptr+2 = ESI
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_FREQ
|
|
mov eax,[esi+FMUSIC_CHANNEL.freq-2]
|
|
mov ecx,[esi+FMUSIC_CHANNEL.portatarget-2]
|
|
movzx edx,BYTE PTR [esi+FMUSIC_CHANNEL.portaspeed-2]
|
|
shl edx,2
|
|
sub eax,ecx
|
|
jg porta_do_sub
|
|
add eax,edx
|
|
jg _do_trim
|
|
jmp _no_trim
|
|
porta_do_sub:
|
|
sub eax,edx
|
|
jl _do_trim
|
|
_no_trim:
|
|
add ecx,eax
|
|
_do_trim:
|
|
mov [esi+FMUSIC_CHANNEL.freq-2],ecx
|
|
ret
|
|
endif ; PORTATO_OR_VOLSLIDE
|
|
|
|
if VOLUME_OR_PANENVELOPE
|
|
Envelope:
|
|
; cptr+2 = ESI
|
|
; env_iptr = ECX
|
|
; control = AL
|
|
env_type equ -4
|
|
envstopped equ -8
|
|
envdelta equ -12
|
|
env_value equ -16
|
|
valfrac equ -20
|
|
; env_tick = -24
|
|
sustain_l2 equ -26
|
|
sustain_l1 equ -27
|
|
sustain_loop equ -28
|
|
env_next equ -32
|
|
env_pos equ -36
|
|
push edi
|
|
push ebx
|
|
push ebp
|
|
mov ebp,esp
|
|
; Initialize local vars with PAN/VOL data
|
|
lea edi,[ecx+FMUSIC_INSTRUMENT.PANPoints]
|
|
xor ebx,ebx
|
|
if PANENVELOPE_ON
|
|
mov edx,DWORD PTR [edi+FMUSIC_INSTRUMENT.PANsustain-FMUSIC_INSTRUMENT.PANPoints]
|
|
mov [ebp+sustain_loop],edx ; load PANsustain, PANLoopStart and PANLoopEnd
|
|
mov cl,BYTE PTR [edi+FMUSIC_INSTRUMENT.PANtype-FMUSIC_INSTRUMENT.PANPoints]
|
|
movzx edx,BYTE PTR [edi+FMUSIC_INSTRUMENT.PANnumpoints-FMUSIC_INSTRUMENT.PANPoints]
|
|
endif
|
|
or [esi+FMUSIC_CHANNEL.notectrl-2],al ; cptr->notectrl |= control
|
|
if PANENVELOPE_ON
|
|
if VOLUMEENVELOPE_ON
|
|
cmp al,FMUSIC_VOLUME ; is it FMUSIC_VOLUME or FMUSIC_PAN?
|
|
endif
|
|
lea eax,[esi+FMUSIC_CHANNEL.envpanstopped-2]
|
|
endif
|
|
if VOLUMEENVELOPE_ON
|
|
if PANENVELOPE_ON
|
|
jnz pan_or_vol_ok
|
|
endif
|
|
; control = FMUSIC_VOLUME
|
|
add ebx,FMUSIC_CHANNEL.envvol-FMUSIC_CHANNEL.envpan
|
|
mov eax,DWORD PTR [edi+FMUSIC_INSTRUMENT.VOLsustain-FMUSIC_INSTRUMENT.PANPoints]
|
|
mov [ebp+sustain_loop],eax ; load VOLsustain, VOLLoopStart and VOLLoopEnd
|
|
mov cl,BYTE PTR [edi+FMUSIC_INSTRUMENT.VOLtype-FMUSIC_INSTRUMENT.PANPoints]
|
|
movzx edx,BYTE PTR [edi+FMUSIC_INSTRUMENT.VOLnumpoints-FMUSIC_INSTRUMENT.PANPoints]
|
|
lea eax,[esi+FMUSIC_CHANNEL.envvolstopped-2]
|
|
add edi,FMUSIC_INSTRUMENT.VOLPoints-FMUSIC_INSTRUMENT.PANPoints
|
|
pan_or_vol_ok:
|
|
endif
|
|
cmp BYTE PTR [eax],dh
|
|
jne goto_envelope_ret
|
|
push ecx ; -> env_type
|
|
push eax ; -> envstopped
|
|
lea ecx,[esi+ebx+FMUSIC_CHANNEL.envpanpos-2]
|
|
lea eax,[esi+ebx+FMUSIC_CHANNEL.envpandelta-2]
|
|
push eax ; -> envdelta
|
|
lea eax,[esi+ebx+FMUSIC_CHANNEL.envpan-2]
|
|
push eax ; -> env_value
|
|
lea eax,[esi+ebx+FMUSIC_CHANNEL.envpanfrac-2]
|
|
lea ebx,[esi+ebx+FMUSIC_CHANNEL.envpantick-2]
|
|
push eax ; -> valfrac
|
|
mov eax,[ecx]
|
|
cmp eax,edx ; if(*pos>=numpoints) envelop out of bound
|
|
push ebx ; -> env_tick
|
|
jge envelope_done
|
|
movzx eax,WORD PTR [edi+eax*4]
|
|
cmp [ebx],eax ; if(*tick == points[(*pos)<<1]) we are at the correct tick for the position
|
|
jnz add_envdelta
|
|
test BYTE PTR [ebp+env_type],FMUSIC_ENVELOPE_LOOP
|
|
jz loop_ok
|
|
movzx eax,BYTE PTR [ebp+sustain_l2]
|
|
cmp [ecx],eax
|
|
jnz loop_ok ; if((type&FMUSIC_ENVELOPE_LOOP) && *pos == loopend) handle loop
|
|
movzx eax,BYTE PTR [ebp+sustain_l1]
|
|
mov [ecx],eax ; *pos = loopstart
|
|
movzx eax,WORD PTR [edi+eax*4]
|
|
mov [ebx],eax ; *tick = points[(*pos)<<1]
|
|
loop_ok:
|
|
mov eax,[ecx]
|
|
mov [ebp+env_pos],eax
|
|
lea eax,[edi+eax*4]
|
|
dec edx
|
|
movzx ebx,WORD PTR [eax] ; get tick at this point
|
|
cmp [ecx],edx
|
|
mov edx,[eax+4]
|
|
mov edi,edx
|
|
movzx eax,WORD PTR [eax+2]
|
|
mov [ebp+env_next],edx ; get tick at next point
|
|
mov edx,[ebp+env_value]
|
|
mov [edx],eax ; *value = points[(currpos<<1)+1]
|
|
jne env_continue
|
|
; if it is at the last position, abort the envelope and continue last value
|
|
mov eax,[ebp+envstopped]
|
|
inc BYTE PTR [eax] ; *envstopped = TRUE
|
|
goto_envelope_ret:
|
|
jmp Envelope_Ret
|
|
env_continue:
|
|
shl eax,16
|
|
sub edi,eax
|
|
xchg eax,edi
|
|
xor ax,ax
|
|
; sustain
|
|
test BYTE PTR [ebp+env_type],FMUSIC_ENVELOPE_SUSTAIN
|
|
jz not_sustain
|
|
movzx edx,BYTE PTR [ebp+sustain_loop]
|
|
cmp [ebp+env_pos],edx
|
|
jne not_sustain
|
|
cmp BYTE PTR [esi+FMUSIC_CHANNEL.keyoff-2],al
|
|
je Envelope_Ret
|
|
not_sustain:
|
|
; interpolate 2 points to find delta step
|
|
inc DWORD PTR [ecx] ; (*pos)++
|
|
mov ecx,[ebp+valfrac]
|
|
mov [ecx],edi ; *valfrac = curr
|
|
mov edi,[ebp+envdelta]
|
|
movzx ecx,WORD PTR [ebp+env_next]
|
|
and DWORD PTR [edi],0 ; *envdelta = 0
|
|
sub ecx,ebx
|
|
jz envelope_done
|
|
cdq
|
|
idiv ecx
|
|
mov [edi],eax ; *envdelta = (next-curr)/(nexttick-currtick)
|
|
jmp envelope_done
|
|
add_envdelta:
|
|
; interpolate
|
|
mov eax,[ebp+envdelta]
|
|
mov ecx,[eax]
|
|
mov eax,[ebp+valfrac]
|
|
add [eax],ecx ; *valfrac += *envdelta
|
|
envelope_done:
|
|
pop edx ; <- env_tick
|
|
pop eax ; <- valfrac
|
|
pop ecx ; <- env_value
|
|
mov eax,[eax]
|
|
inc DWORD PTR [edx] ; (*tick)++
|
|
sar eax,16
|
|
mov [ecx],eax ; *value = *valfrac >> 16
|
|
Envelope_Ret:
|
|
leave
|
|
pop ebx
|
|
pop edi
|
|
ret
|
|
endif ; VOLUME_OR_PANENVELOPE
|
|
|
|
if VOLUMEBYTE_ON
|
|
VolByte:
|
|
; volume = EDX
|
|
; cptr+2 = ESI
|
|
sub edx,16
|
|
jb switch_volume
|
|
cmp edx,40h
|
|
ja switch_volume
|
|
; if(volume >= 0x10 && volume <= 0x50)
|
|
mov [esi+FMUSIC_CHANNEL.volume-2],edx
|
|
switch_volume:
|
|
mov eax,edx
|
|
and edx,0Fh
|
|
shr eax,4 ; switch(volume>>4)
|
|
sub eax,5
|
|
jz case_6
|
|
dec eax
|
|
jz case_7
|
|
dec eax
|
|
jz case_6
|
|
dec eax
|
|
jz case_7
|
|
sub eax,2
|
|
jbe case_AB
|
|
dec eax
|
|
jz case_C
|
|
dec eax
|
|
jz case_D
|
|
dec eax
|
|
jz case_E
|
|
dec eax
|
|
jnz vol_default
|
|
; case 0xF
|
|
test edx,edx
|
|
jz vol_z
|
|
shl dl,4
|
|
mov [esi+FMUSIC_CHANNEL.portaspeed-2],dl
|
|
vol_z:
|
|
and BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],NOT_FMUSIC_TRIGGER
|
|
if PORTATO_OR_VOLSLIDE
|
|
mov eax,[esi+FMUSIC_CHANNEL.period-2]
|
|
mov [esi+FMUSIC_CHANNEL.portatarget-2],eax ; cptr->portatarget = cptr->period
|
|
endif
|
|
vol_default:
|
|
ret
|
|
case_6: ; / case 8
|
|
neg edx
|
|
case_7: ; / case 9
|
|
add [esi+FMUSIC_CHANNEL.volume-2],edx
|
|
ret
|
|
case_AB:
|
|
mov [esi+eax+FMUSIC_CHANNEL.vibspeed-1],dl
|
|
ret
|
|
case_C:
|
|
shl edx,4
|
|
mov [esi+FMUSIC_CHANNEL.pan-2],edx
|
|
xchg eax,edx
|
|
case_D:
|
|
neg edx
|
|
case_E:
|
|
add [esi+FMUSIC_CHANNEL.pan-2],edx
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_PAN
|
|
ret
|
|
endif ; VOLUMEBYTE_ON
|
|
|
|
if TREMOR_ON
|
|
Tremor:
|
|
; cptr+2 = ESI
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME
|
|
mov dx,WORD PTR [esi+FMUSIC_CHANNEL.tremorpos-2]
|
|
cmp dl,dh
|
|
jbe inc_pos
|
|
mov ecx,[esi+FMUSIC_CHANNEL.volume-2]
|
|
neg ecx
|
|
mov [esi+FMUSIC_CHANNEL.voldelta-2],ecx
|
|
inc_pos:
|
|
add dh,[esi+FMUSIC_CHANNEL.tremoroff-2]
|
|
cmp dl,dh
|
|
jbe Tremor_Ret
|
|
mov dl,-1
|
|
Tremor_Ret:
|
|
inc dl
|
|
mov [esi+FMUSIC_CHANNEL.tremorpos-2],dl
|
|
ret
|
|
endif ; TREMOR_ON
|
|
|
|
SetBPM:
|
|
; bpm = ECX
|
|
test ecx,ecx
|
|
mov eax,FSOUND_MixRate*5/2
|
|
jz SetBPM_Ret
|
|
cdq
|
|
div ecx
|
|
SetBPM_Ret:
|
|
mov DWORD PTR [_mod+FMUSIC_MODULE.mixer_samplespertick],eax
|
|
ret
|
|
|
|
; Loads an XM stream into memory. Returns non-zero on success.
|
|
LoadXM:
|
|
loadxm_count1 equ -4
|
|
loadxm_numpat equ -8
|
|
loadxm_fnumpat equ -12
|
|
loadxm_count2 equ -16
|
|
loadxm_skip equ -20
|
|
loadxm_s0loopmode equ -38
|
|
loadxm_s0bytes equ -42
|
|
loadxm_s0looplen equ -48
|
|
loadxm_s0loopstart equ -52
|
|
loadxm_sample_2 equ -56
|
|
loadxm_pat_size equ -63
|
|
loadxm_pat equ -68
|
|
loadxm_tmp29 equ -91
|
|
loadxm_tmp27 equ -93
|
|
loadxm_tmp equ -120
|
|
mov eax,OFFSET _mod
|
|
push ebp
|
|
mov esi,eax
|
|
mov ebp,esp
|
|
mov edx,FMUSIC_MODULE_size
|
|
; buf : EAX
|
|
; size : EDX
|
|
call [uFMOD_fread]
|
|
xor ecx,ecx
|
|
mov eax,[esi+FMUSIC_MODULE.mixer_samplespertick]
|
|
push ecx ; -> loadxm_count1
|
|
; GOTO PATTERN DATA
|
|
lea eax,[eax+60]
|
|
; pos : EAX
|
|
; org : ECX
|
|
; !org : Z
|
|
call uFMOD_lseek
|
|
add esp,-116
|
|
push ebx
|
|
; SAVE TRACK TITLE
|
|
if INFO_API_ON
|
|
push 20 ; a title has max. 20 chars
|
|
lea edx,[esi+17]
|
|
mov edi,OFFSET szTtl
|
|
if UCODE
|
|
xor eax,eax
|
|
endif
|
|
pop ecx
|
|
loadxm_ttl:
|
|
mov al,[edx]
|
|
inc edx
|
|
cmp al,20h ; copy only printable chars
|
|
jl loadxm_ttl_ok
|
|
if UCODE
|
|
stosw
|
|
else
|
|
stosb
|
|
endif
|
|
loadxm_ttl_ok:
|
|
dec ecx
|
|
jnz loadxm_ttl
|
|
xchg eax,ecx
|
|
stosd
|
|
else
|
|
xor eax,eax
|
|
endif
|
|
; COUNT NUM. OF PATTERNS
|
|
movzx ecx,WORD PTR [esi+FMUSIC_MODULE.numorders]
|
|
movzx ebx,WORD PTR [esi+FMUSIC_MODULE.numpatternsmem]
|
|
neg ebx
|
|
mov edi,esi
|
|
sbb edx,edx
|
|
and ecx,edx
|
|
neg ebx
|
|
dec ecx
|
|
movzx edx,dl
|
|
mov [ebp+loadxm_fnumpat],ebx
|
|
if CHK4VALIDITY
|
|
cmp ecx,edx
|
|
ja loadxm_R
|
|
endif
|
|
loadxm_for_pats:
|
|
mov dl,[esi+FMUSIC_MODULE.orderlist]
|
|
cmp edx,eax
|
|
jbe loadxm_for_continue
|
|
xchg eax,edx
|
|
loadxm_for_continue:
|
|
inc esi
|
|
dec ecx
|
|
jns loadxm_for_pats
|
|
mov [ebp+loadxm_numpat],eax
|
|
inc eax
|
|
mov esi,edi
|
|
; ALLOCATE THE PATTERN ARRAY (whatever is bigger: fnumpat or numpat) & CHANNEL POOL
|
|
cmp eax,ebx
|
|
jae loadxm_pats_ok2
|
|
xchg eax,ebx
|
|
loadxm_pats_ok2:
|
|
movzx ecx,BYTE PTR [esi+FMUSIC_MODULE.numinsts]
|
|
imul ecx,FMUSIC_INSTRUMENT_size
|
|
mov [esi+FMUSIC_MODULE.numpatternsmem],ax
|
|
lea edi,[ecx+eax*FMUSIC_PATTERN_size]
|
|
mov eax,edi
|
|
sub edi,ecx
|
|
movzx ecx,BYTE PTR [esi+FMUSIC_MODULE.numchannels_xm]
|
|
if CHK4VALIDITY
|
|
cmp ecx,64
|
|
jle loadxm_numchan_ok
|
|
xor ecx,ecx
|
|
loadxm_numchan_ok:
|
|
endif
|
|
mov [esi+FMUSIC_MODULE.numchannels],ecx
|
|
mov ebx,ecx
|
|
shl ebx,7 ; *FSOUND_CHANNEL_size*2 == *FMUSIC_CHANNEL_size
|
|
if CHK4VALIDITY
|
|
jz loadxm_R
|
|
endif
|
|
mov [ebp+loadxm_count2],ecx
|
|
lea eax,[eax+ebx*2]
|
|
; numbytes : EAX
|
|
call alloc
|
|
lea edx,[eax+ebx]
|
|
mov [esi+FMUSIC_MODULE.Channels],eax
|
|
mov [esi+FMUSIC_MODULE.uFMOD_Ch],edx
|
|
mov ebx,FMUSIC_CHANNEL_size ; = FSOUND_CHANNEL_size*2
|
|
loop_2:
|
|
mov BYTE PTR [eax+FSOUND_CHANNEL.speedhi],1
|
|
mov [edx+FMUSIC_CHANNEL.cptr],eax
|
|
add eax,ebx
|
|
add edx,ebx
|
|
dec DWORD PTR [ebp+loadxm_count2]
|
|
jnz loop_2
|
|
mov [esi],edx ; FMUSIC_MODULE.pattern
|
|
add edi,edx
|
|
movzx ecx,WORD PTR [esi+FMUSIC_MODULE.defaultbpm]
|
|
mov [esi+FMUSIC_MODULE.instrument],edi
|
|
mov edi,edx
|
|
; bpm : ECX
|
|
call SetBPM
|
|
push 64
|
|
movzx ecx,WORD PTR [esi+FMUSIC_MODULE.defaultspeed]
|
|
pop DWORD PTR [esi+FMUSIC_MODULE.globalvolume]
|
|
mov [esi+FMUSIC_MODULE.speed],ecx
|
|
; ALLOCATE INSTRUMENT ARRAY
|
|
mov eax,[ebp+loadxm_fnumpat]
|
|
; READ & UNPACK PATTERNS
|
|
loadxm_load_pats:
|
|
push 9
|
|
lea eax,[ebp+loadxm_pat]
|
|
pop edx
|
|
; buf : EAX
|
|
; size : EDX
|
|
call [uFMOD_fread]
|
|
; ALLOCATE PATTERN BUFFER
|
|
mov eax,[ebp+loadxm_pat_size] ; length of pattern & packed pattern size
|
|
mov ecx,[esi+FMUSIC_MODULE.numchannels]
|
|
cmp eax,10000h
|
|
mov [edi],eax
|
|
movzx eax,ax
|
|
jb loadxm_ldpats_continue ; skip an empty pattern
|
|
if CHK4VALIDITY
|
|
cmp eax,257
|
|
sbb edx,edx
|
|
and eax,edx
|
|
jz loadxm_R
|
|
endif
|
|
mul ecx
|
|
mov [ebp+loadxm_count2],eax
|
|
lea eax,[eax+eax*4] ; x SIZE FMUSIC_NOTE
|
|
; numbytes : EAX
|
|
call alloc
|
|
mov [edi+FMUSIC_PATTERN.data],eax
|
|
xchg eax,ebx
|
|
loadxm_for_rowsxchan:
|
|
push esi
|
|
mov esi,[uFMOD_fread]
|
|
xor edx,edx
|
|
lea eax,[ebp+loadxm_skip]
|
|
inc edx
|
|
; buf : EAX
|
|
; size : EDX
|
|
call esi ; uFMOD_fread
|
|
movzx edx,BYTE PTR [ebp+loadxm_skip]
|
|
test dl,80h
|
|
jz loadxm_noskip
|
|
and edx,1
|
|
jz loadxm_nonote
|
|
mov eax,ebx ; &nptr->note
|
|
; buf : EAX
|
|
; size : EDX
|
|
call esi ; uFMOD_fread
|
|
loadxm_nonote:
|
|
test BYTE PTR [ebp+loadxm_skip],2
|
|
jz loadxm_nonumber
|
|
xor edx,edx
|
|
lea eax,[ebx+1] ; &nptr->number
|
|
inc edx
|
|
; buf : EAX
|
|
; size : EDX
|
|
call esi ; uFMOD_fread
|
|
loadxm_nonumber:
|
|
test BYTE PTR [ebp+loadxm_skip],4
|
|
jz loadxm_novolume
|
|
xor edx,edx
|
|
lea eax,[ebx+2] ; &nptr->volume
|
|
inc edx
|
|
; buf : EAX
|
|
; size : EDX
|
|
call esi ; uFMOD_fread
|
|
loadxm_novolume:
|
|
test BYTE PTR [ebp+loadxm_skip],8
|
|
jz loadxm_noeffect
|
|
xor edx,edx
|
|
lea eax,[ebx+3] ; &nptr->effect
|
|
inc edx
|
|
; buf : EAX
|
|
; size : EDX
|
|
call esi ; uFMOD_fread
|
|
loadxm_noeffect:
|
|
test BYTE PTR [ebp+loadxm_skip],16
|
|
jz loadxm_isnote97
|
|
xor edx,edx
|
|
lea eax,[ebx+4] ; &nptr->eparam
|
|
inc edx
|
|
jmp loadxm_skip_read
|
|
loadxm_noskip:
|
|
test edx,edx
|
|
jz loadxm_skip_z
|
|
mov [ebx],dl
|
|
loadxm_skip_z:
|
|
lea eax,[ebx+1]
|
|
mov dl,4
|
|
loadxm_skip_read:
|
|
; buf : EAX
|
|
; size : EDX
|
|
call esi ; uFMOD_fread
|
|
loadxm_isnote97:
|
|
pop esi
|
|
inc ebx
|
|
mov dl,BYTE PTR [esi+FMUSIC_MODULE.numinsts]
|
|
cmp [ebx],dl
|
|
jbe loadxm_number_ok
|
|
mov BYTE PTR [ebx],0
|
|
loadxm_number_ok:
|
|
add ebx,4
|
|
dec DWORD PTR [ebp+loadxm_count2]
|
|
jnz loadxm_for_rowsxchan
|
|
loadxm_ldpats_continue:
|
|
inc DWORD PTR [ebp+loadxm_count1]
|
|
mov eax,[ebp+loadxm_fnumpat]
|
|
add edi,8
|
|
cmp eax,[ebp+loadxm_count1]
|
|
ja loadxm_load_pats
|
|
; allocate and clean out any extra patterns
|
|
mov ecx,[ebp+loadxm_numpat]
|
|
cmp ecx,eax
|
|
jb loadxm_extrapats_ok
|
|
mov ebx,[esi] ; FMUSIC_MODULE.pattern
|
|
mov eax,[esi+FMUSIC_MODULE.numchannels]
|
|
push esi
|
|
lea esi,[ebx+ecx*FMUSIC_PATTERN_size]
|
|
lea edi,[eax+eax*4]
|
|
shl edi,6 ; numchannels*64*SIZE FMUSIC_NOTE
|
|
loadxm_for_extrapats:
|
|
dec DWORD PTR [ebp+loadxm_numpat]
|
|
mov eax,edi
|
|
mov BYTE PTR [esi],64 ; pptr->rows = 64
|
|
; Allocate memory for pattern buffer
|
|
; numbytes : EAX
|
|
call alloc
|
|
mov [esi+FMUSIC_PATTERN.data],eax
|
|
sub esi,FMUSIC_PATTERN_size
|
|
mov eax,[ebp+loadxm_fnumpat]
|
|
cmp [ebp+loadxm_numpat],eax
|
|
jae loadxm_for_extrapats
|
|
pop esi
|
|
loadxm_extrapats_ok:
|
|
xor eax,eax
|
|
mov [esi+FMUSIC_MODULE.mixer_samplesleft],eax
|
|
mov [esi+FMUSIC_MODULE.tick],eax
|
|
if PATTERNDELAY_ON
|
|
lea edi,[esi+FMUSIC_MODULE.patterndelay]
|
|
stosd
|
|
else
|
|
lea edi,[esi+FMUSIC_MODULE.nextorder]
|
|
endif
|
|
stosd
|
|
stosd
|
|
; Load instrument information
|
|
mov al,BYTE PTR [esi+FMUSIC_MODULE.numinsts]
|
|
test al,al
|
|
jz loadxm_ret1
|
|
mov [ebp+loadxm_count1],al
|
|
mov ebx,[esi+FMUSIC_MODULE.instrument]
|
|
loadxm_for_instrs:
|
|
push 33
|
|
lea eax,[ebp+loadxm_tmp]
|
|
pop edx
|
|
; buf : EAX
|
|
; size : EDX
|
|
call [uFMOD_fread] ; instrument size & name
|
|
mov esi,[ebp+loadxm_tmp] ; firstsampleoffset = tmp[0]
|
|
mov dl,[ebp+loadxm_tmp27]
|
|
sub esi,33
|
|
test dl,dl
|
|
jz loadxm_inst_ok
|
|
if CHK4VALIDITY
|
|
xor eax,eax
|
|
cmp DWORD PTR [ebp+loadxm_tmp29],41
|
|
sbb ecx,ecx
|
|
not ecx
|
|
or edx,ecx
|
|
cmp dl,16
|
|
ja loadxm_R ; if(numsamples > 16) goto error
|
|
endif
|
|
mov edx,208
|
|
lea eax,[ebx+FMUSIC_INSTRUMENT.keymap]
|
|
sub esi,edx
|
|
; buf : EAX
|
|
; size : EDX
|
|
call [uFMOD_fread]
|
|
loadxm_inst_ok:
|
|
xor ecx,ecx
|
|
xchg eax,esi
|
|
inc ecx ; SEEK_CUR
|
|
; pos : EAX
|
|
; org : ECX
|
|
; !org : Z
|
|
call uFMOD_lseek
|
|
lea edx,[ebx+FMUSIC_INSTRUMENT.VOLfade]
|
|
xor eax,eax
|
|
mov cx,[edx]
|
|
shl ecx,1
|
|
cmp BYTE PTR [edx+FMUSIC_INSTRUMENT.VOLnumpoints-FMUSIC_INSTRUMENT.VOLfade],2
|
|
mov [edx],cx ; iptr->VOLfade *= 2
|
|
jnb ladxm_voltype_ok
|
|
mov BYTE PTR [edx+FMUSIC_INSTRUMENT.VOLtype-FMUSIC_INSTRUMENT.VOLfade],al
|
|
ladxm_voltype_ok:
|
|
cmp BYTE PTR [edx+FMUSIC_INSTRUMENT.PANnumpoints-FMUSIC_INSTRUMENT.VOLfade],2
|
|
jnb loadxm_PANtype_ok
|
|
mov BYTE PTR [edx+FMUSIC_INSTRUMENT.PANtype-FMUSIC_INSTRUMENT.VOLfade],al
|
|
loadxm_PANtype_ok:
|
|
cmp [ebp+loadxm_tmp27],al
|
|
je loadx_for_loadsamp_end
|
|
mov [ebp+loadxm_numpat],eax
|
|
mov [ebp+loadxm_fnumpat],ebx ; FMUSIC_INSTRUMENT.sample
|
|
loadxm_for_samp:
|
|
lea eax,[ebp+loadxm_sample_2]
|
|
mov edx,[ebp+loadxm_tmp29]
|
|
; buf : EAX
|
|
; size : EDX
|
|
call [uFMOD_fread]
|
|
mov esi,[ebp+loadxm_s0loopstart]
|
|
mov edi,[ebp+loadxm_s0looplen]
|
|
mov al,[ebp+loadxm_s0bytes]
|
|
mov ecx,eax
|
|
shr eax,4 ; sample[0].bytes >>= 4
|
|
and al,1 ; [b 4] : 8/16 bit sample data
|
|
mov [ebp+loadxm_s0bytes],al
|
|
jz loadxm_s0bytes_ok
|
|
shr DWORD PTR [ebp+loadxm_sample_2],1
|
|
shr esi,1
|
|
shr edi,1
|
|
loadxm_s0bytes_ok:
|
|
mov eax,[ebp+loadxm_sample_2]
|
|
cmp eax,esi
|
|
jg loadxm_loopstart_ok
|
|
mov esi,eax
|
|
loadxm_loopstart_ok:
|
|
lea edx,[esi+edi]
|
|
sub edx,eax
|
|
js loadxm_looplen_ok
|
|
sub edi,edx
|
|
loadxm_looplen_ok:
|
|
and ecx,3 ; [b 0-1] : loop type
|
|
jz loadxm_reset_sample
|
|
test edi,edi
|
|
jnz loadxm_s0loop_ok
|
|
loadxm_reset_sample:
|
|
xor esi,esi
|
|
xor ecx,ecx
|
|
mov edi,eax
|
|
loadxm_s0loop_ok:
|
|
mov [ebp+loadxm_s0loopstart],esi
|
|
mov [ebp+loadxm_s0looplen],edi
|
|
mov [ebp+loadxm_s0loopmode],cl
|
|
lea eax,[eax+eax+26] ; sample[0].length*2+SIZE FSOUND_SAMPLE+4
|
|
; numbytes : EAX
|
|
call alloc
|
|
mov ecx,[ebp+loadxm_fnumpat]
|
|
mov [ecx],eax
|
|
; memcpy(iptr->sample[count2],sample,sizeof(FSOUND_SAMPLE))
|
|
inc DWORD PTR [ebp+loadxm_numpat]
|
|
add DWORD PTR [ebp+loadxm_fnumpat],4
|
|
push 5
|
|
xchg eax,edi
|
|
mov eax,[ebp+loadxm_numpat]
|
|
pop ecx
|
|
cmp al,[ebp+loadxm_tmp27]
|
|
lea esi,[ebp+loadxm_sample_2]
|
|
rep movsd
|
|
jb loadxm_for_samp
|
|
; Load sample data
|
|
mov [ebp+loadxm_numpat],ecx
|
|
; ebx <- FMUSIC_INSTRUMENT.sample
|
|
loadx_for_loadsamp:
|
|
mov esi,[ebx+ecx*4]
|
|
xor eax,eax
|
|
mov edx,[esi]
|
|
mov ch,[esi+FSOUND_SAMPLE.Resved]
|
|
mov cl,[esi+FSOUND_SAMPLE.bytes]
|
|
if CHK4VALIDITY
|
|
test edx,0FFC00000h
|
|
jnz loadxm_R
|
|
endif
|
|
add esi,FSOUND_SAMPLE.buff
|
|
if ADPCM_ON
|
|
cmp ch,0ADh ; ModPlug 4-bit ADPCM
|
|
jne loadxm_regular_samp
|
|
inc edx
|
|
mov edi,esi
|
|
sar edx,1
|
|
push ebx
|
|
push edx
|
|
lea edx,[edx+edx*2]
|
|
add edi,edx ; ptr = buff+compressed_length*3
|
|
; Read in the compression table
|
|
lea edx,[eax+16] ; edx = 16
|
|
lea eax,[ebp+loadxm_sample_2]
|
|
mov ebx,eax
|
|
; buf : EAX
|
|
; size : EDX
|
|
call [uFMOD_fread]
|
|
; Read in the sample data
|
|
pop edx
|
|
mov eax,edi
|
|
; buf : EAX
|
|
; size : EDX
|
|
call [uFMOD_fread]
|
|
; Decompress sample data
|
|
mov edx,esi
|
|
xor ecx,ecx ; delta
|
|
loadxm_unpack_loop:
|
|
cmp edx,edi
|
|
jge loadxm_unpack_ok
|
|
mov al,[edi]
|
|
mov ah,al
|
|
and al,0Fh
|
|
xlatb
|
|
shr ah,4
|
|
inc edi
|
|
add ch,al
|
|
mov al,ah
|
|
xlatb
|
|
add al,ch
|
|
shl eax,24
|
|
or ecx,eax
|
|
mov [edx],ecx
|
|
shr ecx,16 ; ch <- delta
|
|
add edx,4
|
|
jmp loadxm_unpack_loop
|
|
loadxm_unpack_ok:
|
|
pop ebx
|
|
jmp loadxm_chk_loop_bidi
|
|
loadxm_regular_samp:
|
|
endif
|
|
shl edx,cl ; sptr->length << sptr->bytes
|
|
mov eax,esi
|
|
; buf : EAX
|
|
; size : EDX
|
|
call [uFMOD_fread]
|
|
mov ecx,DWORD PTR [esi+FSOUND_SAMPLE._length-FSOUND_SAMPLE.buff]
|
|
lea edi,[ecx+esi] ; buff = sptr->buff+sptr->length
|
|
lea eax,[edi+ecx] ; ptr = buff+sptr->length
|
|
xor edx,edx
|
|
cmp BYTE PTR [esi+FSOUND_SAMPLE.bytes-FSOUND_SAMPLE.buff],dl
|
|
jne loadxm_16bit_ok
|
|
; Promote to 16 bits
|
|
loadxm_to16bits:
|
|
dec eax
|
|
dec edi
|
|
dec eax
|
|
mov dh,[edi]
|
|
cmp eax,edi
|
|
mov [eax],dx
|
|
ja loadxm_to16bits
|
|
xor edx,edx
|
|
loadxm_16bit_ok:
|
|
mov eax,esi
|
|
; Do delta conversion
|
|
loadxm_do_delta_conv:
|
|
add dx,[eax]
|
|
mov [eax],dx
|
|
dec ecx
|
|
lea eax,[eax+2]
|
|
jg loadxm_do_delta_conv
|
|
js loadxm_loops_ok
|
|
loadxm_chk_loop_bidi:
|
|
mov eax,DWORD PTR [esi+FSOUND_SAMPLE.looplen-FSOUND_SAMPLE.buff]
|
|
mov ecx,DWORD PTR [esi+FSOUND_SAMPLE.loopstart-FSOUND_SAMPLE.buff]
|
|
add eax,ecx
|
|
cmp BYTE PTR [esi+FSOUND_SAMPLE.loopmode-FSOUND_SAMPLE.buff],2 ; LOOP_BIDI
|
|
lea eax,[esi+eax*2]
|
|
jnz loadxm_chk_loop_normal
|
|
mov cx,[eax-2]
|
|
jmp loadxm_fix_loop
|
|
loadxm_chk_loop_normal:
|
|
cmp BYTE PTR [esi+FSOUND_SAMPLE.loopmode-FSOUND_SAMPLE.buff],1 ; LOOP_NORMAL
|
|
jnz loadxm_loops_ok
|
|
mov cx,WORD PTR [esi+ecx*2]
|
|
loadxm_fix_loop:
|
|
mov [eax],cx
|
|
loadxm_loops_ok:
|
|
inc DWORD PTR [ebp+loadxm_numpat]
|
|
mov ecx,[ebp+loadxm_numpat]
|
|
cmp cl,[ebp+loadxm_tmp27]
|
|
jb loadx_for_loadsamp
|
|
loadx_for_loadsamp_end:
|
|
add ebx,FMUSIC_INSTRUMENT_size
|
|
dec BYTE PTR [ebp+loadxm_count1]
|
|
jnz loadxm_for_instrs
|
|
loadxm_ret1:
|
|
inc eax
|
|
loadxm_R:
|
|
pop ebx
|
|
donote_R:
|
|
leave
|
|
ret
|
|
|
|
DoNote:
|
|
; mod+36 = ESI
|
|
var_mod equ -4
|
|
donote_sptr equ -8
|
|
donote_jumpflag equ -10
|
|
donote_porta equ -12
|
|
donote_oldpan equ -16
|
|
donote_currtick equ -20
|
|
donote_oldfreq equ -24
|
|
donote_iptr equ -28
|
|
; Point our note pointer to the correct pattern buffer, and to the
|
|
; correct offset in this buffer indicated by row and number of channels
|
|
mov eax,[esi+FMUSIC_MODULE.order-36]
|
|
push ebp
|
|
movzx ebx,BYTE PTR [eax+esi+FMUSIC_MODULE.orderlist-36]
|
|
mov ebp,esp
|
|
mov eax,[esi+FMUSIC_MODULE.row-36]
|
|
lea ebx,[ecx+ebx*FMUSIC_PATTERN_size]
|
|
mov ecx,[esi+FMUSIC_MODULE.numchannels-36]
|
|
if PATTERNBREAK_ON
|
|
if PATTERNJUMP_ON
|
|
mov BYTE PTR [ebp+donote_jumpflag],ch
|
|
endif
|
|
endif
|
|
mul ecx
|
|
lea edi,[eax+eax*4] ; x SIZE FMUSIC_NOTE
|
|
push esi
|
|
add edi,[ebx+FMUSIC_PATTERN.data] ; mod->pattern[mod->orderlist[mod->order]].data+(mod->row*mod->numchannels)
|
|
sub esp,24
|
|
; Loop through each channel in the row
|
|
shl ecx,7 ; x FMUSIC_CHANNEL_size
|
|
jz donote_R
|
|
push esi
|
|
mov esi,[esi+FMUSIC_MODULE.uFMOD_Ch-36]
|
|
push ebx
|
|
inc esi
|
|
inc esi
|
|
add ecx,esi
|
|
donote_for_channels:
|
|
push ecx
|
|
mov bl,[edi+FMUSIC_NOTE.eparam]
|
|
mov al,[edi+FMUSIC_NOTE.effect]
|
|
and ebx,0Fh
|
|
cmp al,FMUSIC_XM_PORTATO
|
|
je donote_doporta
|
|
cmp al,FMUSIC_XM_PORTATOVOLSLIDE
|
|
donote_doporta:
|
|
setz [ebp+donote_porta]
|
|
; First store note and instrument number if there was one
|
|
mov cl,[edi+FMUSIC_NOTE.number]
|
|
jz donote_rem_note
|
|
dec cl
|
|
js donote_rem_inst
|
|
mov [esi+FMUSIC_CHANNEL.inst-2],cl ; remember the instrument #
|
|
donote_rem_inst:
|
|
mov cl,[edi] ; get current note
|
|
dec ecx
|
|
cmp cl,96
|
|
jae donote_rem_note
|
|
mov [esi+FMUSIC_CHANNEL.note-2],cl ; remember the note
|
|
donote_rem_note:
|
|
movzx ecx,BYTE PTR [esi+FMUSIC_CHANNEL.inst-2]
|
|
mov eax,[ebp+var_mod]
|
|
imul ecx,FMUSIC_INSTRUMENT_size
|
|
add ecx,[eax+FMUSIC_MODULE.instrument-36]
|
|
movzx eax,BYTE PTR [esi+FMUSIC_CHANNEL.note-2]
|
|
cdq
|
|
mov al,[eax+ecx+FMUSIC_INSTRUMENT.keymap]
|
|
cmp al,16
|
|
mov [ebp+donote_iptr],ecx
|
|
jae donote_set_sptr
|
|
mov edx,[ecx+eax*4+FMUSIC_INSTRUMENT.sample]
|
|
donote_set_sptr:
|
|
test edx,edx
|
|
jnz donote_valid_sptr
|
|
mov edx,OFFSET DummySamp
|
|
donote_valid_sptr:
|
|
mov [ebp+donote_sptr],edx
|
|
if NOTEDELAY_ON
|
|
mov ecx,[esi+FMUSIC_CHANNEL.freq-2]
|
|
mov eax,[esi+FMUSIC_CHANNEL.volume-2]
|
|
mov [ebp+donote_oldfreq],ecx
|
|
mov ecx,[esi+FMUSIC_CHANNEL.pan-2]
|
|
mov [ebp+donote_currtick],eax
|
|
mov [ebp+donote_oldpan],ecx
|
|
endif
|
|
if TREMOLO_ON
|
|
; if there is no more tremolo, set volume to volume + last tremolo delta
|
|
mov al,[edi+FMUSIC_NOTE.effect]
|
|
cmp al,FMUSIC_XM_TREMOLO
|
|
je donote_tremolo_vol
|
|
cmp BYTE PTR [esi+FMUSIC_CHANNEL.recenteffect-2],FMUSIC_XM_TREMOLO
|
|
jne donote_tremolo_vol
|
|
mov ecx,[esi+FMUSIC_CHANNEL.voldelta-2]
|
|
add [esi+FMUSIC_CHANNEL.volume-2],ecx
|
|
donote_tremolo_vol:
|
|
mov [esi+FMUSIC_CHANNEL.recenteffect-2],al
|
|
endif
|
|
xor ecx,ecx
|
|
mov [esi+FMUSIC_CHANNEL.voldelta-2],ecx
|
|
mov [esi+FMUSIC_CHANNEL.freqdelta-2],ecx
|
|
mov BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME_OR_FREQ
|
|
; PROCESS NOTE
|
|
mov cl,[edi] ; note
|
|
dec ecx
|
|
cmp cl,96
|
|
jae donote_note_ok
|
|
; get note according to relative note
|
|
movsx eax,BYTE PTR [edx+FSOUND_SAMPLE.relative]
|
|
add ecx,eax
|
|
mov eax,[ebp+var_mod]
|
|
mov [esi+FMUSIC_CHANNEL.realnote-2],cl
|
|
; Get period according to realnote and finetune
|
|
test BYTE PTR [eax+FMUSIC_MODULE.flags-36],1
|
|
je donote_flagsn1
|
|
mov eax,[ebp+donote_sptr]
|
|
movsx eax,BYTE PTR [eax+FSOUND_SAMPLE.finetune]
|
|
cdq
|
|
shl ecx,6
|
|
sub eax,edx
|
|
sar eax,1
|
|
lea eax,[ecx+eax-7680]
|
|
neg eax
|
|
if AMIGAPERIODS_ON
|
|
jmp donote_chk_porta
|
|
donote_flagsn1:
|
|
xchg eax,ecx ; note : EAX
|
|
mov ecx,[ebp+donote_sptr] ; [sptr] : ECX
|
|
; ESI != 0
|
|
call AmigaPeriod
|
|
donote_chk_porta:
|
|
mov [esi+FMUSIC_CHANNEL.period-2],eax
|
|
else
|
|
mov [esi+FMUSIC_CHANNEL.period-2],eax
|
|
donote_flagsn1:
|
|
mov eax,[esi+FMUSIC_CHANNEL.period-2]
|
|
endif
|
|
; Frequency only changes if there are no portamento effects
|
|
cmp BYTE PTR [ebp+donote_porta],0
|
|
jne donote_freq_ok
|
|
mov [esi+FMUSIC_CHANNEL.freq-2],eax
|
|
donote_freq_ok:
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_TRIGGER
|
|
donote_note_ok:
|
|
; PROCESS INSTRUMENT NUMBER
|
|
cmp BYTE PTR [edi+FMUSIC_NOTE.number],0
|
|
je donote_zcptr_ok
|
|
mov eax,[ebp+donote_sptr]
|
|
; DESCRIPTION: Reset current channel
|
|
push edi
|
|
push 9
|
|
movzx ecx,BYTE PTR [eax+FSOUND_SAMPLE.defvol]
|
|
mov [esi+FMUSIC_CHANNEL.volume-2],ecx
|
|
pop ecx
|
|
movzx eax,BYTE PTR [eax+FSOUND_SAMPLE.defpan]
|
|
mov [esi+FMUSIC_CHANNEL.pan-2],eax
|
|
push 64
|
|
xor eax,eax
|
|
pop DWORD PTR [esi+FMUSIC_CHANNEL.envvol-2]
|
|
push 32
|
|
lea edi,[esi+FMUSIC_CHANNEL.envvoltick-2]
|
|
pop DWORD PTR [esi+FMUSIC_CHANNEL.envpan-2]
|
|
mov DWORD PTR [esi+FMUSIC_CHANNEL.fadeoutvol-2],65536
|
|
; memset(&cptr->envvoltick,0,36)
|
|
rep stosd
|
|
; Retrigger tremolo and vibrato waveforms
|
|
mov cl,[esi+FMUSIC_CHANNEL.wavecontrol-2]
|
|
pop edi
|
|
cmp cl,4Fh
|
|
jge z_tremolopos_ok
|
|
mov BYTE PTR [esi+FMUSIC_CHANNEL.tremolopos-2],al ; = 0
|
|
z_tremolopos_ok:
|
|
test cl,0Ch
|
|
jnz z_vibpos_ok
|
|
mov BYTE PTR [esi+FMUSIC_CHANNEL.vibpos-2],al ; = 0
|
|
z_vibpos_ok:
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME_OR_PAN
|
|
donote_zcptr_ok:
|
|
if VOLUMEBYTE_ON
|
|
; PROCESS VOLUME BYTE
|
|
movzx edx,BYTE PTR [edi+FMUSIC_NOTE.uvolume]
|
|
; volume : EDX
|
|
; cptr+2 : ESI
|
|
call VolByte
|
|
endif
|
|
; PROCESS KEY OFF
|
|
cmp BYTE PTR [edi],97 ; note
|
|
jae donote_set_keyoff
|
|
cmp BYTE PTR [edi+FMUSIC_NOTE.effect],FMUSIC_XM_KEYOFF
|
|
jne donote_keyoff_ok
|
|
donote_set_keyoff:
|
|
inc BYTE PTR [esi+FMUSIC_CHANNEL.keyoff-2]
|
|
donote_keyoff_ok:
|
|
; PROCESS ENVELOPES
|
|
if VOLUMEENVELOPE_ON
|
|
mov ecx,[ebp+donote_iptr]
|
|
test BYTE PTR [ecx+FMUSIC_INSTRUMENT.VOLtype],1
|
|
jz donote_no_voltype
|
|
mov al,FMUSIC_VOLUME
|
|
; cptr+2 : ESI
|
|
; env_iptr : ECX
|
|
; control : AL
|
|
call Envelope
|
|
jmp donote_volenv_ok
|
|
donote_no_voltype:
|
|
endif
|
|
cmp BYTE PTR [esi+FMUSIC_CHANNEL.keyoff-2],0
|
|
je donote_volenv_ok
|
|
and DWORD PTR [esi+FMUSIC_CHANNEL.envvol-2],0
|
|
donote_volenv_ok:
|
|
if PANENVELOPE_ON
|
|
mov ecx,[ebp+donote_iptr]
|
|
test BYTE PTR [ecx+FMUSIC_INSTRUMENT.PANtype],1
|
|
je donote_no_pantype
|
|
mov al,FMUSIC_PAN
|
|
; cptr+2 : ESI
|
|
; env_iptr : ECX
|
|
; control : AL
|
|
call Envelope
|
|
donote_no_pantype:
|
|
endif
|
|
; PROCESS VOLUME FADEOUT
|
|
cmp BYTE PTR [esi+FMUSIC_CHANNEL.keyoff-2],0
|
|
mov ecx,[ebp+donote_iptr]
|
|
je donote_fadevol_ok
|
|
movzx eax,WORD PTR [ecx+FMUSIC_INSTRUMENT.VOLfade]
|
|
sub [esi+FMUSIC_CHANNEL.fadeoutvol-2],eax
|
|
jns donote_fadevol_ok
|
|
and DWORD PTR [esi+FMUSIC_CHANNEL.fadeoutvol-2],0
|
|
donote_fadevol_ok:
|
|
; PROCESS TICK 0 EFFECTS
|
|
movzx eax,BYTE PTR [edi+FMUSIC_NOTE.effect]
|
|
dec eax ; skip FMUSIC_XM_ARPEGGIO
|
|
movzx edx,BYTE PTR [edi+FMUSIC_NOTE.eparam]
|
|
if EXTRAFINEPORTA_ON
|
|
cmp al,32
|
|
else
|
|
if TREMOR_ON
|
|
cmp al,28
|
|
else
|
|
if MULTIRETRIG_ON
|
|
cmp al,26
|
|
else
|
|
if PANSLIDE_ON
|
|
cmp al,24
|
|
else
|
|
if SETENVELOPEPOS_ON
|
|
cmp al,20
|
|
else
|
|
if GLOBALVOLSLIDE_ON
|
|
cmp al,16
|
|
else
|
|
if SETGLOBALVOLUME_ON
|
|
cmp al,15
|
|
else
|
|
if SETSPEED_ON
|
|
cmp al,14
|
|
else
|
|
cmp al,13
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
ja donote_s1_brk
|
|
test edx,edx
|
|
call DWORD PTR [eax*4+S1_TBL]
|
|
donote_s1_brk:
|
|
if INSTRUMENTVIBRATO_ON
|
|
push DWORD PTR [ebp+donote_iptr]
|
|
endif
|
|
push DWORD PTR [ebp+donote_sptr]
|
|
; cptr+2 : ESI
|
|
call DoFlags
|
|
sub esi,-(FMUSIC_CHANNEL_size)
|
|
pop ecx
|
|
add edi,FMUSIC_NOTE_size
|
|
cmp esi,ecx
|
|
jl donote_for_channels
|
|
pop ebx
|
|
pop esi
|
|
leave
|
|
S1_r:
|
|
ret
|
|
S1_TBL:
|
|
if PORTAUP_OR_DOWN_ON
|
|
dd S1_C1
|
|
dd S1_C1
|
|
else
|
|
dd S1_r
|
|
dd S1_r
|
|
endif
|
|
if PORTATO_ON
|
|
dd S1_C3
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if VIBRATO_ON
|
|
dd S1_C4
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if PORTATOVOLSLIDE_ON
|
|
dd S1_C5
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if VIBRATOVOLSLIDE_ON
|
|
dd S1_C6
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if TREMOLO_ON
|
|
dd S1_C7
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if SETPANPOSITION_ON
|
|
dd S1_C8
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if SETSAMPLEOFFSET_ON
|
|
dd S1_C9
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if VOLUMESLIDE_ON
|
|
dd S1_C10
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if PATTERNJUMP_ON
|
|
dd S1_C11
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if SETVOLUME_ON
|
|
dd S1_C12
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if PATTERNBREAK_ON
|
|
dd S1_C13
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_C14
|
|
if EXTRAFINEPORTA_ON
|
|
if SETSPEED_ON
|
|
dd S1_C15
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if SETGLOBALVOLUME_ON
|
|
dd S1_C16
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if GLOBALVOLSLIDE_ON
|
|
dd S1_C17
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r ; unassigned effect ordinal [18]
|
|
dd S1_r ; unassigned effect ordinal [19]
|
|
dd S1_r ; skip FMUSIC_XM_KEYOFF
|
|
if SETENVELOPEPOS_ON
|
|
dd S1_C21
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r ; unassigned effect ordinal [22]
|
|
dd S1_r ; unassigned effect ordinal [23]
|
|
dd S1_r ; unassigned effect ordinal [24]
|
|
if PANSLIDE_ON
|
|
dd S1_C25
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r ; unassigned effect ordinal [26]
|
|
if MULTIRETRIG_ON
|
|
dd S1_C27
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r ; unassigned effect ordinal [28]
|
|
if TREMOR_ON
|
|
dd S1_C29
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r ; unassigned effect ordinal [30]
|
|
dd S1_r ; unassigned effect ordinal [31]
|
|
dd S1_r ; unassigned effect ordinal [32]
|
|
dd S1_C33
|
|
else
|
|
if TREMOR_ON
|
|
if SETSPEED_ON
|
|
dd S1_C15
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if SETGLOBALVOLUME_ON
|
|
dd S1_C16
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if GLOBALVOLSLIDE_ON
|
|
dd S1_C17
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r
|
|
dd S1_r
|
|
dd S1_r
|
|
if SETENVELOPEPOS_ON
|
|
dd S1_C21
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r
|
|
dd S1_r
|
|
dd S1_r
|
|
if PANSLIDE_ON
|
|
dd S1_C25
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r
|
|
if MULTIRETRIG_ON
|
|
dd S1_C27
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r
|
|
dd S1_C29
|
|
else
|
|
if MULTIRETRIG_ON
|
|
if SETSPEED_ON
|
|
dd S1_C15
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if SETGLOBALVOLUME_ON
|
|
dd S1_C16
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if GLOBALVOLSLIDE_ON
|
|
dd S1_C17
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r
|
|
dd S1_r
|
|
dd S1_r
|
|
if SETENVELOPEPOS_ON
|
|
dd S1_C21
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r
|
|
dd S1_r
|
|
dd S1_r
|
|
if PANSLIDE_ON
|
|
dd S1_C25
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r
|
|
dd S1_C27
|
|
else
|
|
if PANSLIDE_ON
|
|
if SETSPEED_ON
|
|
dd S1_C15
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if SETGLOBALVOLUME_ON
|
|
dd S1_C16
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if GLOBALVOLSLIDE_ON
|
|
dd S1_C17
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r
|
|
dd S1_r
|
|
dd S1_r
|
|
if SETENVELOPEPOS_ON
|
|
dd S1_C21
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r
|
|
dd S1_r
|
|
dd S1_r
|
|
dd S1_C25
|
|
else
|
|
if SETENVELOPEPOS_ON
|
|
if SETSPEED_ON
|
|
dd S1_C15
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if SETGLOBALVOLUME_ON
|
|
dd S1_C16
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if GLOBALVOLSLIDE_ON
|
|
dd S1_C17
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_r
|
|
dd S1_r
|
|
dd S1_r
|
|
dd S1_C21
|
|
else
|
|
if GLOBALVOLSLIDE_ON
|
|
if SETSPEED_ON
|
|
dd S1_C15
|
|
else
|
|
dd S1_r
|
|
endif
|
|
if SETGLOBALVOLUME_ON
|
|
dd S1_C16
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_C17
|
|
else
|
|
if SETGLOBALVOLUME_ON
|
|
if SETSPEED_ON
|
|
dd S1_C15
|
|
else
|
|
dd S1_r
|
|
endif
|
|
dd S1_C16
|
|
else
|
|
if SETSPEED_ON
|
|
dd S1_C15
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
if PORTAUP_OR_DOWN_ON
|
|
S1_C1:
|
|
jz donote_xm_porta_end
|
|
mov [esi+FMUSIC_CHANNEL.portaupdown-2],dl
|
|
donote_xm_porta_end:
|
|
ret
|
|
endif
|
|
if PORTATO_ON
|
|
S1_C3:
|
|
jz donote_xm_portato_end
|
|
mov [esi+FMUSIC_CHANNEL.portaspeed-2],dl
|
|
donote_xm_portato_end:
|
|
if PORTATOVOLSLIDE_ON
|
|
jmp donote_xm_portavolsl_end
|
|
else
|
|
mov eax,[esi+FMUSIC_CHANNEL.period-2]
|
|
and BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],NOT_FMUSIC_TRIGGER_OR_FRQ
|
|
mov [esi+FMUSIC_CHANNEL.portatarget-2],eax
|
|
ret
|
|
endif
|
|
endif
|
|
if PORTATOVOLSLIDE_ON
|
|
S1_C5:
|
|
jz donote_xm_portavolsl_end
|
|
mov [esi+FMUSIC_CHANNEL.volslide-2],dl
|
|
donote_xm_portavolsl_end:
|
|
mov eax,[esi+FMUSIC_CHANNEL.period-2]
|
|
and BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],NOT_FMUSIC_TRIGGER_OR_FRQ
|
|
mov [esi+FMUSIC_CHANNEL.portatarget-2],eax
|
|
ret
|
|
endif
|
|
if VIBRATO_ON
|
|
S1_C4:
|
|
shr edx,4
|
|
jz donote_vib_x_ok
|
|
mov [esi+FMUSIC_CHANNEL.vibspeed-2],dl
|
|
donote_vib_x_ok:
|
|
test ebx,ebx
|
|
jz donote_vib_y_ok
|
|
mov BYTE PTR [esi+FMUSIC_CHANNEL.vibdepth-2],bl
|
|
donote_vib_y_ok:
|
|
if VIBRATOVOLSLIDE_ON
|
|
xor eax,eax
|
|
else
|
|
; cptr+2 : ESI
|
|
jmp Vibrato
|
|
endif
|
|
endif
|
|
if VIBRATOVOLSLIDE_ON
|
|
S1_C6:
|
|
jz donote_xm_vibvolsl_end
|
|
mov [esi+FMUSIC_CHANNEL.volslide-2],dl
|
|
donote_xm_vibvolsl_end:
|
|
; cptr+2 : ESI
|
|
jmp Vibrato
|
|
endif
|
|
if TREMOLO_ON
|
|
S1_C7:
|
|
shr edx,4
|
|
jz donote_trem_x_ok
|
|
mov [esi+FMUSIC_CHANNEL.tremolospeed-2],dl
|
|
donote_trem_x_ok:
|
|
test ebx,ebx
|
|
jz donote_trem_y_ok
|
|
mov [esi+FMUSIC_CHANNEL.tremolodepth-2],bl
|
|
donote_trem_y_ok:
|
|
ret
|
|
endif
|
|
if SETPANPOSITION_ON
|
|
if PANSLIDE_ON
|
|
else
|
|
S1_C8:
|
|
mov [esi+FMUSIC_CHANNEL.pan-2],edx
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_PAN
|
|
ret
|
|
endif
|
|
endif
|
|
if SETSAMPLEOFFSET_ON
|
|
S1_C9:
|
|
shl edx,8
|
|
jz donote_soffset_ok
|
|
mov [esi+FMUSIC_CHANNEL.sampleoffset-2],edx
|
|
donote_soffset_ok:
|
|
mov ecx,[ebp+donote_sptr]
|
|
mov edx,[ecx+FSOUND_SAMPLE.loopstart]
|
|
add edx,[ecx+FSOUND_SAMPLE.looplen]
|
|
mov eax,[esi+FMUSIC_CHANNEL.sampleoffset-2]
|
|
cmp eax,edx
|
|
mov ecx,[esi+FMUSIC_CHANNEL.cptr-2]
|
|
jb donote_set_offset
|
|
xor eax,eax
|
|
and BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],NOT_FMUSIC_TRIGGER
|
|
mov [ecx+FSOUND_CHANNEL.mixpos],eax
|
|
mov [ecx+FSOUND_CHANNEL.mixposlo],eax
|
|
donote_set_offset:
|
|
mov [ecx+FSOUND_CHANNEL.fsampleoffset],eax
|
|
ret
|
|
endif
|
|
if VOLUMESLIDE_ON
|
|
S1_C10:
|
|
jz donote_volslide_ok
|
|
mov [esi+FMUSIC_CHANNEL.volslide-2],dl
|
|
donote_volslide_ok:
|
|
ret
|
|
endif
|
|
if PATTERNJUMP_ON
|
|
S1_C11:
|
|
mov eax,[ebp+var_mod]
|
|
and DWORD PTR [eax+FMUSIC_MODULE.nextrow-36],0
|
|
mov [eax+FMUSIC_MODULE.nextorder-36],edx
|
|
if PATTERNBREAK_ON
|
|
inc BYTE PTR [ebp+donote_jumpflag]
|
|
donote_set_nextord:
|
|
endif
|
|
movzx ecx,WORD PTR [eax+FMUSIC_MODULE.numorders-36]
|
|
cmp [eax+FMUSIC_MODULE.nextorder-36],ecx
|
|
jl donote_nextorder_ok
|
|
and DWORD PTR [eax+FMUSIC_MODULE.nextorder-36],0
|
|
donote_nextorder_ok:
|
|
ret
|
|
endif
|
|
if PATTERNBREAK_ON
|
|
S1_C13:
|
|
shr edx,4
|
|
lea edx,[edx+edx*4]
|
|
lea ecx,[ebx+edx*2] ; paramx*10+paramy
|
|
mov eax,[ebp+var_mod]
|
|
mov [eax+FMUSIC_MODULE.nextrow-36],ecx
|
|
if PATTERNJUMP_ON
|
|
cmp BYTE PTR [ebp+donote_jumpflag],0
|
|
jne donote_nextorder_ok
|
|
endif
|
|
mov ecx,[eax+FMUSIC_MODULE.order-36]
|
|
inc ecx
|
|
mov [eax+FMUSIC_MODULE.nextorder-36],ecx
|
|
if PATTERNJUMP_ON
|
|
jmp donote_set_nextord
|
|
else
|
|
movzx ecx,WORD PTR [eax+FMUSIC_MODULE.numorders-36]
|
|
cmp [eax+FMUSIC_MODULE.nextorder-36],ecx
|
|
jl donote_jump_pat
|
|
and DWORD PTR [eax+FMUSIC_MODULE.nextorder-36],0
|
|
donote_jump_pat:
|
|
ret
|
|
endif
|
|
endif
|
|
if SETSPEED_ON
|
|
S1_C15:
|
|
cmp dl,20h
|
|
mov ecx,edx
|
|
jae donote_setbpm
|
|
mov eax,[ebp+var_mod]
|
|
mov [eax+FMUSIC_MODULE.speed-36],ecx
|
|
ret
|
|
donote_setbpm:
|
|
; bpm : ECX
|
|
jmp SetBPM
|
|
endif
|
|
if GLOBALVOLSLIDE_ON
|
|
S1_C17:
|
|
jz donote_globalvsl_ok
|
|
mov ecx,[ebp+var_mod]
|
|
mov [ecx+FMUSIC_MODULE.globalvsl-36],dl
|
|
donote_globalvsl_ok:
|
|
ret
|
|
endif
|
|
if SETENVELOPEPOS_ON
|
|
S1_C21:
|
|
test BYTE PTR [ecx+FMUSIC_INSTRUMENT.VOLtype],1
|
|
je donote_envelope_r
|
|
lea ebx,[ecx+FMUSIC_INSTRUMENT.VOLPoints+4]
|
|
; Search and reinterpolate new envelope position
|
|
movzx ecx,BYTE PTR [ecx+FMUSIC_INSTRUMENT.VOLnumpoints]
|
|
xor eax,eax
|
|
cmp dx,[ebx]
|
|
jbe donote_env_endwhile
|
|
donote_envwhile:
|
|
cmp eax,ecx ; if(currpos == iptr->VOLnumpoints) break
|
|
je donote_env_endwhile
|
|
inc eax
|
|
cmp dx,[ebx+eax*4] ; if(current->eparam > iptr->VOLPoints[(currpos+1)<<1]) break
|
|
ja donote_envwhile
|
|
donote_env_endwhile:
|
|
mov [esi+FMUSIC_CHANNEL.envvolpos-2],eax
|
|
; if it is at the last position, abort the envelope and continue last volume
|
|
dec ecx
|
|
cmp eax,ecx
|
|
setnl [esi+FMUSIC_CHANNEL.envvolstopped-2]
|
|
jl donote_env_continue
|
|
movzx eax,WORD PTR [ebx+ecx*4-2]
|
|
mov [esi+FMUSIC_CHANNEL.envvol-2],eax ; cptr->envvol = iptr->VOLPoints[((iptr->VOLnumpoints-1)<<1)+1]
|
|
donote_envelope_r:
|
|
ret
|
|
donote_env_continue:
|
|
mov [esi+FMUSIC_CHANNEL.envvoltick-2],edx
|
|
mov ecx,[ebx+eax*4-4] ; get tick at this point + VOL at this point
|
|
mov edx,ecx
|
|
movzx ecx,cx
|
|
mov [ebp+donote_currtick],ecx
|
|
mov ecx,[ebx+eax*4] ; get tick at next point + VOL at next point
|
|
mov eax,ecx
|
|
movzx ecx,cx
|
|
xor dx,dx
|
|
; interpolate 2 points to find delta step
|
|
sub ecx,[ebp+donote_currtick]
|
|
push edx
|
|
jz donote_no_tickdiff
|
|
xor ax,ax
|
|
sub eax,edx
|
|
cdq
|
|
idiv ecx
|
|
xchg eax,ecx
|
|
donote_no_tickdiff:
|
|
mov [esi+FMUSIC_CHANNEL.envvoldelta-2],ecx
|
|
mov eax,[esi+FMUSIC_CHANNEL.envvoltick-2]
|
|
sub eax,[ebp+donote_currtick]
|
|
imul ecx
|
|
pop edx
|
|
add eax,edx
|
|
mov [esi+FMUSIC_CHANNEL.envvolfrac-2],eax
|
|
sar eax,16
|
|
mov [esi+FMUSIC_CHANNEL.envvol-2],eax
|
|
inc DWORD PTR [esi+FMUSIC_CHANNEL.envvolpos-2]
|
|
ret
|
|
endif
|
|
if PANSLIDE_ON
|
|
S1_C25:
|
|
jz donote_panslide_ok
|
|
mov [esi+FMUSIC_CHANNEL.panslide-2],dl
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_PAN
|
|
donote_panslide_ok:
|
|
ret
|
|
endif
|
|
if MULTIRETRIG_ON
|
|
S1_C27:
|
|
jz donote_multiretrig_ok
|
|
shr edx,4
|
|
mov dh,bl
|
|
mov WORD PTR [esi+FMUSIC_CHANNEL.retrigx-2],dx
|
|
donote_multiretrig_ok:
|
|
ret
|
|
endif
|
|
if TREMOR_ON
|
|
S1_C29:
|
|
jz donote_do_tremor
|
|
shr edx,4
|
|
mov dh,bl
|
|
mov WORD PTR [esi+FMUSIC_CHANNEL.tremoron-2],dx
|
|
donote_do_tremor:
|
|
; cptr : ESI
|
|
jmp Tremor
|
|
endif
|
|
if EXTRAFINEPORTA_ON
|
|
S1_C33:
|
|
shr edx,4
|
|
dec edx
|
|
jnz donote_paramx_n1
|
|
test ebx,ebx
|
|
jz donote_paramy_z1
|
|
mov [esi+FMUSIC_CHANNEL.xtraportaup-2],bl
|
|
donote_paramy_z1:
|
|
movzx eax,BYTE PTR [esi+FMUSIC_CHANNEL.xtraportaup-2]
|
|
sub [esi+FMUSIC_CHANNEL.freq-2],eax
|
|
donote_paramx_n1:
|
|
dec edx
|
|
jnz donote_paramx_n2
|
|
test ebx,ebx
|
|
jz donote_paramy_z2
|
|
mov [esi+FMUSIC_CHANNEL.xtraportadown-2],bl
|
|
donote_paramy_z2:
|
|
movzx eax,BYTE PTR [esi+FMUSIC_CHANNEL.xtraportadown-2]
|
|
add [esi+FMUSIC_CHANNEL.freq-2],eax
|
|
donote_paramx_n2:
|
|
endif
|
|
S2_r:
|
|
ret
|
|
S1_C14:
|
|
shr edx,4
|
|
dec edx ; skip FMUSIC_XM_SETFILTER
|
|
if FINEPORTAUP_ON
|
|
else
|
|
dec edx
|
|
endif
|
|
if PATTERNDELAY_ON
|
|
cmp dl,13
|
|
else
|
|
if NOTEDELAY_ON
|
|
cmp dl,12
|
|
else
|
|
if FINEVOLUMESLIDE_ON
|
|
cmp dl,10
|
|
else
|
|
if SETPANPOSITION16_ON
|
|
cmp dl,7
|
|
else
|
|
if SETTREMOLOWAVE_ON
|
|
cmp dl,6
|
|
else
|
|
if PATTERNLOOP_ON
|
|
cmp dl,5
|
|
else
|
|
cmp dl,4
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
if FINEPORTAUP_ON
|
|
ja S2_r
|
|
else
|
|
jae S2_r
|
|
endif
|
|
donote_do_special:
|
|
test ebx,ebx
|
|
jmp DWORD PTR [edx*4+S2_TBL]
|
|
S2_TBL:
|
|
if FINEPORTAUP_ON
|
|
dd S2_C1
|
|
endif
|
|
if FINEPORTADOWN_ON
|
|
dd S2_C2
|
|
else
|
|
dd S2_r
|
|
endif
|
|
dd S2_r ; skip FMUSIC_XM_SETGLISSANDO
|
|
if SETVIBRATOWAVE_ON
|
|
dd S2_C4
|
|
else
|
|
dd S2_r
|
|
endif
|
|
if SETFINETUNE_ON
|
|
dd S2_C5
|
|
else
|
|
dd S2_r
|
|
endif
|
|
if PATTERNDELAY_ON
|
|
if PATTERNLOOP_ON
|
|
dd S2_C6
|
|
else
|
|
dd S2_r
|
|
endif
|
|
if SETTREMOLOWAVE_ON
|
|
dd S2_C7
|
|
else
|
|
dd S2_r
|
|
endif
|
|
if SETPANPOSITION16_ON
|
|
dd S2_C8
|
|
else
|
|
dd S2_r
|
|
endif
|
|
dd S2_r ; skip FMUSIC_XM_RETRIG
|
|
if FINEVOLUMESLIDE_ON
|
|
dd S2_C10
|
|
dd S2_C11
|
|
else
|
|
dd S2_r
|
|
dd S2_r
|
|
endif
|
|
dd S2_r ; skip FMUSIC_XM_NOTECUT
|
|
if NOTEDELAY_ON
|
|
dd S2_C13
|
|
else
|
|
dd S2_r
|
|
endif
|
|
dd S2_C14
|
|
else
|
|
if NOTEDELAY_ON
|
|
if PATTERNLOOP_ON
|
|
dd S2_C6
|
|
else
|
|
dd S2_r
|
|
endif
|
|
if SETTREMOLOWAVE_ON
|
|
dd S2_C7
|
|
else
|
|
dd S2_r
|
|
endif
|
|
if SETPANPOSITION16_ON
|
|
dd S2_C8
|
|
else
|
|
dd S2_r
|
|
endif
|
|
dd S2_r ; skip FMUSIC_XM_RETRIG
|
|
if FINEVOLUMESLIDE_ON
|
|
dd S2_C10
|
|
dd S2_C11
|
|
else
|
|
dd S2_r
|
|
dd S2_r
|
|
endif
|
|
dd S2_r
|
|
dd S2_C13
|
|
else
|
|
if FINEVOLUMESLIDE_ON
|
|
if PATTERNLOOP_ON
|
|
dd S2_C6
|
|
else
|
|
dd S2_r
|
|
endif
|
|
if SETTREMOLOWAVE_ON
|
|
dd S2_C7
|
|
else
|
|
dd S2_r
|
|
endif
|
|
if SETPANPOSITION16_ON
|
|
dd S2_C8
|
|
else
|
|
dd S2_r
|
|
endif
|
|
dd S2_r
|
|
dd S2_C10
|
|
dd S2_C11
|
|
else
|
|
if SETPANPOSITION16_ON
|
|
if PATTERNLOOP_ON
|
|
dd S2_C6
|
|
else
|
|
dd S2_r
|
|
endif
|
|
if SETTREMOLOWAVE_ON
|
|
dd S2_C7
|
|
else
|
|
dd S2_r
|
|
endif
|
|
dd S2_C8
|
|
else
|
|
if SETTREMOLOWAVE_ON
|
|
if PATTERNLOOP_ON
|
|
dd S2_C6
|
|
else
|
|
dd S2_r
|
|
endif
|
|
dd S2_C7
|
|
else
|
|
if PATTERNLOOP_ON
|
|
dd S2_C6
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
if FINEPORTAUP_ON
|
|
S2_C1:
|
|
jz donote_finepup_ok
|
|
mov [esi+FMUSIC_CHANNEL.fineportaup-2],bl
|
|
donote_finepup_ok:
|
|
movzx eax,BYTE PTR [esi+FMUSIC_CHANNEL.fineportaup-2]
|
|
shl eax,2
|
|
sub [esi+FMUSIC_CHANNEL.freq-2],eax
|
|
ret
|
|
endif
|
|
if FINEPORTADOWN_ON
|
|
S2_C2:
|
|
jz donote_finepdown_ok
|
|
mov [esi+FMUSIC_CHANNEL.fineportadown-2],bl
|
|
donote_finepdown_ok:
|
|
movzx eax,BYTE PTR [esi+FMUSIC_CHANNEL.fineportadown-2]
|
|
shl eax,2
|
|
add [esi+FMUSIC_CHANNEL.freq-2],eax
|
|
ret
|
|
endif
|
|
if SETVIBRATOWAVE_ON
|
|
S2_C4:
|
|
and BYTE PTR [esi+FMUSIC_CHANNEL.wavecontrol-2],0F0h
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.wavecontrol-2],bl
|
|
ret
|
|
endif
|
|
if SETFINETUNE_ON
|
|
S2_C5:
|
|
mov eax,[ebp+donote_sptr]
|
|
mov [eax+FSOUND_SAMPLE.finetune],bl
|
|
ret
|
|
endif
|
|
if PATTERNLOOP_ON
|
|
S2_C6:
|
|
jnz donote_not_paramy
|
|
mov eax,[ebp+var_mod]
|
|
mov eax,[eax+FMUSIC_MODULE.row-36]
|
|
mov [esi+FMUSIC_CHANNEL.patlooprow-2],eax
|
|
ret
|
|
donote_not_paramy:
|
|
mov cl,[esi+FMUSIC_CHANNEL.patloopno-2]
|
|
dec cl
|
|
jns donote_patloopno_ok
|
|
mov ecx,ebx
|
|
donote_patloopno_ok:
|
|
mov [esi+FMUSIC_CHANNEL.patloopno-2],cl
|
|
jz donote_patloopno_end
|
|
mov eax,[esi+FMUSIC_CHANNEL.patlooprow-2]
|
|
mov ecx,[ebp+var_mod]
|
|
mov [ecx+FMUSIC_MODULE.nextrow-36],eax
|
|
donote_patloopno_end:
|
|
ret
|
|
endif
|
|
if SETTREMOLOWAVE_ON
|
|
S2_C7:
|
|
and BYTE PTR [esi+FMUSIC_CHANNEL.wavecontrol-2],0Fh
|
|
shl ebx,4
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.wavecontrol-2],bl
|
|
ret
|
|
endif
|
|
if SETPANPOSITION16_ON
|
|
S2_C8:
|
|
shl ebx,4
|
|
mov [esi+FMUSIC_CHANNEL.pan-2],ebx
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_PAN
|
|
ret
|
|
endif
|
|
if FINEVOLUMESLIDE_ON
|
|
S2_C10:
|
|
neg ebx
|
|
S2_C11:
|
|
jz donote_finevols_ok
|
|
mov [esi+FMUSIC_CHANNEL.finevslup-2],bl
|
|
donote_finevols_ok:
|
|
movsx eax,BYTE PTR [esi+FMUSIC_CHANNEL.finevslup-2]
|
|
sub [esi+FMUSIC_CHANNEL.volume-2],eax
|
|
ret
|
|
endif
|
|
if NOTEDELAY_ON
|
|
S2_C13:
|
|
mov eax,[ebp+donote_oldfreq]
|
|
mov edx,[ebp+donote_currtick]
|
|
mov [esi+FMUSIC_CHANNEL.freq-2],eax
|
|
mov eax,[ebp+donote_oldpan]
|
|
mov [esi+FMUSIC_CHANNEL.pan-2],eax
|
|
mov BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],0
|
|
if SETVOLUME_ON
|
|
else
|
|
mov [esi+FMUSIC_CHANNEL.volume-2],edx
|
|
ret
|
|
endif
|
|
endif
|
|
if SETVOLUME_ON
|
|
S1_C12:
|
|
mov [esi+FMUSIC_CHANNEL.volume-2],edx
|
|
ret
|
|
endif
|
|
if PATTERNDELAY_ON
|
|
S2_C14:
|
|
mov ecx,[ebp+var_mod]
|
|
imul ebx,DWORD PTR [ecx+FMUSIC_MODULE.speed-36]
|
|
mov [ecx+FMUSIC_MODULE.patterndelay-36],ebx
|
|
ret
|
|
endif
|
|
|
|
DoEffs:
|
|
; mod+36 = ESI
|
|
; var_mod equ -4
|
|
doeff_current equ -8
|
|
; Point our note pointer to the correct pattern buffer, and to the
|
|
; correct offset in this buffer indicated by row and number of channels
|
|
mov eax,[esi+FMUSIC_MODULE.order-36]
|
|
push ebp
|
|
mov bl,[eax+esi+FMUSIC_MODULE.orderlist-36]
|
|
mov eax,[esi+FMUSIC_MODULE.row-36]
|
|
mul DWORD PTR [esi+FMUSIC_MODULE.numchannels-36]
|
|
lea eax,[eax+eax*4] ; x SIZE FMUSIC_NOTE
|
|
mov ebp,esp
|
|
; mod->pattern[mod->orderlist[mod->order]].data+(mod->row*mod->numchannels)
|
|
add eax,[ecx+ebx*FMUSIC_PATTERN_size+FMUSIC_PATTERN.data]
|
|
push esi ; -> var_mod
|
|
push eax ; -> doeff_current
|
|
mov eax,[esi+FMUSIC_MODULE.numchannels-36]
|
|
shl eax,7 ; x FMUSIC_CHANNEL_size
|
|
push esi
|
|
mov esi,[esi+FMUSIC_MODULE.uFMOD_Ch-36]
|
|
inc esi
|
|
inc esi
|
|
add eax,esi
|
|
doeff_for_channels:
|
|
push eax
|
|
movzx edi,BYTE PTR [esi+FMUSIC_CHANNEL.inst-2]
|
|
mov edx,[ebp+var_mod]
|
|
imul edi,FMUSIC_INSTRUMENT_size
|
|
movzx eax,BYTE PTR [esi+FMUSIC_CHANNEL.note-2]
|
|
add edi,[edx+FMUSIC_MODULE.instrument-36]
|
|
cdq
|
|
mov al,[eax+edi+FMUSIC_INSTRUMENT.keymap]
|
|
cmp al,16
|
|
jae doeff_set_sptr
|
|
mov edx,[edi+eax*4+FMUSIC_INSTRUMENT.sample]
|
|
doeff_set_sptr:
|
|
test edx,edx
|
|
jnz doeff_valid_sptr
|
|
mov edx,OFFSET DummySamp
|
|
doeff_valid_sptr:
|
|
xor ebx,ebx
|
|
if INSTRUMENTVIBRATO_ON
|
|
push edi ; iptr
|
|
endif
|
|
push edx ; sptr
|
|
mov [esi+FMUSIC_CHANNEL.voldelta-2],ebx
|
|
mov [esi+FMUSIC_CHANNEL.freqdelta-2],ebx
|
|
mov [esi+FMUSIC_CHANNEL.notectrl-2],bl
|
|
; PROCESS ENVELOPES
|
|
if VOLUMEENVELOPE_ON
|
|
test BYTE PTR [edi+FMUSIC_INSTRUMENT.VOLtype],1
|
|
je doeff_no_voltype
|
|
mov al,FMUSIC_VOLUME
|
|
mov ecx,edi
|
|
; cptr+2 : ESI
|
|
; env_iptr : ECX
|
|
; control : AL
|
|
call Envelope
|
|
doeff_no_voltype:
|
|
endif
|
|
if PANENVELOPE_ON
|
|
test BYTE PTR [edi+FMUSIC_INSTRUMENT.PANtype],1
|
|
je doeff_no_pantype
|
|
mov al,FMUSIC_PAN
|
|
mov ecx,edi
|
|
; cptr+2 : ESI
|
|
; env_iptr : ECX
|
|
; control : AL
|
|
call Envelope
|
|
doeff_no_pantype:
|
|
endif
|
|
; PROCESS VOLUME FADEOUT
|
|
cmp [esi+FMUSIC_CHANNEL.keyoff-2],bl
|
|
je doeff_fadevol_ok
|
|
movzx eax,WORD PTR [edi+FMUSIC_INSTRUMENT.VOLfade]
|
|
sub [esi+FMUSIC_CHANNEL.fadeoutvol-2],eax
|
|
jns doeff_fadevol_ns
|
|
mov [esi+FMUSIC_CHANNEL.fadeoutvol-2],ebx
|
|
doeff_fadevol_ns:
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME
|
|
doeff_fadevol_ok:
|
|
if VOLUMEBYTE_ON
|
|
mov eax,[ebp+doeff_current]
|
|
movzx eax,BYTE PTR [eax+FMUSIC_NOTE.uvolume]
|
|
mov ecx,eax
|
|
shr eax,4
|
|
and cl,0Fh
|
|
sub al,6
|
|
jz doeff_case_vol6
|
|
dec eax
|
|
jz doeff_case_vol7
|
|
if VIBRATO_ON
|
|
sub al,4
|
|
jz doeff_case_volB
|
|
dec eax
|
|
dec eax
|
|
else
|
|
sub al,6
|
|
endif
|
|
jz doeff_case_volD
|
|
dec eax
|
|
if PORTATO_ON
|
|
jz doeff_case_volE
|
|
dec eax
|
|
jnz doeff_volbyte_end
|
|
; cptr+2 : ESI
|
|
call Portamento
|
|
jmp doeff_volbyte_end
|
|
else
|
|
jnz doeff_volbyte_end
|
|
endif
|
|
doeff_case_volE:
|
|
neg ecx
|
|
doeff_case_volD:
|
|
sub [esi+FMUSIC_CHANNEL.pan-2],ecx
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_PAN
|
|
jmp doeff_volbyte_end
|
|
if VIBRATO_ON
|
|
doeff_case_volB:
|
|
mov [esi+FMUSIC_CHANNEL.vibdepth-2],cl
|
|
; cptr+2 : ESI
|
|
call Vibrato
|
|
jmp doeff_volbyte_end
|
|
endif
|
|
doeff_case_vol6:
|
|
neg ecx
|
|
doeff_case_vol7:
|
|
add [esi+FMUSIC_CHANNEL.volume-2],ecx
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME
|
|
doeff_volbyte_end:
|
|
endif ; VOLUMEBYTE_ON
|
|
mov edx,[ebp+doeff_current]
|
|
movzx ebx,BYTE PTR [edx+FMUSIC_NOTE.eparam]
|
|
mov ecx,ebx
|
|
and ebx,0Fh ; grab the effect parameter y
|
|
movzx eax,BYTE PTR [edx+FMUSIC_NOTE.effect]
|
|
shr cl,4 ; grab the effect parameter x
|
|
if ARPEGGIO_ON
|
|
else
|
|
dec eax
|
|
endif
|
|
if TREMOR_ON
|
|
cmp al,29
|
|
else
|
|
if MULTIRETRIG_ON
|
|
cmp al,27
|
|
else
|
|
if PANSLIDE_ON
|
|
cmp al,25
|
|
else
|
|
if GLOBALVOLSLIDE_ON
|
|
cmp al,17
|
|
else
|
|
if RETRIG_ON
|
|
cmp al,14
|
|
else
|
|
if NOTECUT_ON
|
|
cmp al,14
|
|
else
|
|
if NOTEDELAY_ON
|
|
cmp al,14
|
|
else
|
|
cmp al,10
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
if ARPEGGIO_ON
|
|
ja doeff_s3_brk
|
|
else
|
|
jae doeff_s3_brk
|
|
endif
|
|
call DWORD PTR [eax*4+S3_TBL]
|
|
doeff_s3_brk:
|
|
; cptr+2 : ESI
|
|
call DoFlags
|
|
sub esi,-(FMUSIC_CHANNEL_size)
|
|
pop eax
|
|
add DWORD PTR [ebp+doeff_current],FMUSIC_NOTE_size
|
|
cmp esi,eax
|
|
jl doeff_for_channels
|
|
pop esi
|
|
doeff_R:
|
|
leave
|
|
S3_r:
|
|
ret
|
|
S3_TBL:
|
|
if ARPEGGIO_ON
|
|
dd S3_C0
|
|
endif
|
|
if PORTAUP_ON
|
|
dd S3_C1
|
|
else
|
|
dd S3_r
|
|
endif
|
|
if PORTADOWN_ON
|
|
dd S3_C2
|
|
else
|
|
dd S3_r
|
|
endif
|
|
if PORTATO_ON
|
|
; cptr+2 : ESI
|
|
dd Portamento
|
|
else
|
|
dd S3_r
|
|
endif
|
|
if VIBRATO_ON
|
|
; cptr+2 : ESI
|
|
dd Vibrato
|
|
else
|
|
dd S3_r
|
|
endif
|
|
if PORTATOVOLSLIDE_ON
|
|
dd S3_C5
|
|
else
|
|
dd S3_r
|
|
endif
|
|
if VIBRATOVOLSLIDE_ON
|
|
dd S3_C6
|
|
else
|
|
dd S3_r
|
|
endif
|
|
if TREMOLO_ON
|
|
; cptr+2 : ESI
|
|
dd Tremolo
|
|
else
|
|
dd S3_r
|
|
endif
|
|
dd S3_r ; skip FMUSIC_XM_SETPANPOSITION
|
|
dd S3_r ; skip FMUSIC_XM_SETSAMPLEOFFSET
|
|
if VOLUMESLIDE_ON
|
|
dd S3_C10
|
|
else
|
|
dd S3_r
|
|
endif
|
|
if TREMOR_ON
|
|
dd S3_r ; skip FMUSIC_XM_PATTERNJUMP
|
|
dd S3_r ; slip FMUSIC_XM_SETVOLUME
|
|
dd S3_r ; skip FMUSIC_XM_PATTERNBREAK
|
|
dd S3_C14
|
|
dd S3_r ; skip FMUSIC_XM_SETSPEED
|
|
dd S3_r ; skip FMUSIC_XM_SETGLOBALVOLUME
|
|
if GLOBALVOLSLIDE_ON
|
|
dd S3_C17
|
|
else
|
|
dd S3_r
|
|
endif
|
|
dd S3_r ; unassigned effect ordinal [18]
|
|
dd S3_r ; unassigned effect ordinal [19]
|
|
dd S3_r ; skip FMUSIC_XM_KEYOFF
|
|
dd S3_r ; skip FMUSIC_XM_SETENVELOPEPOS
|
|
dd S3_r ; unassigned effect ordinal [22]
|
|
dd S3_r ; unassigned effect ordinal [23]
|
|
dd S3_r ; unassigned effect ordinal [24]
|
|
if PANSLIDE_ON
|
|
dd S3_C25
|
|
else
|
|
dd S3_r
|
|
endif
|
|
dd S3_r ; unassigned effect ordinal [26]
|
|
if MULTIRETRIG_ON
|
|
dd S3_C27
|
|
else
|
|
dd S3_r
|
|
endif
|
|
dd S3_r ; unassigned effect ordinal [28]
|
|
; case FMUSIC_XM_TREMOR
|
|
; cptr : ESI
|
|
dd Tremor
|
|
else
|
|
if MULTIRETRIG_ON
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_C14
|
|
dd S3_r
|
|
dd S3_r
|
|
if GLOBALVOLSLIDE_ON
|
|
dd S3_C17
|
|
else
|
|
dd S3_r
|
|
endif
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
if PANSLIDE_ON
|
|
dd S3_C25
|
|
else
|
|
dd S3_r
|
|
endif
|
|
dd S3_r
|
|
dd S3_C27
|
|
else
|
|
if PANSLIDE_ON
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_C14
|
|
dd S3_r
|
|
dd S3_r
|
|
if GLOBALVOLSLIDE_ON
|
|
dd S3_C17
|
|
else
|
|
dd S3_r
|
|
endif
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_C25
|
|
else
|
|
if GLOBALVOLSLIDE_ON
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_C14
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_C17
|
|
else
|
|
if RETRIG_ON
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_C14
|
|
else
|
|
if NOTECUT_ON
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_C14
|
|
else
|
|
if NOTEDELAY_ON
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_r
|
|
dd S3_C14
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
endif
|
|
endif
|
|
if VIBRATOVOLSLIDE_ON
|
|
S3_C6:
|
|
; cptr+2 : ESI
|
|
call Vibrato
|
|
if VOLUMESLIDE_ON
|
|
if PORTATOVOLSLIDE_ON
|
|
jmp S3_C10
|
|
endif
|
|
else
|
|
mov cl,[esi+FMUSIC_CHANNEL.volslide-2]
|
|
mov eax,ecx
|
|
and eax,0Fh
|
|
shr ecx,4
|
|
jz doeff_volslide_ok
|
|
; Slide up takes precedence over down
|
|
xchg eax,ecx
|
|
neg eax
|
|
doeff_volslide_ok:
|
|
sub [esi+FMUSIC_CHANNEL.volume-2],eax
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME
|
|
ret
|
|
endif
|
|
endif
|
|
if PORTATOVOLSLIDE_ON
|
|
S3_C5:
|
|
; cptr+2 : ESI
|
|
call Portamento
|
|
if VOLUMESLIDE_ON
|
|
xor ecx,ecx
|
|
else
|
|
movzx ecx,BYTE PTR [esi+FMUSIC_CHANNEL.volslide-2]
|
|
mov eax,ecx
|
|
and eax,0Fh
|
|
shr ecx,4
|
|
jz doeff_volslide_ok
|
|
; Slide up takes precedence over down
|
|
xchg eax,ecx
|
|
neg eax
|
|
doeff_volslide_ok:
|
|
sub [esi+FMUSIC_CHANNEL.volume-2],eax
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME
|
|
ret
|
|
endif
|
|
endif
|
|
if VOLUMESLIDE_ON
|
|
S3_C10:
|
|
mov cl,[esi+FMUSIC_CHANNEL.volslide-2]
|
|
mov eax,ecx
|
|
and eax,0Fh
|
|
shr ecx,4
|
|
jz doeff_volslide_ok
|
|
; Slide up takes precedence over down
|
|
xchg eax,ecx
|
|
neg eax
|
|
doeff_volslide_ok:
|
|
sub [esi+FMUSIC_CHANNEL.volume-2],eax
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME
|
|
ret
|
|
endif
|
|
if PORTADOWN_ON
|
|
S3_C2:
|
|
mov al,[esi+FMUSIC_CHANNEL.portaupdown-2]
|
|
DoFreqSlide:
|
|
mov ecx,[esi+FMUSIC_CHANNEL.freq-2]
|
|
lea ecx,[ecx+eax*4]
|
|
cmp ecx,1
|
|
jge DoFreqSlide_ok
|
|
push 1
|
|
pop ecx
|
|
DoFreqSlide_ok:
|
|
mov [esi+FMUSIC_CHANNEL.freq-2],ecx
|
|
and DWORD PTR [esi+FMUSIC_CHANNEL.freqdelta-2],0
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_FREQ
|
|
ret
|
|
endif
|
|
if PORTAUP_ON
|
|
S3_C1:
|
|
mov al,[esi+FMUSIC_CHANNEL.portaupdown-2]
|
|
if PORTADOWN_ON
|
|
neg eax
|
|
jmp DoFreqSlide
|
|
else
|
|
shl eax,2
|
|
mov ecx,[esi+FMUSIC_CHANNEL.freq-2]
|
|
sub ecx,eax
|
|
cmp ecx,1
|
|
jge DoFreqSlide_ok
|
|
push 1
|
|
pop ecx
|
|
DoFreqSlide_ok:
|
|
mov [esi+FMUSIC_CHANNEL.freq-2],ecx
|
|
and DWORD PTR [esi+FMUSIC_CHANNEL.freqdelta-2],0
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_FREQ
|
|
ret
|
|
endif
|
|
endif
|
|
if ARPEGGIO_ON
|
|
S3_C0:
|
|
cmp BYTE PTR [edx+FMUSIC_NOTE.eparam],ch
|
|
jbe doeff_arpeggio_ok
|
|
mov eax,[ebp+var_mod]
|
|
mov eax,[eax+FMUSIC_MODULE.tick-36]
|
|
push 3
|
|
cdq
|
|
pop edi
|
|
idiv edi
|
|
dec edx
|
|
jz doeff_arpeg_c1
|
|
dec edx
|
|
jne doeffs_enable_freq
|
|
mov ecx,ebx
|
|
doeff_arpeg_c1:
|
|
mov eax,[ebp+var_mod]
|
|
test BYTE PTR [eax+FMUSIC_MODULE.flags-36],1
|
|
je doeffs_flagsn1
|
|
doeffs_arpeggio_freqd:
|
|
shl ecx,6
|
|
mov [esi+FMUSIC_CHANNEL.freqdelta-2],ecx
|
|
if AMIGAPERIODS_ON
|
|
jmp doeffs_enable_freq
|
|
endif
|
|
doeffs_flagsn1:
|
|
if AMIGAPERIODS_ON
|
|
movzx eax,BYTE PTR [esi+FMUSIC_CHANNEL.realnote-2]
|
|
mov edi,eax
|
|
add eax,ecx ; note : EAX
|
|
mov ecx,[esp+4] ; [sptr] : ECX
|
|
; ESI != 0
|
|
call AmigaPeriod
|
|
xchg eax,edi ; note : EAX
|
|
mov ecx,[esp+4] ; [sptr] : ECX
|
|
; ESI != 0
|
|
call AmigaPeriod
|
|
sub edi,eax
|
|
mov [esi+FMUSIC_CHANNEL.freqdelta-2],edi
|
|
endif
|
|
doeffs_enable_freq:
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_FREQ
|
|
doeff_arpeggio_ok:
|
|
ret
|
|
endif
|
|
if MULTIRETRIG_ON
|
|
S3_C27:
|
|
mov cl,[esi+FMUSIC_CHANNEL.retrigy-2]
|
|
test ecx,ecx
|
|
jz doeff_multiretrig_ok
|
|
mov eax,[ebp+var_mod]
|
|
mov eax,[eax+FMUSIC_MODULE.tick-36]
|
|
cdq
|
|
idiv ecx
|
|
test edx,edx
|
|
jnz doeff_multiretrig_ok
|
|
mov cl,[esi+FMUSIC_CHANNEL.retrigx-2]
|
|
and ecx,0Fh
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_TRIGGER
|
|
dec ecx
|
|
mov eax,[esi+FMUSIC_CHANNEL.volume-2]
|
|
js doeff_multiretrig_ok
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME
|
|
call DWORD PTR [ecx*4+S4_TBL]
|
|
mov [esi+FMUSIC_CHANNEL.volume-2],eax
|
|
S4_C2:
|
|
dec eax
|
|
S4_C1:
|
|
dec eax
|
|
doeff_multiretrig_ok:
|
|
ret
|
|
S4_C5:
|
|
sub eax,8
|
|
S4_C4:
|
|
sub eax,4
|
|
S4_C3:
|
|
sub eax,4
|
|
ret
|
|
S4_C6:
|
|
shl eax,1
|
|
push 3
|
|
cdq
|
|
pop ecx
|
|
idiv ecx
|
|
ret
|
|
S4_C14:
|
|
lea eax,[eax+eax*2]
|
|
S4_C7:
|
|
sar eax,1
|
|
ret
|
|
S4_C10:
|
|
inc eax
|
|
S4_C9:
|
|
inc eax
|
|
ret
|
|
S4_C13:
|
|
add eax,8
|
|
S4_C12:
|
|
add eax,4
|
|
S4_C11:
|
|
add eax,4
|
|
ret
|
|
S4_C15:
|
|
shl eax,1
|
|
S4_r:
|
|
ret
|
|
S4_TBL:
|
|
dd S4_C1
|
|
dd S4_C2
|
|
dd S4_C3
|
|
dd S4_C4
|
|
dd S4_C5
|
|
dd S4_C6
|
|
dd S4_C7
|
|
dd S4_r
|
|
dd S4_C9
|
|
dd S4_C10
|
|
dd S4_C11
|
|
dd S4_C12
|
|
dd S4_C13
|
|
dd S4_C14
|
|
dd S4_C15
|
|
endif
|
|
if PANSLIDE_ON
|
|
S3_C25:
|
|
mov cl,[esi+FMUSIC_CHANNEL.panslide-2]
|
|
mov eax,ecx
|
|
and eax,0Fh
|
|
mov edx,[esi+FMUSIC_CHANNEL.pan-2]
|
|
shr ecx,4
|
|
; Slide right takes precedence over left
|
|
jnz doeff_pan_slide_right
|
|
sub edx,eax
|
|
jns doeff_panslide_ok
|
|
mov edx,ecx
|
|
jmp doeff_panslide_ok
|
|
doeff_pan_slide_right:
|
|
add ecx,edx
|
|
cdq
|
|
dec dl ; edx = 255
|
|
cmp ecx,edx
|
|
jg doeff_panslide_ok
|
|
mov edx,ecx
|
|
doeff_panslide_ok:
|
|
if SETPANPOSITION_ON
|
|
S1_C8:
|
|
endif
|
|
mov [esi+FMUSIC_CHANNEL.pan-2],edx
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_PAN
|
|
ret
|
|
endif
|
|
if GLOBALVOLSLIDE_ON
|
|
S3_C17:
|
|
mov ecx,[ebp+var_mod]
|
|
mov edx,[ecx+FMUSIC_MODULE.globalvolume-36]
|
|
mov al,[ecx+FMUSIC_MODULE.globalvsl-36]
|
|
test al,0F0h
|
|
; Slide up takes precedence over down
|
|
jnz doeff_gvsl_slide_up
|
|
and eax,0Fh
|
|
sub edx,eax
|
|
jns set_global_vol
|
|
cdq
|
|
xor eax,eax
|
|
doeff_gvsl_slide_up:
|
|
shr eax,4
|
|
add edx,eax
|
|
set_global_vol:
|
|
if SETGLOBALVOLUME_ON
|
|
else
|
|
cmp edx,64
|
|
jle doeff_setglobalvol
|
|
push 64
|
|
pop edx
|
|
doeff_setglobalvol:
|
|
mov [ecx+FMUSIC_MODULE.globalvolume-36],edx
|
|
ret
|
|
endif
|
|
endif
|
|
if SETGLOBALVOLUME_ON
|
|
S1_C16:
|
|
cmp edx,64
|
|
mov ecx,[ebp+var_mod]
|
|
jle do_setglobalvol
|
|
push 64
|
|
pop edx
|
|
do_setglobalvol:
|
|
mov [ecx+FMUSIC_MODULE.globalvolume-36],edx
|
|
ret
|
|
endif
|
|
S3_C14:
|
|
if RETRIG_ON
|
|
cmp cl,FMUSIC_XM_RETRIG
|
|
je doeff_do_retrig
|
|
endif
|
|
if NOTECUT_ON
|
|
sub cl,FMUSIC_XM_NOTECUT
|
|
jz doeff_do_notecut
|
|
endif
|
|
if NOTEDELAY_ON
|
|
if NOTECUT_ON
|
|
dec cl
|
|
else
|
|
cmp cl,FMUSIC_XM_NOTEDELAY
|
|
endif
|
|
jne doeff_special_r
|
|
mov ecx,[ebp+var_mod]
|
|
xor eax,eax
|
|
cmp [ecx+FMUSIC_MODULE.tick-36],ebx
|
|
jne doeff_notectrl_z
|
|
mov edx,[esp+4]
|
|
mov DWORD PTR [esi+FMUSIC_CHANNEL.fadeoutvol-2],65536
|
|
movzx edx,BYTE PTR [edx+FSOUND_SAMPLE.defvol]
|
|
lea ecx,[eax+9]
|
|
mov [esi+FMUSIC_CHANNEL.volume-2],edx
|
|
mov edx,[esi+FMUSIC_CHANNEL.envvol-2]
|
|
lea edi,[esi+FMUSIC_CHANNEL.envvoltick-2]
|
|
cmp ecx,edx
|
|
sbb edx,edx
|
|
and edx,64
|
|
mov [esi+FMUSIC_CHANNEL.envvol-2],edx
|
|
; memset(&cptr->envvoltick,0,36)
|
|
rep stosd
|
|
; Retrigger tremolo and vibrato waveforms
|
|
mov cl,[esi+FMUSIC_CHANNEL.wavecontrol-2]
|
|
cmp cl,4Fh
|
|
jge z2_tremolopos_ok
|
|
mov BYTE PTR [esi+FMUSIC_CHANNEL.tremolopos-2],al ; = 0
|
|
z2_tremolopos_ok:
|
|
test cl,0Ch
|
|
jnz z2_vibpos_ok
|
|
mov BYTE PTR [esi+FMUSIC_CHANNEL.vibpos-2],al ; = 0
|
|
z2_vibpos_ok:
|
|
mov eax,[esi+FMUSIC_CHANNEL.period-2]
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOL_OR_FREQ_OR_TR
|
|
mov [esi+FMUSIC_CHANNEL.freq-2],eax
|
|
if VOLUMEBYTE_ON
|
|
mov eax,[ebp+doeff_current]
|
|
movzx edx,BYTE PTR [eax+FMUSIC_NOTE.uvolume]
|
|
; volume : EDX
|
|
; cptr : ESI
|
|
jmp VolByte
|
|
else
|
|
ret
|
|
endif
|
|
doeff_notectrl_z:
|
|
mov BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],al
|
|
doeff_special_r:
|
|
endif
|
|
ret
|
|
if NOTECUT_ON
|
|
doeff_do_notecut:
|
|
mov ecx,[ebp+var_mod]
|
|
cmp [ecx+FMUSIC_MODULE.tick-36],ebx
|
|
jne doeff_notecut_ok
|
|
and DWORD PTR [esi+FMUSIC_CHANNEL.volume-2],0
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME
|
|
doeff_notecut_ok:
|
|
ret
|
|
endif
|
|
if RETRIG_ON
|
|
doeff_do_retrig:
|
|
test ebx,ebx
|
|
jz doeff_retrig_ok
|
|
mov eax,[ebp+var_mod]
|
|
mov eax,[eax+FMUSIC_MODULE.tick-36]
|
|
cdq
|
|
idiv ebx
|
|
test edx,edx
|
|
jne doeff_retrig_ok
|
|
or BYTE PTR [esi+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOL_OR_FREQ_OR_TR
|
|
doeff_retrig_ok:
|
|
ret
|
|
endif
|
|
|
|
; DESCRIPTION: Process sample flags
|
|
DoFlags:
|
|
; cptr+2 - ESI
|
|
flags_iptr equ 16
|
|
flags_sptr equ 12
|
|
mov ebx,esi
|
|
push esi
|
|
push edi
|
|
if INSTRUMENTVIBRATO_ON
|
|
; THIS GETS ADDED TO PREVIOUS FREQDELTAS
|
|
mov esi,[esp+flags_iptr]
|
|
xor eax,eax
|
|
movzx edx,BYTE PTR [esi+FMUSIC_INSTRUMENT.VIBtype]
|
|
lea edi,[ebx+FMUSIC_CHANNEL.ivibpos-2]
|
|
dec edx ; switch(iptr->VIBtype)
|
|
js ivib_case_0
|
|
mov al,128
|
|
jz ivib_case_1
|
|
dec edx
|
|
jz ivib_case_2
|
|
; case 3 / default
|
|
mov dl,-128 ; -128 = 384 on a 1byte scope
|
|
sub edx,[edi]
|
|
trim:
|
|
movzx edx,dl
|
|
sub eax,edx
|
|
sar eax,1 ; delta = (128-((384-cptr->ivibpos)&0xFF))>>1 (case 3)
|
|
; delta = (128-((cptr->ivibpos+128)&0xFF))>>1 (case 2)
|
|
jmp ivib_end_switch
|
|
ivib_case_2:
|
|
mov edx,[edi]
|
|
sub edx,eax
|
|
jmp trim
|
|
ivib_case_1:
|
|
cmp [edi],eax
|
|
sbb edx,edx
|
|
and edx,eax
|
|
lea eax,[edx-64] ; delta = +/- 64
|
|
jmp ivib_end_switch
|
|
ivib_case_0:
|
|
; delta = 64 sin(2 Pi x/256)
|
|
mov ecx,[edi]
|
|
mov edx,ecx
|
|
and ecx,7Fh
|
|
cmp ecx,65
|
|
adc eax,-1
|
|
xor ecx,eax
|
|
and eax,129
|
|
add ecx,eax
|
|
shr edx,8
|
|
movzx eax,BYTE PTR [OFFSET sin64+ecx]
|
|
sbb edx,edx
|
|
xor eax,edx
|
|
sub eax,edx
|
|
ivib_end_switch:
|
|
movzx edx,BYTE PTR [esi+FMUSIC_INSTRUMENT.iVIBdepth]
|
|
imul edx,eax ; delta *= iptr->iVIBdepth
|
|
movzx eax,BYTE PTR [esi+FMUSIC_INSTRUMENT.VIBsweep]
|
|
test eax,eax
|
|
jz sweep_ok
|
|
push edi
|
|
xchg eax,edi
|
|
mov eax,[ebx+FMUSIC_CHANNEL.ivibsweeppos-2]
|
|
imul edx
|
|
idiv edi
|
|
xchg eax,edx ; delta *= cptr->ivibsweeppos/iptr->VIBsweep
|
|
xchg eax,edi ; iptr->VIBsweep
|
|
pop edi
|
|
sweep_ok:
|
|
sar edx,6
|
|
add [ebx+FMUSIC_CHANNEL.freqdelta-2],edx ; cptr->freqdelta += delta>>6
|
|
mov edx,[ebx+FMUSIC_CHANNEL.ivibsweeppos-2]
|
|
inc edx
|
|
cmp edx,eax
|
|
jle sweeppos_ok
|
|
xchg eax,edx
|
|
sweeppos_ok:
|
|
movzx eax,BYTE PTR [esi+FMUSIC_INSTRUMENT.VIBrate]
|
|
add eax,[edi] ; cptr->ivibpos += iptr->VIBrate
|
|
mov [ebx+FMUSIC_CHANNEL.ivibsweeppos-2],edx
|
|
neg ah
|
|
or BYTE PTR [ebx+FMUSIC_CHANNEL.notectrl-2],FMUSIC_FREQ
|
|
neg ah
|
|
sbb ah,0 ; ivibpos - 256
|
|
mov [edi],eax
|
|
endif ; INSTRUMENTVIBRATO_ON
|
|
mov esi,[ebx+FMUSIC_CHANNEL.cptr-2]
|
|
test BYTE PTR [ebx+FMUSIC_CHANNEL.notectrl-2],FMUSIC_TRIGGER
|
|
jz no_trig
|
|
; TRIGGER: allocate a channel
|
|
cmp DWORD PTR [esi+FSOUND_CHANNEL.fsptr],0
|
|
jz no_swap
|
|
; Swap between channels to avoid sounds cutting each other off and causing a click
|
|
mov ecx,esi
|
|
sub ecx,DWORD PTR [OFFSET _mod+FMUSIC_MODULE.Channels]
|
|
shr ecx,7 ; /FSOUND_CHANNEL_size + 1
|
|
sbb edi,edi
|
|
and edi,-FSOUND_CHANNEL_size*2
|
|
lea edi,[esi+edi+FSOUND_CHANNEL_size]
|
|
push edi
|
|
; Copy the whole channel except it's trailing data
|
|
push (FSOUND_CHANNEL_size-20)/4
|
|
mov [ebx+FMUSIC_CHANNEL.cptr-2],edi
|
|
pop ecx
|
|
rep movsd
|
|
; This should cause the old channel to ramp out nicely
|
|
mov [esi+FSOUND_CHANNEL.actualvolume-FSOUND_CHANNEL.fsptr],ecx
|
|
mov [esi+FSOUND_CHANNEL.leftvolume-FSOUND_CHANNEL.fsptr],ecx
|
|
mov [esi+FSOUND_CHANNEL.rightvolume-FSOUND_CHANNEL.fsptr],ecx
|
|
pop esi
|
|
no_swap:
|
|
lea edi,[esi+FSOUND_CHANNEL.fsptr]
|
|
mov eax,[esp+flags_sptr]
|
|
stosd ; fsptr
|
|
; START THE SOUND!
|
|
xor eax,eax
|
|
mov edx,[esi+FSOUND_CHANNEL.fsampleoffset]
|
|
stosd ; mixposlo
|
|
stosd ; ramp_leftvolume
|
|
stosd ; ramp_rightvolume
|
|
stosd ; ramp_count, speeddir
|
|
mov [esi+FSOUND_CHANNEL.fsampleoffset],eax
|
|
mov [esi+FSOUND_CHANNEL.mixpos],edx
|
|
no_trig:
|
|
mov eax,[ebx+FMUSIC_CHANNEL.volume-2]
|
|
xor ecx,ecx
|
|
cdq
|
|
not edx
|
|
and eax,edx
|
|
cmp eax,64
|
|
jle volume_le64
|
|
lea eax,[ecx+64]
|
|
volume_le64:
|
|
dec cl ; ecx <- 255
|
|
mov [ebx+FMUSIC_CHANNEL.volume-2],eax
|
|
test BYTE PTR [ebx+FMUSIC_CHANNEL.notectrl-2],FMUSIC_VOLUME
|
|
jz no_volume
|
|
add eax,[ebx+FMUSIC_CHANNEL.voldelta-2] ; 6 bit (64)
|
|
imul DWORD PTR [ebx+FMUSIC_CHANNEL.envvol-2] ; 6 bit (64)
|
|
imul DWORD PTR [_mod+FMUSIC_MODULE.globalvolume] ; 6 bit (64)
|
|
imul ecx ; eax *= 255
|
|
imul DWORD PTR [ebx+FMUSIC_CHANNEL.fadeoutvol-2] ; 16 bit (65536)
|
|
; eax:edx /= (2 * 64 * 64 * 64 * 65536)
|
|
sar edx,3
|
|
mov eax,[esi+FSOUND_CHANNEL.actualpan]
|
|
mov [esi+FSOUND_CHANNEL.actualvolume],edx
|
|
mov edi,edx
|
|
imul edx
|
|
idiv ecx
|
|
mov [esi+FSOUND_CHANNEL.leftvolume],eax ; leftvolume <- volume*actualpan/255
|
|
mov eax,ecx
|
|
sub eax,[esi+FSOUND_CHANNEL.actualpan]
|
|
imul edi
|
|
idiv ecx
|
|
mov [esi+FSOUND_CHANNEL.rightvolume],eax
|
|
no_volume:
|
|
test BYTE PTR [ebx+FMUSIC_CHANNEL.notectrl-2],FMUSIC_PAN
|
|
jz no_pan
|
|
mov edi,128
|
|
mov eax,[ebx+FMUSIC_CHANNEL.pan-2]
|
|
sub eax,edi
|
|
cdq
|
|
xor eax,edx
|
|
sub eax,edx
|
|
sub edi,eax
|
|
mov eax,[ebx+FMUSIC_CHANNEL.envpan-2]
|
|
sar edi,5
|
|
sub eax,32
|
|
imul edi
|
|
add eax,[ebx+FMUSIC_CHANNEL.pan-2]
|
|
cdq
|
|
not edx
|
|
and eax,edx ; if(pan < 0) pan = 0
|
|
mov edi,[esi] ; actualvolume
|
|
cmp eax,ecx
|
|
mov edx,ecx
|
|
xchg eax,edi
|
|
jae pan_ae255
|
|
imul edi
|
|
idiv ecx
|
|
mov edx,edi
|
|
pan_ae255:
|
|
xchg eax,edx
|
|
mov [esi+FSOUND_CHANNEL.actualpan],eax
|
|
mov [esi+FSOUND_CHANNEL.leftvolume],edx
|
|
not al ; 255 - pan
|
|
imul DWORD PTR [esi] ; actualvolume
|
|
idiv ecx
|
|
mov [esi+FSOUND_CHANNEL.rightvolume],eax
|
|
no_pan:
|
|
test BYTE PTR [ebx+FMUSIC_CHANNEL.notectrl-2],FMUSIC_FREQ
|
|
jz no_freq
|
|
mov ecx,[ebx+FMUSIC_CHANNEL.freq-2]
|
|
xor edx,edx
|
|
add ecx,[ebx+FMUSIC_CHANNEL.freqdelta-2]
|
|
lea eax,[edx+40] ; f = 40 Hz
|
|
jle freq_bounds_ok
|
|
test BYTE PTR [_mod+FMUSIC_MODULE.flags],1
|
|
jnz modflags_n1
|
|
mov eax,0DA7790h
|
|
div ecx
|
|
xor edx,edx
|
|
jmp freq_bounds_ok
|
|
modflags_n1:
|
|
mov eax,4608
|
|
sub eax,[ebx+FMUSIC_CHANNEL.freq-2]
|
|
add eax,[ebx+FMUSIC_CHANNEL.freqdelta-2]
|
|
push eax
|
|
fild DWORD PTR [esp]
|
|
fmul DWORD PTR [f0_0013]
|
|
fld st0
|
|
frndint
|
|
fsub st1,st0
|
|
fxch st1
|
|
f2xm1
|
|
fld1
|
|
faddp st1,st0
|
|
fscale
|
|
fstp st1
|
|
fmul DWORD PTR [f8363_0]
|
|
fistp DWORD PTR [esp]
|
|
pop eax ; freq = 625.271028*exp2((4608-period)/64)
|
|
freq_bounds_ok:
|
|
mov ebx,FSOUND_MixRate
|
|
div ebx
|
|
mov [esi+FSOUND_CHANNEL.speedhi],eax
|
|
div ebx
|
|
mov [esi+FSOUND_CHANNEL.speedlo],eax
|
|
no_freq:
|
|
pop edi
|
|
pop esi
|
|
if INSTRUMENTVIBRATO_ON
|
|
ret 8
|
|
else
|
|
ret 4
|
|
endif |