public SingleThreadSegmentPool(int segmentCount)
        {
            if (segmentCount < 1024)
            {
                throw new ArgumentException($"SegmentCount must be at least {MinimalSegmentCount}", nameof(segmentCount));
            }

            var segmentStructureOverhead = segmentCount*Segment.Size;
            var segmentData = segmentCount*SegmentSize;

            _buffer = new UnsafeBuffer(segmentData + segmentStructureOverhead);

            var segments = (Segment*) _buffer.RawBytes;
            var data = _buffer.RawBytes + segmentStructureOverhead;

            for (var i = 0; i < segmentCount; i++)
            {
                var s = segments + i;
                var buffer = data + i*SegmentSize;
                var segment = new Segment(buffer, SegmentSize);

                // copy to the memory pointed by s
                Native.MemcpyUnmanaged((byte*) s, (byte*) &segment, Segment.Size);

                Push(s);
            }
        }

 public void WhenAllocatedAndDisposed_ShouldFreeMemory()
 {
     using (var buffer = new UnsafeBuffer(short.MaxValue + 1))
     {
         GC.KeepAlive(buffer);
     }
 }

        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 ComplexFilter(Complex[] kernel)
     : base(ComplexFilter.GetFFTSize(kernel.Length))
 {
     this._kernelBuffer = UnsafeBuffer.Create(this.FFTSize, sizeof (Complex));
       this._kernelPtr = (Complex*) (void*) this._kernelBuffer;
       this.SetKernel(kernel);
 }

        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 NoiseFilter(int fftSize = 4096)
     : base(fftSize)
 {
     this._gainBuffer1 = UnsafeBuffer.Create(fftSize, 4);
       this._gainPtr1 = (float*) (void*) this._gainBuffer1;
       this._gainBuffer2 = UnsafeBuffer.Create(fftSize, 4);
       this._gainPtr2 = (float*) (void*) this._gainBuffer2;
 }

 public unsafe void Dispose()
 {
     this._coeffBuffer = (UnsafeBuffer) null;
       this._queueBuffer = (UnsafeBuffer) null;
       this._coeffPtr = (float*) null;
       this._queuePtr = (float*) null;
       GC.SuppressFinalize((object) this);
 }

 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;
       this._bitDecoder = new RdsDetectorBank();
       this._bitDecoder.FrameAvailable += new RdsFrameAvailableDelegate(this.FrameAvailableHandler);
 }

        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;
        }

 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._windowBuffer = UnsafeBuffer.Create((Array) FilterBuilder.MakeWindow(WindowType.Hamming, 1024));
       this._windowPtr = (float*) (void*) this._windowBuffer;
       this._isMultithreaded = Environment.ProcessorCount > 1;
 }

        public NoiseFilter(int fftSize)
            : base(fftSize)
        {
            _gainBuffer = UnsafeBuffer.Create(fftSize, sizeof(float));
            _gainPtr = (float*) _gainBuffer;

            _smoothedGainBuffer = UnsafeBuffer.Create(fftSize, sizeof(float));
            _smoothedGainPtr = (float*) _smoothedGainBuffer;

            _powerBuffer = UnsafeBuffer.Create(fftSize, sizeof(float));
            _powerPtr = (float*) _powerBuffer;
        }

 public unsafe OverlapSaveProcessor(int fftSize)
 {
     this._fftSize = fftSize;
       this._halfSize = this._fftSize / 2;
       this._inputPos = this._halfSize;
       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._halfSize, sizeof (Complex));
       this._outputPtr = (Complex*) (void*) this._outputBuffer;
 }

 public IQBalancer()
 {
     _dcRemoverIBuffer = UnsafeBuffer.Create(sizeof(DcRemover));
     _dcRemoverI = (DcRemover*) _dcRemoverIBuffer;
     _dcRemoverI->Init(DcTimeConst);
     _dcRemoverQBuffer = UnsafeBuffer.Create(sizeof(DcRemover));
     _dcRemoverQ = (DcRemover*) _dcRemoverQBuffer;
     _dcRemoverQ->Init(DcTimeConst);
     var window = FilterBuilder.MakeWindow(WindowType.Hamming, FFTBins);
     _windowBuffer = UnsafeBuffer.Create(window);
     _windowPtr = (float*) _windowBuffer;
     _isMultithreaded = Environment.ProcessorCount > 1;
 }

        private void ProcessMono(float* baseBand, float* interleavedStereo, int length)
        {
            #region Prepare buffer

            if (_channelABuffer == null || _channelABuffer.Length != length)
            {
                _channelABuffer = UnsafeBuffer.Create(length, sizeof(float));
                _channelAPtr = (float*)_channelABuffer;
            }

            #endregion

            #region Decimate L+R

            Utils.Memcpy(_channelAPtr, baseBand, length * sizeof(float));
            _channelADecimator.Process(_channelAPtr, length);

            #endregion

            #region Filter L+R

            length /= _audioDecimationFactor;
            _channelAFilter.Process(_channelAPtr, length);

            #endregion

            #region Process deemphasis

            for (var i = 0; i < length; i++)
            {
                _deemphasisAvgL += _deemphasisAlpha * (_channelAPtr[i] - _deemphasisAvgL);
                _channelAPtr[i] = _deemphasisAvgL;
            }

            #endregion

            #region Fill output buffer

            for (var i = 0; i < length; i++)
            {
                var sample = _channelAPtr[i] * AudioGain;
                interleavedStereo[i * 2] = sample;
                interleavedStereo[i * 2 + 1] = sample;
            }

            #endregion
        }

 public Resampler(double inputSampleRate, double outputSampleRate, int taps)
 {
     DoubleToFraction(outputSampleRate / inputSampleRate, out _interpolationFactor, out _decimationFactor);
     var filterLenght = (int) (500.0 / 32000 * inputSampleRate) / _interpolationFactor * _interpolationFactor;
     _tapsPerPhase = filterLenght / _interpolationFactor;
     _firKernelBuffer = UnsafeBuffer.Create(filterLenght, sizeof(float));
     _firKernel = (float*) _firKernelBuffer;
     var cutoff = Math.Min(inputSampleRate, outputSampleRate) * ProtectedPassband;
     var kernel = FilterBuilder.MakeLowPassKernel(inputSampleRate * _interpolationFactor, filterLenght - 1, cutoff, WindowType.BlackmanHarris4);
     fixed (float* ptr = kernel)
     {
         for (var i = 0; i < kernel.Length; i++)
         {
             ptr[i] *= _interpolationFactor;
         }
         Utils.Memcpy(_firKernel, ptr, filterLenght * sizeof(float));
     }
     _firQueueBuffer = UnsafeBuffer.Create(filterLenght, sizeof(float));
     _firQueue = (float*) _firQueueBuffer;
 }

 static unsafe Trig()
 {
     int length = Trig._mask + 1;
       Trig._sinBuffer = UnsafeBuffer.Create(length, 4);
       Trig._cosBuffer = UnsafeBuffer.Create(length, 4);
       Trig._sinPtr = (float*) (void*) Trig._sinBuffer;
       Trig._cosPtr = (float*) (void*) Trig._cosBuffer;
       Trig._indexScale = (float) length / 6.283185f;
       for (int index = 0; index < length; ++index)
       {
     Trig._sinPtr[index] = (float) Math.Sin(((double) index + 0.5) / (double) length * 6.28318548202515);
     Trig._cosPtr[index] = (float) Math.Cos(((double) index + 0.5) / (double) length * 6.28318548202515);
       }
       float num = 0.0f;
       while ((double) num < 6.28318548202515)
       {
     Trig._sinPtr[(int) ((double) num * (double) Trig._indexScale) & Trig._mask] = (float) Math.Sin((double) num);
     Trig._cosPtr[(int) ((double) num * (double) Trig._indexScale) & Trig._mask] = (float) Math.Cos((double) num);
     num += 1.570796f;
       }
 }

        public FftProcessor(int fftSize)
        {            
            _fftSize = fftSize;
            _halfSize = fftSize / 2;
            _overlapSize = (int) Math.Ceiling(_fftSize * OverlapRatio);
            _fftBufferPos = _halfSize;

            _blendFactor = 1.0f / _overlapSize;

            _fftBuffer = UnsafeBuffer.Create(fftSize, sizeof(Complex));
            _fftBufferPtr = (Complex*)_fftBuffer;

            _outOverlapBuffer = UnsafeBuffer.Create(_overlapSize, sizeof(float));
            _outOverlapPtr = (float*) _outOverlapBuffer;

            _overlapBuffer = UnsafeBuffer.Create(fftSize / 2, sizeof(float));
            _overlapBufferPtr = (float*)_overlapBuffer;

            _sampleBuffer = UnsafeBuffer.Create(fftSize, sizeof(float));
            _sampleBufferPtr = (float*)_sampleBuffer;
            _sampleBufferHead = _halfSize;
        }

 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 length = tapsPerPhase * this._interpolationFactor;
       this._firKernelBuffer = UnsafeBuffer.Create(length, 4);
       this._firKernel = (float*) (void*) this._firKernelBuffer;
       double cutoffFrequency = Math.Min(inputSampleRate, outputSampleRate) * protectedPassband;
       float[] numArray = FilterBuilder.MakeLowPassKernel(inputSampleRate * (double) this._interpolationFactor, length - 1, cutoffFrequency, WindowType.BlackmanHarris4);
       fixed (float* numPtr = numArray)
       {
     for (int index = 0; index < numArray.Length; ++index)
     {
       IntPtr num1 = (IntPtr) (numPtr + index);
       double num2 = (double) *(float*) num1 * (double) this._interpolationFactor;
       *(float*) num1 = (float) num2;
     }
     Utils.Memcpy((void*) this._firKernel, (void*) numPtr, length * 4);
       }
       this._firQueueBuffer = UnsafeBuffer.Create(length, 4);
       this._firQueue = (float*) (void*) this._firQueueBuffer;
 }

 public unsafe OverlapAddProcessor(int fftSize)
 {
     this._fftSize = fftSize;
       this._halfSize = this._fftSize / 2;
       this._inputPos = this._halfSize;
       this._queuepBuffer = UnsafeBuffer.Create(this._fftSize, sizeof (Complex));
       this._queuePtr = (Complex*) (void*) this._queuepBuffer;
       this._windowBuffer = UnsafeBuffer.Create(this._fftSize, 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._halfSize, sizeof (Complex));
       this._outputPtr = (Complex*) (void*) this._outputBuffer;
       this._overlapBuffer = UnsafeBuffer.Create(this._halfSize, sizeof (Complex));
       this._overlapPtr = (Complex*) (void*) this._overlapBuffer;
       double num = Math.PI / 2.0 / (double) (this._halfSize - 1);
       for (int index = 0; index < this._halfSize; ++index)
       {
     double a = (double) index * num;
     this._windowPtr[index] = (float) Math.Sin(a);
     this._windowPtr[this._fftSize - 1 - index] = this._windowPtr[index];
       }
 }

 public unsafe OverlapCrossfadeProcessor(int fftSize, float crossFadingRatio = 0.0f)
 {
     this._fftSize = fftSize;
       this._halfSize = this._fftSize / 2;
       this._crossFadingSize = (int) ((double) this._halfSize * (double) 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 = Math.PI / 2.0 / (double) (this._crossFadingSize - 1);
       for (int index = 0; index < this._crossFadingSize; ++index)
       {
     double a = (double) index * num;
     this._windowPtr[index] = (float) Math.Pow(Math.Sin(a), 2.0);
       }
 }