545 lines
14 KiB
C
545 lines
14 KiB
C
/*
|
|
PokeMini - Pokémon-Mini Emulator
|
|
Copyright (C) 2009-2015 JustBurn
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "PokeMini.h"
|
|
|
|
TMinxAudio MinxAudio;
|
|
int AudioEnabled = 0;
|
|
int SoundEngine = MINX_AUDIO_DISABLED;
|
|
int PiezoFilter = 0;
|
|
int RequireSoundSync = 0;
|
|
int16_t *MinxAudio_FIFO = NULL;
|
|
volatile int MinxAudio_ReadPtr = 0;
|
|
volatile int MinxAudio_WritePtr = 0;
|
|
int MinxAudio_FIFOSize = 0;
|
|
int MinxAudio_FIFOMask = 0;
|
|
int MinxAudio_FIFOThreshold = 0;
|
|
int16_t (*MinxAudio_AudioProcess)(void) = NULL;
|
|
|
|
// Timers counting frequency table
|
|
const uint32_t MinxAudio_CountFreq[32] = {
|
|
// Osci1 disabled
|
|
1, 0, 0, 0, 0, 0, 0, 0,
|
|
// Osci1 Enabled
|
|
(4000000/2), (4000000/8), (4000000/32), (4000000/64),
|
|
(4000000/128), (4000000/256), (4000000/1024), (4000000/4096),
|
|
// Osci2 disabled
|
|
0, 0, 0, 0, 0, 0, 0, 0,
|
|
// Osci2 Enabled
|
|
(32768/1), (32768/2), (32768/4), (32768/8),
|
|
(32768/16), (32768/32), (32768/64), (32768/128)
|
|
};
|
|
|
|
//
|
|
// FIFO I/O
|
|
//
|
|
|
|
static inline int MinxAudio_iSamplesInBuffer(void)
|
|
{
|
|
if (MinxAudio_WritePtr > MinxAudio_ReadPtr) return MinxAudio_WritePtr - MinxAudio_ReadPtr;
|
|
else return (MinxAudio_FIFOSize - MinxAudio_ReadPtr) + MinxAudio_WritePtr;
|
|
}
|
|
|
|
int MinxAudio_TotalSamples(void)
|
|
{
|
|
return MinxAudio_FIFOSize;
|
|
}
|
|
|
|
int MinxAudio_SamplesInBuffer(void)
|
|
{
|
|
return MinxAudio_iSamplesInBuffer();
|
|
}
|
|
|
|
static inline void MinxAudio_FIFOWrite(int16_t data)
|
|
{
|
|
if (MinxAudio_iSamplesInBuffer() < MinxAudio_FIFOSize) {
|
|
MinxAudio_FIFO[MinxAudio_WritePtr] = data;
|
|
MinxAudio_WritePtr = (MinxAudio_WritePtr + 1) & MinxAudio_FIFOMask;
|
|
}
|
|
}
|
|
|
|
static inline int16_t MinxAudio_FIFORead(void)
|
|
{
|
|
int16_t data = 0;
|
|
if (MinxAudio_iSamplesInBuffer() > 0) {
|
|
data = MinxAudio_FIFO[MinxAudio_ReadPtr];
|
|
MinxAudio_ReadPtr = (MinxAudio_ReadPtr + 1) & MinxAudio_FIFOMask;
|
|
}
|
|
return data;
|
|
}
|
|
|
|
//
|
|
// Functions
|
|
//
|
|
|
|
int MinxAudio_Create(int audioenable, int fifosize)
|
|
{
|
|
// Init variables
|
|
AudioEnabled = audioenable;
|
|
SoundEngine = MINX_AUDIO_DISABLED;
|
|
RequireSoundSync = 0;
|
|
|
|
// Reset
|
|
MinxAudio_Reset(1);
|
|
|
|
// Init FIFO if audio enabled
|
|
MinxAudio_ReadPtr = 0;
|
|
MinxAudio_WritePtr = 0;
|
|
if (fifosize) {
|
|
MinxAudio_FIFOMask = GetMultiple2Mask(fifosize);
|
|
MinxAudio_FIFOSize = MinxAudio_FIFOMask + 1;
|
|
MinxAudio_FIFOThreshold = (fifosize * 3) >> 2; // ... at 3 / 4
|
|
} else {
|
|
MinxAudio_FIFOMask = 0;
|
|
MinxAudio_FIFOSize = 0;
|
|
MinxAudio_FIFOThreshold = 0;
|
|
}
|
|
if ((audioenable) && (fifosize)) {
|
|
MinxAudio_FIFO = (int16_t *)malloc(MinxAudio_FIFOSize*2);
|
|
if (!MinxAudio_FIFO) return 0;
|
|
memset(MinxAudio_FIFO, 0, MinxAudio_FIFOSize*2);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void MinxAudio_Destroy(void)
|
|
{
|
|
if (MinxAudio_FIFO) {
|
|
free(MinxAudio_FIFO);
|
|
MinxAudio_FIFO = NULL;
|
|
}
|
|
}
|
|
|
|
void MinxAudio_Reset(int hardreset)
|
|
{
|
|
// Initialize State
|
|
memset((void *)&MinxAudio, 0, sizeof(TMinxAudio));
|
|
}
|
|
|
|
int MinxAudio_LoadState(FILE *fi, uint32_t bsize)
|
|
{
|
|
POKELOADSS_START(32);
|
|
POKELOADSS_32(MinxAudio.AudioCCnt);
|
|
POKELOADSS_32(MinxAudio.AudioSCnt);
|
|
POKELOADSS_16(MinxAudio.Volume);
|
|
POKELOADSS_16(MinxAudio.PWMMul);
|
|
POKELOADSS_X(20);
|
|
POKELOADSS_END(32);
|
|
}
|
|
|
|
int MinxAudio_SaveState(FILE *fi)
|
|
{
|
|
POKESAVESS_START(32);
|
|
POKESAVESS_32(MinxAudio.AudioCCnt);
|
|
POKESAVESS_32(MinxAudio.AudioSCnt);
|
|
POKESAVESS_16(MinxAudio.Volume);
|
|
POKESAVESS_16(MinxAudio.PWMMul);
|
|
POKESAVESS_X(20);
|
|
POKESAVESS_END(32);
|
|
}
|
|
|
|
void MinxAudio_ChangeEngine(int engine)
|
|
{
|
|
if (PokeMini_Flags & POKEMINI_GENSOUND) {
|
|
engine = engine ? 1 : 0;
|
|
}
|
|
SoundEngine = engine;
|
|
switch (engine) {
|
|
case MINX_AUDIO_GENERATED:
|
|
RequireSoundSync = 0;
|
|
MinxAudio_AudioProcess = NULL;
|
|
break;
|
|
case MINX_AUDIO_DIRECT:
|
|
RequireSoundSync = 1;
|
|
MinxAudio_AudioProcess = MinxAudio_AudioProcessDirect;
|
|
break;
|
|
case MINX_AUDIO_EMULATED:
|
|
RequireSoundSync = 1;
|
|
MinxAudio_AudioProcess = MinxAudio_AudioProcessEmulated;
|
|
break;
|
|
case MINX_AUDIO_DIRECTPWM:
|
|
RequireSoundSync = 1;
|
|
MinxAudio_AudioProcess = MinxAudio_AudioProcessDirectPWM;
|
|
break;
|
|
default:
|
|
RequireSoundSync = 0;
|
|
MinxAudio_AudioProcess = NULL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void MinxAudio_ChangeFilter(int piezo)
|
|
{
|
|
PiezoFilter = piezo;
|
|
}
|
|
|
|
void MinxAudio_Sync(void)
|
|
{
|
|
// Process single audio sample
|
|
MinxAudio.AudioCCnt += MINX_AUDIOINC * PokeHWCycles;
|
|
if (MinxAudio.AudioCCnt >= 0x01000000) {
|
|
MinxAudio.AudioCCnt -= 0x01000000;
|
|
if (MinxAudio_AudioProcess) {
|
|
if (PiezoFilter) {
|
|
MinxAudio_FIFOWrite(MinxAudio_PiezoFilter(MinxAudio_AudioProcess()));
|
|
} else {
|
|
MinxAudio_FIFOWrite(MinxAudio_AudioProcess());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
uint8_t MinxAudio_ReadReg(uint8_t reg)
|
|
{
|
|
// 0x70 to 0x71
|
|
switch(reg) {
|
|
case 0x70: // Unknown Audio Control
|
|
return PMR_AUD_CTRL & 0x07;
|
|
case 0x71: // Audio Volume Control
|
|
return PMR_AUD_VOL & 0x07;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void MinxAudio_WriteReg(uint8_t reg, uint8_t val)
|
|
{
|
|
// 0x70 to 0x71
|
|
switch(reg) {
|
|
case 0x70: // Unknown Audio Control
|
|
PMR_AUD_CTRL = val & 0x07;
|
|
break;
|
|
case 0x71: // Audio Volume Control
|
|
PMR_AUD_VOL = val & 0x07;
|
|
break;
|
|
}
|
|
|
|
// Calculate volume
|
|
if (PMR_AUD_CTRL & 0x03) {
|
|
// Mute audio
|
|
MinxAudio.Volume = 0;
|
|
} else {
|
|
switch (PMR_AUD_VOL & 3) {
|
|
case 0:
|
|
// 0% Sound
|
|
MinxAudio.Volume = MINX_AUDIO_SILENCE;
|
|
MinxAudio.PWMMul = 0;
|
|
break;
|
|
case 1:
|
|
case 2:
|
|
// 50% Sound
|
|
MinxAudio.Volume = MINX_AUDIO_MED_VOL;
|
|
MinxAudio.PWMMul = 1;
|
|
break;
|
|
case 3:
|
|
// 100% Sound
|
|
MinxAudio.Volume = MINX_AUDIO_MAX_VOL;
|
|
MinxAudio.PWMMul = 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get emulated frequency and pulsewidth
|
|
// Sound_Frequency is in Hz
|
|
// Pulse_Width is between 0 to 4095 (0% to ~99.99%)
|
|
void MinxAudio_GetEmulated(int *Sound_Frequency, int *Pulse_Width)
|
|
{
|
|
int Timer3_Frequency;
|
|
int Preset_Value, Sound_Pivot;
|
|
|
|
// Calculate timer 3 frequency
|
|
Timer3_Frequency = MinxAudio_CountFreq[(PMR_TMR3_SCALE & 0xF) | ((PMR_TMR3_OSC & 0x01) << 4)];
|
|
if (!(PMR_TMR3_CTRL_L & 0x04)) Timer3_Frequency = 0;
|
|
if (PMR_TMR3_OSC & 0x01) {
|
|
// Osci2
|
|
if (!MinxTimers.TmrXEna2) Timer3_Frequency = 0;
|
|
} else {
|
|
// Osci1
|
|
if (!MinxTimers.TmrXEna1) Timer3_Frequency = 0;
|
|
}
|
|
|
|
if (Timer3_Frequency) {
|
|
// Calculate preset value
|
|
Preset_Value = (MinxTimers.Tmr3PreA >> 24) + ((MinxTimers.Tmr3PreB >> 24) << 8);
|
|
|
|
// Calculate sound frequency
|
|
*Sound_Frequency = Timer3_Frequency / (Preset_Value + 1);
|
|
|
|
// ... and pulse width
|
|
if (Preset_Value) {
|
|
Sound_Pivot = (int)MinxTimers.Timer3Piv;
|
|
*Pulse_Width = 4095 - (Sound_Pivot * 4096 / Preset_Value);
|
|
if (*Pulse_Width < 0) *Pulse_Width = 0;
|
|
} else *Pulse_Width = 0;
|
|
} else {
|
|
*Sound_Frequency = 0;
|
|
*Pulse_Width = 0;
|
|
}
|
|
}
|
|
|
|
int16_t MinxAudio_AudioProcessDirect(void)
|
|
{
|
|
uint16_t TmrCnt;
|
|
TmrCnt = (MinxTimers.Tmr3CntA >> 24) | ((MinxTimers.Tmr3CntB >> 24) << 8);
|
|
|
|
if (TmrCnt <= MinxTimers.Timer3Piv) {
|
|
return MinxAudio.Volume;
|
|
}
|
|
return MINX_AUDIO_SILENCE;
|
|
}
|
|
|
|
int16_t MinxAudio_AudioProcessEmulated(void)
|
|
{
|
|
int Sound_Frequency, Pulse_Width;
|
|
MinxAudio_GetEmulated(&Sound_Frequency, &Pulse_Width);
|
|
if (Sound_Frequency < 50) {
|
|
// Silence
|
|
return MINX_AUDIO_SILENCE;
|
|
} else if (Sound_Frequency < 20000) {
|
|
// Normal
|
|
MinxAudio.AudioSCnt -= Sound_Frequency * MINX_AUDIOCONV;
|
|
if ((MinxAudio.AudioSCnt & 0xFFF00000) >= (Pulse_Width << 20)) {
|
|
return MinxAudio.Volume;
|
|
}
|
|
return MINX_AUDIO_SILENCE;
|
|
}
|
|
// PWM
|
|
if (Pulse_Width > 4095) Pulse_Width = 4095;
|
|
return MINX_AUDIO_SILENCE + (Pulse_Width << 2) * MinxAudio.PWMMul;
|
|
}
|
|
|
|
int16_t MinxAudio_AudioProcessDirectPWM(void)
|
|
{
|
|
uint16_t TmrCnt, TmrPre;
|
|
uint32_t Pwm;
|
|
TmrCnt = (MinxTimers.Tmr3CntA >> 24) | ((MinxTimers.Tmr3CntB >> 24) << 8);
|
|
TmrPre = (MinxTimers.Tmr3PreA >> 24) | ((MinxTimers.Tmr3PreB >> 24) << 8);
|
|
|
|
// Affect sound based of PWM
|
|
if (TmrPre) Pwm = MinxTimers.Timer3Piv * MINX_AUDIO_PWM_RAG / TmrPre; else Pwm = 0;
|
|
if (Pwm > MINX_AUDIO_PWM_RAG) Pwm = MINX_AUDIO_PWM_RAG-1; // Avoid clipping
|
|
if (TmrPre < 128) TmrCnt = 0; // Avoid high hizz
|
|
|
|
// Output
|
|
if (TmrCnt <= MinxTimers.Timer3Piv) {
|
|
return MinxAudio.Volume + Pwm * MinxAudio.PWMMul;
|
|
}
|
|
return MINX_AUDIO_SILENCE + Pwm * MinxAudio.PWMMul;
|
|
}
|
|
|
|
int16_t MinxAudio_PiezoFilter(int32_t Sample)
|
|
{
|
|
int32_t HP_pCoeff = 40960;
|
|
int32_t LP_pCoeff = 4096;
|
|
int32_t LP_nCoeff = (65535 - LP_pCoeff);
|
|
static int32_t HPSamples[4], LPSamples[4];
|
|
int32_t TmpSamples[4];
|
|
|
|
// High pass to simulate a piezo crystal speaker
|
|
TmpSamples[0] = Sample;
|
|
TmpSamples[1] = (HP_pCoeff * (TmpSamples[0] + HPSamples[1] - HPSamples[0])) >> 16;
|
|
TmpSamples[2] = (HP_pCoeff * (TmpSamples[1] + HPSamples[2] - HPSamples[1])) >> 16;
|
|
TmpSamples[3] = (HP_pCoeff * (TmpSamples[2] + HPSamples[3] - HPSamples[2])) >> 16;
|
|
memcpy(HPSamples, TmpSamples, sizeof(HPSamples));
|
|
|
|
// Amplify by 4
|
|
Sample = TmpSamples[3] << 2;
|
|
if (Sample < -32768) Sample = -32768;
|
|
if (Sample > 32767) Sample = 32767;
|
|
|
|
// Low pass to kill the spikes in sound
|
|
LPSamples[0] = Sample;
|
|
LPSamples[1] = (LPSamples[1] * LP_pCoeff + LPSamples[0] * LP_nCoeff) >> 16;
|
|
LPSamples[2] = (LPSamples[2] * LP_pCoeff + LPSamples[1] * LP_nCoeff) >> 16;
|
|
LPSamples[3] = (LPSamples[3] * LP_pCoeff + LPSamples[2] * LP_nCoeff) >> 16;
|
|
|
|
// Amplify by 2, clamp and output
|
|
Sample = LPSamples[3] << 1;
|
|
if (Sample < -32768) Sample = -32768;
|
|
if (Sample > 32767) Sample = 32767;
|
|
|
|
return Sample;
|
|
}
|
|
|
|
void MinxAudio_GetSamplesU8(uint8_t *soundout, int numsamples)
|
|
{
|
|
if (SoundEngine == MINX_AUDIO_GENERATED) {
|
|
MinxAudio_GenerateEmulatedU8(soundout, numsamples, 1);
|
|
return;
|
|
}
|
|
if (AudioEnabled && SoundEngine) {
|
|
while (numsamples--) {
|
|
*soundout++ = 0x80 + (MinxAudio_FIFORead() >> 8);
|
|
}
|
|
} else {
|
|
while (numsamples--) *soundout++ = 0x80;
|
|
}
|
|
}
|
|
|
|
void MinxAudio_GetSamplesS16(int16_t *soundout, int numsamples)
|
|
{
|
|
if (SoundEngine == MINX_AUDIO_GENERATED) {
|
|
MinxAudio_GenerateEmulatedS16(soundout, numsamples, 1);
|
|
return;
|
|
}
|
|
if (AudioEnabled && SoundEngine) {
|
|
while (numsamples--) {
|
|
*soundout++ = MinxAudio_FIFORead();
|
|
}
|
|
} else {
|
|
while (numsamples--) *soundout++ = 0x0000;
|
|
}
|
|
}
|
|
|
|
void MinxAudio_GetSamplesU8Ch(uint8_t *soundout, int numsamples, int channels)
|
|
{
|
|
int j;
|
|
if (SoundEngine == MINX_AUDIO_GENERATED) {
|
|
MinxAudio_GenerateEmulatedU8(soundout, numsamples, channels);
|
|
return;
|
|
}
|
|
if (AudioEnabled && SoundEngine) {
|
|
while (numsamples--) {
|
|
uint8_t sample = 0x80 + (MinxAudio_FIFORead() >> 8);
|
|
for (j=0; j<channels; j++) *soundout++ = sample;
|
|
}
|
|
} else {
|
|
while (numsamples--) for (j=0; j<channels; j++) *soundout++ = 0x80;
|
|
}
|
|
}
|
|
|
|
void MinxAudio_GetSamplesS16Ch(int16_t *soundout, int numsamples, int channels)
|
|
{
|
|
int j;
|
|
if (SoundEngine == MINX_AUDIO_GENERATED) {
|
|
MinxAudio_GenerateEmulatedS16(soundout, numsamples, channels);
|
|
return;
|
|
}
|
|
if (AudioEnabled && SoundEngine) {
|
|
while (numsamples--) {
|
|
int16_t sample = MinxAudio_FIFORead();
|
|
for (j=0; j<channels; j++) *soundout++ = sample;
|
|
}
|
|
} else {
|
|
while (numsamples--) for (j=0; j<channels; j++) *soundout++ = 0x0000;
|
|
}
|
|
}
|
|
|
|
int MinxAudio_SyncWithAudio(void)
|
|
{
|
|
if (!RequireSoundSync) return 0;
|
|
return MinxAudio_iSamplesInBuffer() >= MinxAudio_FIFOThreshold;
|
|
}
|
|
|
|
// This doesn't require audio to be created:
|
|
|
|
void MinxAudio_GenerateEmulatedU8(uint8_t *soundout, int numsamples, int channels)
|
|
{
|
|
int i, j, Sound_Frequency, Pulse_Width;
|
|
if (numsamples <= 0) return;
|
|
MinxAudio_GetEmulated(&Sound_Frequency, &Pulse_Width);
|
|
for (i=0; i<numsamples; i++) {
|
|
if ((Sound_Frequency >= 50) && (Sound_Frequency < 20000)) {
|
|
MinxAudio.AudioSCnt += Sound_Frequency * MINX_AUDIOCONV;
|
|
if ((MinxAudio.AudioSCnt & 0xFFF00000) >= (Pulse_Width << 20)) {
|
|
if (PiezoFilter) {
|
|
for (j=0; j<channels; j++) *soundout++ = 0x80 + (MinxAudio_PiezoFilter(MinxAudio.Volume) >> 8);
|
|
} else {
|
|
for (j=0; j<channels; j++) *soundout++ = 0x80 + (MinxAudio.Volume >> 8);
|
|
}
|
|
} else {
|
|
if (PiezoFilter) {
|
|
for (j=0; j<channels; j++) *soundout++ = 0x80 + (MinxAudio_PiezoFilter(MINX_AUDIO_SILENCE) >> 8);
|
|
} else {
|
|
for (j=0; j<channels; j++) *soundout++ = 0x80;
|
|
}
|
|
}
|
|
} else {
|
|
if (PiezoFilter) {
|
|
for (j=0; j<channels; j++) *soundout++ = 0x80 + (MinxAudio_PiezoFilter(MINX_AUDIO_SILENCE) >> 8);
|
|
} else {
|
|
for (j=0; j<channels; j++) *soundout++ = 0x80;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MinxAudio_GenerateEmulatedS8(int8_t *soundout, int numsamples, int channels)
|
|
{
|
|
int i, j, Sound_Frequency, Pulse_Width;
|
|
if (numsamples <= 0) return;
|
|
MinxAudio_GetEmulated(&Sound_Frequency, &Pulse_Width);
|
|
for (i=0; i<numsamples; i++) {
|
|
if ((Sound_Frequency >= 50) && (Sound_Frequency < 20000)) {
|
|
MinxAudio.AudioSCnt += Sound_Frequency * MINX_AUDIOCONV;
|
|
if ((MinxAudio.AudioSCnt & 0xFFF00000) >= (Pulse_Width << 20)) {
|
|
if (PiezoFilter) {
|
|
for (j=0; j<channels; j++) *soundout++ = (MinxAudio_PiezoFilter(MinxAudio.Volume) >> 8);
|
|
} else {
|
|
for (j=0; j<channels; j++) *soundout++ = (MinxAudio.Volume >> 8);
|
|
}
|
|
} else {
|
|
if (PiezoFilter) {
|
|
for (j=0; j<channels; j++) *soundout++ = (MinxAudio_PiezoFilter(MINX_AUDIO_SILENCE) >> 8);
|
|
} else {
|
|
for (j=0; j<channels; j++) *soundout++ = 0;
|
|
}
|
|
}
|
|
} else {
|
|
if (PiezoFilter) {
|
|
for (j=0; j<channels; j++) *soundout++ = (MinxAudio_PiezoFilter(MINX_AUDIO_SILENCE) >> 8);
|
|
} else {
|
|
for (j=0; j<channels; j++) *soundout++ = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MinxAudio_GenerateEmulatedS16(int16_t *soundout, int numsamples, int channels)
|
|
{
|
|
int i, j, Sound_Frequency, Pulse_Width;
|
|
if (numsamples <= 0) return;
|
|
MinxAudio_GetEmulated(&Sound_Frequency, &Pulse_Width);
|
|
for (i=0; i<numsamples; i++) {
|
|
if ((Sound_Frequency >= 50) && (Sound_Frequency < 20000)) {
|
|
MinxAudio.AudioSCnt += Sound_Frequency * MINX_AUDIOCONV;
|
|
if ((MinxAudio.AudioSCnt & 0xFFF00000) >= (Pulse_Width << 20)) {
|
|
if (PiezoFilter) {
|
|
for (j=0; j<channels; j++) *soundout++ = MinxAudio_PiezoFilter(MinxAudio.Volume);
|
|
} else {
|
|
for (j=0; j<channels; j++) *soundout++ = MinxAudio.Volume;
|
|
}
|
|
} else {
|
|
if (PiezoFilter) {
|
|
for (j=0; j<channels; j++) *soundout++ = MinxAudio_PiezoFilter(MINX_AUDIO_SILENCE);
|
|
} else {
|
|
for (j=0; j<channels; j++) *soundout++ = 0;
|
|
}
|
|
}
|
|
} else {
|
|
if (PiezoFilter) {
|
|
for (j=0; j<channels; j++) *soundout++ = MinxAudio_PiezoFilter(MINX_AUDIO_SILENCE);
|
|
} else {
|
|
for (j=0; j<channels; j++) *soundout++ = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|