public unsafe void Configure(double sampleRate, int decimationStageCount) { this._audioDecimationRatio = 1 << decimationStageCount; if (this._sampleRate != sampleRate) { this._sampleRate = sampleRate; this._pilotFilterBuffer = UnsafeBuffer.Create(sizeof(IirFilter)); this._pilotFilter = (IirFilter *)(void *)this._pilotFilterBuffer; this._pilotFilter->Init(IirFilterType.BandPass, 19000.0, this._sampleRate, 500.0); this._pll->SampleRate = (float)this._sampleRate; this._pll->DefaultFrequency = 19000f; this._pll->Range = 20f; this._pll->Bandwidth = 10f; this._pll->Zeta = 0.707f; this._pll->PhaseAdjM = StereoDecoder._pllPhaseAdjM; this._pll->PhaseAdjB = StereoDecoder._pllPhaseAdjB; this._pll->LockTime = 0.5f; this._pll->LockThreshold = 1f; double num = sampleRate / (double)this._audioDecimationRatio; Complex[] kernel = FilterBuilder.MakeComplexKernel(num, 250, Math.Min(0.9 * num, 30000.0), 0.0, WindowType.BlackmanHarris4); this._channelAFilter = new ComplexFilter(kernel); this._channelBFilter = new ComplexFilter(kernel); this._deemphasisAlpha = (float)(1.0 - Math.Exp(-1.0 / (num * (double)StereoDecoder._deemphasisTime))); this._deemphasisAvgL = 0f; this._deemphasisAvgR = 0f; } if (this._channelADecimator != null && this._channelBDecimator != null && this._audioDecimationRatio == this._channelADecimator.DecimationRatio) { return; } this._channelADecimator = new FloatDecimator(this._audioDecimationRatio); this._channelBDecimator = new FloatDecimator(this._audioDecimationRatio); }
private void DSPProc() { #region Prepare buffers if (_dspInBuffer == null || _dspInBuffer.Length != _inputBufferSize) { _dspInBuffer = UnsafeBuffer.Create(_inputBufferSize, sizeof(Complex)); _dspInPtr = (Complex *)_dspInBuffer; } if (_dspOutBuffer == null || _dspOutBuffer.Length != _outputBufferSize) { _dspOutBuffer = UnsafeBuffer.Create(_outputBufferSize, sizeof(float)); _dspOutPtr = (float *)_dspOutBuffer; } #endregion while (IsPlaying) { var total = 0; while (IsPlaying && total < _dspInBuffer.Length) { var len = _dspInBuffer.Length - total; total += _iqStream.Read(_dspInPtr, total, len); // Blocking read } ProcessIQ(); _audioStream.Write(_dspOutPtr, _dspOutBuffer.Length); // Blocking write } }
private void DuplexFiller(float *buffer, int frameCount) { #region Prepare buffers if (_dspInBuffer == null || _dspInBuffer.Length != frameCount) { _dspInBuffer = UnsafeBuffer.Create(frameCount, sizeof(Complex)); _dspInPtr = (Complex *)_dspInBuffer; } if (_dspOutBuffer == null || _dspOutBuffer.Length != _dspInBuffer.Length * 2) { _dspOutBuffer = UnsafeBuffer.Create(_dspInBuffer.Length * 2, sizeof(float)); _dspOutPtr = (float *)_dspOutBuffer; } #endregion Utils.Memcpy(_dspInPtr, buffer, frameCount * sizeof(Complex)); ProcessIQ(); ScaleBuffer(_dspOutPtr, _dspOutBuffer.Length); Utils.Memcpy(buffer, _dspOutPtr, _dspOutBuffer.Length * sizeof(float)); }
public unsafe DownConverter(int phaseCount) { this._phaseCount = phaseCount; this._oscillatorsBuffer = UnsafeBuffer.Create(sizeof(Oscillator) * phaseCount); this._oscillators = (Oscillator *)(void *)this._oscillatorsBuffer; this._isMultithreaded = (Utils.ProcessorCount > 1); }
private unsafe void DSPProc() { if (this._dspInBuffer == null || this._dspInBuffer.Length != this._inputBufferSize) { this._dspInBuffer = UnsafeBuffer.Create(this._inputBufferSize, sizeof(Complex)); this._dspInPtr = (Complex *)(void *)this._dspInBuffer; } if (this._dspOutBuffer == null || this._dspOutBuffer.Length != this._outputBufferSize) { this._dspOutBuffer = UnsafeBuffer.Create(this._outputBufferSize, 4); this._dspOutPtr = (float *)(void *)this._dspOutBuffer; } Console.WriteLine("DSPPROC started"); while (this.IsPlaying) { int num = 0; while (this.IsPlaying && num < this._dspInBuffer.Length) { int count = this._dspInBuffer.Length - num; num += this._iqStream.Read(this._dspInPtr, num, count); } int count2 = this.ProcessBuffer(); this._audioStream.Write(this._dspOutPtr, count2); } this._isBuffering = false; Console.WriteLine("DSPPROC stopped"); }
public unsafe void Configure(double sampleRate, int decimationStageCount) { int num = (int)Math.Pow(2.0, (double)decimationStageCount); if (this._sampleRate != sampleRate || this._audioDecimationFactor != num) { this._sampleRate = sampleRate; this._pilotFilterBuffer = UnsafeBuffer.Create(sizeof(IirFilter)); this._pilotFilter = (IirFilter *)(void *)this._pilotFilterBuffer; this._pilotFilter->Init(IirFilterType.BandPass, 19000.0, this._sampleRate, 500); this._pll->SampleRate = (float)this._sampleRate; this._pll->DefaultFrequency = 19000f; this._pll->Range = 20f; this._pll->Bandwidth = 10f; this._pll->Zeta = 0.707f; this._pll->PhaseAdjM = StereoDecoder._pllPhaseAdjM; this._pll->PhaseAdjB = StereoDecoder._pllPhaseAdjB; this._pll->LockTime = 0.5f; this._pll->LockThreshold = 1f; double num2 = sampleRate / (double)num; float[] coefficients = FilterBuilder.MakeBandPassKernel(num2, 250, 20.0, 16000.0, WindowType.BlackmanHarris4); this._channelAFilter = new FirFilter(coefficients, 1); this._channelBFilter = new FirFilter(coefficients, 1); this._deemphasisAlpha = (float)(1.0 - Math.Exp(-1.0 / (num2 * (double)StereoDecoder._deemphasisTime))); this._deemphasisAvgL = 0f; this._deemphasisAvgR = 0f; } if (this._channelADecimator != null && this._channelBDecimator != null && this._audioDecimationFactor == num) { return; } this._channelADecimator = new FloatDecimator(decimationStageCount); this._channelBDecimator = new FloatDecimator(decimationStageCount); this._audioDecimationFactor = num; }
public static void StartHW(int freq) { if (_dllHandle == IntPtr.Zero || _startHW == null) { return; } _iqBuffer = null; _iqPtr = null; int result = _startHW(freq); if (result < 0) { throw new Exception("ExtIO StartHW() returned " + result); } _isHWStarted = true; _sampleCount = result; /* Allocate the sample buffers */ /* We must do it here since we do not know the size until the hardware is started! */ _iqBuffer = UnsafeBuffer.Create(_sampleCount, sizeof(Complex)); _iqPtr = (Complex *)_iqBuffer; }
unsafe static ExtIO() { ExtIO._iqBuffer = UnsafeBuffer.Create(1024, sizeof(Complex)); ExtIO._callbackInst = ExtIO.extIOCallback; GCHandle.Alloc(ExtIO._callbackInst); }
static Trig() { _mask = ~(-1 << ResolutionInBits); var sampleCount = _mask + 1; _sinBuffer = UnsafeBuffer.Create(sampleCount, sizeof(float)); _cosBuffer = UnsafeBuffer.Create(sampleCount, sizeof(float)); _sinPtr = (float *)_sinBuffer; _cosPtr = (float *)_cosBuffer; const float twoPi = (float)(Math.PI * 2.0); const float pi2 = (float)(Math.PI / 2.0); _indexScale = sampleCount / twoPi; for (var i = 0; i < sampleCount; i++) { _sinPtr[i] = (float)Math.Sin((i + 0.5f) / sampleCount * twoPi); _cosPtr[i] = (float)Math.Cos((i + 0.5f) / sampleCount * twoPi); } for (var angle = 0.0f; angle < twoPi; angle += pi2) { _sinPtr[(int)(angle * _indexScale) & _mask] = (float)Math.Sin(angle); _cosPtr[(int)(angle * _indexScale) & _mask] = (float)Math.Cos(angle); } }
public unsafe OverlapCrossfadeProcessor(int fftSize, float crossFadingRatio = 0f) { this._fftSize = fftSize; this._halfSize = this._fftSize / 2; this._crossFadingSize = (int)((float)this._halfSize * crossFadingRatio); this._outputSize = this._halfSize - this._crossFadingSize; this._inputPos = this._halfSize + this._crossFadingSize; this._queuepBuffer = UnsafeBuffer.Create(this._fftSize, sizeof(Complex)); this._queuePtr = (Complex *)(void *)this._queuepBuffer; this._windowBuffer = UnsafeBuffer.Create(this._crossFadingSize, 4); this._windowPtr = (float *)(void *)this._windowBuffer; this._fftBuffer = UnsafeBuffer.Create(this._fftSize, sizeof(Complex)); this._fftPtr = (Complex *)(void *)this._fftBuffer; this._outputBuffer = UnsafeBuffer.Create(this._outputSize, sizeof(Complex)); this._outputPtr = (Complex *)(void *)this._outputBuffer; this._crossFadingBuffer = UnsafeBuffer.Create(this._crossFadingSize, sizeof(Complex)); this._crossFadingPtr = (Complex *)(void *)this._crossFadingBuffer; double num = 1.5707963267948966 / (double)(this._crossFadingSize - 1); for (int i = 0; i < this._crossFadingSize; i++) { double a = (double)i * num; this._windowPtr[i] = (float)Math.Pow(Math.Sin(a), 2.0); } }
private unsafe void ProcessMono(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; } Utils.Memcpy(this._channelAPtr, baseBand, length * 4); this._channelADecimator.Process(this._channelAPtr, length); length /= this._audioDecimationFactor; if (this._useFilter) { this._channelAFilter.Process(this._channelAPtr, length); } if (this._useFilter) { for (int i = 0; i < length; i++) { this._deemphasisAvgL += this._deemphasisAlpha * (this._channelAPtr[i] - this._deemphasisAvgL); this._channelAPtr[i] = this._deemphasisAvgL; } } for (int j = 0; j < length; j++) { interleavedStereo[j * 2 + 1] = (interleavedStereo[j * 2] = this._channelAPtr[j] * 0.2f); } }
private void ProcessSquelch(float *audio, int length) { if (_squelchThreshold > 0) { if (_hissBuffer == null || _hissBuffer.Length != length) { _hissBuffer = UnsafeBuffer.Create(length, sizeof(float)); _hissPtr = (float *)_hissBuffer; } Utils.Memcpy(_hissPtr, audio, length * sizeof(float)); _hissFilter.Process(_hissPtr, length); for (var i = 0; i < _hissBuffer.Length; i++) { var n = (1 - _noiseAveragingRatio) * _noiseLevel + _noiseAveragingRatio * Math.Abs(_hissPtr[i]); if (!float.IsNaN(n)) { _noiseLevel = n; } if (_noiseLevel > _noiseThreshold) { audio[i] = 0.0f; } } _isSquelchOpen = _noiseLevel < _noiseThreshold; } else { _isSquelchOpen = true; } }
public unsafe void Demodulate(Complex *iq, float *rPtr, float *lPtr, int length) { if (this._cpxBuf == null || this._cpxBuf.Length != length) { if (this._cpxBuf != null) { this._cpxBuf.Dispose(); } this._cpxBuf = UnsafeBuffer.Create(length, sizeof(Complex)); this._cpxPtr = (Complex *)(void *)this._cpxBuf; } for (int i = 0; i < length; i++) { float num = (float)Math.Cos((double)this._phase); float num2 = (float)Math.Sin((double)this._phase); float num3 = num * iq[i].Real + num2 * iq[i].Imag; float num4 = (0f - num2) * iq[i].Real + num * iq[i].Imag; float num5 = (float)Math.Atan2((double)num4, (double)num3); this._freqN += this._beta * num5; this._freqN = Math.Max(this._fLowN, Math.Min(this._fhighN, this._freqN)); this._phase += this._freqN + this._alpha * num5; this._phase %= this.TWOPI; this._dcReal = 0.9999f * this._dcReal + 0.0001f * num3; this._dcImag = 0.9999f * this._dcImag + 0.0001f * num4; this._cpxPtr[i].Real = num3 - this._dcReal; this._cpxPtr[i].Imag = num4 - this._dcImag; } this._cuteFir.ProcessFilter(length, this._cpxPtr, this._cpxPtr); for (int j = 0; j < length; j++) { Complex complex = this._cpxPtr[j]; rPtr[j] = (complex.Real - complex.Imag) * 0.002f; lPtr[j] = (complex.Real + complex.Imag) * 0.002f; } }
public unsafe OverlapSlideProcessor(int fftSize, float overlapRatio) { if (overlapRatio < 0.75f) { throw new ArgumentException("Overlap ratio must be greater than or equal to 0.75", "overlapRatio"); } if (overlapRatio > 1f) { throw new ArgumentException("Overlap ratio must be less than 1.0", "overlapRatio"); } this._fftSize = fftSize; this._outputSize = (int)Math.Round((double)((float)this._fftSize * (1f - overlapRatio))); if (this._outputSize < 3) { this._outputSize = 3; } this._overlapRatio = 1f - (float)this._outputSize / (float)this._fftSize; this._inputPos = this._fftSize - this._outputSize; this._queuepBuffer = UnsafeBuffer.Create(this._fftSize, sizeof(Complex)); this._queuePtr = (Complex *)(void *)this._queuepBuffer; this._fftBuffer = UnsafeBuffer.Create(this._fftSize, sizeof(Complex)); this._fftPtr = (Complex *)(void *)this._fftBuffer; this._outputBuffer = UnsafeBuffer.Create(this._outputSize, sizeof(Complex)); this._outputPtr = (Complex *)(void *)this._outputBuffer; this._overlapBuffer = UnsafeBuffer.Create(this._outputSize, sizeof(Complex)); this._overlapPtr = (Complex *)(void *)this._overlapBuffer; }
private unsafe void ProcessSquelch(float *audio, int length) { if (this._squelchThreshold > 0) { if (this._hissBuffer == null || this._hissBuffer.Length != length) { this._hissBuffer = UnsafeBuffer.Create(length, 4); this._hissPtr = (float *)(void *)this._hissBuffer; } Utils.Memcpy(this._hissPtr, audio, length * 4); this._hissFilter.Process(this._hissPtr, length); for (int i = 0; i < this._hissBuffer.Length; i++) { this._noiseLevel = (1f - this._noiseAveragingRatio) * this._noiseLevel + this._noiseAveragingRatio * Math.Abs(this._hissPtr[i]); if (this._noiseLevel > this._noiseThreshold) { audio[i] *= 1E-15f; } } this._isSquelchOpen = (this._noiseLevel < this._noiseThreshold); } else { this._isSquelchOpen = true; } }
public unsafe static void StartHW(int freq) { if (!(ExtIO._dllHandle == IntPtr.Zero) && ExtIO._startHW != null) { ExtIO.logInfo("StartHW(), freq=" + freq.ToString()); if (!ExtIO._isHWInit) { ExtIO.OpenHW(true); } if (ExtIO._iqBuffer != null) { ExtIO._iqBuffer.Dispose(); } ExtIO._iqBuffer = null; ExtIO._iqPtr = null; int num = ExtIO._startHW(freq); ExtIO.logResult("StartHW: "); if (num <= 0) { ExtIO.logInfo("StartHW() returned " + num); throw new Exception("ExtIO StartHW() returned " + num); } ExtIO._isHWStarted = true; ExtIO._sampleCount = num; ExtIO._iqBuffer = UnsafeBuffer.Create(ExtIO._sampleCount, sizeof(Complex)); ExtIO._iqPtr = (Complex *)(void *)ExtIO._iqBuffer; ExtIO.logInfo("StartHW succeeded, samplecount=" + ExtIO._sampleCount.ToString() + ", iqBuffer created."); } }
public unsafe Resampler(double inputSampleRate, double outputSampleRate, int tapsPerPhase = 160, double protectedPassband = 0.45) { Resampler.DoubleToFraction(outputSampleRate / inputSampleRate, out this._interpolationFactor, out this._decimationFactor); this._tapsPerPhase = tapsPerPhase; int num = tapsPerPhase * this._interpolationFactor; this._firKernelBuffer = UnsafeBuffer.Create(num, 4); this._firKernel = (float *)(void *)this._firKernelBuffer; double cutoffFrequency = Math.Min(inputSampleRate, outputSampleRate) * protectedPassband; float[] array = FilterBuilder.MakeLowPassKernel(inputSampleRate * (double)this._interpolationFactor, num - 1, cutoffFrequency, WindowType.BlackmanHarris4); float[] array2 = array; fixed(float *ptr = array2) { for (int i = 0; i < array.Length; i++) { ptr[i] *= (float)this._interpolationFactor; } Utils.Memcpy(this._firKernel, ptr, (num - 1) * 4); this._firKernel[num - 1] = 0f; } this._firQueueBuffer = UnsafeBuffer.Create(num, 4); this._firQueue = (float *)(void *)this._firQueueBuffer; }
private unsafe UnsafeBuffer AllocBlock() { if (this._usedBlocks.Count <= 0) { return(UnsafeBuffer.Create(8192, sizeof(Complex))); } return(this._usedBlocks.Pop()); }
private UnsafeBuffer AllocBlock() { if (this._usedBlocks.Count <= 0) { return(UnsafeBuffer.Create(16384, 4)); } return(this._usedBlocks.Pop()); }
public unsafe int Resample(int inLength, double rate, float *pInBuf, float *pOutBuf) { if (this._workL == null || this._workL.Length != inLength / 2 + 28) { if (this._workL != null) { this._workL.Dispose(); } this._workL = UnsafeBuffer.Create(inLength / 2 + 28, 8); this._pWorkL = (double *)(void *)this._workL; } if (this._workR == null || this._workR.Length != inLength / 2 + 28) { if (this._workR != null) { this._workR.Dispose(); } this._workR = UnsafeBuffer.Create(inLength / 2 + 28, 8); this._pWorkR = (double *)(void *)this._workR; } int num = (int)this._fTime; int num2 = 0; int num3 = 0; int i; for (i = 28; i < 28 + inLength / 2; i++) { this._pWorkL[i] = (double)pInBuf[num3++]; this._pWorkR[i] = (double)pInBuf[num3++]; } while (num < inLength / 2) { double num6 = 0.0; double num7 = 0.0; for (i = 1; i <= 28; i++) { num3 = num + i; int num8 = (int)(((double)num3 - this._fTime) * 10000.0); num6 += this._pWorkL[num3] * this._pSinc[num8]; num7 += this._pWorkR[num3] * this._pSinc[num8]; } pOutBuf[num2++] = (float)num6; pOutBuf[num2++] = (float)num7; this._fTime += rate; num = (int)this._fTime; } this._fTime -= (double)inLength / 2.0; num3 = inLength / 2; i = 0; while (i < 28) { this._pWorkL[i] = this._pWorkL[num3]; this._pWorkR[i] = this._pWorkR[num3]; i++; num3++; } return(num2); }
public unsafe RdsDecoder() { this._pllBuffer = UnsafeBuffer.Create(sizeof(Pll)); this._pll = (Pll *)(void *)this._pllBuffer; this._oscBuffer = UnsafeBuffer.Create(sizeof(Oscillator)); this._osc = (Oscillator *)(void *)this._oscBuffer; this._syncFilterBuffer = UnsafeBuffer.Create(sizeof(IirFilter)); this._syncFilter = (IirFilter *)(void *)this._syncFilterBuffer; }
public unsafe RdsDecoder() { this._pllBuffer = UnsafeBuffer.Create(sizeof(Pll)); this._pll = (Pll *)(void *)this._pllBuffer; this._syncFilterBuffer = UnsafeBuffer.Create(sizeof(IirFilter)); this._syncFilter = (IirFilter *)(void *)this._syncFilterBuffer; this._bitDecoder = new RdsDetectorBank(); this._bitDecoder.FrameAvailable += this.FrameAvailableHandler; }
unsafe static Fourier() { Fourier._lutBuffer = UnsafeBuffer.Create(32768, sizeof(Complex)); Fourier._lut = (Complex *)(void *)Fourier._lutBuffer; for (int i = 0; i < 32768; i++) { Fourier._lut[i] = Complex.FromAngle(9.5873799242852573E-05 * (double)i).Conjugate(); } }
private void Configure(bool resetBuffers) { if (resetBuffers) { _sigDelayPtr = 0; _hangTimer = 0; _peak = -16.0f; _decayAve = -5.0f; _attackAve = -5.0f; _magBufPos = 0; if (_sampleRate > 0) { _delaySamples = (int)(_sampleRate * DelayTimeconst); _windowSamples = (int)(_sampleRate * WindowTimeconst); _sigDelayBuf = UnsafeBuffer.Create(_delaySamples, sizeof(float)); _sigDelayBufPtr = (float *)_sigDelayBuf; _magBuf = UnsafeBuffer.Create(_windowSamples, sizeof(float)); _magBufPtr = (float *)_magBuf; for (int i = 0; i < _windowSamples; i++) { _magBufPtr[i] = -16.0f; } //clamp Delay samples within buffer limit if (_delaySamples >= _sigDelayBuf.Length - 1) { _delaySamples = _sigDelayBuf.Length - 1; } } } //calculate parameters for AGC gain as a function of input magnitude _knee = _threshold / 20.0f; _gainSlope = _slopeFactor / 100.0f; _fixedGain = AGCOutscale * (float)Math.Pow(10.0, _knee * (_gainSlope - 1.0)); //fixed gain value used below knee threshold //calculate fast and slow filter values. _attackRiseAlpha = (1.0f - (float)Math.Exp(-1.0 / (_sampleRate * AttackRiseTimeconst))); _attackFallAlpha = (1.0f - (float)Math.Exp(-1.0 / (_sampleRate * AttackFallTimeconst))); _decayRiseAlpha = (1.0f - (float)Math.Exp(-1.0 / (_sampleRate * Decay * .001 * DecayRisefallRatio))); //make rise time DECAY_RISEFALL_RATIO of fall _hangTime = (int)(_sampleRate * Decay * .001); if (_useHang) { _decayFallAlpha = (1.0f - (float)Math.Exp(-1.0 / (_sampleRate * ReleaseTimeconst))); } else { _decayFallAlpha = (1.0f - (float)Math.Exp(-1.0 / (_sampleRate * Decay * .001))); } }
public unsafe void Process(float *baseBand, int length) { if (this._configureNeeded) { this.Configure(); this._configureNeeded = false; } if (this._rawBuffer == null || this._rawBuffer.Length != length) { this._rawBuffer = UnsafeBuffer.Create(length, sizeof(Complex)); this._rawPtr = (Complex *)(void *)this._rawBuffer; } if (this._magBuffer == null || this._magBuffer.Length != length) { this._magBuffer = UnsafeBuffer.Create(length, 4); this._magPtr = (float *)(void *)this._magBuffer; } if (this._dataBuffer == null || this._dataBuffer.Length != length) { this._dataBuffer = UnsafeBuffer.Create(length, 4); this._dataPtr = (float *)(void *)this._dataBuffer; } for (int i = 0; i < length; i++) { this._osc.Tick(); this._rawPtr[i] = this._osc.Phase * baseBand[i]; } this._decimator.Process(this._rawPtr, length); length /= this._decimationFactor; this._baseBandFilter.Process(this._rawPtr, length); for (int j = 0; j < length; j++) { this._dataPtr[j] = this._pll->Process(this._rawPtr[j]).Imag; } this._matchedFilter.Process(this._dataPtr, length); for (int k = 0; k < length; k++) { this._magPtr[k] = Math.Abs(this._dataPtr[k]); } this._syncFilter->Process(this._magPtr, length); for (int l = 0; l < length; l++) { float lastData = this._dataPtr[l]; float num = this._magPtr[l]; float num2 = num - this._lastSync; this._lastSync = num; if (num2 < 0f && this._lastSyncSlope * num2 < 0f) { bool flag = this._lastData > 0f; this._bitDecoder.Process(flag ^ this._lastBit); this._lastBit = flag; } this._lastData = lastData; this._lastSyncSlope = num2; } }
protected CircularBuffer(int bufferSize, int elementSize, int maxBufferCount) { this._bufferSize = bufferSize; this._elementSize = elementSize; this._maxBufferCount = maxBufferCount; for (int i = 0; i < this._maxBufferCount; i++) { this._buffers.Add(UnsafeBuffer.Create(this._bufferSize, this._elementSize)); } }
public unsafe IQBalancer() { this._dcRemoverIBuffer = UnsafeBuffer.Create(sizeof(DcRemover)); this._dcRemoverI = (DcRemover *)(void *)this._dcRemoverIBuffer; this._dcRemoverI->Init(1E-05f); this._dcRemoverQBuffer = UnsafeBuffer.Create(sizeof(DcRemover)); this._dcRemoverQ = (DcRemover *)(void *)this._dcRemoverQBuffer; this._dcRemoverQ->Init(1E-05f); this._isMultithreaded = (Environment.ProcessorCount > 1); }
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 num = length / this._audioDecimationRatio; Utils.Memcpy(this._channelAPtr, baseBand, length * 4); this._channelADecimator.Process(this._channelAPtr, length); this._channelAFilter.Process(this._channelAPtr, num, 1); 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) { for (int j = 0; j < num; j++) { this._deemphasisAvgL += this._deemphasisAlpha * (this._channelAPtr[j] - this._deemphasisAvgL); this._channelAPtr[j] = this._deemphasisAvgL; } for (int k = 0; k < num; k++) { interleavedStereo[k * 2 + 1] = (interleavedStereo[k * 2] = this._channelAPtr[k] * 0.2f); } } else { this._channelBDecimator.Process(this._channelBPtr, length); this._channelBFilter.Process(this._channelBPtr, num, 1); for (int l = 0; l < num; l++) { float num2 = this._channelAPtr[l]; float num3 = 2f * this._channelBPtr[l]; interleavedStereo[l * 2] = (num2 + num3) * 0.2f; interleavedStereo[l * 2 + 1] = (num2 - num3) * 0.2f; } for (int m = 0; m < num; 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; } } }
public RdsDecoder() { _pllBuffer = UnsafeBuffer.Create(sizeof(Pll)); _pll = (Pll *)_pllBuffer; _oscBuffer = UnsafeBuffer.Create(sizeof(Oscillator)); _osc = (Oscillator *)_oscBuffer; _syncFilterBuffer = UnsafeBuffer.Create(sizeof(IirFilter)); _syncFilter = (IirFilter *)_syncFilterBuffer; }
unsafe static Fourier() { Fourier._lrBuffer = UnsafeBuffer.Create(32768, 4); Fourier._liBuffer = UnsafeBuffer.Create(32768, 4); Fourier._lr = (float *)(void *)Fourier._lrBuffer; Fourier._li = (float *)(void *)Fourier._liBuffer; for (int i = 0; i < 32768; i++) { Fourier._lr[i] = (float)Math.Cos(9.5873799242852573E-05 * (double)i); Fourier._li[i] = (float)(0.0 - Math.Sin(9.5873799242852573E-05 * (double)i)); } }