public void Process(Complex *iq, int length)
{
var ptr = (float *)iq;
if (_isMultiThteaded)
{
DSPThreadPool.QueueUserWorkItem(
delegate
{
_rFilter.ProcessInterleaved(ptr, length);
_event.Set();
});
}
else
{
_rFilter.ProcessInterleaved(ptr, length);
}
_iFilter.ProcessInterleaved(ptr + 1, length);
if (_isMultiThteaded)
{
_event.WaitOne();
}
}
public void Process(Complex *buffer, int length)
{
var rPtr = (float *)buffer;
var iPtr = rPtr + 1;
if (_isMultithreaded)
{
DSPThreadPool.QueueUserWorkItem(
delegate
{
_rDecimator.ProcessInterleaved(rPtr, length);
_event.Set();
});
}
else
{
_rDecimator.ProcessInterleaved(rPtr, length);
}
_iDecimator.ProcessInterleaved(iPtr, length);
if (_isMultithreaded)
{
_event.WaitOne();
}
}
private void RemoveDC(Complex *iq, int length)
{
var iPtr = (float *)iq;
var qPtr = iPtr + 1;
if (_isMultithreaded)
{
DSPThreadPool.QueueUserWorkItem(
delegate
{
// I branch
_dcRemoverI->ProcessInterleaved(iPtr, length);
_event.Set();
});
}
else
{
// I branch
_dcRemoverI->ProcessInterleaved(iPtr, length);
}
// Q branch
_dcRemoverQ->ProcessInterleaved(qPtr, length);
if (_isMultithreaded)
{
_event.WaitOne();
}
}
public void Process(Complex *buffer, int length)
{
_completedCount = 0;
for (var i = 1; i < _phaseCount; i++)
{
DSPThreadPool.QueueUserWorkItem(
parameter =>
{
var index = (int)parameter;
_oscillators[index].Mix(buffer, length, index, _phaseCount);
Interlocked.Increment(ref _completedCount);
_event.Set();
}, i);
}
_oscillators[0].Mix(buffer, length, 0, _phaseCount);
if (_phaseCount > 1)
{
Interlocked.Increment(ref _completedCount);
while (_completedCount < _phaseCount)
{
_event.WaitOne();
}
}
}
public void Flush()
{
lock (this)
{
foreach (var block in _blocks)
{
FreeBlock(block);
}
_blocks.Clear();
_readPos = 0;
_writePos = 0;
_size = 0;
}
if (_writeEvent != null)
{
_writeEvent.Set();
}
if (_readEvent != null)
{
_readEvent.Set();
}
}
public void ProcessIQHook(Complex *buffer, int length)
{
var copyBuffer = false;
for (var i = 0; i < _iqObservers.Count; i++)
{
if (_iqObservers[i].Enabled)
{
copyBuffer = true;
break;
}
}
if (copyBuffer)
{
if (_iqObserverThread.ThreadState == ThreadState.WaitSleepJoin)
{
Utils.Memcpy(_iqObserverBufferPtr, buffer, length * sizeof(Complex));
_iqObserverEvent.Set();
}
}
}
private void ProcessStereo(float *baseBand, float *interleavedStereo, int length)
{
#region Prepare L+R buffer
if (_channelABuffer == null || _channelABuffer.Length != length)
{
_channelABuffer = UnsafeBuffer.Create(length, sizeof(float));
_channelAPtr = (float *)_channelABuffer;
}
#endregion
#region Prepare L-R buffer
if (_channelBBuffer == null || _channelBBuffer.Length != length)
{
_channelBBuffer = UnsafeBuffer.Create(length, sizeof(float));
_channelBPtr = (float *)_channelBBuffer;
}
#endregion
#region Decimate and filter L+R
var audioLength = length / _audioDecimationFactor;
if (_isMultiThreaded)
{
DSPThreadPool.QueueUserWorkItem(
delegate
{
Utils.Memcpy(_channelAPtr, baseBand, length * sizeof(float));
_channelADecimator.Process(_channelAPtr, length);
_channelAFilter.Process(_channelAPtr, audioLength);
_event.Set();
});
}
else
{
Utils.Memcpy(_channelAPtr, baseBand, length * sizeof(float));
_channelADecimator.Process(_channelAPtr, length);
_channelAFilter.Process(_channelAPtr, audioLength);
}
#endregion
#region Demodulate L-R
for (var i = 0; i < length; i++)
{
var pilot = _pilotFilter->Process(baseBand[i]);
_pll->Process(pilot);
_channelBPtr[i] = baseBand[i] * Trig.Sin((float)(_pll->AdjustedPhase * 2.0));
}
if (!_pll->IsLocked)
{
if (_isMultiThreaded)
{
_event.WaitOne();
}
#region Process mono deemphasis
for (var i = 0; i < audioLength; i++)
{
_deemphasisAvgL += _deemphasisAlpha * (_channelAPtr[i] - _deemphasisAvgL);
_channelAPtr[i] = _deemphasisAvgL;
}
#endregion
#region Fill output buffer with mono
for (var i = 0; i < audioLength; i++)
{
var sample = _channelAPtr[i] * AudioGain;
interleavedStereo[i * 2] = sample;
interleavedStereo[i * 2 + 1] = sample;
}
#endregion
return;
}
#endregion
#region Decimate and filter L-R
_channelBDecimator.Process(_channelBPtr, length);
_channelBFilter.Process(_channelBPtr, audioLength);
#endregion
#region Recover L and R audio channels
if (_isMultiThreaded)
{
_event.WaitOne();
}
for (var i = 0; i < audioLength; i++)
{
var a = _channelAPtr[i];
var b = 2f * _channelBPtr[i];
interleavedStereo[i * 2] = (a + b) * AudioGain;
interleavedStereo[i * 2 + 1] = (a - b) * AudioGain;
}
#endregion
#region Process deemphasis
for (var i = 0; i < audioLength; i++)
{
_deemphasisAvgL += _deemphasisAlpha * (interleavedStereo[i * 2] - _deemphasisAvgL);
interleavedStereo[i * 2] = _deemphasisAvgL;
_deemphasisAvgR += _deemphasisAlpha * (interleavedStereo[i * 2 + 1] - _deemphasisAvgR);
interleavedStereo[i * 2 + 1] = _deemphasisAvgR;
}
#endregion
}
