583 lines
16 KiB
C++
583 lines
16 KiB
C++
|
#include <windows.h>
|
||
|
|
#include "chorusp.h"
|
||
|
|
#include "Debug.h"
|
||
|
|
#include "clone.h"
|
||
|
|
|
||
|
|
STD_CREATE(Chorus)
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CDirectSoundChorusDMO::QueryInterface
|
||
|
|
//
|
||
|
|
// Subclass can override if it wants to implement more interfaces.
|
||
|
|
//
|
||
|
|
HRESULT CDirectSoundChorusDMO::NDQueryInterface(REFIID riid, void **ppv) {
|
||
|
|
|
||
|
|
IMP_DSDMO_QI(riid,ppv);
|
||
|
|
|
||
|
|
if (riid == IID_IPersist)
|
||
|
|
{
|
||
|
|
return GetInterface((IPersist*)this, ppv);
|
||
|
|
}
|
||
|
|
else if (riid == IID_IMediaObject)
|
||
|
|
{
|
||
|
|
return GetInterface((IMediaObject*)this, ppv);
|
||
|
|
}
|
||
|
|
else if (riid == IID_IDirectSoundFXChorus)
|
||
|
|
{
|
||
|
|
return GetInterface((IDirectSoundFXChorus*)this, ppv);
|
||
|
|
}
|
||
|
|
else if (riid == IID_ISpecifyPropertyPages)
|
||
|
|
{
|
||
|
|
return GetInterface((ISpecifyPropertyPages*)this, ppv);
|
||
|
|
}
|
||
|
|
else if (riid == IID_IMediaParams)
|
||
|
|
{
|
||
|
|
return GetInterface((IMediaParams*)this, ppv);
|
||
|
|
}
|
||
|
|
else if (riid == IID_IMediaParamInfo)
|
||
|
|
{
|
||
|
|
return GetInterface((IMediaParamInfo*)this, ppv);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
return CComBase::NDQueryInterface(riid, ppv);
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CDirectSoundChorusDMO::CDirectSoundChorusDMO
|
||
|
|
//
|
||
|
|
CDirectSoundChorusDMO::CDirectSoundChorusDMO( IUnknown *pUnk, HRESULT *phr )
|
||
|
|
: CComBase( pUnk, phr ),
|
||
|
|
m_fDirty(false)
|
||
|
|
// { EAX: put init data here if any (otherwise use Discontinuity).
|
||
|
|
// } EAX
|
||
|
|
{
|
||
|
|
m_EaxSamplesPerSec = 22050;
|
||
|
|
m_DelayLine.Init(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CDirectSoundChorusDMO::Init()
|
||
|
|
//
|
||
|
|
HRESULT CDirectSoundChorusDMO::Init()
|
||
|
|
{
|
||
|
|
DSFXChorus chorus;
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
// Force recalc of all internal parameters
|
||
|
|
//
|
||
|
|
hr = GetAllParameters(&chorus);
|
||
|
|
if (SUCCEEDED(hr)) hr = SetAllParameters(&chorus);
|
||
|
|
|
||
|
|
if (SUCCEEDED(hr)) hr = m_DelayLine.Init(m_EaxSamplesPerSec);
|
||
|
|
if (SUCCEEDED(hr)) hr = Discontinuity();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
const MP_CAPS g_capsAll = MP_CAPS_CURVE_JUMP | MP_CAPS_CURVE_LINEAR | MP_CAPS_CURVE_SQUARE | MP_CAPS_CURVE_INVSQUARE | MP_CAPS_CURVE_SINE;
|
||
|
|
static ParamInfo g_params[] =
|
||
|
|
{
|
||
|
|
// index type caps min, max, neutral, unit text, label, pwchText
|
||
|
|
CFP_Wetdrymix, MPT_FLOAT, g_capsAll, DSFXCHORUS_WETDRYMIX_MIN, DSFXCHORUS_WETDRYMIX_MAX, 50, L"%", L"WetDryMix", L"",
|
||
|
|
CFP_Depth, MPT_FLOAT, g_capsAll, DSFXCHORUS_DEPTH_MIN, DSFXCHORUS_DEPTH_MAX, 10, L"", L"Depth", L"",
|
||
|
|
CFP_Frequency, MPT_FLOAT, g_capsAll, DSFXCHORUS_FREQUENCY_MIN, DSFXCHORUS_FREQUENCY_MAX, (float)1.1, L"Hz", L"Frequency", L"",
|
||
|
|
CFP_Waveform, MPT_ENUM, g_capsAll, DSFXCHORUS_WAVE_TRIANGLE, DSFXCHORUS_WAVE_SIN, DSFXCHORUS_WAVE_SIN, L"", L"WaveShape", L"Triangle,Sine",
|
||
|
|
CFP_Phase, MPT_INT, g_capsAll, DSFXCHORUS_PHASE_MIN, DSFXCHORUS_PHASE_MAX, 3, L"", L"Phase", L"",
|
||
|
|
CFP_Feedback, MPT_FLOAT, g_capsAll, DSFXCHORUS_FEEDBACK_MIN, DSFXCHORUS_FEEDBACK_MAX, 25, L"", L"Feedback", L"",
|
||
|
|
CFP_Delay, MPT_FLOAT, g_capsAll, DSFXCHORUS_DELAY_MIN, DSFXCHORUS_DELAY_MAX, 16, L"", L"Delay", L"",
|
||
|
|
};
|
||
|
|
|
||
|
|
HRESULT CDirectSoundChorusDMO::InitOnCreation()
|
||
|
|
{
|
||
|
|
HRESULT hr = InitParams(1, &GUID_TIME_REFERENCE, 0, 0, sizeof(g_params)/sizeof(*g_params), g_params);
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CDirectSoundChorusDMO::~CDirectSoundChorusDMO
|
||
|
|
//
|
||
|
|
CDirectSoundChorusDMO::~CDirectSoundChorusDMO()
|
||
|
|
{
|
||
|
|
m_DelayLine.Init(-1);
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CDirectSoundChorusDMO::Clone
|
||
|
|
//
|
||
|
|
STDMETHODIMP CDirectSoundChorusDMO::Clone(IMediaObjectInPlace **pp)
|
||
|
|
{
|
||
|
|
return StandardDMOClone<CDirectSoundChorusDMO, DSFXChorus>(this, pp);
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CDirectSoundChorusDMO::Discontinuity()
|
||
|
|
{
|
||
|
|
if (!m_EaxWaveform) {
|
||
|
|
m_LfoState[0] = (float)0.0;
|
||
|
|
m_LfoState[1] = (float)0.5;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
m_LfoState[0] = (float)0.0;
|
||
|
|
m_LfoState[1] = (float)0.99999999999;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_DelayLine.ZeroBuffer();
|
||
|
|
|
||
|
|
m_DelayFixedPtr = (int)m_EaxDelayCoef;
|
||
|
|
m_DelayL = m_DelayFixedPtr;
|
||
|
|
m_DelayL1 = m_DelayFixedPtr;
|
||
|
|
m_DelayR = m_DelayFixedPtr;
|
||
|
|
m_DelayR1 = m_DelayFixedPtr;
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
static int LMul [5] = { 1, 1, 1, 1, -1};
|
||
|
|
static int RMul [5] = { -1, -1, 1, 1, 1};
|
||
|
|
static int RPhase[5] = { 0, 1, 0, 1, 0};
|
||
|
|
|
||
|
|
__forceinline void CDirectSoundChorusDMO::DoOneSample(int *l, int *r)
|
||
|
|
{
|
||
|
|
float inPortL, inPortR;
|
||
|
|
float TempVar;
|
||
|
|
float XWave[2];
|
||
|
|
// float sinwave, coswave;
|
||
|
|
#define sinwave XWave[0]
|
||
|
|
#define coswave XWave[1]
|
||
|
|
|
||
|
|
int Pos0, Pos1;
|
||
|
|
int DelayFixedPtr = m_DelayLine.Pos(m_DelayFixedPtr);
|
||
|
|
|
||
|
|
Pos0 = m_DelayLine.Pos(0);
|
||
|
|
|
||
|
|
TempVar = m_DelayLine[DelayFixedPtr] * m_EaxFbCoef;
|
||
|
|
|
||
|
|
inPortL = (float)*l;
|
||
|
|
inPortR = (float)*r;
|
||
|
|
|
||
|
|
m_DelayLine[Pos0] = TempVar + (inPortL + inPortR) / 2;
|
||
|
|
|
||
|
|
if (!m_EaxWaveform) {
|
||
|
|
|
||
|
|
m_LfoState[0] = m_LfoState[0] + m_EaxLfoCoef;
|
||
|
|
|
||
|
|
if (m_LfoState[0] > 1) m_LfoState[0] -= 2;
|
||
|
|
|
||
|
|
m_LfoState[1] = m_LfoState[1] + m_EaxLfoCoef;
|
||
|
|
|
||
|
|
if (m_LfoState[1] > 1) m_LfoState[1] -= 2;
|
||
|
|
|
||
|
|
sinwave = (float)fabs(m_LfoState[0]);
|
||
|
|
coswave = (float)fabs(m_LfoState[1]);
|
||
|
|
sinwave = -1 + 2 * sinwave;
|
||
|
|
coswave = -1 + 2 * coswave;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
m_LfoState[0] = m_LfoState[0] + m_EaxLfoCoef * m_LfoState[1];
|
||
|
|
m_LfoState[1] = m_LfoState[1] - m_EaxLfoCoef * m_LfoState[0];
|
||
|
|
sinwave = m_LfoState[0];
|
||
|
|
coswave = m_LfoState[1];
|
||
|
|
}
|
||
|
|
|
||
|
|
Pos0 = m_DelayLine.Pos(m_DelayL);
|
||
|
|
Pos1 = m_DelayLine.Pos(m_DelayL1);
|
||
|
|
|
||
|
|
TempVar = (float)(m_DelayL & FractMask);
|
||
|
|
TempVar /= (float)FractMultiplier;
|
||
|
|
|
||
|
|
TempVar = Interpolate(m_DelayLine[Pos0], m_DelayLine[Pos1], TempVar);
|
||
|
|
inPortL = Interpolate(inPortL, TempVar, m_EaxWetLevel);
|
||
|
|
|
||
|
|
// m_DelayL = m_DelayFixedPtr + (int)(sinwave * m_EaxDepthCoef);
|
||
|
|
#if 0
|
||
|
|
switch (m_EaxPhase) {
|
||
|
|
case 0:
|
||
|
|
case 1:
|
||
|
|
case 2:
|
||
|
|
case 3: m_DelayL = (int)(sinwave * m_EaxDepthCoef); break;
|
||
|
|
case 4: m_DelayL = - (int)(sinwave * m_EaxDepthCoef); break;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
#ifdef DONTUSEi386
|
||
|
|
{
|
||
|
|
int x;
|
||
|
|
float f = (sinwave * m_EaxDepthCoef);
|
||
|
|
|
||
|
|
_asm {
|
||
|
|
fld f
|
||
|
|
fistp x
|
||
|
|
}
|
||
|
|
|
||
|
|
m_DelayL = LMul[m_EaxPhase] * x;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
m_DelayL = LMul[m_EaxPhase] * (int)(sinwave * m_EaxDepthCoef);
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
m_DelayL += m_DelayFixedPtr;
|
||
|
|
m_DelayL1 = m_DelayL + FractMultiplier;
|
||
|
|
|
||
|
|
*l = Saturate(inPortL);
|
||
|
|
|
||
|
|
Pos0 = m_DelayLine.Pos(m_DelayR);
|
||
|
|
Pos1 = m_DelayLine.Pos(m_DelayR1);
|
||
|
|
|
||
|
|
TempVar = (float)(m_DelayR & FractMask);
|
||
|
|
TempVar /= (float)FractMultiplier;
|
||
|
|
|
||
|
|
TempVar = Interpolate(m_DelayLine[Pos0], m_DelayLine[Pos1], TempVar);
|
||
|
|
inPortR = Interpolate(inPortR, TempVar, m_EaxWetLevel);
|
||
|
|
|
||
|
|
// m_DelayR = m_DelayFixedPtr + (int)(coswave * m_EaxDepthCoef);
|
||
|
|
#if 0
|
||
|
|
switch (m_EaxPhase) {
|
||
|
|
case 0: m_DelayR = - (int)(sinwave * m_EaxDepthCoef); break;
|
||
|
|
case 1: m_DelayR = - (int)(coswave * m_EaxDepthCoef); break;
|
||
|
|
case 3: m_DelayR = (int)(coswave * m_EaxDepthCoef); break;
|
||
|
|
case 2:
|
||
|
|
case 4: m_DelayR = (int)(sinwave * m_EaxDepthCoef); break;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
Pos0 = RPhase[m_EaxPhase];
|
||
|
|
#ifdef DONTUSEi386
|
||
|
|
{
|
||
|
|
int x;
|
||
|
|
float f = (XWave[Pos0] * m_EaxDepthCoef);
|
||
|
|
|
||
|
|
_asm {
|
||
|
|
fld f
|
||
|
|
fistp x
|
||
|
|
}
|
||
|
|
m_DelayR = RMul [m_EaxPhase] * x;
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
m_DelayR = RMul [m_EaxPhase] * (int)(XWave[Pos0] * m_EaxDepthCoef);
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
m_DelayR += m_DelayFixedPtr;
|
||
|
|
m_DelayR1 = m_DelayR + FractMultiplier;
|
||
|
|
|
||
|
|
*r = Saturate(inPortR);
|
||
|
|
|
||
|
|
m_DelayLine.Bump();
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CDirectSoundChorusDMO::FBRProcess
|
||
|
|
//
|
||
|
|
HRESULT CDirectSoundChorusDMO::FBRProcess(DWORD cSamples, BYTE *pIn, BYTE *pOut)
|
||
|
|
{
|
||
|
|
#define cb cSamples
|
||
|
|
#define pin pIn
|
||
|
|
#define pout pOut
|
||
|
|
|
||
|
|
if (m_cChannels == 1) {
|
||
|
|
if (m_b8bit) {
|
||
|
|
for (;cb > 0; --cb) {
|
||
|
|
int i, j;
|
||
|
|
|
||
|
|
i = *(pin+0)-128;
|
||
|
|
i *=256;
|
||
|
|
j = i;
|
||
|
|
|
||
|
|
DoOneSample(&i, &j);
|
||
|
|
|
||
|
|
i += j;
|
||
|
|
i /= 2;
|
||
|
|
|
||
|
|
i /= 256;
|
||
|
|
|
||
|
|
*(pout+0) = (unsigned char)(i + 128);
|
||
|
|
|
||
|
|
pin += sizeof(unsigned char);
|
||
|
|
pout += sizeof(unsigned char);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (!m_b8bit) {
|
||
|
|
for (;cb > 0; --cb) { // for (;cb > 0; cb -= sizeof(short)) {
|
||
|
|
short int *psi = (short int *)pin;
|
||
|
|
short int *pso = (short int *)pout;
|
||
|
|
int i, j;
|
||
|
|
|
||
|
|
i = *psi;
|
||
|
|
j = i;
|
||
|
|
|
||
|
|
DoOneSample(&i, &j);
|
||
|
|
|
||
|
|
i += j;
|
||
|
|
i /= 2;
|
||
|
|
|
||
|
|
*pso = (short)i;
|
||
|
|
|
||
|
|
pin += sizeof(short);
|
||
|
|
pout += sizeof(short);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (m_cChannels == 2) {
|
||
|
|
if (m_b8bit) {
|
||
|
|
for (;cb > 0; --cb) { // for (;cb > 0; cb -= 2 * sizeof(unsigned char)) {
|
||
|
|
int i, j;
|
||
|
|
|
||
|
|
i = *(pin+0)-128;
|
||
|
|
j = *(pin+1)-128;
|
||
|
|
|
||
|
|
i *=256; j *=256;
|
||
|
|
|
||
|
|
DoOneSample(&i, &j);
|
||
|
|
|
||
|
|
i /= 256; j /= 256;
|
||
|
|
|
||
|
|
*(pout+0) = (unsigned char)(i + 128);
|
||
|
|
*(pout+1) = (unsigned char)(j + 128);
|
||
|
|
|
||
|
|
pin += 2 * sizeof(unsigned char);
|
||
|
|
pout += 2 * sizeof(unsigned char);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (!m_b8bit) {
|
||
|
|
for (;cb > 0; --cb) { // for (;cb > 0; cb -= 2 * sizeof(short)) {
|
||
|
|
short int *psi = (short int *)pin;
|
||
|
|
short int *pso = (short int *)pout;
|
||
|
|
int i, j;
|
||
|
|
|
||
|
|
i = *(psi+0);
|
||
|
|
j = *(psi+1);
|
||
|
|
|
||
|
|
DoOneSample(&i, &j);
|
||
|
|
|
||
|
|
*(pso+0) = (short)i;
|
||
|
|
*(pso+1) = (short)j;
|
||
|
|
|
||
|
|
pin += 2 * sizeof(short);
|
||
|
|
pout += 2 * sizeof(short);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CDirectSoundChorusDMO::ProcessInPlace
|
||
|
|
//
|
||
|
|
HRESULT CDirectSoundChorusDMO::ProcessInPlace(ULONG ulQuanta, LPBYTE pcbData, REFERENCE_TIME rtStart, DWORD dwFlags)
|
||
|
|
{
|
||
|
|
// Update parameter values from any curves that may be in effect.
|
||
|
|
this->UpdateActiveParams(rtStart, *this);
|
||
|
|
|
||
|
|
return FBRProcess(ulQuanta, pcbData, pcbData);
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CDirectSoundChorusDMO::SetParamInternal
|
||
|
|
//
|
||
|
|
HRESULT CDirectSoundChorusDMO::SetParamInternal(DWORD dwParamIndex, MP_DATA value, bool fSkipPasssingToParamManager)
|
||
|
|
{
|
||
|
|
long l;
|
||
|
|
|
||
|
|
if (!m_EaxSamplesPerSec) return DMO_E_TYPE_NOT_ACCEPTED; // NO TYPE!
|
||
|
|
|
||
|
|
switch (dwParamIndex)
|
||
|
|
{
|
||
|
|
// { EAX
|
||
|
|
case CFP_Wetdrymix :
|
||
|
|
CHECK_PARAM(DSFXCHORUS_WETDRYMIX_MIN, DSFXCHORUS_WETDRYMIX_MAX);
|
||
|
|
|
||
|
|
PUT_EAX_VALUE(WetLevel, value / 100);
|
||
|
|
|
||
|
|
break;
|
||
|
|
|
||
|
|
case CFP_Depth : {
|
||
|
|
CHECK_PARAM(DSFXCHORUS_DEPTH_MIN, DSFXCHORUS_DEPTH_MAX);
|
||
|
|
|
||
|
|
PUT_EAX_VALUE(Depth, value / 100);
|
||
|
|
|
||
|
|
double midpoint = m_EaxDelay * m_EaxSamplesPerSec/1000;
|
||
|
|
|
||
|
|
INTERPOLATE(DepthCoef, (float)((m_EaxDepth * midpoint) / 2) * FractMultiplier);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case CFP_Delay : {
|
||
|
|
CHECK_PARAM(DSFXCHORUS_DELAY_MIN, DSFXCHORUS_DELAY_MAX);
|
||
|
|
|
||
|
|
PUT_EAX_VALUE(Delay, value);
|
||
|
|
|
||
|
|
double midpoint = m_EaxDelay * m_EaxSamplesPerSec/1000;
|
||
|
|
|
||
|
|
m_EaxDepthCoef = (float)(((m_EaxDepth * midpoint) / 2) * FractMultiplier);
|
||
|
|
m_EaxDelayCoef = (float)((midpoint + 2) * FractMultiplier);
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case CFP_Frequency : {
|
||
|
|
CHECK_PARAM(DSFXCHORUS_FREQUENCY_MIN, DSFXCHORUS_FREQUENCY_MAX);
|
||
|
|
|
||
|
|
PUT_EAX_VALUE(Frequency, value);
|
||
|
|
x:
|
||
|
|
if (!m_EaxWaveform) {
|
||
|
|
INTERPOLATE
|
||
|
|
(
|
||
|
|
LfoCoef,
|
||
|
|
TOFRACTION(2.0 * (m_EaxFrequency/m_EaxSamplesPerSec) * 1.0)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
INTERPOLATE
|
||
|
|
(
|
||
|
|
LfoCoef,
|
||
|
|
TOFRACTION(2.0*sin(PI*m_EaxFrequency/m_EaxSamplesPerSec))
|
||
|
|
);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case CFP_Waveform :
|
||
|
|
CHECK_PARAM(DSFXCHORUS_WAVE_TRIANGLE, DSFXCHORUS_WAVE_SIN);
|
||
|
|
|
||
|
|
l = m_EaxWaveform;
|
||
|
|
|
||
|
|
PUT_EAX_VALUE(Waveform, (long)value);
|
||
|
|
|
||
|
|
if (l != m_EaxWaveform) {
|
||
|
|
if (!m_EaxWaveform) {
|
||
|
|
m_LfoState[0] = (float)0.0;
|
||
|
|
m_LfoState[1] = (float)0.5;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
m_LfoState[0] = (float)0.0;
|
||
|
|
m_LfoState[1] = (float)0.99999999999;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
goto x;
|
||
|
|
|
||
|
|
case CFP_Phase :
|
||
|
|
CHECK_PARAM(DSFXCHORUS_PHASE_MIN, DSFXCHORUS_PHASE_MAX);
|
||
|
|
|
||
|
|
PUT_EAX_VALUE(Phase, (long)value);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case CFP_Feedback :
|
||
|
|
CHECK_PARAM(DSFXCHORUS_FEEDBACK_MIN, DSFXCHORUS_FEEDBACK_MAX);
|
||
|
|
|
||
|
|
PUT_EAX_VALUE(FbCoef, value / 100);
|
||
|
|
|
||
|
|
// m_EaxFbCoef = TOFRACTION(m_EaxFbCoef);
|
||
|
|
break;
|
||
|
|
|
||
|
|
// } EAX
|
||
|
|
default:
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Let base class set this so it can handle all the rest of the param calls.
|
||
|
|
// Skip the base class if fSkipPasssingToParamManager. This indicates that we're calling the function
|
||
|
|
// internally using valuds that came from the base class -- thus there's no need to tell it values it
|
||
|
|
// already knows.
|
||
|
|
return fSkipPasssingToParamManager ? S_OK : CParamsManager::SetParam(dwParamIndex, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CDirectSoundChorusDMO::SetAllParameters
|
||
|
|
//
|
||
|
|
STDMETHODIMP CDirectSoundChorusDMO::SetAllParameters(LPCDSFXChorus pChorus)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
|
||
|
|
// Check that the pointer is not NULL
|
||
|
|
if (pChorus == NULL)
|
||
|
|
{
|
||
|
|
Trace(1,"ERROR: pChorus is NULL\n");
|
||
|
|
hr = E_POINTER;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set the parameters
|
||
|
|
if (SUCCEEDED(hr)) hr = SetParam(CFP_Wetdrymix, pChorus->fWetDryMix);
|
||
|
|
if (SUCCEEDED(hr)) hr = SetParam(CFP_Depth, pChorus->fDepth);
|
||
|
|
if (SUCCEEDED(hr)) hr = SetParam(CFP_Frequency, pChorus->fFrequency);
|
||
|
|
if (SUCCEEDED(hr)) hr = SetParam(CFP_Waveform, (float)pChorus->lWaveform);
|
||
|
|
if (SUCCEEDED(hr)) hr = SetParam(CFP_Phase, (float)pChorus->lPhase);
|
||
|
|
if (SUCCEEDED(hr)) hr = SetParam(CFP_Feedback, pChorus->fFeedback);
|
||
|
|
if (SUCCEEDED(hr)) hr = SetParam(CFP_Delay, pChorus->fDelay);
|
||
|
|
|
||
|
|
m_fDirty = true;
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CDirectSoundChorusDMO::GetAllParameters
|
||
|
|
//
|
||
|
|
STDMETHODIMP CDirectSoundChorusDMO::GetAllParameters(LPDSFXChorus pChorus)
|
||
|
|
{
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
MP_DATA mpd;
|
||
|
|
|
||
|
|
if (pChorus == NULL)
|
||
|
|
{
|
||
|
|
return E_POINTER;
|
||
|
|
}
|
||
|
|
|
||
|
|
#define GET_PARAM(x,y) \
|
||
|
|
if (SUCCEEDED(hr)) { \
|
||
|
|
hr = GetParam(x, &mpd); \
|
||
|
|
if (SUCCEEDED(hr)) pChorus->y = mpd; \
|
||
|
|
}
|
||
|
|
|
||
|
|
#define GET_PARAM_LONG(x,y) \
|
||
|
|
if (SUCCEEDED(hr)) { \
|
||
|
|
hr = GetParam(x, &mpd); \
|
||
|
|
if (SUCCEEDED(hr)) pChorus->y = (long)mpd; \
|
||
|
|
}
|
||
|
|
GET_PARAM(CFP_Wetdrymix, fWetDryMix);
|
||
|
|
GET_PARAM(CFP_Delay, fDelay);
|
||
|
|
GET_PARAM(CFP_Depth, fDepth);
|
||
|
|
GET_PARAM(CFP_Frequency, fFrequency);
|
||
|
|
GET_PARAM_LONG(CFP_Waveform, lWaveform);
|
||
|
|
GET_PARAM_LONG(CFP_Phase, lPhase);
|
||
|
|
GET_PARAM(CFP_Feedback, fFeedback);
|
||
|
|
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetClassID
|
||
|
|
//
|
||
|
|
// Part of the persistent file support. We must supply our class id
|
||
|
|
// which can be saved in a graph file and used on loading a graph with
|
||
|
|
// this fx in it to instantiate this filter via CoCreateInstance.
|
||
|
|
//
|
||
|
|
HRESULT CDirectSoundChorusDMO::GetClassID(CLSID *pClsid)
|
||
|
|
{
|
||
|
|
if (pClsid==NULL) {
|
||
|
|
return E_POINTER;
|
||
|
|
}
|
||
|
|
*pClsid = GUID_DSFX_STANDARD_CHORUS;
|
||
|
|
return NOERROR;
|
||
|
|
|
||
|
|
} // GetClassID
|
||
|
|
|
||
|
|
HRESULT CDirectSoundChorusDMO::CheckInputType(const DMO_MEDIA_TYPE *pmt)
|
||
|
|
{
|
||
|
|
HRESULT hr = CPCMDMO::CheckInputType(pmt);
|
||
|
|
if (FAILED(hr)) return hr;
|
||
|
|
|
||
|
|
WAVEFORMATEX *pWave = (WAVEFORMATEX*)pmt->pbFormat;
|
||
|
|
if (pWave->wFormatTag != WAVE_FORMAT_PCM ||
|
||
|
|
(pWave->wBitsPerSample != 8 && pWave->wBitsPerSample != 16) ||
|
||
|
|
(pWave->nChannels != 1 && pWave->nChannels != 2)) {
|
||
|
|
return DMO_E_TYPE_NOT_ACCEPTED;
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|