1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/** CircularBuffer.h */

class CircularBuffer
{
public:
    /** 默认构造 */
	CircularBuffer();
    /** 可以设置最大buffer值与delay长度的构造 */
	CircularBuffer(int bufferSize, int delayLength);
    /** 获取当前readIndex下buffer数据 */
	float getData();
    /** 设置当前writeIndex下buffer数据 */
	void setData(float data);
    /** 计算下一个readIndex和writeIndex */
	void nextSample();

private:
    /** 原始buffer数据 */
	juce::AudioSampleBuffer buffer;
    /** 写入数据下标 */
	int writeIndex;
	/** 读取数据下标 */
    int readIndex;
    /** 读写数据的延迟长度 */
	int delayLength;
};

1
2
3
4
5
6
7
8
9
/** CircularBuffer.cpp */

/** 根据延迟长度更新readIndex与writeIndex */
void CircularBuffer::nextSample()
{
	int bufferLength = buffer.getNumSamples();
	readIndex = ((bufferLength + writeIndex) - delayLength) % bufferLength;
	writeIndex = (writeIndex + 1) % bufferLength;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/** PluginProcessor.cpp */

void LimitAudioProcessor::processBlock (juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midiMessages)
{
	float coeff;

	for (int i = 0; i < buffer.getNumSamples(); i++)
	{
		for (int channel = 0; channel < getMainBusNumOutputChannels(); channel++)
		{
			/** 取当前声道buffer */
			auto* data = buffer.getWritePointer(channel);
			/** 取当前声道CircularBuffer */
			CircularBuffer* delayBuffer = &allBuffers.getReference(channel);
			/** 取当前sample */
			float sample = data[i];
			
			float amplitude = abs(sample);
			/** sample响度大于上一个peak值，系数取attack */
			if (amplitude > xPeak)
			{
				coeff = attackTime;
			}
			/** sample响度小于上一个peak值，系数取release */
			else
			{
				coeff = releaseTime;
			}
			/** 计算当前peak值 */
			xPeak = (1 - coeff) * xPeak + coeff * amplitude;
			/** 计算threshold与Peak的系数 */
			float filter = fmin(1.0f, limiterThresh / xPeak);

			if (gain > filter)
			{
				coeff = attackTime;
			}
			else
			{
				coeff = releaseTime;
			}
			/** 计算增益值 */
			gain = (1 - coeff) * gain + coeff * filter;
			/** 当前sample被处理后的值 */
			float limitedSample = gain * delayBuffer->getData();
			/** 设置writeIndex的buffer值 */
			delayBuffer->setData(sample);
			/** 更新readIndex与writeIndex */
			delayBuffer->nextSample();
			/** 写回buffer */
			data[i] = limitedSample;
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/** PluginEditor.h */
juce::Slider thresholdSlider, attackSlider, releaseSlider;

/** PluginEditor.cpp */

/** threshold控件 */
addAndMakeVisible(thresholdSlider);
threshold.setValue(0);
threshold.setRange(-60.f, 10.f, 0.001);
threshold.onValueChange = [this] 
{
	audioProcessor.limiterThresh = std::pow(10, (threshold.getValue() / 20));
};
/** attack控件 */
addAndMakeVisible(attackSlider);
at.setRange(0.f, 10.f, 0.001);
at.onValueChange = [this]
{
	audioProcessor.attackTime = 1 - std::pow(juce::MathConstants<float>::euler, ((1 /audioProcessor.getSampleRate()) * -2.2f) / attackSlider.getValue());
};
/** release控件 */
addAndMakeVisible(releaseSlider);
rt.setRange(0.f, 10.f, 0.001);
rt.onValueChange = [this]
{
	audioProcessor.releaseTime = 1 - std::pow(juce::MathConstants<float>::euler, ((1 /audioProcessor.getSampleRate()) * -2.2f) / releaseSlider.getValue());
};

1
2
3
4
5
6
7
8
9
/** JuceLimit.cpp */

/** 这个是MFC创建程序窗口的入口函数，创建窗体后可以进行插件 */
BOOL JuceLimitApp::InitInstance()
{
    CWinApp::InitInstance();
    AK::Wwise::RegisterWwisePlugin();
    return TRUE;
}

1
2
3
4
5
6
7
8
9
10
/** JuceLimit.cpp */

/** 创建插件效果器实例的接口 */
AK::Wwise::IPluginBase* __stdcall AkCreatePlugin(unsigned short in_companyID, unsigned short in_pluginID)
{
    if (in_companyID == JuceLimitConfig::CompanyID && in_pluginID == JuceLimitConfig::PluginID)
        return new JuceLimitPlugin;

    return nullptr;
}

1
2
3
4
5
6
7
/** JuceLimit.cpp */

/** 声明导出插件注册列表 */
DEFINE_PLUGIN_REGISTER_HOOK

/** 定义 */
#define DEFINE_PLUGIN_REGISTER_HOOK AK_DLLEXPORT AK::PluginRegistration * g_pAKPluginList = NULL;

1
2
3
4
5
6
7
8
9
10
    /** 构造 */
    JuceLimitPlugin();
    /** 析构 */
    ~JuceLimitPlugin();
    /** 对象回收 */
    void Destroy() override;
    /** Wwise设置PropertySet的回调 */
    void SetPluginPropertySet(AK::Wwise::IPluginPropertySet* in_pPSet) override;
    /** Wwise将界面数据写入bank时的回调 */
    bool GetBankParameters(const GUID& in_guidPlatform, AK::Wwise::IWriteData* in_pDataWriter) const override;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/** IAkPluginMemAlloc.h */

/** 创建IAkPlugin对象 */
#define AK_PLUGIN_NEW(_allocator,_what)	new(_allocator) _what

/** 销毁IAkPlugin对象 */
template <class T>
AkForceInline void AK_PLUGIN_DELETE( AK::IAkPluginMemAlloc * in_pAllocator, T * in_pObject )      
{
	if ( in_pObject )
	{
		in_pObject->~T();
		in_pAllocator->Free( in_pObject );
	}
}

/** Wwise提供的Melloc接口 */
#define AK_PLUGIN_ALLOC(_allocator,_size) (_allocator)->Malloc((_size))

/** Wwise提供的Free接口 */
#define AK_PLUGIN_FREE(_allocator,_pvmem) (_allocator)->Free((_pvmem))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/** AkJuceAudioBuffer.h */

/** 把所有DSP用到的接口用AkAudioBuffer的方法实现一下 */
class AkJuceAudioBuffer : public AkAudioBuffer
{
public:

	AkJuceAudioBuffer();
	AkJuceAudioBuffer(int numChannelsToAllocate, int numSamplesToAllocate, AK::IAkPluginMemAlloc* in_pAllocator);
	
	~AkJuceAudioBuffer();

	AkSampleType getSample(int channel, int sampleIndex);
	
	void setSample(int destChannel, int sampleIndex, float newValue);
	
	int getNumSamples();

	AkSampleType* getWritePointer(int channel);

	void clear();
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
/** JuceLimitFX.cpp */

AKRESULT JuceLimitFX::Init(AK::IAkPluginMemAlloc* in_pAllocator, AK::IAkEffectPluginContext* in_pContext, AK::IAkPluginParam* in_pParams, AkAudioFormat& in_rFormat)
{
	m_pParams = (JuceLimitFXParams*)in_pParams;
	m_pAllocator = in_pAllocator;
	m_pContext = in_pContext;

    /** 获取最新效果器参数 */
	limiterThresh = m_pParams->RTPC.fThreshold;
	attackTime = m_pParams->RTPC.fAttack;
	releaseTime = m_pParams->RTPC.fRelease;
	
	gain = 1.0f;
	xPeak = 0.f;

	/** 为每个声道创建一个CircularBuffer */
	for (int i = 0; i < in_rFormat.GetNumChannels(); i++)
	{
		allBuffers.push_back(new CircularBuffer(10, 1, in_pAllocator));
	}

	return AK_Success;
}

void JuceLimitFX::Execute(AkAudioBuffer* io_pBuffer)
{
    /** 替换buffer类 */
	AkJuceAudioBuffer* buffer = static_cast<AkJuceAudioBuffer*>(io_pBuffer);
	const AkUInt32 uNumChannels = buffer->NumChannels();

	AkUInt16 uFramesProcessed;
	float coeff;
	for (AkUInt32 i = 0; i < uNumChannels; ++i)
	{
        /** 获取指定声道数据块 */
		AkReal32* AK_RESTRICT pBuf = (AkReal32 * AK_RESTRICT)io_pBuffer->GetChannel(i);
		uFramesProcessed = 0;
		coeff = 0.f;
		while (uFramesProcessed < buffer->uValidFrames)
		{
			/** 取当前声道CircularBuffer */
			CircularBuffer* delayBuffer = allBuffers[i];
			/** 取当前sample */
			float sample = pBuf[uFramesProcessed];

			float amplitude = abs(sample);
			/** sample响度大于上一个peak值，系数取attack */
			if (amplitude > xPeak)
			{
				coeff = attackTime;
			}
			/** sample响度小于上一个peak值，系数取release */
			else
			{
				coeff = releaseTime;
			}
			/** 计算当前peak值 */
			xPeak = (1 - coeff) * xPeak + coeff * amplitude;
			/** 计算threshold与Peak的系数 */
			float filter = fmin(1.0f, limiterThresh / xPeak);

			if (gain > filter)
			{
				coeff = attackTime;
			}
			else
			{
				coeff = releaseTime;
			}
			/** 计算增益值 */
			gain = (1 - coeff) * gain + coeff * filter;
			/** 当前sample被处理后的值 */
			float limitedSample = gain * delayBuffer->getData();
			/** 设置writeIndex的buffer值 */
			delayBuffer->setData(sample);
			/** 更新readIndex与writeIndex */
			delayBuffer->nextSample();
			/** 写回buffer */
			pBuf[uFramesProcessed] = limitedSample;
			++uFramesProcessed;
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
    /** 构造 */
    JuceLimitFXParams();
    /** 拷贝构造 */
    JuceLimitFXParams(const JuceLimitFXParams& in_rParams);
    /** 析构 */
    ~JuceLimitFXParams();
    /** 拷贝 */
    IAkPluginParam* Clone(AK::IAkPluginMemAlloc* in_pAllocator);
    /** 初始化 */
    AKRESULT Init(AK::IAkPluginMemAlloc* in_pAllocator, const void* in_pParamsBlock, AkUInt32 in_ulBlockSize);
    /** 卸载 */
    AKRESULT Term(AK::IAkPluginMemAlloc* in_pAllocator);
    /** 参数设置 */
    AKRESULT SetParamsBlock(const void* in_pParamsBlock, AkUInt32 in_ulBlockSize);
    AKRESULT SetParam(AkPluginParamID in_paramID, const void* in_pValue, AkUInt32 in_ulParamSize);

1
2
3
4
5
6
7
8
9
10
11
/** 效果器参数ID，需要与xml文件中ID属性设置一致 */
static const AkPluginParamID PARAM_THRESHOLD_ID = 0;
static const AkPluginParamID PARAM_ATTACK_ID = 1;
static const AkPluginParamID PARAM_RELEASE_ID = 2;
/** 自定义效果器参数结构 */
struct JuceLimitRTPCParams
{
    AkReal32 fThreshold;
	AkReal32 fAttack;
	AkReal32 fRelease;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
AKRESULT JuceLimitFXParams::Init(AK::IAkPluginMemAlloc* in_pAllocator, const void* in_pParamsBlock, AkUInt32 in_ulBlockSize)
{
    if (in_ulBlockSize == 0)
    {
        /** 默认效果器参数 */
        RTPC.fThreshold = 1.0f;
		RTPC.fAttack = 0.001f;
		RTPC.fRelease = 0.2f;
        m_paramChangeHandler.SetAllParamChanges();
        return AK_Success;
    }

    return SetParamsBlock(in_pParamsBlock, in_ulBlockSize);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/** 设置效果器所有参数 */
AKRESULT JuceLimitFXParams::SetParamsBlock(const void* in_pParamsBlock, AkUInt32 in_ulBlockSize)
{
    AKRESULT eResult = AK_Success;
    AkUInt8* pParamsBlock = (AkUInt8*)in_pParamsBlock;

    /** 读取bank数据 */
    RTPC.fThreshold = READBANKDATA(AkReal32, pParamsBlock, in_ulBlockSize);
	RTPC.fAttack = READBANKDATA(AkReal32, pParamsBlock, in_ulBlockSize);
	RTPC.fRelease = READBANKDATA(AkReal32, pParamsBlock, in_ulBlockSize);

    CHECKBANKDATASIZE(in_ulBlockSize, eResult);
    /** 更新所有效果器参数 */
    m_paramChangeHandler.SetAllParamChanges();

    return eResult;
}

/** 设置效果器单个参数 */
AKRESULT JuceLimitFXParams::SetParam(AkPluginParamID in_paramID, const void* in_pValue, AkUInt32 in_ulParamSize)
{
    AKRESULT eResult = AK_Success;

    /** 读取并更新单个效果器参数 */
    switch (in_paramID)
    {
    case PARAM_THRESHOLD_ID:
        RTPC.fThreshold = *((AkReal32*)in_pValue);
        m_paramChangeHandler.SetParamChange(PARAM_THRESHOLD_ID);
        break;
    case PARAM_ATTACK_ID:
		RTPC.fAttack = *((AkReal32*)in_pValue);
		m_paramChangeHandler.SetParamChange(PARAM_ATTACK_ID);
		break;
	case PARAM_RELEASE_ID:
		RTPC.fAttack = *((AkReal32*)in_pValue);
		m_paramChangeHandler.SetParamChange(PARAM_RELEASE_ID);
		break;
    default:
        eResult = AK_InvalidParameter;
        break;
    }

    return eResult;
}

1
2
/** JuceLimitFXFactory */
AK_STATIC_LINK_PLUGIN(JuceLimitFX);

1
2
/** AkAudio.Build.cs */
AddWwiseLib(Target, "JuceLimitFX");

1
#include <AK/Plugin/JuceLimitFX.h>