mirror of
https://github.com/WinampDesktop/winamp.git
synced 2024-12-18 18:46:22 +01:00
738 lines
21 KiB
C++
738 lines
21 KiB
C++
/*
|
|
* SampleGenerator.cpp
|
|
* -------------------
|
|
* Purpose: Generate samples from math formulas using muParser
|
|
* Notes : (currently none)
|
|
* Authors: OpenMPT Devs
|
|
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
|
|
*/
|
|
|
|
|
|
#include "stdafx.h"
|
|
|
|
#if MPT_DISABLED_CODE
|
|
|
|
#include "SampleGenerator.h"
|
|
#include "modsmp_ctrl.h"
|
|
|
|
int CSampleGenerator::sample_frequency = 44100;
|
|
int CSampleGenerator::sample_length = CSampleGenerator::sample_frequency;
|
|
mu::string_type CSampleGenerator::expression = _T("sin(xp * _pi)");
|
|
smpgen_clip_methods CSampleGenerator::sample_clipping = smpgen_normalize;
|
|
|
|
mu::value_type *CSampleGenerator::sample_buffer = nullptr;
|
|
size_t CSampleGenerator::samples_written = 0;
|
|
|
|
|
|
CSampleGenerator::CSampleGenerator()
|
|
{
|
|
|
|
// Setup function callbacks
|
|
muParser.DefineFun(_T("clip"), &ClipCallback, false);
|
|
muParser.DefineFun(_T("pwm"), &PWMCallback, false);
|
|
muParser.DefineFun(_T("rnd"), &RndCallback, false);
|
|
muParser.DefineFun(_T("smp"), &SampleDataCallback, false);
|
|
muParser.DefineFun(_T("tri"), &TriangleCallback, false);
|
|
|
|
// Setup binary operator callbacks
|
|
muParser.DefineOprt(_T("mod"), &ModuloCallback, 0);
|
|
|
|
//muParser.DefineConst("pi", (mu::value_type)PARSER_CONST_PI);
|
|
|
|
}
|
|
|
|
|
|
// Open the smpgen dialog
|
|
bool CSampleGenerator::ShowDialog()
|
|
{
|
|
bool isDone = false, result = false;
|
|
while(!isDone)
|
|
{
|
|
CSmpGenDialog dlg(sample_frequency, sample_length, sample_clipping, expression);
|
|
dlg.DoModal();
|
|
|
|
// pressed "OK" button?
|
|
if(dlg.CanApply())
|
|
{
|
|
sample_frequency = dlg.GetFrequency();
|
|
sample_length = dlg.GetLength();
|
|
sample_clipping = dlg.GetClipping();
|
|
expression = dlg.GetExpression();
|
|
isDone = CanRenderSample();
|
|
if(isDone) isDone = TestExpression(); // show dialog again if the formula can't be parsed.
|
|
result = true;
|
|
} else
|
|
{
|
|
isDone = true; // just quit.
|
|
result = false;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
// Check if the currently select expression can be parsed by muParser.
|
|
bool CSampleGenerator::TestExpression()
|
|
{
|
|
// reset helper variables
|
|
samples_written = 0;
|
|
sample_buffer = nullptr;
|
|
|
|
muParser.SetExpr(expression);
|
|
mu::value_type x = 0;
|
|
muParser.DefineVar(_T("x"), &x);
|
|
muParser.DefineVar(_T("xp"), &x);
|
|
muParser.DefineVar(_T("len"), &x);
|
|
muParser.DefineVar(_T("lens"), &x);
|
|
muParser.DefineVar(_T("freq"), &x);
|
|
|
|
try
|
|
{
|
|
muParser.Eval();
|
|
}
|
|
catch (mu::Parser::exception_type &e)
|
|
{
|
|
ShowError(&e);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
// Check if sample parameters are valid.
|
|
bool CSampleGenerator::CanRenderSample() const
|
|
{
|
|
if(sample_frequency < SMPGEN_MINFREQ || sample_frequency > SMPGEN_MAXFREQ || sample_length < SMPGEN_MINLENGTH || sample_length > SMPGEN_MAXLENGTH) return false;
|
|
return true;
|
|
}
|
|
|
|
|
|
// Actual render loop.
|
|
bool CSampleGenerator::RenderSample(CSoundFile *pSndFile, SAMPLEINDEX nSample)
|
|
{
|
|
if(!CanRenderSample() || !TestExpression() || (pSndFile == nullptr) || (nSample < 1) || (nSample > pSndFile->m_nSamples)) return false;
|
|
|
|
// allocate a new buffer
|
|
sample_buffer = (mu::value_type *)malloc(sample_length * sizeof(mu::value_type));
|
|
if(sample_buffer == nullptr) return false;
|
|
memset(sample_buffer, 0, sample_length * sizeof(mu::value_type));
|
|
|
|
mu::value_type x = 0, xp = 0;
|
|
mu::value_type v_len = sample_length, v_freq = sample_frequency, v_lens = v_len / v_freq;
|
|
muParser.DefineVar(_T("x"), &x);
|
|
muParser.DefineVar(_T("xp"), &xp);
|
|
muParser.DefineVar(_T("len"), &v_len);
|
|
muParser.DefineVar(_T("lens"), &v_lens);
|
|
muParser.DefineVar(_T("freq"), &v_freq);
|
|
|
|
bool success = true;
|
|
mu::value_type minmax = 0;
|
|
|
|
for(size_t i = 0; i < (size_t)sample_length; i++)
|
|
{
|
|
samples_written = i;
|
|
x = (mu::value_type)i;
|
|
xp = x * 100 / sample_length;
|
|
|
|
try
|
|
{
|
|
sample_buffer[i] = muParser.Eval();
|
|
}
|
|
catch (mu::Parser::exception_type &e)
|
|
{
|
|
// let's just ignore div by zero errors (note: this error code is currently unused (muParser 1.30))
|
|
if(e.GetCode() != mu::ecDIV_BY_ZERO)
|
|
{
|
|
ShowError(&e);
|
|
success = false;
|
|
break;
|
|
}
|
|
sample_buffer[i] = 0;
|
|
}
|
|
// new maximum value?
|
|
if(std::abs(sample_buffer[i]) > minmax) minmax = std::abs(sample_buffer[i]);
|
|
|
|
}
|
|
|
|
if(success)
|
|
{
|
|
MODSAMPLE *pModSample = &pSndFile->Samples[nSample];
|
|
|
|
BEGIN_CRITICAL();
|
|
|
|
// first, save some memory... (leads to crashes)
|
|
//CSoundFile::FreeSample(pModSample->pSample);
|
|
//pModSample->pSample = nullptr;
|
|
|
|
if(minmax == 0) minmax = 1; // avoid division by 0
|
|
|
|
// convert sample to 16-bit (or whateve rhas been specified)
|
|
int16 *pSample = (sampling_type *)CSoundFile::AllocateSample((sample_length + 4) * SMPGEN_MIXBYTES);
|
|
for(size_t i = 0; i < (size_t)sample_length; i++)
|
|
{
|
|
switch(sample_clipping)
|
|
{
|
|
case smpgen_clip: sample_buffer[i] = CLAMP(sample_buffer[i], -1, 1); break; // option 1: clip
|
|
case smpgen_normalize: sample_buffer[i] /= minmax; break; // option 3: normalize
|
|
}
|
|
|
|
pSample[i] = (sampling_type)(sample_buffer[i] * sample_maxvalue);
|
|
}
|
|
|
|
// set new sample proprerties
|
|
pModSample->nC5Speed = sample_frequency;
|
|
CSoundFile::FrequencyToTranspose(pModSample);
|
|
pModSample->uFlags |= CHN_16BIT; // has to be adjusted if SMPGEN_MIXBYTES changes!
|
|
pModSample->uFlags &= ~(CHN_STEREO|CHN_SUSTAINLOOP|CHN_PINGPONGSUSTAIN);
|
|
pModSample->nLoopStart = 0;
|
|
pModSample->nLoopEnd = sample_length;
|
|
pModSample->nSustainStart = pModSample->nSustainEnd = 0;
|
|
if(sample_length / sample_frequency < 5) // arbitrary limit for automatic sample loop (5 seconds)
|
|
pModSample->uFlags |= CHN_LOOP;
|
|
else
|
|
pModSample->uFlags &= ~(CHN_LOOP|CHN_PINGPONGLOOP);
|
|
|
|
ctrlSmp::ReplaceSample(*pModSample, (LPSTR)pSample, sample_length, pSndFile);
|
|
|
|
END_CRITICAL();
|
|
}
|
|
|
|
free(sample_buffer);
|
|
sample_buffer = nullptr;
|
|
|
|
return success;
|
|
}
|
|
|
|
|
|
// Callback function to access sample data
|
|
mu::value_type CSampleGenerator::SampleDataCallback(mu::value_type v)
|
|
{
|
|
if(sample_buffer == nullptr) return 0;
|
|
v = CLAMP(v, 0, samples_written);
|
|
size_t pos = static_cast<size_t>(v);
|
|
return sample_buffer[pos];
|
|
}
|
|
|
|
|
|
void CSampleGenerator::ShowError(mu::Parser::exception_type *e)
|
|
{
|
|
std::string errmsg;
|
|
errmsg = "The expression\n " + e->GetExpr() + "\ncontains an error ";
|
|
if(!e->GetToken().empty())
|
|
errmsg += "in the token\n " + e->GetToken() + "\n";
|
|
errmsg += "at position " + Stringify(e->GetPos()) + ".\nThe error message was: " + e->GetMsg();
|
|
::MessageBox(0, errmsg.c_str(), _T("muParser Sample Generator"), 0);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Sample Generator Dialog implementation
|
|
|
|
#define MAX_SAMPLEGEN_EXPRESSIONS 61
|
|
|
|
BEGIN_MESSAGE_MAP(CSmpGenDialog, CDialog)
|
|
ON_EN_CHANGE(IDC_EDIT_SAMPLE_LENGTH, &CSmpGenDialog::OnSampleLengthChanged)
|
|
ON_EN_CHANGE(IDC_EDIT_SAMPLE_LENGTH_SEC, &CSmpGenDialog::OnSampleSecondsChanged)
|
|
ON_EN_CHANGE(IDC_EDIT_SAMPLE_FREQ, &CSmpGenDialog::OnSampleFreqChanged)
|
|
ON_EN_CHANGE(IDC_EDIT_FORMULA, &CSmpGenDialog::OnExpressionChanged)
|
|
ON_COMMAND(IDC_BUTTON_SHOW_EXPRESSIONS, &CSmpGenDialog::OnShowExpressions)
|
|
ON_COMMAND(IDC_BUTTON_SAMPLEGEN_PRESETS, &CSmpGenDialog::OnShowPresets)
|
|
ON_COMMAND_RANGE(ID_SAMPLE_GENERATOR_MENU, ID_SAMPLE_GENERATOR_MENU + MAX_SAMPLEGEN_EXPRESSIONS - 1, &CSmpGenDialog::OnInsertExpression)
|
|
ON_COMMAND_RANGE(ID_SAMPLE_GENERATOR_PRESET_MENU, ID_SAMPLE_GENERATOR_PRESET_MENU + MAX_SAMPLEGEN_PRESETS + 1, &CSmpGenDialog::OnSelectPreset)
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
// List of all possible expression for expression menu
|
|
const samplegen_expression menu_descriptions[MAX_SAMPLEGEN_EXPRESSIONS] =
|
|
{
|
|
{"Variables", ""},
|
|
{"Current position (sampling point)", "x"},
|
|
{"Current position (percentage)", "xp"},
|
|
{"Sample length", "len"},
|
|
{"Sample length (seconds)", "lens"},
|
|
{"Sampling frequency", "freq"},
|
|
{"Constants", ""},
|
|
{"Pi", "_pi"},
|
|
{"e", "_e"},
|
|
{"Trigonometric functions", ""},
|
|
{"Sine", "sin(x)"},
|
|
{"Cosine", "cos(x)"},
|
|
{"Tangens", "tan(x)"},
|
|
{"Arcus Sine", "asin(x)"},
|
|
{"Arcus Cosine", "acos(x)"},
|
|
{"Arcus Tangens", "atan(x)"},
|
|
{"Hyperbolic Sine", "sinh(x)"},
|
|
{"Hyperbolic Cosine", "cosh(x)"},
|
|
{"Hyperbolic Tangens", "tanh(x)"},
|
|
{"Hyperbolic Arcus Sine", "asinh(x)"},
|
|
{"Hyperbolic Arcus Cosine", "acosh(x)"},
|
|
{"Hyperbolic Arcus Tangens", "atanh(x)"},
|
|
{"Log, Exp, Root", ""},
|
|
{"Logarithm (base 2)", "log2(x)"},
|
|
{"Logarithm (base 10)", "log(x)"},
|
|
{"Natural Logarithm (base e)", "ln(x)"},
|
|
{"e^x", "exp(x)"},
|
|
{"Square Root", "sqrt(x)"},
|
|
{"Sign and rounding", ""},
|
|
{"Sign", "sign(x)"},
|
|
{"Absolute value", "abs(x)"},
|
|
{"Round to nearest integer", "rint(x)"},
|
|
{"Sets", ""},
|
|
{"Minimum", "min(x, y, ...)"},
|
|
{"Maximum", "max(x, y, ...)"},
|
|
{"Sum", "sum(x, y, ...)"},
|
|
{"Mean value", "avg(x, y, ...)"},
|
|
{"Misc functions", ""},
|
|
{"Pulse generator", "pwm(position, duty%, width)"},
|
|
{"Triangle", "tri(position, width)"},
|
|
{"Random value between 0 and x", "rnd(x)"},
|
|
{"Access previous sampling point", "smp(position)"},
|
|
{"Clip between values", "clip(value, minclip, maxclip)"},
|
|
{"If...Then...Else", "if(condition, statement1, statement2)"},
|
|
{"Operators", ""},
|
|
{"Assignment", "x = y"},
|
|
{"Logical And", "x abd y"},
|
|
{"Logical Or", "x or y"},
|
|
{"Logical Xor", "x xor y"},
|
|
{"Less or equal", "x <= y"},
|
|
{"Greater or equal", "x >= y"},
|
|
{"Not equal", "x != y"},
|
|
{"Equal", "x == y"},
|
|
{"Greater than", "x > y"},
|
|
{"Less than", "x < y"},
|
|
{"Addition", "x + y"},
|
|
{"Subtraction", "x - y"},
|
|
{"Multiplication", "x * y"},
|
|
{"Division", "x / y"},
|
|
{"x^y", "x ^ y"},
|
|
{"Modulo", "x mod y"},
|
|
};
|
|
|
|
|
|
BOOL CSmpGenDialog::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
RecalcParameters(false, true);
|
|
SetDlgItemText(IDC_EDIT_FORMULA, expression.c_str());
|
|
|
|
int check = IDC_RADIO_SMPCLIP1;
|
|
switch(sample_clipping)
|
|
{
|
|
case smpgen_clip: check = IDC_RADIO_SMPCLIP1; break;
|
|
case smpgen_overflow: check = IDC_RADIO_SMPCLIP2; break;
|
|
case smpgen_normalize: check = IDC_RADIO_SMPCLIP3; break;
|
|
}
|
|
CheckRadioButton(IDC_RADIO_SMPCLIP1, IDC_RADIO_SMPCLIP3, check);
|
|
|
|
if(presets.GetNumPresets() == 0)
|
|
{
|
|
CreateDefaultPresets();
|
|
}
|
|
|
|
// Create font for "dropdown" button (Marlett system font)
|
|
hButtonFont = CreateFont(14, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FF_DONTCARE, TEXT("Marlett"));
|
|
::SendMessage(GetDlgItem(IDC_BUTTON_SHOW_EXPRESSIONS)->m_hWnd, WM_SETFONT, (WPARAM)hButtonFont, MAKELPARAM(TRUE, 0));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CSmpGenDialog::OnOK()
|
|
{
|
|
CDialog::OnOK();
|
|
apply = true;
|
|
|
|
int check = GetCheckedRadioButton(IDC_RADIO_SMPCLIP1, IDC_RADIO_SMPCLIP3);
|
|
switch(check)
|
|
{
|
|
case IDC_RADIO_SMPCLIP1: sample_clipping = smpgen_clip; break;
|
|
case IDC_RADIO_SMPCLIP2: sample_clipping = smpgen_overflow; break;
|
|
case IDC_RADIO_SMPCLIP3: sample_clipping = smpgen_normalize; break;
|
|
}
|
|
|
|
DeleteObject(hButtonFont);
|
|
}
|
|
|
|
|
|
void CSmpGenDialog::OnCancel()
|
|
{
|
|
CDialog::OnCancel();
|
|
apply = false;
|
|
}
|
|
|
|
|
|
// User changed formula
|
|
void CSmpGenDialog::OnExpressionChanged()
|
|
{
|
|
CString result;
|
|
GetDlgItemText(IDC_EDIT_FORMULA, result);
|
|
expression = result;
|
|
}
|
|
|
|
|
|
// User changed sample length field
|
|
void CSmpGenDialog::OnSampleLengthChanged()
|
|
{
|
|
int temp_length = GetDlgItemInt(IDC_EDIT_SAMPLE_LENGTH);
|
|
if(temp_length >= SMPGEN_MINLENGTH && temp_length <= SMPGEN_MAXLENGTH)
|
|
{
|
|
sample_length = temp_length;
|
|
RecalcParameters(false);
|
|
}
|
|
}
|
|
|
|
|
|
// User changed sample length (seconds) field
|
|
void CSmpGenDialog::OnSampleSecondsChanged()
|
|
{
|
|
CString str;
|
|
GetDlgItemText(IDC_EDIT_SAMPLE_LENGTH_SEC, str);
|
|
double temp_seconds = atof(str);
|
|
if(temp_seconds > 0)
|
|
{
|
|
sample_seconds = temp_seconds;
|
|
RecalcParameters(true);
|
|
}
|
|
}
|
|
|
|
|
|
// User changed sample frequency field
|
|
void CSmpGenDialog::OnSampleFreqChanged()
|
|
{
|
|
int temp_freq = GetDlgItemInt(IDC_EDIT_SAMPLE_FREQ);
|
|
if(temp_freq >= SMPGEN_MINFREQ && temp_freq <= SMPGEN_MAXFREQ)
|
|
{
|
|
sample_frequency = temp_freq;
|
|
RecalcParameters(false);
|
|
}
|
|
}
|
|
|
|
|
|
// Show all expressions that can be input
|
|
void CSmpGenDialog::OnShowExpressions()
|
|
{
|
|
HMENU hMenu = ::CreatePopupMenu(), hSubMenu = NULL;
|
|
if(!hMenu) return;
|
|
|
|
for(int i = 0; i < MAX_SAMPLEGEN_EXPRESSIONS; i++)
|
|
{
|
|
if(menu_descriptions[i].expression == "")
|
|
{
|
|
// add sub menu
|
|
if(hSubMenu != NULL) ::DestroyMenu(hSubMenu);
|
|
hSubMenu = ::CreatePopupMenu();
|
|
|
|
AppendMenu(hMenu, MF_POPUP, (UINT_PTR)hSubMenu, menu_descriptions[i].description.c_str());
|
|
} else
|
|
{
|
|
// add sub menu entry (formula)
|
|
AppendMenu(hSubMenu, MF_STRING, ID_SAMPLE_GENERATOR_MENU + i, menu_descriptions[i].description.c_str());
|
|
}
|
|
}
|
|
|
|
// place popup menu below button
|
|
RECT button;
|
|
GetDlgItem(IDC_BUTTON_SHOW_EXPRESSIONS)->GetWindowRect(&button);
|
|
::TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, button.left, button.bottom, 0, m_hWnd, NULL);
|
|
::DestroyMenu(hMenu);
|
|
::DestroyMenu(hSubMenu);
|
|
}
|
|
|
|
|
|
// Show all expression presets
|
|
void CSmpGenDialog::OnShowPresets()
|
|
{
|
|
HMENU hMenu = ::CreatePopupMenu();
|
|
if(!hMenu) return;
|
|
|
|
bool prestsExist = false;
|
|
for(size_t i = 0; i < presets.GetNumPresets(); i++)
|
|
{
|
|
if(presets.GetPreset(i)->expression != "")
|
|
{
|
|
AppendMenu(hMenu, MF_STRING, ID_SAMPLE_GENERATOR_PRESET_MENU + i, presets.GetPreset(i)->description.c_str());
|
|
prestsExist = true;
|
|
}
|
|
}
|
|
|
|
if(prestsExist) AppendMenu(hMenu, MF_SEPARATOR, 0, NULL);
|
|
|
|
AppendMenu(hMenu, MF_STRING, ID_SAMPLE_GENERATOR_PRESET_MENU + MAX_SAMPLEGEN_PRESETS, _TEXT("Manage..."));
|
|
|
|
CString result;
|
|
GetDlgItemText(IDC_EDIT_FORMULA, result);
|
|
if((!result.IsEmpty()) && (presets.GetNumPresets() < MAX_SAMPLEGEN_PRESETS))
|
|
{
|
|
AppendMenu(hMenu, MF_STRING, ID_SAMPLE_GENERATOR_PRESET_MENU + MAX_SAMPLEGEN_PRESETS + 1, _TEXT("Add current..."));
|
|
}
|
|
|
|
// place popup menu below button
|
|
RECT button;
|
|
GetDlgItem(IDC_BUTTON_SAMPLEGEN_PRESETS)->GetWindowRect(&button);
|
|
::TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, button.left, button.bottom, 0, m_hWnd, NULL);
|
|
::DestroyMenu(hMenu);
|
|
}
|
|
|
|
|
|
|
|
// Insert expression from context menu
|
|
void CSmpGenDialog::OnInsertExpression(UINT nId)
|
|
{
|
|
if((nId < ID_SAMPLE_GENERATOR_MENU) || (nId >= ID_SAMPLE_GENERATOR_MENU + MAX_SAMPLEGEN_EXPRESSIONS)) return;
|
|
|
|
expression += " " + menu_descriptions[nId - ID_SAMPLE_GENERATOR_MENU].expression;
|
|
|
|
SetDlgItemText(IDC_EDIT_FORMULA, expression.c_str());
|
|
}
|
|
|
|
|
|
// Select a preset (or manage them, or add one)
|
|
void CSmpGenDialog::OnSelectPreset(UINT nId)
|
|
{
|
|
if((nId < ID_SAMPLE_GENERATOR_PRESET_MENU) || (nId >= ID_SAMPLE_GENERATOR_PRESET_MENU + MAX_SAMPLEGEN_PRESETS + 2)) return;
|
|
|
|
if(nId - ID_SAMPLE_GENERATOR_PRESET_MENU >= MAX_SAMPLEGEN_PRESETS)
|
|
{
|
|
// add...
|
|
if((nId - ID_SAMPLE_GENERATOR_PRESET_MENU == MAX_SAMPLEGEN_PRESETS + 1))
|
|
{
|
|
samplegen_expression newPreset;
|
|
newPreset.description = newPreset.expression = expression;
|
|
presets.AddPreset(newPreset);
|
|
// call preset manager now.
|
|
}
|
|
|
|
// manage...
|
|
CSmpGenPresetDlg dlg(&presets);
|
|
dlg.DoModal();
|
|
} else
|
|
{
|
|
expression = presets.GetPreset(nId - ID_SAMPLE_GENERATOR_PRESET_MENU)->expression;
|
|
SetDlgItemText(IDC_EDIT_FORMULA, expression.c_str());
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// Update input fields, depending on what has been chagned
|
|
void CSmpGenDialog::RecalcParameters(bool secondsChanged, bool forceRefresh)
|
|
{
|
|
static bool isLocked = false;
|
|
if(isLocked) return;
|
|
isLocked = true; // avoid deadlock
|
|
|
|
if(secondsChanged)
|
|
{
|
|
// seconds changed => recalc length
|
|
sample_length = (int)(sample_seconds * sample_frequency);
|
|
if(sample_length < SMPGEN_MINLENGTH || sample_length > SMPGEN_MAXLENGTH) sample_length = SMPGEN_MAXLENGTH;
|
|
} else
|
|
{
|
|
// length/freq changed => recalc seconds
|
|
sample_seconds = ((double)sample_length) / ((double)sample_frequency);
|
|
}
|
|
|
|
if(secondsChanged || forceRefresh) SetDlgItemInt(IDC_EDIT_SAMPLE_LENGTH, sample_length);
|
|
if(secondsChanged || forceRefresh) SetDlgItemInt(IDC_EDIT_SAMPLE_FREQ, sample_frequency);
|
|
CString str;
|
|
str.Format("%.4f", sample_seconds);
|
|
if(!secondsChanged || forceRefresh) SetDlgItemText(IDC_EDIT_SAMPLE_LENGTH_SEC, str);
|
|
|
|
int smpsize = sample_length * SMPGEN_MIXBYTES;
|
|
if(smpsize < 1024)
|
|
{
|
|
str.Format("Sample Size: %d Bytes", smpsize);
|
|
} else if((smpsize >> 10) < 1024)
|
|
{
|
|
str.Format("Sample Size: %d KB", smpsize >> 10);
|
|
} else
|
|
{
|
|
str.Format("Sample Size: %d MB", smpsize >> 20);
|
|
}
|
|
SetDlgItemText(IDC_STATIC_SMPSIZE_KB, str);
|
|
|
|
isLocked = false;
|
|
}
|
|
|
|
|
|
// Create a set of default formla presets
|
|
void CSmpGenDialog::CreateDefaultPresets()
|
|
{
|
|
samplegen_expression preset;
|
|
|
|
preset.description = "A440";
|
|
preset.expression = "sin(xp * _pi / 50 * 440 * len / freq)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "Brown Noise (kind of)";
|
|
preset.expression = "rnd(1) * 0.1 + smp(x - 1) * 0.9";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "Noisy Saw";
|
|
preset.expression = "(x mod 800) / 800 - 0.5 + rnd(0.1)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "PWM Filter";
|
|
preset.expression = "pwm(x, 50 + sin(xp * _pi / 100) * 40, 100) + tri(x, 50)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "Fat PWM Pad";
|
|
preset.expression = "pwm(x, xp, 500) + pwm(x, abs(50 - xp), 1000)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "Dual Square";
|
|
preset.expression = "if((x mod 100) < 50, (x mod 200), -x mod 200)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "Noise Hit";
|
|
preset.expression = "exp(-xp) * (rnd(x) - x / 2)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "Laser";
|
|
preset.expression = "sin(xp * _pi * 100 /(xp ^ 2)) * 100 / sqrt(xp)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "Noisy Laser Hit";
|
|
preset.expression = "(sin(sqrt(xp) * 100) + rnd(1) - 0.5) * exp(-xp / 10)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "Twinkle, Twinkle...";
|
|
preset.expression = "sin(xp * _pi * 100 / xp) * 100 / sqrt(xp)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "FM Tom";
|
|
preset.expression = "sin(xp * _pi * 2 + (xp / 5 - 50) ^ 2) * exp(-xp / 10)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "FM Warp";
|
|
preset.expression = "sin(_pi * xp / 2 * (1 + (1 + sin(_pi * xp / 4 * 50)) / 4)) * exp(-(xp / 8) * .6)";
|
|
presets.AddPreset(preset);
|
|
|
|
preset.description = "Weird Noise";
|
|
preset.expression = "rnd(1) * 0.1 + smp(x - rnd(xp)) * 0.9";
|
|
presets.AddPreset(preset);
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Sample Generator Preset Dialog implementation
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CSmpGenPresetDlg, CDialog)
|
|
ON_COMMAND(IDC_BUTTON_ADD, &CSmpGenPresetDlg::OnAddPreset)
|
|
ON_COMMAND(IDC_BUTTON_REMOVE, &CSmpGenPresetDlg::OnRemovePreset)
|
|
ON_EN_CHANGE(IDC_EDIT_PRESET_NAME, &CSmpGenPresetDlg::OnTextChanged)
|
|
ON_EN_CHANGE(IDC_EDIT_PRESET_EXPR, &CSmpGenPresetDlg::OnExpressionChanged)
|
|
ON_LBN_SELCHANGE(IDC_LIST_SAMPLEGEN_PRESETS, &CSmpGenPresetDlg::OnListSelChange)
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
BOOL CSmpGenPresetDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
RefreshList();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CSmpGenPresetDlg::OnOK()
|
|
{
|
|
// remove empty presets
|
|
for(size_t i = 0; i < presets->GetNumPresets(); i++)
|
|
{
|
|
if(presets->GetPreset(i)->expression.empty())
|
|
{
|
|
presets->RemovePreset(i);
|
|
}
|
|
}
|
|
CDialog::OnOK();
|
|
}
|
|
|
|
|
|
void CSmpGenPresetDlg::OnListSelChange()
|
|
{
|
|
currentItem = ((CListBox *)GetDlgItem(IDC_LIST_SAMPLEGEN_PRESETS))->GetCurSel() + 1;
|
|
if(currentItem == 0 || currentItem > presets->GetNumPresets()) return;
|
|
samplegen_expression *preset = presets->GetPreset(currentItem - 1);
|
|
if(preset == nullptr) return;
|
|
SetDlgItemText(IDC_EDIT_PRESET_NAME, preset->description.c_str());
|
|
SetDlgItemText(IDC_EDIT_PRESET_EXPR, preset->expression.c_str());
|
|
}
|
|
|
|
|
|
void CSmpGenPresetDlg::OnTextChanged()
|
|
{
|
|
if(currentItem == 0 || currentItem > presets->GetNumPresets()) return;
|
|
CString result;
|
|
GetDlgItemText(IDC_EDIT_PRESET_NAME, result);
|
|
|
|
samplegen_expression *preset = presets->GetPreset(currentItem - 1);
|
|
if(preset == nullptr) return;
|
|
preset->description = result;
|
|
|
|
CListBox *clist = (CListBox *)GetDlgItem(IDC_LIST_SAMPLEGEN_PRESETS);
|
|
clist->DeleteString(currentItem - 1);
|
|
clist->InsertString(currentItem - 1, (preset->description).c_str());
|
|
clist->SetCurSel(currentItem - 1);
|
|
}
|
|
|
|
|
|
void CSmpGenPresetDlg::OnExpressionChanged()
|
|
{
|
|
if(currentItem == 0 || currentItem > presets->GetNumPresets()) return;
|
|
CString result;
|
|
GetDlgItemText(IDC_EDIT_PRESET_EXPR, result);
|
|
|
|
samplegen_expression *preset = presets->GetPreset(currentItem - 1);
|
|
if(preset != nullptr) preset->expression = result;
|
|
|
|
}
|
|
|
|
|
|
void CSmpGenPresetDlg::OnAddPreset()
|
|
{
|
|
samplegen_expression newPreset;
|
|
newPreset.description = "New Preset";
|
|
newPreset.expression = "";
|
|
if(presets->AddPreset(newPreset))
|
|
{
|
|
currentItem = presets->GetNumPresets();
|
|
RefreshList();
|
|
}
|
|
}
|
|
|
|
|
|
void CSmpGenPresetDlg::OnRemovePreset()
|
|
{
|
|
if(currentItem == 0 || currentItem > presets->GetNumPresets()) return;
|
|
if(presets->RemovePreset(currentItem - 1))
|
|
RefreshList();
|
|
}
|
|
|
|
|
|
void CSmpGenPresetDlg::RefreshList()
|
|
{
|
|
CListBox *clist = (CListBox *)GetDlgItem(IDC_LIST_SAMPLEGEN_PRESETS);
|
|
clist->SetRedraw(FALSE); //disable lisbox refreshes during fill to avoid flicker
|
|
clist->ResetContent();
|
|
for(size_t i = 0; i < presets->GetNumPresets(); i++)
|
|
{
|
|
samplegen_expression *preset = presets->GetPreset(i);
|
|
if(preset != nullptr)
|
|
clist->AddString((preset->description).c_str());
|
|
}
|
|
clist->SetRedraw(TRUE); //re-enable lisbox refreshes
|
|
if(currentItem == 0 || currentItem > presets->GetNumPresets())
|
|
{
|
|
currentItem = presets->GetNumPresets();
|
|
}
|
|
if(currentItem != 0) clist->SetCurSel(currentItem - 1);
|
|
OnListSelChange();
|
|
}
|
|
|
|
#endif // MPT_DISABLED_CODE
|