ref: 5ffa61cd4ef639f057683070f1c85fe5ecaeec0c
dir: /src/ft2_smpfx.c/
// for finding memory leaks in debug mode with Visual Studio
#if defined _DEBUG && defined _MSC_VER
#include <crtdbg.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <math.h>
#include "ft2_header.h"
#include "ft2_audio.h"
#include "ft2_pattern_ed.h"
#include "ft2_gui.h"
#include "ft2_sample_ed.h"
#include "ft2_structs.h"
#include "ft2_replayer.h"
#define RESONANCE_RANGE 99
#define RESONANCE_MIN 0.01 /* prevent massive blow-up */
enum
{
REMOVE_SAMPLE_MARK = 0,
KEEP_SAMPLE_MARK = 1
};
static struct
{
bool filled, keepSampleMark;
uint8_t flags, undoInstr, undoSmp;
uint32_t length, loopStart, loopLength;
int8_t *smpData8;
int16_t *smpData16;
} sampleUndo;
typedef struct
{
double a1, a2, a3, b1, b2;
double inTmp[2], outTmp[2];
} resoFilter_t;
enum
{
FILTER_LOWPASS = 0,
FILTER_HIGHPASS = 1
};
static bool normalization;
static uint8_t lastFilterType;
static int32_t lastLpCutoff = 2000, lastHpCutoff = 200, filterResonance, smpCycles = 1, lastWaveLength = 64, lastAmp = 75;
void clearSampleUndo(void)
{
if (sampleUndo.smpData8 != NULL)
{
free(sampleUndo.smpData8);
sampleUndo.smpData8 = NULL;
}
if (sampleUndo.smpData16 != NULL)
{
free(sampleUndo.smpData16);
sampleUndo.smpData16 = NULL;
}
sampleUndo.filled = false;
sampleUndo.keepSampleMark = false;
}
static void fillSampleUndo(bool keepSampleMark)
{
sampleUndo.filled = false;
sample_t *s = getCurSample();
if (s != NULL && s->length > 0)
{
pauseAudio();
unfixSample(s);
clearSampleUndo();
sampleUndo.undoInstr = editor.curInstr;
sampleUndo.undoSmp = editor.curSmp;
sampleUndo.flags = s->flags;
sampleUndo.length = s->length;
sampleUndo.loopStart = s->loopStart;
sampleUndo.loopLength = s->loopLength;
sampleUndo.keepSampleMark = keepSampleMark;
if (s->flags & SAMPLE_16BIT)
{
sampleUndo.smpData16 = (int16_t *)malloc(s->length * sizeof (int16_t));
if (sampleUndo.smpData16 != NULL)
{
memcpy(sampleUndo.smpData16, s->dataPtr, s->length * sizeof (int16_t));
sampleUndo.filled = true;
}
}
else
{
sampleUndo.smpData8 = (int8_t *)malloc(s->length * sizeof (int8_t));
if (sampleUndo.smpData8 != NULL)
{
memcpy(sampleUndo.smpData8, s->dataPtr, s->length * sizeof (int8_t));
sampleUndo.filled = true;
}
}
fixSample(s);
resumeAudio();
}
}
static sample_t *setupNewSample(uint32_t length)
{
pauseAudio();
if (instr[editor.curInstr] == NULL)
allocateInstr(editor.curInstr);
if (instr[editor.curInstr] == NULL)
goto Error;
sample_t *s = &instr[editor.curInstr]->smp[editor.curSmp];
if (!reallocateSmpData(s, length, true))
goto Error;
s->isFixed = false;
s->length = length;
s->loopLength = s->loopStart = 0;
s->flags = SAMPLE_16BIT;
resumeAudio();
return s;
Error:
resumeAudio();
return NULL;
}
void cbSfxNormalization(void)
{
normalization ^= 1;
}
static void drawSampleCycles(void)
{
const int16_t x = 54;
fillRect(x, 352, 7*3, 8, PAL_DESKTOP);
char str[16];
sprintf(str, "%03d", smpCycles);
textOut(x, 352, PAL_FORGRND, str);
}
void pbSfxCyclesUp(void)
{
if (smpCycles < 256)
{
smpCycles++;
drawSampleCycles();
}
}
void pbSfxCyclesDown(void)
{
if (smpCycles > 1)
{
smpCycles--;
drawSampleCycles();
}
}
void pbSfxTriangle(void)
{
char lengthStr[5+1];
memset(lengthStr, '\0', sizeof (lengthStr));
snprintf(lengthStr, sizeof (lengthStr), "%d", lastWaveLength);
if (inputBox(1, "Enter new waveform length:", lengthStr, sizeof (lengthStr)-1) != 1)
return;
if (lengthStr[0] == '\0')
return;
lastWaveLength = (int32_t)atoi(lengthStr);
if (lastWaveLength <= 1 || lastWaveLength > 65536)
{
okBox(0, "System message", "Illegal range! Allowed range is 2..65535", NULL);
return;
}
fillSampleUndo(REMOVE_SAMPLE_MARK);
int32_t newLength = lastWaveLength * smpCycles;
pauseAudio();
sample_t *s = setupNewSample(newLength);
if (s == NULL)
{
resumeAudio();
okBox(0, "System message", "Not enough memory!", NULL);
return;
}
const double delta = 4.0 / lastWaveLength;
double phase = 0.0;
int16_t *ptr16 = (int16_t *)s->dataPtr;
for (int32_t i = 0; i < newLength; i++)
{
double t = phase;
if (t > 3.0)
t -= 4.0;
else if (t >= 1.0)
t = 2.0 - t;
*ptr16++ = (int16_t)(t * INT16_MAX);
phase = fmod(phase + delta, 4.0);
}
s->loopLength = newLength;
s->flags |= LOOP_FORWARD;
fixSample(s);
resumeAudio();
updateSampleEditorSample();
}
void pbSfxSaw(void)
{
char lengthStr[5+1];
memset(lengthStr, '\0', sizeof (lengthStr));
snprintf(lengthStr, sizeof (lengthStr), "%d", lastWaveLength);
if (inputBox(1, "Enter new waveform length:", lengthStr, sizeof (lengthStr)-1) != 1)
return;
if (lengthStr[0] == '\0')
return;
lastWaveLength = (int32_t)atoi(lengthStr);
if (lastWaveLength <= 1 || lastWaveLength > 65536)
{
okBox(0, "System message", "Illegal range! Allowed range is 2..65535", NULL);
return;
}
fillSampleUndo(REMOVE_SAMPLE_MARK);
int32_t newLength = lastWaveLength * smpCycles;
pauseAudio();
sample_t *s = setupNewSample(newLength);
if (s == NULL)
{
resumeAudio();
okBox(0, "System message", "Not enough memory!", NULL);
return;
}
uint64_t point64 = 0;
uint64_t delta64 = ((uint64_t)(INT16_MAX*2) << 32ULL) / lastWaveLength;
int16_t *ptr16 = (int16_t *)s->dataPtr;
for (int32_t i = 0; i < newLength; i++)
{
*ptr16++ = (int16_t)(point64 >> 32);
point64 += delta64;
}
s->loopLength = newLength;
s->flags |= LOOP_FORWARD;
fixSample(s);
resumeAudio();
updateSampleEditorSample();
}
void pbSfxSine(void)
{
char lengthStr[5+1];
memset(lengthStr, '\0', sizeof (lengthStr));
snprintf(lengthStr, sizeof (lengthStr), "%d", lastWaveLength);
if (inputBox(1, "Enter new waveform length:", lengthStr, sizeof (lengthStr)-1) != 1)
return;
if (lengthStr[0] == '\0')
return;
lastWaveLength = (int32_t)atoi(lengthStr);
if (lastWaveLength <= 1 || lastWaveLength > 65536)
{
okBox(0, "System message", "Illegal range! Allowed range is 2..65535", NULL);
return;
}
fillSampleUndo(REMOVE_SAMPLE_MARK);
int32_t newLength = lastWaveLength * smpCycles;
pauseAudio();
sample_t *s = setupNewSample(newLength);
if (s == NULL)
{
resumeAudio();
okBox(0, "System message", "Not enough memory!", NULL);
return;
}
const double dMul = (2.0 * M_PI) / lastWaveLength;
int16_t *ptr16 = (int16_t *)s->dataPtr;
for (int32_t i = 0; i < newLength; i++)
*ptr16++ = (int16_t)(INT16_MAX * sin(i * dMul));
s->loopLength = newLength;
s->flags |= LOOP_FORWARD;
fixSample(s);
resumeAudio();
updateSampleEditorSample();
}
void pbSfxSquare(void)
{
char lengthStr[5+1];
memset(lengthStr, '\0', sizeof (lengthStr));
snprintf(lengthStr, sizeof (lengthStr), "%d", lastWaveLength);
if (inputBox(1, "Enter new waveform length:", lengthStr, sizeof (lengthStr)-1) != 1)
return;
if (lengthStr[0] == '\0')
return;
lastWaveLength = (int32_t)atoi(lengthStr);
if (lastWaveLength <= 1 || lastWaveLength > 65536)
{
okBox(0, "System message", "Illegal range! Allowed range is 2..65535", NULL);
return;
}
fillSampleUndo(REMOVE_SAMPLE_MARK);
uint32_t newLength = lastWaveLength * smpCycles;
pauseAudio();
sample_t *s = setupNewSample(newLength);
if (s == NULL)
{
resumeAudio();
okBox(0, "System message", "Not enough memory!", NULL);
return;
}
const uint32_t halfWaveLength = lastWaveLength / 2;
int16_t currValue = INT16_MAX;
uint32_t counter = 0;
int16_t *ptr16 = (int16_t *)s->dataPtr;
for (uint32_t i = 0; i < newLength; i++)
{
*ptr16++ = currValue;
if (++counter >= halfWaveLength)
{
counter = 0;
currValue = -currValue;
}
}
s->loopLength = newLength;
s->flags |= LOOP_FORWARD;
fixSample(s);
resumeAudio();
updateSampleEditorSample();
}
void drawFilterResonance(void)
{
const int16_t x = 172;
fillRect(x, 352, 18, 12, PAL_DESKTOP);
if (filterResonance <= 0)
{
textOut(x, 352, PAL_FORGRND, "off");
}
else
{
char str[16];
sprintf(str, "%02d", filterResonance);
textOut(x+3, 352, PAL_FORGRND, str);
}
}
void pbSfxResoUp(void)
{
if (filterResonance < RESONANCE_RANGE)
{
filterResonance++;
drawFilterResonance();
}
}
void pbSfxResoDown(void)
{
if (filterResonance > 0)
{
filterResonance--;
drawFilterResonance();
}
}
#define CUTOFF_EPSILON (1E-4)
static void setupResoLpFilter(sample_t *s, resoFilter_t *f, double cutoff, uint32_t resonance, bool absoluteCutoff)
{
// 12dB/oct resonant low-pass filter
if (!absoluteCutoff)
{
const double sampleFreq = getSampleC4Rate(s);
if (cutoff >= sampleFreq/2.0)
cutoff = (sampleFreq/2.0) - CUTOFF_EPSILON;
cutoff /= sampleFreq;
}
double r = sqrt(2.0);
if (resonance > 0)
{
r = pow(10.0, (resonance * -24.0) / (RESONANCE_RANGE * 20.0));
if (r < RESONANCE_MIN)
r = RESONANCE_MIN;
}
const double c = 1.0 / tan(PI * cutoff);
f->a1 = 1.0 / (1.0 + r * c + c * c);
f->a2 = 2.0 * f->a1;
f->a3 = f->a1;
f->b1 = 2.0 * (1.0 - c*c) * f->a1;
f->b2 = (1.0 - r * c + c * c) * f->a1;
f->inTmp[0] = f->inTmp[1] = f->outTmp[0] = f->outTmp[1] = 0.0; // clear filter history
}
static void setupResoHpFilter(sample_t *s, resoFilter_t *f, double cutoff, uint32_t resonance, bool absoluteCutoff)
{
// 12dB/oct resonant high-pass filter
if (!absoluteCutoff)
{
const double sampleFreq = getSampleC4Rate(s);
if (cutoff >= sampleFreq/2.0)
cutoff = (sampleFreq/2.0) - CUTOFF_EPSILON;
cutoff /= sampleFreq;
}
double r = sqrt(2.0);
if (resonance > 0)
{
r = pow(10.0, (resonance * -24.0) / (RESONANCE_RANGE * 20.0));
if (r < RESONANCE_MIN)
r = RESONANCE_MIN;
}
const double c = tan(PI * cutoff);
f->a1 = 1.0 / (1.0 + r * c + c * c);
f->a2 = -2.0 * f->a1;
f->a3 = f->a1;
f->b1 = 2.0 * (c*c - 1.0) * f->a1;
f->b2 = (1.0 - r * c + c * c) * f->a1;
f->inTmp[0] = f->inTmp[1] = f->outTmp[0] = f->outTmp[1] = 0.0; // clear filter history
}
static bool applyResoFilter(sample_t *s, resoFilter_t *f)
{
int32_t x1, x2;
if (smpEd_Rx1 < smpEd_Rx2)
{
x1 = smpEd_Rx1;
x2 = smpEd_Rx2;
if (x2 > s->length)
x2 = s->length;
if (x1 < 0)
x1 = 0;
if (x2 <= x1)
return true;
}
else
{
// no mark, operate on whole sample
x1 = 0;
x2 = s->length;
}
const int32_t len = x2 - x1;
if (!normalization)
{
pauseAudio();
unfixSample(s);
if (s->flags & SAMPLE_16BIT)
{
int16_t *ptr16 = (int16_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
{
double out = (f->a1*ptr16[i]) + (f->a2*f->inTmp[0]) + (f->a3*f->inTmp[1]) - (f->b1*f->outTmp[0]) - (f->b2*f->outTmp[1]);
f->inTmp[1] = f->inTmp[0];
f->inTmp[0] = ptr16[i];
f->outTmp[1] = f->outTmp[0];
f->outTmp[0] = out;
ptr16[i] = (int16_t)CLAMP(out, INT16_MIN, INT16_MAX);
}
}
else
{
int8_t *ptr8 = (int8_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
{
double out = (f->a1*ptr8[i]) + (f->a2*f->inTmp[0]) + (f->a3*f->inTmp[1]) - (f->b1*f->outTmp[0]) - (f->b2*f->outTmp[1]);
f->inTmp[1] = f->inTmp[0];
f->inTmp[0] = ptr8[i];
f->outTmp[1] = f->outTmp[0];
f->outTmp[0] = out;
ptr8[i] = (int8_t)CLAMP(out, INT8_MIN, INT8_MAX);
}
}
fixSample(s);
resumeAudio();
}
else // normalize peak, no clipping
{
double *dSmp = (double *)malloc(len * sizeof (double));
if (dSmp == NULL)
{
okBox(0, "System message", "Not enough memory!", NULL);
return false;
}
pauseAudio();
unfixSample(s);
if (s->flags & SAMPLE_16BIT)
{
int16_t *ptr16 = (int16_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
dSmp[i] = (double)ptr16[i];
}
else
{
int8_t *ptr8 = (int8_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
dSmp[i] = (double)ptr8[i];
}
double peak = 0.0;
for (int32_t i = 0; i < len; i++)
{
const double out = (f->a1*dSmp[i]) + (f->a2*f->inTmp[0]) + (f->a3*f->inTmp[1]) - (f->b1*f->outTmp[0]) - (f->b2*f->outTmp[1]);
f->inTmp[1] = f->inTmp[0];
f->inTmp[0] = dSmp[i];
f->outTmp[1] = f->outTmp[0];
f->outTmp[0] = out;
dSmp[i] = out;
const double outAbs = fabs(out);
if (outAbs > peak)
peak = outAbs;
}
if (s->flags & SAMPLE_16BIT)
{
const double scale = INT16_MAX / peak;
int16_t *ptr16 = (int16_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
ptr16[i] = (int16_t)(dSmp[i] * scale);
}
else
{
const double scale = INT8_MAX / peak;
int8_t *ptr8 = (int8_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
ptr8[i] = (int8_t)(dSmp[i] * scale);
}
free(dSmp);
fixSample(s);
resumeAudio();
}
return true;
}
void pbSfxLowPass(void)
{
resoFilter_t f;
sample_t *s = getCurSample();
if (s == NULL || s->dataPtr == NULL)
return;
char lengthStr[5+1];
memset(lengthStr, '\0', sizeof (lengthStr));
snprintf(lengthStr, sizeof (lengthStr), "%d", lastLpCutoff);
lastFilterType = FILTER_LOWPASS;
if (inputBox(6, "Enter low-pass filter cutoff (in Hz):", lengthStr, sizeof (lengthStr)-1) != 1)
return;
if (lengthStr[0] == '\0')
return;
lastLpCutoff = (int32_t)atoi(lengthStr);
if (lastLpCutoff < 1 || lastLpCutoff > 99999)
{
okBox(0, "System message", "Illegal range! Allowed range is 1..99999", NULL);
return;
}
setupResoLpFilter(s, &f, lastLpCutoff, filterResonance, false);
fillSampleUndo(KEEP_SAMPLE_MARK);
applyResoFilter(s, &f);
writeSample(true);
}
void pbSfxHighPass(void)
{
resoFilter_t f;
sample_t *s = getCurSample();
if (s == NULL || s->dataPtr == NULL)
return;
char lengthStr[5+1];
memset(lengthStr, '\0', sizeof (lengthStr));
snprintf(lengthStr, sizeof (lengthStr), "%d", lastHpCutoff);
lastFilterType = FILTER_HIGHPASS;
if (inputBox(6, "Enter high-pass filter cutoff (in Hz):", lengthStr, sizeof (lengthStr)-1) != 1)
return;
if (lengthStr[0] == '\0')
return;
lastHpCutoff = (int32_t)atoi(lengthStr);
if (lastHpCutoff < 1 || lastHpCutoff > 99999)
{
okBox(0, "System message", "Illegal range! Allowed range is 1..99999", NULL);
return;
}
setupResoHpFilter(s, &f, lastHpCutoff, filterResonance, false);
fillSampleUndo(KEEP_SAMPLE_MARK);
applyResoFilter(s, &f);
writeSample(true);
}
void sfxPreviewFilter(uint32_t cutoff)
{
sample_t oldSample;
resoFilter_t f;
sample_t *s = getCurSample();
if (s == NULL || s->dataPtr == NULL || s->length == 0 || cutoff < 1 || cutoff > 99999)
return;
int32_t x1, x2;
if (smpEd_Rx1 < smpEd_Rx2)
{
x1 = smpEd_Rx1;
x2 = smpEd_Rx2;
if (x2 > s->length)
x2 = s->length;
if (x1 < 0)
x1 = 0;
if (x2 <= x1)
return;
}
else
{
// no mark, operate on whole sample
x1 = 0;
x2 = s->length;
}
const int32_t len = x2 - x1;
pauseAudio();
unfixSample(s);
memcpy(&oldSample, s, sizeof (sample_t));
if (lastFilterType == FILTER_LOWPASS)
setupResoLpFilter(s, &f, cutoff, filterResonance, false);
else
setupResoHpFilter(s, &f, cutoff, filterResonance, false);
// prepare new sample
int8_t *sampleData;
if (s->flags & SAMPLE_16BIT)
{
sampleData = (int8_t *)malloc((len * sizeof (int16_t)) + SAMPLE_PAD_LENGTH);
if (sampleData == NULL)
goto Error;
memcpy(sampleData + SMP_DAT_OFFSET, (int16_t *)s->dataPtr + x1, len * sizeof (int16_t));
}
else
{
sampleData = (int8_t *)malloc((len * sizeof (int8_t)) + SAMPLE_PAD_LENGTH);
if (sampleData == NULL)
goto Error;
memcpy(sampleData + SMP_DAT_OFFSET, (int8_t *)s->dataPtr + x1, len * sizeof (int8_t));
}
s->origDataPtr = sampleData;
s->length = len;
s->dataPtr = s->origDataPtr + SMP_DAT_OFFSET;
s->loopStart = s->loopLength = 0;
fixSample(s);
const int32_t oldX1 = smpEd_Rx1;
const int32_t oldX2 = smpEd_Rx2;
smpEd_Rx1 = smpEd_Rx2 = 0;
applyResoFilter(s, &f);
smpEd_Rx1 = oldX1;
smpEd_Rx2 = oldX2;
// set up preview sample on channel 0
channel_t *ch = &channel[0];
uint8_t note = editor.smpEd_NoteNr;
ch->smpNum = editor.curSmp;
ch->instrNum = editor.curInstr;
ch->copyOfInstrAndNote = (ch->instrNum << 8) | note;
ch->efx = 0;
ch->smpStartPos = 0;
resumeAudio();
triggerNote(note, 0, 0, ch);
resetVolumes(ch);
triggerInstrument(ch);
ch->realVol = ch->outVol = ch->oldVol = 64;
updateVolPanAutoVib(ch);
while (ch->status & IS_Trigger); // wait for sample to latch in mixer
SDL_Delay(1500); // wait 1.5 seconds
// we're done, stop voice and free temporary data
pauseAudio();
free(sampleData);
Error:
// set back old sample
memcpy(s, &oldSample, sizeof (sample_t));
fixSample(s);
resumeAudio();
}
void pbSfxSubBass(void)
{
resoFilter_t f;
sample_t *s = getCurSample();
if (s == NULL || s->dataPtr == NULL)
return;
setupResoHpFilter(s, &f, 0.001, 0, true);
fillSampleUndo(KEEP_SAMPLE_MARK);
applyResoFilter(s, &f);
writeSample(true);
}
void pbSfxAddBass(void)
{
resoFilter_t f;
sample_t *s = getCurSample();
if (s == NULL || s->dataPtr == NULL)
return;
int32_t x1, x2;
if (smpEd_Rx1 < smpEd_Rx2)
{
x1 = smpEd_Rx1;
x2 = smpEd_Rx2;
if (x2 > s->length)
x2 = s->length;
if (x1 < 0)
x1 = 0;
if (x2 <= x1)
return;
}
else
{
// no mark, operate on whole sample
x1 = 0;
x2 = s->length;
}
const int32_t len = x2 - x1;
setupResoLpFilter(s, &f, 0.015, 0, true);
double *dSmp = (double *)malloc(len * sizeof (double));
if (dSmp == NULL)
{
okBox(0, "System message", "Not enough memory!", NULL);
return;
}
fillSampleUndo(KEEP_SAMPLE_MARK);
pauseAudio();
unfixSample(s);
if (s->flags & SAMPLE_16BIT)
{
int16_t *ptr16 = (int16_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
dSmp[i] = (double)ptr16[i];
}
else
{
int8_t *ptr8 = (int8_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
dSmp[i] = (double)ptr8[i];
}
if (!normalization)
{
for (int32_t i = 0; i < len; i++)
{
double out = (f.a1*dSmp[i]) + (f.a2*f.inTmp[0]) + (f.a3*f.inTmp[1]) - (f.b1*f.outTmp[0]) - (f.b2*f.outTmp[1]);
f.inTmp[1] = f.inTmp[0];
f.inTmp[0] = dSmp[i];
f.outTmp[1] = f.outTmp[0];
f.outTmp[0] = out;
dSmp[i] = out;
}
if (s->flags & SAMPLE_16BIT)
{
int16_t *ptr16 = (int16_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
{
double out = ptr16[i] + (dSmp[i] * 0.25);
out = CLAMP(out, INT16_MIN, INT16_MAX);
ptr16[i] = (int16_t)out;
}
}
else
{
int8_t *ptr8 = (int8_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
{
double out = ptr8[i] + (dSmp[i] * 0.25);
out = CLAMP(out, INT8_MIN, INT8_MAX);
ptr8[i] = (int8_t)out;
}
}
}
else
{
if (s->flags & SAMPLE_16BIT)
{
int16_t *ptr16 = (int16_t *)s->dataPtr + x1;
double peak = 0.0;
for (int32_t i = 0; i < len; i++)
{
double out = (f.a1*dSmp[i]) + (f.a2*f.inTmp[0]) + (f.a3*f.inTmp[1]) - (f.b1*f.outTmp[0]) - (f.b2*f.outTmp[1]);
f.inTmp[1] = f.inTmp[0];
f.inTmp[0] = dSmp[i];
f.outTmp[1] = f.outTmp[0];
f.outTmp[0] = out;
dSmp[i] = out;
double bass = ptr16[i] + (out * 0.25);
const double outAbs = fabs(bass);
if (outAbs > peak)
peak = outAbs;
}
double scale = INT16_MAX / peak;
for (int32_t i = 0; i < len; i++)
ptr16[i] = (int16_t)((ptr16[i] + (dSmp[i] * 0.25)) * scale);
}
else
{
int8_t *ptr8 = (int8_t *)s->dataPtr + x1;
double peak = 0.0;
for (int32_t i = 0; i < len; i++)
{
double out = (f.a1*dSmp[i]) + (f.a2*f.inTmp[0]) + (f.a3*f.inTmp[1]) - (f.b1*f.outTmp[0]) - (f.b2*f.outTmp[1]);
f.inTmp[1] = f.inTmp[0];
f.inTmp[0] = dSmp[i];
f.outTmp[1] = f.outTmp[0];
f.outTmp[0] = out;
dSmp[i] = out;
double bass = ptr8[i] + (out * 0.25);
const double outAbs = fabs(bass);
if (outAbs > peak)
peak = outAbs;
}
double scale = INT8_MAX / peak;
for (int32_t i = 0; i < len; i++)
ptr8[i] = (int8_t)((ptr8[i] + (dSmp[i] * 0.25)) * scale);
}
}
free(dSmp);
fixSample(s);
resumeAudio();
writeSample(true);
}
void pbSfxSubTreble(void)
{
resoFilter_t f;
sample_t *s = getCurSample();
if (s == NULL || s->dataPtr == NULL)
return;
setupResoLpFilter(s, &f, 0.33, 0, true);
fillSampleUndo(KEEP_SAMPLE_MARK);
applyResoFilter(s, &f);
writeSample(true);
}
void pbSfxAddTreble(void)
{
resoFilter_t f;
sample_t *s = getCurSample();
if (s == NULL || s->dataPtr == NULL)
return;
int32_t x1, x2;
if (smpEd_Rx1 < smpEd_Rx2)
{
x1 = smpEd_Rx1;
x2 = smpEd_Rx2;
if (x2 > s->length)
x2 = s->length;
if (x1 < 0)
x1 = 0;
if (x2 <= x1)
return;
}
else
{
// no mark, operate on whole sample
x1 = 0;
x2 = s->length;
}
const int32_t len = x2 - x1;
setupResoHpFilter(s, &f, 0.27, 0, true);
double *dSmp = (double *)malloc(len * sizeof (double));
if (dSmp == NULL)
{
okBox(0, "System message", "Not enough memory!", NULL);
return;
}
fillSampleUndo(KEEP_SAMPLE_MARK);
pauseAudio();
unfixSample(s);
if (s->flags & SAMPLE_16BIT)
{
int16_t *ptr16 = (int16_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
dSmp[i] = (double)ptr16[i];
}
else
{
int8_t *ptr8 = (int8_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
dSmp[i] = (double)ptr8[i];
}
if (!normalization)
{
for (int32_t i = 0; i < len; i++)
{
double out = (f.a1*dSmp[i]) + (f.a2*f.inTmp[0]) + (f.a3*f.inTmp[1]) - (f.b1*f.outTmp[0]) - (f.b2*f.outTmp[1]);
f.inTmp[1] = f.inTmp[0];
f.inTmp[0] = dSmp[i];
f.outTmp[1] = f.outTmp[0];
f.outTmp[0] = out;
dSmp[i] = out;
}
if (s->flags & SAMPLE_16BIT)
{
int16_t *ptr16 = (int16_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
{
double out = ptr16[i] - (dSmp[i] * 0.25);
out = CLAMP(out, INT16_MIN, INT16_MAX);
ptr16[i] = (int16_t)out;
}
}
else
{
int8_t *ptr8 = (int8_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
{
double out = ptr8[i] - (dSmp[i] * 0.25);
out = CLAMP(out, INT8_MIN, INT8_MAX);
ptr8[i] = (int8_t)out;
}
}
}
else
{
if (s->flags & SAMPLE_16BIT)
{
int16_t *ptr16 = (int16_t *)s->dataPtr + x1;
double peak = 0.0;
for (int32_t i = 0; i < len; i++)
{
double out = (f.a1*dSmp[i]) + (f.a2*f.inTmp[0]) + (f.a3*f.inTmp[1]) - (f.b1*f.outTmp[0]) - (f.b2*f.outTmp[1]);
f.inTmp[1] = f.inTmp[0];
f.inTmp[0] = dSmp[i];
f.outTmp[1] = f.outTmp[0];
f.outTmp[0] = out;
dSmp[i] = out;
double treble = ptr16[i] - (out * 0.25);
const double outAbs = fabs(treble);
if (outAbs > peak)
peak = outAbs;
}
double scale = INT16_MAX / peak;
for (int32_t i = 0; i < len; i++)
ptr16[i] = (int16_t)((ptr16[i] - (dSmp[i] * 0.25)) * scale);
}
else
{
int8_t *ptr8 = (int8_t *)s->dataPtr + x1;
double peak = 0.0;
for (int32_t i = 0; i < len; i++)
{
double out = (f.a1*dSmp[i]) + (f.a2*f.inTmp[0]) + (f.a3*f.inTmp[1]) - (f.b1*f.outTmp[0]) - (f.b2*f.outTmp[1]);
f.inTmp[1] = f.inTmp[0];
f.inTmp[0] = dSmp[i];
f.outTmp[1] = f.outTmp[0];
f.outTmp[0] = out;
dSmp[i] = out;
double treble = ptr8[i] - (out * 0.25);
const double outAbs = fabs(treble);
if (outAbs > peak)
peak = outAbs;
}
double scale = INT8_MAX / peak;
for (int32_t i = 0; i < len; i++)
ptr8[i] = (int8_t)((ptr8[i] - (dSmp[i] * 0.25)) * scale);
}
}
free(dSmp);
fixSample(s);
resumeAudio();
writeSample(true);
}
void pbSfxSetAmp(void)
{
sample_t *s = getCurSample();
if (s == NULL || s->dataPtr == NULL)
return;
int32_t x1, x2;
if (smpEd_Rx1 < smpEd_Rx2)
{
x1 = smpEd_Rx1;
x2 = smpEd_Rx2;
if (x2 > s->length)
x2 = s->length;
if (x1 < 0)
x1 = 0;
if (x2 <= x1)
return;
}
else
{
// no mark, operate on whole sample
x1 = 0;
x2 = s->length;
}
const int32_t len = x2 - x1;
char ampStr[3+1];
memset(ampStr, '\0', sizeof (ampStr));
snprintf(ampStr, sizeof (ampStr), "%d", lastAmp);
if (inputBox(1, "Change sample amplitude (in percentage, 0..999):", ampStr, sizeof (ampStr)-1) != 1)
return;
if (ampStr[0] == '\0')
return;
lastAmp = (int32_t)atoi(ampStr);
fillSampleUndo(KEEP_SAMPLE_MARK);
pauseAudio();
unfixSample(s);
const int32_t mul = (int32_t)round((1 << 22UL) * (lastAmp / 100.0));
if (s->flags & SAMPLE_16BIT)
{
int16_t *ptr16 = (int16_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
{
int32_t sample = ((int64_t)ptr16[i] * (int32_t)mul) >> 22;
sample = CLAMP(sample, INT16_MIN, INT16_MAX);
ptr16[i] = (int16_t)sample;
}
}
else
{
int8_t *ptr8 = (int8_t *)s->dataPtr + x1;
for (int32_t i = 0; i < len; i++)
{
int32_t sample = ((int64_t)ptr8[i] * (int32_t)mul) >> 22;
sample = CLAMP(sample, INT8_MIN, INT8_MAX);
ptr8[i] = (int8_t)sample;
}
}
fixSample(s);
resumeAudio();
writeSample(true);
}
void pbSfxUndo(void)
{
if (!sampleUndo.filled || sampleUndo.undoInstr != editor.curInstr || sampleUndo.undoSmp != editor.curSmp)
return;
sample_t *s = getCurSample();
if (s == NULL || s->dataPtr == NULL)
return;
pauseAudio();
freeSmpData(s);
s->flags = sampleUndo.flags;
s->length = sampleUndo.length;
s->loopStart = sampleUndo.loopStart;
s->loopLength = sampleUndo.loopLength;
if (allocateSmpData(s, s->length, !!(s->flags & SAMPLE_16BIT)))
{
if (s->flags & SAMPLE_16BIT)
memcpy(s->dataPtr, sampleUndo.smpData16, s->length * sizeof (int16_t));
else
memcpy(s->dataPtr, sampleUndo.smpData8, s->length * sizeof (int8_t));
fixSample(s);
resumeAudio();
}
else
{
resumeAudio();
okBox(0, "System message", "Not enough memory!", NULL);
}
int32_t oldRx1 = smpEd_Rx1;
int32_t oldRx2 = smpEd_Rx2;
updateSampleEditorSample();
if (sampleUndo.keepSampleMark && oldRx1 < oldRx2)
{
smpEd_Rx1 = oldRx1;
smpEd_Rx2 = oldRx2;
writeSample(false); // redraw sample mark only
}
sampleUndo.keepSampleMark = false;
sampleUndo.filled = false;
}
void hideSampleEffectsScreen(void)
{
ui.sampleEditorEffectsShown = false;
hideCheckBox(CB_SAMPFX_NORMALIZATION);
hidePushButton(PB_SAMPFX_CYCLES_UP);
hidePushButton(PB_SAMPFX_CYCLES_DOWN);
hidePushButton(PB_SAMPFX_TRIANGLE);
hidePushButton(PB_SAMPFX_SAW);
hidePushButton(PB_SAMPFX_SINE);
hidePushButton(PB_SAMPFX_SQUARE);
hidePushButton(PB_SAMPFX_RESO_UP);
hidePushButton(PB_SAMPFX_RESO_DOWN);
hidePushButton(PB_SAMPFX_LOWPASS);
hidePushButton(PB_SAMPFX_HIGHPASS);
hidePushButton(PB_SAMPFX_SUB_BASS);
hidePushButton(PB_SAMPFX_SUB_TREBLE);
hidePushButton(PB_SAMPFX_ADD_BASS);
hidePushButton(PB_SAMPFX_ADD_TREBLE);
hidePushButton(PB_SAMPFX_SET_AMP);
hidePushButton(PB_SAMPFX_UNDO);
hidePushButton(PB_SAMPFX_XFADE);
hidePushButton(PB_SAMPFX_BACK);
drawFramework(0, 346, 115, 54, FRAMEWORK_TYPE1);
drawFramework(115, 346, 133, 54, FRAMEWORK_TYPE1);
drawFramework(248, 346, 49, 54, FRAMEWORK_TYPE1);
drawFramework(297, 346, 56, 54, FRAMEWORK_TYPE1);
showPushButton(PB_SAMP_PNOTE_UP);
showPushButton(PB_SAMP_PNOTE_DOWN);
showPushButton(PB_SAMP_STOP);
showPushButton(PB_SAMP_PWAVE);
showPushButton(PB_SAMP_PRANGE);
showPushButton(PB_SAMP_PDISPLAY);
showPushButton(PB_SAMP_SHOW_RANGE);
showPushButton(PB_SAMP_RANGE_ALL);
showPushButton(PB_SAMP_CLR_RANGE);
showPushButton(PB_SAMP_ZOOM_OUT);
showPushButton(PB_SAMP_SHOW_ALL);
showPushButton(PB_SAMP_SAVE_RNG);
showPushButton(PB_SAMP_CUT);
showPushButton(PB_SAMP_COPY);
showPushButton(PB_SAMP_PASTE);
showPushButton(PB_SAMP_CROP);
showPushButton(PB_SAMP_VOLUME);
showPushButton(PB_SAMP_EFFECTS);
drawFramework(2, 366, 34, 15, FRAMEWORK_TYPE2);
textOutShadow(5, 352, PAL_FORGRND, PAL_DSKTOP2, "Play:");
updateSampleEditor();
}
void pbEffects(void)
{
hidePushButton(PB_SAMP_PNOTE_UP);
hidePushButton(PB_SAMP_PNOTE_DOWN);
hidePushButton(PB_SAMP_STOP);
hidePushButton(PB_SAMP_PWAVE);
hidePushButton(PB_SAMP_PRANGE);
hidePushButton(PB_SAMP_PDISPLAY);
hidePushButton(PB_SAMP_SHOW_RANGE);
hidePushButton(PB_SAMP_RANGE_ALL);
hidePushButton(PB_SAMP_CLR_RANGE);
hidePushButton(PB_SAMP_ZOOM_OUT);
hidePushButton(PB_SAMP_SHOW_ALL);
hidePushButton(PB_SAMP_SAVE_RNG);
hidePushButton(PB_SAMP_CUT);
hidePushButton(PB_SAMP_COPY);
hidePushButton(PB_SAMP_PASTE);
hidePushButton(PB_SAMP_CROP);
hidePushButton(PB_SAMP_VOLUME);
hidePushButton(PB_SAMP_EFFECTS);
drawFramework(0, 346, 116, 54, FRAMEWORK_TYPE1);
drawFramework(116, 346, 114, 54, FRAMEWORK_TYPE1);
drawFramework(230, 346, 67, 54, FRAMEWORK_TYPE1);
drawFramework(297, 346, 56, 54, FRAMEWORK_TYPE1);
checkBoxes[CB_SAMPFX_NORMALIZATION].checked = normalization ? true : false;
showCheckBox(CB_SAMPFX_NORMALIZATION);
showPushButton(PB_SAMPFX_CYCLES_UP);
showPushButton(PB_SAMPFX_CYCLES_DOWN);
showPushButton(PB_SAMPFX_TRIANGLE);
showPushButton(PB_SAMPFX_SAW);
showPushButton(PB_SAMPFX_SINE);
showPushButton(PB_SAMPFX_SQUARE);
showPushButton(PB_SAMPFX_RESO_UP);
showPushButton(PB_SAMPFX_RESO_DOWN);
showPushButton(PB_SAMPFX_LOWPASS);
showPushButton(PB_SAMPFX_HIGHPASS);
showPushButton(PB_SAMPFX_SUB_BASS);
showPushButton(PB_SAMPFX_SUB_TREBLE);
showPushButton(PB_SAMPFX_ADD_BASS);
showPushButton(PB_SAMPFX_ADD_TREBLE);
showPushButton(PB_SAMPFX_SET_AMP);
showPushButton(PB_SAMPFX_UNDO);
showPushButton(PB_SAMPFX_XFADE);
showPushButton(PB_SAMPFX_BACK);
textOutShadow(4, 352, PAL_FORGRND, PAL_DSKTOP2, "Cycles:");
drawSampleCycles();
textOutShadow(121, 352, PAL_FORGRND, PAL_DSKTOP2, "Reson.:");
drawFilterResonance();
textOutShadow(135, 386, PAL_FORGRND, PAL_DSKTOP2, "Normalization");
textOutShadow(235, 352, PAL_FORGRND, PAL_DSKTOP2, "Bass");
textOutShadow(235, 369, PAL_FORGRND, PAL_DSKTOP2, "Treb.");
ui.sampleEditorEffectsShown = true;
}