private unsafe float Utility(float phase, float gain)
{
byte * ptr = stackalloc byte[(int)(uint)(1024 * sizeof(Complex) + 16)];
Complex *ptr2 = (Complex *)((long)ptr + 15 & -16);
byte * ptr3 = stackalloc byte[4112];
float * ptr4 = (float *)((long)ptr3 + 15 & -16);
Utils.Memcpy(ptr2, this._iqPtr, 1024 * sizeof(Complex));
IQBalancer.Adjust(ptr2, 1024, phase, gain);
Fourier.ApplyFFTWindow(ptr2, this._windowPtr, 1024);
Fourier.ForwardTransform(ptr2, 1024, true);
Fourier.SpectrumPower(ptr2, ptr4, 1024, 0f, false);
float num = 0f;
for (int i = 0; i < 512; i++)
{
int num2 = 512 - i;
if ((float)num2 > 25.6f && (float)num2 < 486.4f)
{
int num3 = 1022 - i;
if (ptr4[i] - this._averagePower > 20f || ptr4[num3] - this._averagePower > 20f)
{
float num4 = ptr4[i] - ptr4[num3];
num += num4 * num4;
}
}
}
return(num);
}
private float Utility(float phase, float gain)
{
var rawFFTPtr = stackalloc byte[FFTBins * sizeof(Complex) + 16];
var fftPtr = (Complex *)(((long)rawFFTPtr + 15) & ~15);
var rawSpectrumPtr = stackalloc byte[FFTBins * sizeof(float) + 16];
var spectrumPtr = (float *)(((long)rawSpectrumPtr + 15) & ~15);
Utils.Memcpy(fftPtr, _iqPtr, FFTBins * sizeof(Complex));
Adjust(fftPtr, FFTBins, phase, gain);
Fourier.ApplyFFTWindow(fftPtr, _windowPtr, FFTBins);
Fourier.ForwardTransform(fftPtr, FFTBins);
Fourier.SpectrumPower(fftPtr, spectrumPtr, FFTBins);
var result = 0.0f;
const int halfBins = FFTBins / 2;
for (var i = 0; i < halfBins; i++)
{
var distanceFromCenter = halfBins - i;
if (distanceFromCenter > 0.05f * halfBins && distanceFromCenter < 0.95f * halfBins)
{
var j = FFTBins - 2 - i;
if (spectrumPtr[i] - _averagePower > PowerThreshold || spectrumPtr[j] - _averagePower > PowerThreshold)
{
var distance = spectrumPtr[i] - spectrumPtr[j];
result += distance * distance;
}
}
}
return(result);
}
private void EstimatePower()
{
var rawFFTPtr = stackalloc byte[FFTBins * sizeof(Complex) + 16];
var fftPtr = (Complex *)(((long)rawFFTPtr + 15) & ~15);
var rawSpectrumPtr = stackalloc byte[FFTBins * sizeof(float) + 16];
var spectrumPtr = (float *)(((long)rawSpectrumPtr + 15) & ~15);
Utils.Memcpy(fftPtr, _iqPtr, FFTBins * sizeof(Complex));
Fourier.ApplyFFTWindow(fftPtr, _windowPtr, FFTBins);
Fourier.ForwardTransform(fftPtr, FFTBins);
Fourier.SpectrumPower(fftPtr, spectrumPtr, FFTBins);
const int halfBins = FFTBins / 2;
var max = float.NegativeInfinity;
var avg = 0f;
var count = 0;
for (var i = 0; i < halfBins; i++)
{
var distanceFromCenter = halfBins - i;
if (distanceFromCenter > 0.05f * halfBins && distanceFromCenter < 0.95f * halfBins)
{
var j = FFTBins - 2 - i;
if (spectrumPtr[i] > max)
{
max = spectrumPtr[i];
}
if (spectrumPtr[j] > max)
{
max = spectrumPtr[j];
}
avg += spectrumPtr[i] + spectrumPtr[j];
count += 2;
}
}
avg /= count;
_powerRange = max - avg;
_averagePower = avg;
}
private unsafe float Utility(Complex *iq, float phase)
{
Complex *ptr = stackalloc Complex[128 * sizeof(Complex)];
Utils.Memcpy(ptr, iq, 128 * sizeof(Complex));
this.AdjustPhase(ptr, phase);
Fourier.ApplyFFTWindow(ptr, IQBalancer._windowPtr, 128);
Fourier.ForwardTransform(ptr, 128, false);
float num = 0f;
int num2 = 1;
int num3 = 127;
while (num2 < 64)
{
float num4 = Math.Abs(ptr[num2].Real) + Math.Abs(ptr[num2].Imag);
float num5 = Math.Abs(ptr[num3].Real) + Math.Abs(ptr[num3].Imag);
num += Math.Abs(num4 - num5);
num2++;
num3--;
}
return(num);
}
private unsafe void EstimatePower()
{
byte * ptr = stackalloc byte[(int)(uint)(1024 * sizeof(Complex) + 16)];
Complex *ptr2 = (Complex *)((long)ptr + 15 & -16);
byte * ptr3 = stackalloc byte[4112];
float * ptr4 = (float *)((long)ptr3 + 15 & -16);
Utils.Memcpy(ptr2, this._iqPtr, 1024 * sizeof(Complex));
Fourier.ApplyFFTWindow(ptr2, this._windowPtr, 1024);
Fourier.ForwardTransform(ptr2, 1024, true);
Fourier.SpectrumPower(ptr2, ptr4, 1024, 0f, false);
float num = float.NegativeInfinity;
float num2 = 0f;
int num3 = 0;
for (int i = 0; i < 512; i++)
{
int num4 = 512 - i;
if ((float)num4 > 25.6f && (float)num4 < 486.4f)
{
int num5 = 1022 - i;
if (ptr4[i] > num)
{
num = ptr4[i];
}
if (ptr4[num5] > num)
{
num = ptr4[num5];
}
num2 += ptr4[i] + ptr4[num5];
num3 += 2;
}
}
num2 /= (float)num3;
this._powerRange = num - num2;
this._averagePower = num2;
}