private static int HackRFSamplesAvailable(hackrf_transfer* ptr)
        {
            sbyte* buf = ptr->buffer;
            int len = ptr->buffer_length;
            IntPtr ctx = ptr->rx_ctx;

            var gcHandle = GCHandle.FromIntPtr(ctx);
            if (!gcHandle.IsAllocated)
            {
                return -1;
            }
            var instance = (HackRFDevice)gcHandle.Target;

            var sampleCount = (int)len / 2;
            if (instance._iqBuffer == null || instance._iqBuffer.Length != sampleCount)
            {
                instance._iqBuffer = UnsafeBuffer.Create(sampleCount, sizeof(Complex));
                instance._iqPtr = (Complex*)instance._iqBuffer;
            }

            var ptrIq = instance._iqPtr;
            for (var i = 0; i < sampleCount; i++)
            {
                ptrIq->Imag = _lutPtr[*buf++];
                ptrIq->Real = _lutPtr[*buf++];
                ptrIq++;
            }

            instance.ComplexSamplesAvailable(instance._iqPtr, instance._iqBuffer.Length);
            return 0;
        }
Exemple #2
0
 private static unsafe int HackRFSamplesAvailable(hackrf_transfer* ptr)
 {
     sbyte* numPtr1 = ptr->buffer;
       int num1 = ptr->buffer_length;
       GCHandle gcHandle = GCHandle.FromIntPtr(ptr->rx_ctx);
       if (!gcHandle.IsAllocated)
     return -1;
       HackRFDevice hackRfDevice = (HackRFDevice) gcHandle.Target;
       int length = num1 / 2;
       if (hackRfDevice._iqBuffer == null || hackRfDevice._iqBuffer.Length != length)
       {
     hackRfDevice._iqBuffer = UnsafeBuffer.Create(length, sizeof (Complex));
     hackRfDevice._iqPtr = (Complex*) (void*) hackRfDevice._iqBuffer;
       }
       Complex* complexPtr1 = hackRfDevice._iqPtr;
       for (int index = 0; index < length; ++index)
       {
     Complex* complexPtr2 = complexPtr1;
     float* numPtr2 = HackRFDevice._lutPtr;
     sbyte* numPtr3 = numPtr1;
     IntPtr num2 = new IntPtr(1);
     sbyte* numPtr4 = numPtr3 + num2.ToInt64();
     IntPtr num3 = (IntPtr) *numPtr3 * 4;
     double num4 = (double) *(float*) ((IntPtr) numPtr2 + num3);
     complexPtr2->Imag = (float) num4;
     Complex* complexPtr3 = complexPtr1;
     float* numPtr5 = HackRFDevice._lutPtr;
     sbyte* numPtr6 = numPtr4;
     IntPtr num5 = new IntPtr(1);
     numPtr1 = numPtr6 + num5.ToInt64();
     IntPtr num6 = (IntPtr) *numPtr6 * 4;
     double num7 = (double) *(float*) ((IntPtr) numPtr5 + num6);
     complexPtr3->Real = (float) num7;
     ++complexPtr1;
       }
       hackRfDevice.ComplexSamplesAvailable(hackRfDevice._iqPtr, hackRfDevice._iqBuffer.Length);
       return 0;
 }