support for colibri

devices/colibri-handler/LibLoader.cpp

@@ -7,7 +7,7 @@ bool LibLoader::load(const char *file)
 #endif
 {
 #ifndef __linux__
-	hDLL = LoadLibrary(file.data());
+	hDLL = LoadLibrary (file);
 #else
 #  define GetProcAddress dlsym
 	hDLL = dlopen(file, RTLD_LAZY);

devices/colibri-handler/colibri-handler.cpp

@@ -28,23 +28,47 @@
 #include	<QDebug>
 #include	"colibri-handler.h"
 
+#ifdef __MINGW32__
+#define GETPROCADDRESS  GetProcAddress
+#else
+#define GETPROCADDRESS  dlsym
+#endif
+
 	colibriHandler::colibriHandler  (QSettings *s):
 	                                  _I_Buffer (4 * 1024 * 1024),
 	                                  myFrame (nullptr) {
 	colibriSettings		= s;
 	setupUi (&myFrame);
-	QString libName = "libcolibrinano_lib.so";
-	if (!m_loader. load (libName. toLatin1 () .data ())) {
+
+
+#ifdef  __MINGW32__
+        const char *libraryString = "colibrinano_lib.dll";
+        Handle          = LoadLibrary ((wchar_t *)L"colibrinano_lib.dll");
+#else
+        const char *libraryString = "libcolibrinano_lib.so";
+        Handle          = dlopen (libraryString, RTLD_NOW);
+#endif
+
+        if (Handle == nullptr) {
            QMessageBox::critical (nullptr, "colibri",
 	                          tr("Failed to load colibrinano_lib.so"));
 	   throw (21);
 	}
 
 	fprintf (stderr, "library is loaded\n");
-	m_loader. initialize ();
+	if (!loadFunctions ()) {
+#ifdef __MINGW32__
+           FreeLibrary (Handle);
+#else
+           dlclose (Handle);
+#endif
+           throw (21);
+        }
+
+	colibri_initialize ();
 
 	fprintf (stderr, "... and initialized\n");
-	uint32_t t_devices	= m_loader. devices ();
+	uint32_t t_devices	= colibri_devices ();
 	if (t_devices == 0) {
 	   QMessageBox::critical (nullptr, "colibri",
 	                          tr ("No device available\n"));
@@ -53,22 +77,22 @@
 
 	fprintf (stderr, "we found %d device(s)\n", t_devices);
 //	set some defaults
-	if (!m_loader.open (&m_deskriptor, 0)) {
+	if (!colibri_open (&m_deskriptor, 0)) {
 	   QMessageBox::warning (nullptr, "colibri",
 	                         tr("Failed to open ColibriNANO!"));
 	   throw (23);
         }
 
 	fprintf (stderr, "and opening device 0 was ok\n");
-        m_loader.setFrequency (m_deskriptor, defaultFrequency ());
+        colibri_setFrequency (m_deskriptor, defaultFrequency ());
 
 	this		-> lastFrequency	= defaultFrequency ();
 	fprintf (stderr, "set on %d\n", lastFrequency);
 	colibriSettings -> beginGroup ("colibriSettings");
 	int gainSetting = colibriSettings -> value ("colibri-gain", 20). toInt ();
 	gainSelector	-> setValue (gainSetting);
 	colibriSettings -> endGroup ();
-        m_loader.setPream (m_deskriptor, gainSelector ->value () * 0.5 + -31.5);
+        colibri_setPream (m_deskriptor, gainSelector -> value () * 0.5 + -31.5);
 	actualGain	-> display (gainSelector -> value () * 0.5 + -31.5);
 
 //	and be prepared for future changes in the settings
@@ -85,7 +109,8 @@
 
 	colibriHandler::~colibriHandler () {
 	myFrame. hide ();
-	stopReader();
+	stopReader	();
+	colibri_finalize ();
 	colibriSettings	-> beginGroup ("colibriSettings");
 	colibriSettings	-> setValue ("colibri-gain", 
 	                              gainSelector -> value ());
@@ -94,7 +119,7 @@
 //
 
 void	colibriHandler::setVFOFrequency	(int32_t newFrequency) {
-        m_loader. setFrequency (m_deskriptor, newFrequency);
+        colibri_setFrequency (m_deskriptor, newFrequency);
 	this	-> lastFrequency	= newFrequency;
 }
 
@@ -105,7 +130,7 @@ int32_t	colibriHandler::getVFOFrequency () {
 void	colibriHandler::set_gainControl	(int newGain) {
 float	gainValue	= -31.5 + newGain * 0.5;
 	if (gainValue <= 6) {
-           m_loader.setPream (m_deskriptor, newGain);
+           colibri_setPream (m_deskriptor, newGain);
 	   actualGain	-> display (gainSelector -> value () * 0.5 + -31.5);
 	   fprintf (stderr, "gain set to %f\n", 
 	                            gainSelector -> value () * 0.5 + -31.5);
@@ -141,7 +166,7 @@ bool	colibriHandler::restartReader	() {
 	   return true;		// should not happen
 
 	fprintf (stderr, "reader is going to start\n");
-	m_loader.start (m_deskriptor, (SampleRateIndex)Sr_1920kHz,
+	colibri_start (m_deskriptor, (SampleRateIndex)Sr_1920kHz,
                         the_callBackRx,
 	                this);
 	running. store (true);
@@ -152,7 +177,7 @@ void	colibriHandler::stopReader() {
 	if (!running. load())
 	   return;
 	fprintf (stderr, "reader is going to stop\n");
-	m_loader. stop (m_deskriptor);
+	colibri_stop (m_deskriptor);
 	running. store (false);
 }
 
@@ -187,7 +212,7 @@ int16_t	colibriHandler::bitDepth () {
 }
 
 QString	colibriHandler::deviceName	() {
-std::string s = m_loader. information ();
+std::string s = colibri_information ();
 	return QString (s. c_str ());
 }
 
@@ -226,3 +251,140 @@ int32_t	colibriHandler::defaultFrequency	() {
 	return 94700000;
 }
 
+bool	colibriHandler::loadFunctions		() {
+	m_initialize =
+	     reinterpret_cast<pFunc1> (GETPROCADDRESS (Handle, "initialize"));
+	if (m_initialize == nullptr)
+	   return false;
+
+	m_finalize =
+	     reinterpret_cast<pFunc1> (GETPROCADDRESS (Handle, "finalize"));
+	if (m_finalize == nullptr)
+	   return false;
+
+	m_version =
+	     reinterpret_cast<pVersion> (GETPROCADDRESS (Handle, "version"));
+	if (m_version == nullptr)
+	   return false;
+
+	m_information =
+	    reinterpret_cast<pInformation>(GETPROCADDRESS (Handle, "information"));
+	if (m_information == nullptr)
+	   return false;
+
+	m_devices =
+	    reinterpret_cast<pDevices>(GETPROCADDRESS (Handle, "devices"));
+	if (m_devices == nullptr)
+	   return false;
+
+	m_open = reinterpret_cast<pOpen>(GETPROCADDRESS (Handle, "open"));
+	if (m_open == nullptr)
+	   return false;
+
+	m_close =
+	       reinterpret_cast<pClose>(GETPROCADDRESS (Handle, "close"));
+	if (m_close == nullptr)
+	   return false;
+
+	m_start =
+	       reinterpret_cast<pStart>(GETPROCADDRESS (Handle, "start"));
+	if (m_start == nullptr)
+	   return false;
+
+	m_stop = reinterpret_cast<pStop>(GETPROCADDRESS (Handle, "stop"));
+	if (m_stop == nullptr)
+	   return false;
+
+	m_setPreamp =
+	      reinterpret_cast<pSetPreamp>(GETPROCADDRESS (Handle, "setPream"));
+	if (m_setPreamp == nullptr)
+	   return false;
+
+	m_setFrequency =
+	      reinterpret_cast<pSetFrequency>(GETPROCADDRESS (Handle, "setFrequency"));
+	if (m_setFrequency == nullptr)
+	   return false;
+
+	return true;
+}
+
+void colibriHandler::colibri_initialize () {
+    if (m_initialize)
+        m_initialize();
+}
+
+void colibriHandler::colibri_finalize () {
+    if (m_finalize)
+        m_finalize();
+}
+
+void colibriHandler::colibri_version (uint32_t &major,
+	                              uint32_t &minor, uint32_t &patch) {
+    if (m_version) {
+        m_version (major, minor, patch);
+    }
+    else {
+        major = 0;
+        minor = 0;
+        patch = 0;
+    }
+}
+
+string colibriHandler::colibri_information () {
+string t_str;
+
+    if (m_information) {
+        char *pStr = nullptr;
+        m_information (&pStr);
+        if (pStr)
+            t_str = string (pStr);
+    }
+
+    return t_str;
+}
+
+uint32_t colibriHandler::colibri_devices () {
+uint32_t t_count = 0;
+    if (m_devices)
+        m_devices(t_count);
+    return t_count;
+}
+
+bool colibriHandler::colibri_open(Descriptor *pDev, const uint32_t devIndex) {
+	if (m_open)
+        return m_open(pDev, devIndex);
+    return false;
+}
+
+void colibriHandler::colibri_close (Descriptor dev) {
+	if (m_close)
+	   m_close(dev);
+}
+
+bool colibriHandler::colibri_start (Descriptor dev,
+	                            SampleRateIndex sr,
+	                            pCallbackRx p, void *pUserData) {
+	if (m_start)
+	   return m_start(dev, sr, p, pUserData);
+	return false;
+}
+
+bool colibriHandler::colibri_stop (Descriptor dev) {
+	if (m_stop)
+	   return m_stop(dev);
+	return false;
+}
+
+bool colibriHandler::colibri_setPream (Descriptor dev, float value) {
+	if (m_setPreamp)
+	   return m_setPreamp (dev, value);
+	return false;
+}
+
+bool colibriHandler::colibri_setFrequency (Descriptor dev, uint32_t value) {
+	if (m_setFrequency)
+	   return m_setFrequency(dev, value);
+	return false;
+}
+
+

devices/colibri-handler/colibri-handler.h

@@ -28,12 +28,44 @@
 #include	<QLabel>
 #include	<QDebug>
 #include	"ui_colibri-widget.h"
-#include	"common.h"
-#include	"LibLoader.h"
 #include	"ringbuffer.h"
 #include	"device-handler.h"
 
-	class	colibriHandler: public deviceHandler, public Ui_colibriWidget {
+
+#ifdef __MINGW32__
+#  define COLIBRI_NANO_API __stdcall
+#else
+#  define COLIBRI_NANO_API
+#endif
+typedef void* Descriptor;
+
+typedef enum {
+    Sr_48kHz = 0,
+    Sr_96kHz,
+    Sr_192kHz,
+    Sr_384kHz,
+    Sr_768kHz,
+    Sr_1536kHz,
+    Sr_1920kHz,
+    Sr_2560kHz,
+    Sr_3072kHz,
+} SampleRateIndex;
+
+typedef bool (*pCallbackRx)(std::complex<float> *, uint32_t, bool, void *);
+
+
+typedef void (COLIBRI_NANO_API *pVersion)(uint32_t&, uint32_t&, uint32_t&);
+typedef void (COLIBRI_NANO_API *pInformation)(char**);
+typedef void (COLIBRI_NANO_API *pDevices)(uint32_t&);
+typedef void (COLIBRI_NANO_API *pFunc1)(void);
+typedef bool (COLIBRI_NANO_API *pOpen)(Descriptor*, const uint32_t);
+typedef void (COLIBRI_NANO_API *pClose)(Descriptor);
+typedef bool (COLIBRI_NANO_API *pStart)(Descriptor, SampleRateIndex, pCallbackRx, void*);
+typedef bool (COLIBRI_NANO_API *pStop)(Descriptor);
+typedef bool (COLIBRI_NANO_API *pSetPreamp)(Descriptor, float);
+typedef bool (COLIBRI_NANO_API *pSetFrequency)(Descriptor, uint32_t);
+
+class	colibriHandler: public deviceHandler, public Ui_colibriWidget {
 Q_OBJECT
 public:
 
@@ -61,12 +93,45 @@ Q_OBJECT
 	float		mapTable_float [2048];
 private:
 	QFrame			myFrame;
-	LibLoader		m_loader;
 	QSettings		*colibriSettings;
-	int			sampleRate	(int);
+	int			sampleRate		(int);
+	bool			loadFunctions		();
+	HINSTANCE		Handle;
 	Descriptor		m_deskriptor;
 	std::atomic<bool>	running;
 	bool			iqSwitcher;
+	pVersion		m_version;
+	pInformation		m_information;
+	pDevices		m_devices;
+	pFunc1			m_initialize;
+	pFunc1			m_finalize;
+	pOpen			m_open;
+	pClose			m_close;
+	pStart			m_start;
+	pStop			m_stop;
+	pSetPreamp		m_setPreamp;
+	pSetFrequency		m_setFrequency;
+//
+//	and the wrappers
+	void			colibri_initialize	();
+	void			colibri_finalize	();
+	void			colibri_version		(uint32_t &major,
+	                                         uint32_t &minor,
+	                                         uint32_t &patch);
+	string			colibri_information	();
+	uint32_t		colibri_devices		();
+	bool			colibri_open		(Descriptor *pDev,
+	                                         const uint32_t devIndex);
+	void			colibri_close		(Descriptor dev);
+	bool			colibri_start		(Descriptor dev,
+	                                         SampleRateIndex sr,
+	                                         pCallbackRx p,
+	                                         void *pUserData);
+	bool			colibri_stop		(Descriptor dev);
+	bool			colibri_setPream	(Descriptor dev, float value);
+	bool			colibri_setFrequency	(Descriptor dev,
+	                                                uint32_t value);
+
 private slots:
 	void			set_gainControl	(int);
 	void			handle_iqSwitcher	();