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); }
public void Process(Complex* iq, int length) { if (_autoBalanceIQ && length >= FFTBins) { RemoveDC(iq, length); _iqPtr = iq; EstimateImbalance(); Adjust(iq, length, _phase, _gain); } }
static Fourier() { _lut = (Complex*) _lutBuffer; const double angle = TwoPi / MaxLutBins; for (var i = 0; i < LutSize; i++) { _lut[i] = Complex.FromAngle(angle * i).Conjugate(); } }
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; }
private void PopulateGreen(Complex *ptr, int xSym, int ySym, int i, int j) { long shift = _layoutShiftFactor * (i * _ny2 + j); long shiftXSym = _layoutShiftFactor * ((_nx2 - i) * _ny2 + j); long shiftYSym = _layoutShiftFactor * (i * _ny2 + _ny2 - j); long shiftXYSym = _layoutShiftFactor * ((_nx2 - i) * _ny2 + _ny2 - j); var src = ptr + shift; UNM.Zaxpy(_length, xSym, src, _layoutStep, ptr + shiftXSym, _layoutStep); UNM.Zaxpy(_length, ySym, src, _layoutStep, ptr + shiftYSym, _layoutStep); UNM.Zaxpy(_length, xSym * ySym, src, _layoutStep, ptr + shiftXYSym, _layoutStep); }
private void InitFFTBuffers() { _iqBuffer = UnsafeBuffer.Create(_fftBins, sizeof(Complex)); _fftBuffer = UnsafeBuffer.Create(_fftBins, sizeof(Complex)); _fftWindow = UnsafeBuffer.Create(_fftBins, sizeof(float)); _fftSpectrum = UnsafeBuffer.Create(_fftBins, sizeof(float)); _scaledFFTSpectrum = UnsafeBuffer.Create(_fftBins, sizeof(byte)); _iqPtr = (Complex *)_iqBuffer; _fftPtr = (Complex *)_fftBuffer; _fftWindowPtr = (float *)_fftWindow; _fftSpectrumPtr = (float *)_fftSpectrum; _scaledFFTSpectrumPtr = (byte *)_scaledFFTSpectrum; }
public SingleScalarSegment() { I1A = null; I2A = null; I3A = null; I4A = null; I5A = null; I1B = null; I2B = null; I3B = null; I4B = null; I5B = null; }
private unsafe void Configure() { this._index = 0; this._sum = 0f; this._averagingWindowLength = (int)((double)NoiseBlankerProcessor.AveragingWindow * 1E-06 * this._sampleRate); this._norm = 1f / (float)this._averagingWindowLength; this._ratio = ((float)(100 - this._threshold) * 0.1f + 1f) * this._norm; this._delay = UnsafeBuffer.Create((2 * this._averagingWindowLength + 1) * 2, sizeof(Complex)); this._delayPtr = (Complex *)(void *)this._delay; double num = Math.Min(Math.Max(this._pulseWidth * 1E-06 * this._sampleRate, 1.0), (double)this._averagingWindowLength); this._blankingWindowLength = (int)num; this._alpha = 1f / (float)this._blankingWindowLength; }
public void Dispose() { if (m_iqBuffer != null) { m_iqBuffer.Dispose(); m_iqBuffer = null; m_iqBufferPtr = null; } if (m_gui != null) { m_gui.Dispose(); } GC.SuppressFinalize(this); }
private void Dispose(bool disposing) { if (!disposed) { if (disposing) { // Free other state (managed objects) } UnmanagedMemory.Free(electric_field); electric_field = null; disposed = true; } }
private unsafe void ReceiveSamples_sync() { lms_stream_meta_t meta = new lms_stream_meta_t(); meta.timestamp = 0; meta.flushPartialPacket = false; meta.waitForTimestamp = false; while (_isStreaming) { if (_iqBuffer == null || _iqBuffer.Length != _readLength) { _iqBuffer = UnsafeBuffer.Create((int)_readLength, sizeof(Complex)); _iqPtr = (Complex *)_iqBuffer; Thread.Sleep(100); } if (_samplesBuffer == null || _samplesBuffer.Length != (2 * _readLength)) { _samplesBuffer = UnsafeBuffer.Create((int)(2 * _readLength), sizeof(float)); _samplesPtr = (float *)_samplesBuffer; Thread.Sleep(100); } var ptrIq = _iqPtr; if (test_signal) { SineWaveWithNoise(ptrIq, _readLength, phase_accumulator1, sine_freq1); phase_accumulator1 = CosineWaveWithNoise(ptrIq, _readLength, phase_accumulator1, sine_freq1); } else { NativeMethods.LMS_RecvStream(_stream, _samplesPtr, _readLength, ref meta, SampleTimeoutMs); for (int i = 0; i < _readLength; i++) { ptrIq->Real = _samplesPtr[i * 2] / SpectrumOffset; ptrIq->Imag = _samplesPtr[i * 2 + 1] / SpectrumOffset; ptrIq++; } } ComplexSamplesAvailable(_iqPtr, _iqBuffer.Length); } NativeMethods.LMS_StopStream(_stream); Close(); }
internal ComplexFirFilterGeneric(Complex[] coeffs, int decimation) { VolkApi.WarnVolk(); coeffsBuffer = UnsafeBuffer.Create(coeffs.Length, out coeffsBufferPtr); insampBuffer = UnsafeBuffer.Create(coeffs.Length * 2, out insampBufferPtr); insampBufferPtrOffset = insampBufferPtr + coeffs.Length; taps = coeffs.Length; this.decimation = decimation; decimationIndex = 0; offset = 0; for (int i = 0; i < coeffs.Length; i++) { coeffsBufferPtr[i] = coeffs[i]; } }
public unsafe static void InverseTransform(Complex *samples, int length) { for (int i = 0; i < length; i++) { samples[i].Imag = 0f - samples[i].Imag; } Fourier.ForwardTransform(samples, length, false); float num = 1f / (float)length; for (int j = 0; j < length; j++) { samples[j].Real *= num; samples[j].Imag = (0f - samples[j].Imag) * num; } }
public unsafe void _Work(Complex *input, float *output, int length) { if (tempLength != length) { temporaryBuffer = DataBuffer.Create(length, sizeof(Complex)); tempPtr = (Complex *)temporaryBuffer; tempLength = length; } VMath.MultiplyByConjugate(ref tempPtr, &input[1], input, length); for (int i = 0; i < length; i++) { output[i] = (float)(Gain * Math.Atan2(tempPtr[i].imag, tempPtr[i].real)); } }
Complex dotprod_halfband_4(Complex *a, float *b) { Complex sum = new Complex(0, 0); int i; for (i = 0; i < 7; i += 2) { sum.Real += ((a[i].Real + a[14 - i].Real) * b[i]); //>> 15; sum.Imag += ((a[i].Imag + a[14 - i].Imag) * b[i]); //>> 15; } sum.Real += a[7].Real; sum.Imag += a[7].Imag; return(sum); }
Complex dotprod_32(Complex *a, float *b) { Complex sum = new Complex(0, 0); int i; for (i = 1; i < 16; i++) { sum.Real += ((a[i].Real + a[32 - i].Real) * b[i * 2]); //>> 15; sum.Imag += ((a[i].Imag + a[32 - i].Imag) * b[i * 2]); //>> 15; } sum.Real += (a[i].Real * b[i * 2]); //>> 15 sum.Imag += (a[i].Imag * b[i * 2]); //>> 15 return(sum); }
public unsafe void process(Complex *input, float *output, int length) { for (int i = 0; i < length; i++) { Complex complex = input[i] * _lastIq.Conjugate(); float mod = complex.Modulus(); if (mod > 0f) { complex /= mod; } float argument = complex.Argument(); output[i] = argument * _gain; _lastIq = input[i]; } }
public unsafe void Dispose() { this._coeffBuffer = null; this._queueBuffer = null; this._coeffPtr = null; this._queuePtr = null; this._segment = null; this._segPtr = null; this._kernel = null; this._kerPtr = null; this._overlap = null; this._olaPtr = null; this._tmpPtr = null; GC.SuppressFinalize(this); }
private void Configure() { _index = 0; _sum = 0; _averagingWindowLength = (int)(AveragingWindow * 1e-6 * _sampleRate); _norm = 1.0f / _averagingWindowLength; _ratio = ((100 - _threshold) * 0.1f + 1) * _norm; _delay = UnsafeBuffer.Create((2 * _averagingWindowLength + 1) * SizeFactor, sizeof(Complex)); _delayPtr = (Complex *)_delay; var length = Math.Min(Math.Max(_pulseWidth * 1e-6 * _sampleRate, 1), _averagingWindowLength); _blankingWindowLength = (int)length; _alpha = 1.0f / _blankingWindowLength; }
public unsafe static void BackwardTransform(Complex *buffer, int length) { for (int i = 0; i < length; i++) { buffer[i].Imag = 0f - buffer[i].Imag; } Fourier.ForwardTransform(buffer, length, false); float num = 1f / (float)length; for (int j = 0; j < length; j++) { buffer[j].Real *= num; buffer[j].Imag = (0f - buffer[j].Imag) * num; } }
/// <summary> /// Fills the current matrix with (pseudo-)random values from the specified interval. /// </summary> /// <param name="minReal">The minimum real value.</param> /// <param name="maxReal">The maximum real value.</param> /// <param name = "minImag">The minimum imaginary value.</param> /// <param name = "maxImag">The maximum imaginary value.</param> public unsafe void FillWithRandomValues(double minReal, double maxReal, double minImag, double maxImag) { var rnd = new Random(); double rangeReal = maxReal - minReal; double rangeImag = maxImag - minImag; Complex *pThis = this.Data; var pThisDouble = (double *)pThis; int complexSize = this.TotalSize * 2; for (int i = 0; i < complexSize; i += 2) { pThisDouble[i] = rnd.NextDouble() * rangeReal + minReal; pThisDouble[i + 1] = rnd.NextDouble() * rangeImag + minImag; } }
public unsafe void updateData(Complex *c, int length) { FFTWComplex *id = (FFTWComplex *)_input; if (length != _bins) { Console.WriteLine("Warning! Reallocing SFFT!"); realloc(length); } for (int i = 0; i < length; i++) { id[i].imag = c[i].imag; id[i].real = c[i].real; } }
/// <summary> /// Processes the filter. /// </summary> /// protected unsafe override void ProcessFilter(ComplexSignal sourceData, ComplexSignal destinationData) { int length = sourceData.Length; Complex *src = (Complex *)sourceData.Data.ToPointer(); Complex *dst = (Complex *)destinationData.Data.ToPointer(); for (int i = 0; i < length - 1; i++, src++, dst++) { double re = src[i + 1].Real - src[i].Real; // Retain only if difference is positive *dst = (re > 0) ? new Complex(re, 0) : Complex.Zero; } }
internal static extern unsafe void ZGEMM( int order, int transA, int transB, int m, int n, int k, Complex *alpha, Complex *a, int lda, Complex *b, int ldb, Complex *beta, Complex *c, int ldc);
public static unsafe void _DotProduct(out Complex result, Complex *input, float *taps, int length) { float[] res = { 0, 0 }; float *iPtr = (float *)input; float *tPtr = taps; for (int i = 0; i < length; i++) { res[0] += ((*iPtr++) * (*tPtr)); res[1] += ((*iPtr++) * (*tPtr++)); } result = new Complex(res[0], res[1]); }
private void ProcessSamples(byte[] buffer, int actualLength) { const float scale24 = 1.0f / 2147483647.0f; const float scale16 = 1.0f / 32768.0f; var seq = (ushort)buffer[3] << 8 | buffer[2]; if (seq != _nextSequence && _nextSequence != 0) { _lostPacketsCount++; } _nextSequence = (ushort)(seq + 1); if (!_is16Bit) { for (var i = 4; i < actualLength; i += 6) { _workingSamplePtr->Imag = (float)((int)(buffer[i + 2] << 24 | buffer[i + 1] << 16 | buffer[i] << 8)) * scale24; _workingSamplePtr->Real = (float)((int)(buffer[i + 5] << 24 | buffer[i + 4] << 16 | buffer[i + 3] << 8)) * scale24; _workingSamplePtr++; _sampleCount++; } if (_sampleCount >= 240 * 2) { _callback(this, _sampleBufferPtr, _sampleCount); _workingSamplePtr = (Complex *)_sampleBufferPtr; _sampleCount = 0; } } else { for (var i = 4; i < actualLength; i += 4) { _workingSamplePtr->Imag = (float)((short)((buffer[i + 1] << 8) | buffer[i])) * scale16; _workingSamplePtr->Real = (float)((short)((buffer[i + 3] << 8) | buffer[i + 2])) * scale16; _workingSamplePtr++; _sampleCount++; } if (_sampleCount >= 256 * 2) { _callback(this, _sampleBufferPtr, _sampleCount); _workingSamplePtr = (Complex *)_sampleBufferPtr; _sampleCount = 0; } } }
/// <summary> /// Processes the filter. /// </summary> /// protected override void ProcessFilter(ComplexSignal sourceData, ComplexSignal destinationData) { int samples = sourceData.Samples; unsafe { Complex *src = (Complex *)sourceData.Data.ToPointer(); Complex *dst = (Complex *)destinationData.Data.ToPointer(); Complex *comb = (Complex *)combSignal.Data.ToPointer(); for (int i = 0; i < samples; i++, src++, dst++, comb++) { *dst = new Complex((src[0] * comb[0]).Magnitude, 0); } } }
private void CopyToBuffer(int start, int length, int layerSize, int nzSize, Complex *ptr) { var nz3 = 3 * Model.Nz; var dst = Pool.Plan3Nz.Buffer1Ptr; for (int i = 0; i < layerSize; i++) { long srcShift = nzSize * i + start; long dstShift = i * nz3; for (int k = 0; k < length; k++) { dst[dstShift + k] = ptr[srcShift + k]; } } }
/// <summary>Gets a optimal workspace array length for the <c>zhetrf</c> function. /// </summary> /// <param name="n">The order of the matrix.</param> /// <param name="triangularMatrixType">A value indicating whether the upper or lower triangular part of matrix A is stored and how matrix A is factored.</param> /// <returns>The optimal workspace array length.</returns> /// <remarks>The parameter <paramref name="triangularMatrixType"/> should not have an impact of the calculation of the optimal length of the workspace array.</remarks> public int zhetrfQuery(int n, BLAS.TriangularMatrixType triangularMatrixType = BLAS.TriangularMatrixType.LowerTriangularMatrix) { var lwork = -1; var uplo = LAPACK.GetUplo(triangularMatrixType); unsafe { Complex *work = stackalloc Complex[1]; int info; _zhetrf(ref uplo, ref n, null, ref n, null, work, ref lwork, out info); CheckForError(info, "zhetrf"); return(((int)work[0].Real) + 1); } }
public static void IFFT(Complex *input, Complex *output, Complex *scratchpad, int len) { var scale = 1.0f / len; var scaleNeg = -scale; TVal *scratchPtr = (TVal *)scratchpad; TVal *inputPtr = (TVal *)input; for (int i = 0; i < len * 2; i += 2) { scratchPtr[i] = inputPtr[i] * scale; scratchPtr[i + 1] = inputPtr[i + 1] * scaleNeg; } FFT(scratchpad, output, scratchpad, len); }
void kiss_fftr(float *timedata, Complex *freqdata) { /* input buffer timedata is stored row-wise */ int k = 0; int ncfft = 0; Complex fpnk = 0; Complex fpk = 0; Complex f1k = 0; Complex f2k = 0; Complex tw = 0; Complex tdc = 0; /*perform the parallel fft of two real signals packed in real,imag*/ kf_work(this.tmpbuf, (Complex *)timedata, 1, 1, factors); /* The real part of the DC element of the frequency spectrum in this.tmpbuf * contains the sum of the even-numbered elements of the input time sequence * The imag part is the sum of the odd-numbered elements * * The sum of tdc.r and tdc.i is the sum of the input time sequence. * yielding DC of input time sequence * The difference of tdc.r - tdc.i is the sum of the input (dot product) [1,-1,1,-1... * yielding Nyquist bin of input time sequence */ tdc.Real = this.tmpbuf[0].Real; tdc.Imag = this.tmpbuf[0].Imag; freqdata[0].Real = tdc.Real + tdc.Imag; freqdata[ncfft].Real = tdc.Real - tdc.Imag; freqdata[ncfft].Imag = freqdata[0].Imag = 0; for (k = 1; k <= ncfft / 2; ++k) { fpk = this.tmpbuf[k]; fpnk.Real = this.tmpbuf[ncfft - k].Real; fpnk.Imag = -this.tmpbuf[ncfft - k].Imag; C_ADD(&f1k, fpk, fpnk); C_SUB(&f2k, fpk, fpnk); C_MUL(&tw, f2k, this.super_twiddles[k - 1]); freqdata[k].Real = (f1k.Real + tw.Real) / 2; freqdata[k].Imag = (f1k.Imag + tw.Imag) / 2; freqdata[ncfft - k].Real = (f1k.Real - tw.Real) / 2; freqdata[ncfft - k].Imag = (tw.Imag - f1k.Imag) / 2; } }
private void FillIQ(Complex *iqPtr, int length) { if (_isPCM) { if (_blockAlign == 6) { const float scale = 1.0f / 8388607.0f; var ptr = (Int24 *)_tempPtr; for (var i = 0; i < length; i++) { iqPtr->Real = *ptr++ *scale; iqPtr->Imag = *ptr++ *scale; iqPtr++; } } else if (_blockAlign == 4) { var ptr = (Int16 *)_tempPtr; for (var i = 0; i < length; i++) { iqPtr->Real = _lut16[*ptr++ + 32768]; iqPtr->Imag = _lut16[*ptr++ + 32768]; iqPtr++; } } else if (_blockAlign == 2) { var ptr = _tempPtr; for (var i = 0; i < length; i++) { iqPtr->Real = _lutu8[*ptr++]; iqPtr->Imag = _lutu8[*ptr++]; iqPtr++; } } } else { var ptr = (float *)_tempPtr; for (var i = 0; i < length; i++) { iqPtr->Real = *ptr++; iqPtr->Imag = *ptr++; iqPtr++; } } }
public unsafe Contour AutoCorrelation(bool normalize) { int capacity = this.Count / 2; Contour contour = new Contour(capacity); fixed(Complex *complexRef = ((Complex *)contour.array[0])) { Complex *complexPtr = complexRef; double d = 0.0; int shift = 0; while (true) { bool flag = shift < capacity; if (!flag) { if (normalize) { d = Math.Sqrt(d); complexPtr = complexRef; shift = 0; while (true) { flag = shift < capacity; if (!flag) { break; } complexPtr[0] = new Complex(complexPtr->a / d, complexPtr->b / d); complexPtr++; shift++; } } complexRef = ref null; return(contour); } complexPtr[0] = this.Dot(this, shift); double normaSquare = complexPtr.NormaSquare; if (normaSquare > d) { d = normaSquare; } complexPtr++; shift++; } } }
private unsafe void ProcessStandard(Complex *buffer, int length) { if (this._queueBuffer != null) { for (int i = 0; i < length; i++) { Complex *ptr = this._queuePtr + this._offset; * ptr = buffer[i]; this._acc.Real = 0f; this._acc.Imag = 0f; int num = this._queueSize; Complex *ptr2 = ptr; Complex *ptr3 = this._coeffPtr; if (num >= 4) { do { Complex.Mul(ref this._acc, *ptr2, *ptr3); Complex.Mul(ref this._tmp, ptr2[1], ptr3[1]); Complex.Add(ref this._acc, this._tmp); Complex.Mul(ref this._tmp, ptr2[2], ptr3[2]); Complex.Add(ref this._acc, this._tmp); Complex.Mul(ref this._tmp, ptr2[3], ptr3[3]); Complex.Add(ref this._acc, this._tmp); ptr2 += 4; ptr3 += 4; }while ((num -= 4) >= 4); } while (num-- > 0) { ref Complex tmp = ref this._tmp; Complex * intPtr = ptr2; ptr2 = intPtr + 1; Complex c = *intPtr; Complex *intPtr2 = ptr3; ptr3 = intPtr2 + 1; Complex.Mul(ref tmp, c, *intPtr2); Complex.Add(ref this._acc, this._tmp); } if (--this._offset < 0) { this._offset = this._queueSize * 3; Utils.Memcpy(this._queuePtr + this._offset + 1, this._queuePtr, (this._queueSize - 1) * sizeof(Complex)); } buffer[i] = this._acc; } }
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 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); } }
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 } ProcessIQHooks(); ProcessIQ(); ProcessAudioHooks(); _audioStream.Write(_dspOutPtr, _dspOutBuffer.Length); // Blocking write } }
public unsafe void Dispose() { if (this._sampleBuffer == null) return; this._sampleBuffer.Dispose(); this._sampleBufferPtr = (Complex*) null; this._workingSamplePtr = (Complex*) null; }
public static unsafe void StartHW(int freq) { if (ExtIO._dllHandle == IntPtr.Zero || ExtIO._startHW == null) return; ExtIO._iqBuffer = (UnsafeBuffer) null; ExtIO._iqPtr = (Complex*) null; int num = ExtIO._startHW(freq); if (num < 0) throw new Exception("ExtIO StartHW() returned " + (object) num); ExtIO._isHWStarted = true; ExtIO._sampleCount = num; ExtIO._iqBuffer = UnsafeBuffer.Create(ExtIO._sampleCount, sizeof (Complex)); ExtIO._iqPtr = (Complex*) (void*) ExtIO._iqBuffer; }
private void Configure() { _index = 0; _sum = 0; _averagingWindowLength = (int) (AveragingWindow * 1e-6 * _sampleRate); _norm = 1.0f / _averagingWindowLength; _ratio = ((100 - _threshold) * 0.1f + 1) * _norm; _delay = UnsafeBuffer.Create((2 * _averagingWindowLength + 1) * SizeFactor, sizeof(Complex)); _delayPtr = (Complex*) _delay; var length = Math.Min(Math.Max(_pulseWidth * 1e-6 * _sampleRate, 1), _averagingWindowLength); _blankingWindowLength = (int) length; _alpha = 1.0f / _blankingWindowLength; }
private void RecieveSamples() { var recBuffer = new byte[_bufferSize]; var recUnsafeBuffer = UnsafeBuffer.Create(recBuffer); var recPtr = (byte*) recUnsafeBuffer; _iqBuffer = UnsafeBuffer.Create(_bufferSize / 2, sizeof(Complex)); _iqBufferPtr = (Complex*) _iqBuffer; var offs = 0; while (_s != null && _s.Connected) { try { var bytesRec = _s.Receive(recBuffer, offs, _bufferSize - offs, SocketFlags.None); var totalBytes = offs + bytesRec; offs = totalBytes % 2; //Need to correctly handle the hypothetical case where we somehow get an odd number of bytes ProcessSamples(recPtr, totalBytes - offs); //This might work. if (offs == 1) { recPtr[0] = recPtr[totalBytes - 1]; } } catch { Close(); break; } } }
private void InitFFTBuffers() { _iqBuffer = UnsafeBuffer.Create(_fftBins, sizeof(Complex)); _fftBuffer = UnsafeBuffer.Create(_fftBins, sizeof(Complex)); _fftWindow = UnsafeBuffer.Create(_fftBins, sizeof(float)); _fftSpectrum = UnsafeBuffer.Create(_fftBins, sizeof(float)); _scaledFFTSpectrum = UnsafeBuffer.Create(_fftBins, sizeof(byte)); _iqPtr = (Complex*) _iqBuffer; _fftPtr = (Complex*) _fftBuffer; _fftWindowPtr = (float*) _fftWindow; _fftSpectrumPtr = (float*) _fftSpectrum; _scaledFFTSpectrumPtr = (byte*) _scaledFFTSpectrum; }
private unsafe void DuplexFiller(float* buffer, int frameCount) { if (this._dspInBuffer == null || this._dspInBuffer.Length != frameCount) { this._dspInBuffer = UnsafeBuffer.Create(frameCount, sizeof (Complex)); this._dspInPtr = (Complex*) (void*) this._dspInBuffer; } if (this._dspOutBuffer == null || this._dspOutBuffer.Length != this._dspInBuffer.Length * 2) { this._dspOutBuffer = UnsafeBuffer.Create(this._dspInBuffer.Length * 2, 4); this._dspOutPtr = (float*) (void*) this._dspOutBuffer; } Utils.Memcpy((void*) this._dspInPtr, (void*) buffer, frameCount * sizeof (Complex)); if (this._hookManager != null) this._hookManager.ProcessRawIQ(this._dspInPtr, frameCount); this.ProcessIQ(); this.ScaleBuffer(this._dspOutPtr, this._dspOutBuffer.Length); Utils.Memcpy((void*) buffer, (void*) this._dspOutPtr, this._dspOutBuffer.Length * 4); }
private unsafe void ProcessSamples(byte[] buffer, int actualLength) { int num = (int) buffer[3] << 8 | (int) buffer[2]; if (num != (int) this._nextSequence && (int) this._nextSequence != 0) ++this._lostPacketsCount; this._nextSequence = (ushort) (num + 1); if (!this._is16Bit) { int index = 4; while (index < actualLength) { this._workingSamplePtr->Imag = (float) ((int) buffer[index + 2] << 24 | (int) buffer[index + 1] << 16 | (int) buffer[index] << 8) * 4.656613E-10f; this._workingSamplePtr->Real = (float) ((int) buffer[index + 5] << 24 | (int) buffer[index + 4] << 16 | (int) buffer[index + 3] << 8) * 4.656613E-10f; ++this._workingSamplePtr; ++this._sampleCount; index += 6; } if (this._sampleCount < 480) return; this._callback((IFrontendController) this, this._sampleBufferPtr, this._sampleCount); this._workingSamplePtr = this._sampleBufferPtr; this._sampleCount = 0; } else { int index = 4; while (index < actualLength) { this._workingSamplePtr->Imag = (float) (short) ((int) buffer[index + 1] << 8 | (int) buffer[index]) * 3.051758E-05f; this._workingSamplePtr->Real = (float) (short) ((int) buffer[index + 3] << 8 | (int) buffer[index + 2]) * 3.051758E-05f; ++this._workingSamplePtr; ++this._sampleCount; index += 4; } if (this._sampleCount < 512) return; this._callback((IFrontendController) this, this._sampleBufferPtr, this._sampleCount); this._workingSamplePtr = this._sampleBufferPtr; this._sampleCount = 0; } }
private unsafe void Configure() { this._index = 0; this._sum = 0.0f; this._averagingWindowLength = (int) ((double) NoiseBlankerProcessor.AveragingWindow * 1E-06 * this._sampleRate); this._norm = 1f / (float) this._averagingWindowLength; this._ratio = (float) ((double) (100 - this._threshold) * 0.100000001490116 + 1.0) * this._norm; this._delay = UnsafeBuffer.Create((2 * this._averagingWindowLength + 1) * 2, sizeof (Complex)); this._delayPtr = (Complex*) (void*) this._delay; this._blankingWindowLength = (int) Math.Min(Math.Max(this._pulseWidth * 1E-06 * this._sampleRate, 1.0), (double) this._averagingWindowLength); this._alpha = 1f / (float) this._blankingWindowLength; }
private unsafe void RecorderFiller(float* buffer, int frameCount) { if (this._iqInBuffer == null || this._iqInBuffer.Length != frameCount) { this._iqInBuffer = UnsafeBuffer.Create(frameCount, sizeof (Complex)); this._iqInPtr = (Complex*) (void*) this._iqInBuffer; } Utils.Memcpy((void*) this._iqInPtr, (void*) buffer, frameCount * sizeof (Complex)); if (this._hookManager != null) this._hookManager.ProcessRawIQ(this._iqInPtr, frameCount); if (this._iqStream.Length >= this._inputBufferSize * 4) return; this._iqStream.Write(this._iqInPtr, frameCount); }
public void Dispose() { if (_sampleBuffer != null) { _sampleBuffer.Dispose(); _sampleBufferPtr = null; _workingSamplePtr = null; } }
public void Start(SDRSharp.Radio.SamplesAvailableDelegate callback) { _callback = callback; _hostName = _gui.Host; _port = _gui.Port; _is16Bit = _gui.Use16Bit; _lostPacketsCount = 0; _circularBufferHead = 0; _circularBufferTail = 0; _sampleCount = 0; _sampleBuffer = UnsafeBuffer.Create(256 * 2, sizeof(Complex)); _sampleBufferPtr = (Complex*)_sampleBuffer; _workingSamplePtr = _sampleBufferPtr; _client = new SdrIpClient(); _client.Connect(_hostName, _port); _client.Samplerate = _sampleRate; _client.Frequency = _frequency; _client.Use16Bit = _is16Bit; _udpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); _udpSocket.ReceiveBufferSize = 65535; var remoteIpEndPoint = new IPEndPoint(IPAddress.Any, _port); _udpSocket.Bind(remoteIpEndPoint); _udpThread = new Thread(UdpReceiverThread); _udpThread.Priority = ThreadPriority.Highest; _udpThreadRunning = true; _udpThread.Start(); _workerThread = new Thread(WorkerThread); _workerThreadRunning = true; _workerThread.Start(); _client.StartStreaming(); _tuneTimer.Start(); Utils.SaveSetting("SDRIPHost", _hostName); Utils.SaveSetting("SDRIPPort", _port); Utils.SaveSetting("SDRIPRateIndex", _gui.SamepleRateIndex); Utils.SaveSetting("SDRIPFormatIndex", _gui.SampleFormatIndex); }
public void Stop() { _tuneTimer.Stop(); _client.StopStreaming(); _client.Disconnect(); _client = null; if (_udpSocket != null) { _udpSocket.Close(); _udpSocket = null; } _udpThreadRunning = false; if (_udpThread != null) { _udpThread.Join(); _udpThread = null; } _workerThreadRunning = false; if (_workerThread != null) { _bufferEvt.Set(); _workerThread.Join(); _workerThread = null; } if (_sampleBuffer != null) { _sampleBuffer.Dispose(); _sampleBufferPtr = null; _workingSamplePtr = null; } }
public unsafe void Start(SamplesAvailableDelegate callback) { this._callback = callback; this._hostName = this._gui.Host; this._port = this._gui.Port; this._is16Bit = this._gui.Use16Bit; this._lostPacketsCount = 0L; this._circularBufferHead = 0; this._circularBufferTail = 0; this._sampleCount = 0; this._sampleBuffer = UnsafeBuffer.Create(512, sizeof (Complex)); this._sampleBufferPtr = (Complex*) (void*) this._sampleBuffer; this._workingSamplePtr = this._sampleBufferPtr; this._client = new SdrIpClient(); this._client.Connect(this._hostName, this._port); this._client.Samplerate = this._sampleRate; this._client.Frequency = this._frequency; this._client.Use16Bit = this._is16Bit; this._udpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); this._udpSocket.ReceiveBufferSize = (int) ushort.MaxValue; this._udpSocket.Bind((EndPoint) new IPEndPoint(IPAddress.Any, this._port)); this._udpThread = new Thread(new ThreadStart(this.UdpReceiverThread)); this._udpThread.Priority = ThreadPriority.Highest; this._udpThreadRunning = true; this._udpThread.Start(); this._workerThread = new Thread(new ThreadStart(this.WorkerThread)); this._workerThreadRunning = true; this._workerThread.Start(); this._client.StartStreaming(); this._tuneTimer.Start(); Utils.SaveSetting("SDRIPHost", this._hostName); Utils.SaveSetting("SDRIPPort", (object) this._port); Utils.SaveSetting("SDRIPRateIndex", (object) this._gui.SamepleRateIndex); Utils.SaveSetting("SDRIPFormatIndex", (object) this._gui.SampleFormatIndex); }
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; } while (this.IsPlaying) { int ofs = 0; while (this.IsPlaying && ofs < this._dspInBuffer.Length) { int count = this._dspInBuffer.Length - ofs; ofs += this._iqStream.Read(this._dspInPtr, ofs, count); } this.ProcessIQ(); this._audioStream.Write(this._dspOutPtr, this._dspOutBuffer.Length); } }
public unsafe void Stop() { this._tuneTimer.Stop(); this._client.StopStreaming(); this._client.Disconnect(); this._client = (SdrIpClient) null; if (this._udpSocket != null) { this._udpSocket.Close(); this._udpSocket = (Socket) null; } this._udpThreadRunning = false; if (this._udpThread != null) { this._udpThread.Join(); this._udpThread = (Thread) null; } this._workerThreadRunning = false; if (this._workerThread != null) { this._bufferEvt.Set(); this._workerThread.Join(); this._workerThread = (Thread) null; } if (this._sampleBuffer == null) return; this._sampleBuffer.Dispose(); this._sampleBufferPtr = (Complex*) null; this._workingSamplePtr = (Complex*) null; }
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; }
public void Dispose() { if (_iqBuffer != null) { _iqBuffer.Dispose(); _iqBuffer = null; _iqBufferPtr = null; } if (_gui != null) { _gui.Dispose(); } GC.SuppressFinalize(this); }
public void Process(float* baseBand, int length) { #region Initialize buffers if (_rawBuffer == null || _rawBuffer.Length != length) { _rawBuffer = UnsafeBuffer.Create(length, sizeof(Complex)); _rawPtr = (Complex*) _rawBuffer; } if (_magBuffer == null || _magBuffer.Length != length) { _magBuffer = UnsafeBuffer.Create(length, sizeof(float)); _magPtr = (float*) _magBuffer; } if (_dataBuffer == null || _dataBuffer.Length != length) { _dataBuffer = UnsafeBuffer.Create(length, sizeof(float)); _dataPtr = (float*) _dataBuffer; } #endregion // Downconvert for (var i = 0; i < length; i++) { _osc->Tick(); _rawPtr[i] = _osc->Phase * baseBand[i]; } // Decimate _decimator.Process(_rawPtr, length); length /= _decimationFactor; // Filter _baseBandFilter.Process(_rawPtr, length); // PLL for (var i = 0; i < length; i++) { _dataPtr[i] = _pll->Process(_rawPtr[i]).Imag; } //if (!_pll->IsLocked) //{ // _bitDecoder.Reset(); // return; //} // Matched filter _matchedFilter.Process(_dataPtr, length); // Recover signal energy to sustain the oscillation in the IIR for (var i = 0; i < length; i++) { _magPtr[i] = Math.Abs(_dataPtr[i]); } // Synchronize to RDS bitrate _syncFilter->Process(_magPtr, length); // Detect RDS bits for (int i = 0; i < length; i++) { var data = _dataPtr[i]; var syncVal = _magPtr[i]; var slope = syncVal - _lastSync; _lastSync = syncVal; if (slope < 0.0f && _lastSyncSlope * slope < 0.0f) { bool bit = _lastData > 0; _bitDecoder.Process(bit ^ _lastBit); _lastBit = bit; } _lastData = data; _lastSyncSlope = slope; } }
private unsafe void InitFFTBuffers() { this._inputBuffer = UnsafeBuffer.Create(this._fftBins, 4); this._fftBuffer = UnsafeBuffer.Create(this._fftBins, sizeof (Complex)); this._fftWindow = UnsafeBuffer.Create(this._fftBins, 4); this._fftSpectrum = UnsafeBuffer.Create(this._fftBins, 4); this._scaledFFTSpectrum = UnsafeBuffer.Create(this._fftBins, 1); this._inputPtr = (float*) (void*) this._inputBuffer; this._fftPtr = (Complex*) (void*) this._fftBuffer; this._fftWindowPtr = (float*) (void*) this._fftWindow; this._fftSpectrumPtr = (float*) (void*) this._fftSpectrum; this._scaledFFTSpectrumPtr = (byte*) (void*) this._scaledFFTSpectrum; }
public unsafe void Process(float* baseBand, int length) { 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 index = 0; index < length; ++index) { this._osc->Tick(); this._rawPtr[index] = this._osc->Phase * baseBand[index]; } this._decimator.Process(this._rawPtr, length); length /= this._decimationFactor; this._baseBandFilter.Process(this._rawPtr, length); for (int index = 0; index < length; ++index) this._dataPtr[index] = this._pll->Process(this._rawPtr[index]).Imag; this._matchedFilter.Process(this._dataPtr, length); for (int index = 0; index < length; ++index) this._magPtr[index] = Math.Abs(this._dataPtr[index]); this._syncFilter->Process(this._magPtr, length); for (int index = 0; index < length; ++index) { float num1 = this._dataPtr[index]; float num2 = this._magPtr[index]; float num3 = num2 - this._lastSync; this._lastSync = num2; if ((double) num3 < 0.0 && (double) this._lastSyncSlope * (double) num3 < 0.0) { bool flag = (double) this._lastData > 0.0; this._bitDecoder.Process(flag ^ this._lastBit); this._lastBit = flag; } this._lastData = num1; this._lastSyncSlope = num3; } }
private unsafe void ReceiveSamples_sync() { int status = 0; while (_isStreaming) { uint cur_len, new_len; lock (syncLock) { cur_len = new_len = _readLength; } if (_iqBuffer == null || _iqBuffer.Length != cur_len) { _iqBuffer = UnsafeBuffer.Create((int)cur_len, sizeof(Complex)); _iqPtr = (Complex*)_iqBuffer; } if (_samplesBuffer == null || _samplesBuffer.Length != (2 * cur_len)) { _samplesBuffer = UnsafeBuffer.Create((int)(2 * cur_len), sizeof(Int16)); _samplesPtr = (Int16*)_samplesBuffer; } if ((status = NativeMethods.bladerf_sync_config(_dev, bladerf_module.BLADERF_MODULE_RX, bladerf_format.BLADERF_FORMAT_SC16_Q11, NumBuffers, cur_len, NumBuffers / 2, SampleTimeoutMs)) != 0) _isStreaming = false; while (status == 0 && cur_len == new_len) { try { status = NativeMethods.bladerf_sync_rx(_dev, _samplesPtr, cur_len, IntPtr.Zero, SampleTimeoutMs); if (status != 0) throw new ApplicationException(String.Format("bladerf_rx() error. {0}", NativeMethods.bladerf_strerror(status))); var ptrIq = _iqPtr; var ptrSample = _samplesPtr; for (int i = 0; i < cur_len; i++) { ptrIq->Imag = _lutPtr[*ptrSample & 0x0fff]; ptrSample++; ptrIq->Real = _lutPtr[*ptrSample & 0x0fff]; ptrSample++; ptrIq++; } ComplexSamplesAvailable(_iqPtr, _iqBuffer.Length); } catch { break; } lock (syncLock) { new_len = _readLength; } } } }
private void ProcessSamples(byte[] buffer, int actualLength) { const float scale24 = 1.0f / 2147483647.0f; const float scale16 = 1.0f / 32768.0f; var seq = (ushort)buffer[3] << 8 | buffer[2]; if (seq != _nextSequence && _nextSequence != 0) { _lostPacketsCount++; } _nextSequence = (ushort)(seq + 1); if (!_is16Bit) { for (var i = 4; i < actualLength; i += 6) { _workingSamplePtr->Imag = (float)((int)(buffer[i + 2] << 24 | buffer[i + 1] << 16 | buffer[i] << 8)) * scale24; _workingSamplePtr->Real = (float)((int)(buffer[i + 5] << 24 | buffer[i + 4] << 16 | buffer[i + 3] << 8)) * scale24; _workingSamplePtr++; _sampleCount++; } if (_sampleCount >= 240 * 2) { _callback(this, _sampleBufferPtr, _sampleCount); _workingSamplePtr = (Complex*)_sampleBufferPtr; _sampleCount = 0; } } else { for (var i = 4; i < actualLength; i += 4) { _workingSamplePtr->Imag = (float)((short)((buffer[i + 1] << 8) | buffer[i])) * scale16; _workingSamplePtr->Real = (float)((short)((buffer[i + 3] << 8) | buffer[i + 2])) * scale16; _workingSamplePtr++; _sampleCount++; } if (_sampleCount >= 256 * 2) { _callback(this, _sampleBufferPtr, _sampleCount); _workingSamplePtr = (Complex*)_sampleBufferPtr; _sampleCount = 0; } } }