mirror of
https://github.com/SDRSharpR/SDRSharper.git
synced 2025-12-06 04:12:02 +01:00
723 lines
19 KiB
C#
723 lines
19 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
|
|
namespace SDRSharp.Radio
|
|
{
|
|
public static class ExtIO
|
|
{
|
|
public enum HWTypes
|
|
{
|
|
Sdr14 = 1,
|
|
Aud16BInt = 3,
|
|
Soundcard,
|
|
Aud24BInt,
|
|
Aud32BInt,
|
|
Aud32BFloat
|
|
}
|
|
|
|
public enum StatusEvent
|
|
{
|
|
SrChange = 100,
|
|
LOChange,
|
|
ProhibLO,
|
|
LOChangeOk,
|
|
LoChangeNoTune,
|
|
TuneChange,
|
|
DemodChange,
|
|
RsqStart,
|
|
RsqStop,
|
|
FiltChange
|
|
}
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.Cdecl, SetLastError = true, CharSet = CharSet.Ansi)]
|
|
public delegate void ExtIOManagedCallbackDelegate([MarshalAs(UnmanagedType.I4)] int a, [MarshalAs(UnmanagedType.I4)] int b, [MarshalAs(UnmanagedType.R4)] float c, IntPtr data);
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true, CharSet = CharSet.Ansi)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private delegate bool dInitHW([MarshalAs(UnmanagedType.LPStr)] StringBuilder name, [MarshalAs(UnmanagedType.LPStr)] StringBuilder model, [MarshalAs(UnmanagedType.I4)] ref int type);
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true, CharSet = CharSet.Ansi)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
private delegate bool dOpenHW();
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true, CharSet = CharSet.Ansi)]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
private delegate int dStartHW([MarshalAs(UnmanagedType.I4)] int freq);
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true, CharSet = CharSet.Ansi)]
|
|
private delegate void dStopHW();
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true, CharSet = CharSet.Ansi)]
|
|
private delegate void dCloseHW();
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Ansi)]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
private delegate int dSetHWLO([MarshalAs(UnmanagedType.I4)] int freq);
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Ansi)]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
private delegate int dTuneChanged([MarshalAs(UnmanagedType.I4)] int freq);
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true, CharSet = CharSet.Ansi)]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
private delegate int dGetHWLO();
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true, CharSet = CharSet.Ansi)]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
private delegate int dGetHWSR();
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true, CharSet = CharSet.Ansi)]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
private delegate int dGetTune();
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Ansi)]
|
|
[return: MarshalAs(UnmanagedType.I4)]
|
|
private delegate int dGetStatus();
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Ansi)]
|
|
private delegate void dShowGUI();
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Ansi)]
|
|
private delegate void dHideGUI();
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true, CharSet = CharSet.Ansi)]
|
|
private delegate void dSetCallback(ExtIOManagedCallbackDelegate callbackAddr);
|
|
|
|
public static SamplesAvailableDelegate SamplesAvailable;
|
|
|
|
private static dInitHW _initHW;
|
|
|
|
private static dOpenHW _openHW;
|
|
|
|
private static dStartHW _startHW;
|
|
|
|
private static dStopHW _stopHW;
|
|
|
|
private static dCloseHW _closeHW;
|
|
|
|
private static dSetHWLO _setHWLO;
|
|
|
|
private static dTuneChanged _tuneChanged;
|
|
|
|
private static dGetHWLO _getHWLO;
|
|
|
|
private static dGetHWSR _getHWSR;
|
|
|
|
private static dGetTune _getTune;
|
|
|
|
private static dGetStatus _getStatus;
|
|
|
|
private static dShowGUI _showGUI;
|
|
|
|
private static dHideGUI _hideGUI;
|
|
|
|
private static dSetCallback _setCallback;
|
|
|
|
private static IntPtr _dllHandle;
|
|
|
|
private static string _dllName;
|
|
|
|
private static string _name;
|
|
|
|
private static string _model;
|
|
|
|
private static HWTypes _hwType;
|
|
|
|
private static bool _isHWInit;
|
|
|
|
private static bool _isHWStarted;
|
|
|
|
private static UnsafeBuffer _iqBuffer;
|
|
|
|
private unsafe static Complex* _iqPtr;
|
|
|
|
private static int _sampleCount;
|
|
|
|
private static ExtIOManagedCallbackDelegate _callbackInst;
|
|
|
|
private static ListBox _listBox;
|
|
|
|
public static string DllName => ExtIO._dllName;
|
|
|
|
public static HWTypes HWType => ExtIO._hwType;
|
|
|
|
public static bool IsHardwareStarted => ExtIO._isHWStarted;
|
|
|
|
public static bool IsHardwareOpen => ExtIO._isHWInit;
|
|
|
|
public static ListBox ListBox
|
|
{
|
|
set
|
|
{
|
|
ExtIO._listBox = value;
|
|
}
|
|
}
|
|
|
|
public static string HWName
|
|
{
|
|
get
|
|
{
|
|
if (ExtIO._dllHandle != IntPtr.Zero)
|
|
{
|
|
return ExtIO._name;
|
|
}
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
public static string HWModel
|
|
{
|
|
get
|
|
{
|
|
if (ExtIO._dllHandle != IntPtr.Zero)
|
|
{
|
|
return ExtIO._model;
|
|
}
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
public static event dSampleRateChanged SampleRateChanged;
|
|
|
|
public static event dLOFrequencyChanged LOFreqChanged;
|
|
|
|
public static event dTuneFrequencyChanged TuneFreqChanged;
|
|
|
|
public static event dLOFrequencyChangeAccepted LOFreqChangedAccepted;
|
|
|
|
public static event dProhibitLOChanges ProhibitLOChanged;
|
|
|
|
[DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
private static extern IntPtr LoadLibrary(string dllToLoad);
|
|
|
|
[DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
|
|
private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true)]
|
|
private static extern bool FreeLibrary(IntPtr hModule);
|
|
|
|
unsafe static ExtIO()
|
|
{
|
|
ExtIO._iqBuffer = UnsafeBuffer.Create(1024, sizeof(Complex));
|
|
ExtIO._callbackInst = ExtIO.extIOCallback;
|
|
GCHandle.Alloc(ExtIO._callbackInst);
|
|
}
|
|
|
|
public static void UseLibrary(string fileName)
|
|
{
|
|
if (ExtIO._dllHandle != IntPtr.Zero)
|
|
{
|
|
ExtIO.CloseLibrary();
|
|
}
|
|
ExtIO.logInfo("UseLibrary(), dll=" + fileName);
|
|
try
|
|
{
|
|
ExtIO._dllHandle = ExtIO.LoadLibrary(fileName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ExtIO.logInfo("LoadLibrary: " + ex.Message);
|
|
}
|
|
ExtIO.logResult("LoadLibrary:");
|
|
if (ExtIO._dllHandle == IntPtr.Zero)
|
|
{
|
|
ExtIO.logInfo("LoadLibrary(), Unable to load DLL file: " + fileName);
|
|
throw new Exception("Unable to load ExtIO library " + fileName);
|
|
}
|
|
ExtIO._dllName = fileName;
|
|
ExtIO._initHW = null;
|
|
ExtIO._openHW = null;
|
|
ExtIO._startHW = null;
|
|
ExtIO._stopHW = null;
|
|
ExtIO._closeHW = null;
|
|
ExtIO._setHWLO = null;
|
|
ExtIO._tuneChanged = null;
|
|
ExtIO._getHWLO = null;
|
|
ExtIO._getHWSR = null;
|
|
ExtIO._getStatus = null;
|
|
ExtIO._showGUI = null;
|
|
ExtIO._hideGUI = null;
|
|
ExtIO._setCallback = null;
|
|
IntPtr procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "InitHW");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._initHW = (dInitHW)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dInitHW));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "OpenHW");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._openHW = (dOpenHW)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dOpenHW));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "StartHW");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._startHW = (dStartHW)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dStartHW));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "StopHW");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._stopHW = (dStopHW)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dStopHW));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "CloseHW");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._closeHW = (dCloseHW)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dCloseHW));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "SetCallback");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._setCallback = (dSetCallback)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dSetCallback));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "SetHWLO");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._setHWLO = (dSetHWLO)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dSetHWLO));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "TuneChange");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._tuneChanged = (dTuneChanged)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dTuneChanged));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "GetHWLO");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._getHWLO = (dGetHWLO)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dGetHWLO));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "GetHWSR");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._getHWSR = (dGetHWSR)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dGetHWSR));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "GetTune");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._getTune = (dGetTune)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dGetTune));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "GetStatus");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._getStatus = (dGetStatus)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dGetStatus));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "ShowGUI");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._showGUI = (dShowGUI)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dShowGUI));
|
|
}
|
|
procAddress = ExtIO.GetProcAddress(ExtIO._dllHandle, "HideGUI");
|
|
if (procAddress != IntPtr.Zero)
|
|
{
|
|
ExtIO._hideGUI = (dHideGUI)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(dHideGUI));
|
|
}
|
|
if (ExtIO._initHW != null && ExtIO._openHW != null && ExtIO._startHW != null && ExtIO._setHWLO != null && ExtIO._getStatus != null && ExtIO._setCallback != null && ExtIO._stopHW != null && ExtIO._closeHW != null)
|
|
{
|
|
return;
|
|
}
|
|
ExtIO.FreeLibrary(ExtIO._dllHandle);
|
|
ExtIO._dllHandle = IntPtr.Zero;
|
|
ExtIO.logInfo("LoadLibrary(), ExtIO DLL is not valid, not all entries found.");
|
|
throw new ApplicationException("ExtIO DLL is not valid, not all entries found.");
|
|
}
|
|
|
|
public static void CloseLibrary()
|
|
{
|
|
if (ExtIO._isHWStarted)
|
|
{
|
|
ExtIO.StopHW();
|
|
}
|
|
if (ExtIO._isHWInit)
|
|
{
|
|
ExtIO.CloseHW();
|
|
}
|
|
if (!(ExtIO._dllHandle == IntPtr.Zero))
|
|
{
|
|
ExtIO.logInfo("CloseLibrary()");
|
|
try
|
|
{
|
|
ExtIO.FreeLibrary(ExtIO._dllHandle);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ExtIO.logInfo("FreeLibrary: " + ex.Message);
|
|
}
|
|
ExtIO.logResult("FreeLibrary: ");
|
|
ExtIO._dllHandle = IntPtr.Zero;
|
|
}
|
|
}
|
|
|
|
public static void HWInit(bool setCallback)
|
|
{
|
|
if (!(ExtIO._dllHandle == IntPtr.Zero) && !ExtIO._isHWInit && !ExtIO._isHWStarted)
|
|
{
|
|
ExtIO.logInfo("HWInit()");
|
|
StringBuilder stringBuilder = new StringBuilder(256);
|
|
StringBuilder stringBuilder2 = new StringBuilder(256);
|
|
int hwType = 0;
|
|
try
|
|
{
|
|
ExtIO._isHWInit = ExtIO._initHW(stringBuilder, stringBuilder2, ref hwType);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ExtIO.logInfo("InitHW: " + ex.Message);
|
|
}
|
|
ExtIO.logResult("InitHW: ");
|
|
ExtIO._name = stringBuilder.ToString();
|
|
ExtIO._model = stringBuilder2.ToString();
|
|
ExtIO._hwType = (HWTypes)hwType;
|
|
if (!ExtIO._isHWInit)
|
|
{
|
|
ExtIO.logInfo("InitHW() returned " + ExtIO._isHWInit + ", ");
|
|
ExtIO._isHWInit = true;
|
|
ExtIO.CloseHW();
|
|
throw new ApplicationException("InitHW() returned " + ExtIO._isHWInit);
|
|
}
|
|
ExtIO.logInfo("InitHW: " + ExtIO._name + ", " + ExtIO._model + ", type=" + hwType.ToString());
|
|
if (setCallback)
|
|
{
|
|
ExtIO.logInfo("SetCallback: ");
|
|
try
|
|
{
|
|
ExtIO._setCallback(ExtIO._callbackInst);
|
|
}
|
|
catch (Exception ex2)
|
|
{
|
|
ExtIO.logInfo("SetCallback: " + ex2.Message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool OpenHW(bool setCallback = true)
|
|
{
|
|
if (!ExtIO._isHWInit)
|
|
{
|
|
ExtIO.HWInit(setCallback);
|
|
}
|
|
if (!(ExtIO._dllHandle == IntPtr.Zero) && ExtIO._isHWInit && !ExtIO._isHWStarted)
|
|
{
|
|
ExtIO.logInfo("OpenHW()");
|
|
bool flag = false;
|
|
try
|
|
{
|
|
flag = ExtIO._openHW();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ExtIO.logInfo("OpenHW: " + ex.Message);
|
|
}
|
|
if (flag)
|
|
{
|
|
ExtIO.ShowGUI();
|
|
}
|
|
else
|
|
{
|
|
ExtIO.logResult("OpenHW: ");
|
|
}
|
|
return flag;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
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 static void StopHW()
|
|
{
|
|
if (!(ExtIO._dllHandle == IntPtr.Zero) && ExtIO._isHWInit)
|
|
{
|
|
ExtIO.logInfo("StopHW()");
|
|
try
|
|
{
|
|
ExtIO._stopHW();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ExtIO.logInfo("StopHW: " + ex.Message);
|
|
}
|
|
ExtIO._isHWStarted = false;
|
|
}
|
|
}
|
|
|
|
public static void CloseHW()
|
|
{
|
|
if (ExtIO._isHWStarted)
|
|
{
|
|
ExtIO.StopHW();
|
|
}
|
|
if (!(ExtIO._dllHandle == IntPtr.Zero) && ExtIO._isHWInit)
|
|
{
|
|
ExtIO.logInfo("CloseHW()");
|
|
try
|
|
{
|
|
ExtIO._closeHW();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ExtIO.logInfo("CloseHW: " + ex.Message);
|
|
}
|
|
ExtIO._isHWInit = false;
|
|
}
|
|
}
|
|
|
|
public static int GetHWSR()
|
|
{
|
|
int result = 0;
|
|
if (ExtIO._dllHandle != IntPtr.Zero && ExtIO._getHWSR != null && ExtIO._isHWInit)
|
|
{
|
|
result = ExtIO._getHWSR();
|
|
}
|
|
ExtIO.logInfo("getHWSR, SR=" + result.ToString());
|
|
return result;
|
|
}
|
|
|
|
public static int GetHWLO()
|
|
{
|
|
int result = 0;
|
|
if (ExtIO._dllHandle != IntPtr.Zero && ExtIO._getHWLO != null && ExtIO._isHWInit)
|
|
{
|
|
result = ExtIO._getHWLO();
|
|
}
|
|
ExtIO.logInfo("getHWLO, freq=" + result.ToString());
|
|
return result;
|
|
}
|
|
|
|
public static int GetTune()
|
|
{
|
|
int result = 0;
|
|
if (ExtIO._dllHandle != IntPtr.Zero && ExtIO._getTune != null && ExtIO._isHWInit)
|
|
{
|
|
result = ExtIO._getTune();
|
|
}
|
|
ExtIO.logInfo("getTune, freq=" + result.ToString());
|
|
return result;
|
|
}
|
|
|
|
public static void SetHWLO(int freq)
|
|
{
|
|
if (!(ExtIO._dllHandle == IntPtr.Zero) && ExtIO._setHWLO != null && ExtIO._isHWInit)
|
|
{
|
|
try
|
|
{
|
|
ExtIO._setHWLO(freq);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void TuneChanged(int freq)
|
|
{
|
|
if (!(ExtIO._dllHandle == IntPtr.Zero) && ExtIO._tuneChanged != null && ExtIO._isHWInit)
|
|
{
|
|
ExtIO.logInfo("tuneChanged to " + freq.ToString());
|
|
ExtIO._tuneChanged(freq);
|
|
}
|
|
}
|
|
|
|
public static void ShowGUI()
|
|
{
|
|
if (!(ExtIO._dllHandle == IntPtr.Zero) && ExtIO._showGUI != null && ExtIO._isHWInit)
|
|
{
|
|
ExtIO.logInfo("ShowGui()");
|
|
ExtIO._showGUI();
|
|
}
|
|
}
|
|
|
|
public static void HideGUI()
|
|
{
|
|
if (!(ExtIO._dllHandle == IntPtr.Zero) && ExtIO._hideGUI != null && ExtIO._isHWInit)
|
|
{
|
|
ExtIO.logInfo("HideGui()");
|
|
ExtIO._hideGUI();
|
|
}
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.Synchronized)]
|
|
private unsafe static void extIOCallback(int count, int status, float iqOffs, IntPtr dataPtr)
|
|
{
|
|
if (count >= 0 && ExtIO._isHWStarted)
|
|
{
|
|
if (ExtIO._iqPtr != null)
|
|
{
|
|
int length = ExtIO._iqBuffer.Length;
|
|
if (ExtIO._hwType == HWTypes.Aud16BInt || ExtIO._hwType == HWTypes.Sdr14)
|
|
{
|
|
short* ptr = (short*)(void*)dataPtr;
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
Complex* intPtr = ExtIO._iqPtr + i;
|
|
short* intPtr2 = ptr;
|
|
ptr = intPtr2 + 1;
|
|
intPtr->Imag = (float)(*intPtr2) * 3.051851E-05f;
|
|
Complex* intPtr3 = ExtIO._iqPtr + i;
|
|
short* intPtr4 = ptr;
|
|
ptr = intPtr4 + 1;
|
|
intPtr3->Real = (float)(*intPtr4) * 3.051851E-05f;
|
|
}
|
|
}
|
|
else if (ExtIO._hwType == HWTypes.Aud24BInt)
|
|
{
|
|
Int24* ptr2 = (Int24*)(void*)dataPtr;
|
|
for (int j = 0; j < length; j++)
|
|
{
|
|
Complex* intPtr5 = ExtIO._iqPtr + j;
|
|
Int24* intPtr6 = ptr2;
|
|
ptr2 = intPtr6 + 1;
|
|
intPtr5->Imag = (float)(*intPtr6) * 1.1920929E-07f;
|
|
Complex* intPtr7 = ExtIO._iqPtr + j;
|
|
Int24* intPtr8 = ptr2;
|
|
ptr2 = intPtr8 + 1;
|
|
intPtr7->Real = (float)(*intPtr8) * 1.1920929E-07f;
|
|
}
|
|
}
|
|
else if (ExtIO._hwType == HWTypes.Aud32BInt)
|
|
{
|
|
int* ptr3 = (int*)(void*)dataPtr;
|
|
for (int k = 0; k < length; k++)
|
|
{
|
|
Complex* intPtr9 = ExtIO._iqPtr + k;
|
|
int* intPtr10 = ptr3;
|
|
ptr3 = intPtr10 + 1;
|
|
intPtr9->Imag = (float)(*intPtr10) * 4.656613E-10f;
|
|
Complex* intPtr11 = ExtIO._iqPtr + k;
|
|
int* intPtr12 = ptr3;
|
|
ptr3 = intPtr12 + 1;
|
|
intPtr11->Real = (float)(*intPtr12) * 4.656613E-10f;
|
|
}
|
|
}
|
|
else if (ExtIO._hwType == HWTypes.Aud32BFloat)
|
|
{
|
|
float* ptr4 = (float*)(void*)dataPtr;
|
|
for (int l = 0; l < length; l++)
|
|
{
|
|
Complex* intPtr13 = ExtIO._iqPtr + l;
|
|
float* intPtr14 = ptr4;
|
|
ptr4 = intPtr14 + 1;
|
|
intPtr13->Imag = *intPtr14;
|
|
Complex* intPtr15 = ExtIO._iqPtr + l;
|
|
float* intPtr16 = ptr4;
|
|
ptr4 = intPtr16 + 1;
|
|
intPtr15->Real = *intPtr16;
|
|
}
|
|
}
|
|
if (ExtIO.SamplesAvailable != null)
|
|
{
|
|
ExtIO.SamplesAvailable(null, ExtIO._iqPtr, length);
|
|
}
|
|
}
|
|
}
|
|
else if (status > 0)
|
|
{
|
|
int num = 0;
|
|
switch (status)
|
|
{
|
|
case 100:
|
|
ExtIO.logInfo("Status 100, SRChanged");
|
|
num = ExtIO.GetHWSR();
|
|
if (ExtIO.SampleRateChanged != null)
|
|
{
|
|
ExtIO.SampleRateChanged(num);
|
|
}
|
|
break;
|
|
case 101:
|
|
ExtIO.logInfo("Status 101, LOFreqChanged");
|
|
num = ExtIO.GetHWLO();
|
|
if (ExtIO.LOFreqChanged != null && num > 0)
|
|
{
|
|
ExtIO.LOFreqChanged(num);
|
|
}
|
|
break;
|
|
case 102:
|
|
ExtIO.logInfo("Status 102, ProhibitLO");
|
|
if (ExtIO.ProhibitLOChanged != null)
|
|
{
|
|
ExtIO.ProhibitLOChanged();
|
|
}
|
|
break;
|
|
case 103:
|
|
ExtIO.logInfo("Status 103, LOChangeOK");
|
|
if (ExtIO.LOFreqChangedAccepted != null)
|
|
{
|
|
ExtIO.LOFreqChangedAccepted();
|
|
}
|
|
break;
|
|
case 104:
|
|
ExtIO.logInfo("Status 104, LOChangedNoTune");
|
|
num = ExtIO.GetHWLO();
|
|
if (ExtIO.LOFreqChanged != null && num > 0)
|
|
{
|
|
ExtIO.LOFreqChanged(num);
|
|
}
|
|
break;
|
|
case 105:
|
|
ExtIO.logInfo("Status 105, TuneChanged");
|
|
num = ExtIO.GetTune();
|
|
if (ExtIO.TuneFreqChanged != null && num > 0)
|
|
{
|
|
ExtIO.TuneFreqChanged(num);
|
|
}
|
|
break;
|
|
case 106:
|
|
ExtIO.logInfo("Status 106, DemodChange");
|
|
break;
|
|
case 107:
|
|
ExtIO.logInfo("Status 107, RsqStart");
|
|
break;
|
|
case 108:
|
|
ExtIO.logInfo("Status 108, RsqStop");
|
|
break;
|
|
case 109:
|
|
ExtIO.logInfo("FiltChange (109)");
|
|
break;
|
|
default:
|
|
ExtIO.logInfo("Unknown status " + status.ToString() + " received from DLL.");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void logResult(string prefix)
|
|
{
|
|
Marshal.GetLastWin32Error();
|
|
ExtIO.logInfo(prefix + new Win32Exception().Message);
|
|
}
|
|
|
|
private static void logInfo(string msg)
|
|
{
|
|
Console.WriteLine("ExtIO: " + msg);
|
|
}
|
|
}
|
|
}
|