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 unsafe void Process(Complex *buffer, int length) { if (this._isMultithreaded) { this._completedCount = 0; for (int i = 1; i < this._phaseCount; i++) { DSPThreadPool.QueueUserWorkItem(delegate(object parameter) { int num2 = (int)parameter; this._oscillators[num2].Mix(buffer, length, num2, this._phaseCount); Interlocked.Increment(ref this._completedCount); this._event.Set(); }, i); } this._oscillators->Mix(buffer, length, 0, this._phaseCount); if (this._phaseCount > 1) { Interlocked.Increment(ref this._completedCount); while (this._completedCount < this._phaseCount) { this._event.WaitOne(); } } } else { for (int j = 1; j < this._phaseCount; j++) { int num = j; this._oscillators[num].Mix(buffer, length, num, this._phaseCount); } this._oscillators->Mix(buffer, length, 0, this._phaseCount); } }
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 unsafe void Process(Complex *iq, int length) { if (this._isMultiThteaded) { DSPThreadPool.QueueUserWorkItem(delegate { this._rFilter.ProcessInterleaved((float *)iq, length); this._event.Set(); }); } else { this._rFilter.ProcessInterleaved((float *)iq, length); } this._iFilter.ProcessInterleaved((float *)((byte *)iq + 4), length); if (this._isMultiThteaded) { this._event.WaitOne(); } }
private unsafe void remDC(Complex *iq, int length) { float *buffer = (float *)((byte *)iq + 4); if (this._isMultithreaded) { DSPThreadPool.QueueUserWorkItem(delegate { this._dcRemoverI->ProcessInterleaved((float *)iq, length); this._event.Set(); }); } else { this._dcRemoverI->ProcessInterleaved((float *)iq, length); } this._dcRemoverQ->ProcessInterleaved(buffer, length); if (this._isMultithreaded) { this._event.WaitOne(); } }
private unsafe void ProcessStereo(float *baseBand, float *interleavedStereo, int length) { if (this._channelABuffer == null || this._channelABuffer.Length != length) { this._channelABuffer = UnsafeBuffer.Create(length, 4); this._channelAPtr = (float *)(void *)this._channelABuffer; } if (this._channelBBuffer == null || this._channelBBuffer.Length != length) { this._channelBBuffer = UnsafeBuffer.Create(length, 4); this._channelBPtr = (float *)(void *)this._channelBBuffer; } int audioLength = length / this._audioDecimationFactor; if (this._isMultiThreaded) { DSPThreadPool.QueueUserWorkItem(delegate { Utils.Memcpy(this._channelAPtr, baseBand, length * 4); this._channelADecimator.Process(this._channelAPtr, length); if (this._useFilter) { this._channelAFilter.Process(this._channelAPtr, audioLength); } this._event.Set(); }); } else { Utils.Memcpy(this._channelAPtr, baseBand, length * 4); this._channelADecimator.Process(this._channelAPtr, length); if (this._useFilter) { this._channelAFilter.Process(this._channelAPtr, audioLength); } } for (int i = 0; i < length; i++) { float sample = this._pilotFilter->Process(baseBand[i]); this._pll->Process(sample); this._channelBPtr[i] = baseBand[i] * Trig.Sin((float)((double)this._pll->AdjustedPhase * 2.0)); } if (!this._pll->IsLocked) { if (this._isMultiThreaded) { this._event.WaitOne(); } if (this._useFilter) { for (int j = 0; j < audioLength; j++) { this._deemphasisAvgL += this._deemphasisAlpha * (this._channelAPtr[j] - this._deemphasisAvgL); this._channelAPtr[j] = this._deemphasisAvgL; } } for (int k = 0; k < audioLength; k++) { interleavedStereo[k * 2 + 1] = (interleavedStereo[k * 2] = this._channelAPtr[k] * 0.2f); } } else { this._channelBDecimator.Process(this._channelBPtr, length); if (this._useFilter) { this._channelBFilter.Process(this._channelBPtr, audioLength); } if (this._isMultiThreaded) { this._event.WaitOne(); } for (int l = 0; l < audioLength; l++) { float num = this._channelAPtr[l]; float num2 = 2f * this._channelBPtr[l]; interleavedStereo[l * 2] = (num + num2) * 0.2f; interleavedStereo[l * 2 + 1] = (num - num2) * 0.2f; } if (this._useFilter) { for (int m = 0; m < audioLength; m++) { this._deemphasisAvgL += this._deemphasisAlpha * (interleavedStereo[m * 2] - this._deemphasisAvgL); interleavedStereo[m * 2] = this._deemphasisAvgL; this._deemphasisAvgR += this._deemphasisAlpha * (interleavedStereo[m * 2 + 1] - this._deemphasisAvgR); interleavedStereo[m * 2 + 1] = this._deemphasisAvgR; } } } }
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 }