Forgot to add a few things b4 commit

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk/scripts/contrib@13757 d0543943-73ff-0310-b7d9-9358b9ac24b2

jmesquita/mod_khomp/commons/include/k3lapi.hpp

+#include <string>
+
+#include <k3l.h>
+
+#ifndef KHOMP_COMMONS_WITH_CHANNEL
+# include <k3lVersion.h>
+#endif
+
+#ifdef __GNUC_PREREQ
+#if __GNUC_PREREQ(4,3)
+#include <cstring>
+#endif
+#endif
+
+#ifndef INCLUDED_K3LAPI_HPP
+#define INCLUDED_K3LAPI_HPP
+
+struct K3LAPI
+{
+	/* exceptions */
+
+	struct start_failed
+	{
+		start_failed(const char * _msg) : msg(_msg) {};
+		std::string msg;
+	};
+	
+	struct failed_command
+	{
+		failed_command(int32 _code, unsigned int _dev, unsigned int _obj, int32 _rc)
+		: code(_code), dev(_dev), obj(_obj), rc(_rc) {};
+		
+		int32         code;
+		unsigned int  dev;
+		unsigned int  obj;
+		int32         rc;
+	};
+
+	struct failed_raw_command
+	{
+		failed_raw_command(unsigned int _dev, unsigned int _dsp, int32 _rc)
+		: dev(_dev), dsp(_dsp), rc(_rc) {};
+		
+		unsigned int  dev;
+		unsigned int  dsp;
+		int32         rc;
+	};
+
+	struct invalid_device
+	{
+		invalid_device(unsigned int _device)
+		: device(_device) {};
+		
+		unsigned int device;
+	};
+
+	struct invalid_channel
+	{
+		invalid_channel(unsigned int _device, unsigned int _channel)
+		: device(_device), channel(_channel) {};
+
+		unsigned int device, channel;
+	};
+
+	struct invalid_link
+	{
+		invalid_link(unsigned int _device, unsigned int _link)
+		: device(_device), link(_link) {};
+
+		unsigned int device, link;
+	};
+
+	struct get_param_failed
+	{
+		get_param_failed(std::string _name, int32 _rc)
+		: name(_name), rc((KLibraryStatus)_rc) {};
+
+		std::string name;
+		KLibraryStatus rc;
+	};
+	
+	typedef K3L_DEVICE_CONFIG          device_conf_type;
+	typedef K3L_CHANNEL_CONFIG        channel_conf_type;
+	typedef K3L_CHANNEL_CONFIG *  channel_ptr_conf_type;
+	typedef K3L_LINK_CONFIG              link_conf_type;
+	typedef K3L_LINK_CONFIG *        link_ptr_conf_type;
+
+	/* constructors/destructors */
+	
+	K3LAPI();
+	~K3LAPI();
+
+	/* (init|final)ialize the whole thing! */
+	
+	void start(void);
+	void stop(void);
+
+	/* verificacao de intervalos */
+	
+	inline bool valid_device( unsigned int dev )
+	{
+    	return (dev < _device_count);
+	}
+
+	inline bool valid_channel( unsigned int dev, unsigned int obj )
+	{
+	    return (valid_device(dev) && obj < _channel_count[dev]);
+	}
+
+	inline bool valid_link( unsigned int dev, unsigned int obj )
+	{
+	    return (valid_device(dev) && obj < _link_count[dev]);
+	}
+
+	/* envio de comandos para placa */
+	
+	void mixer(int32 dev, int32 obj, byte track, KMixerSource src, int32 index);
+	void mixerCTbus(int32 dev, int32 obj, byte track, KMixerSource src, int32 index);
+	void command (int32 dev, int32 obj, int32 code, std::string & str);
+	void command (int32 dev, int32 obj, int32 code, const char * parms = NULL);
+	void raw_command(int32 dev, int32 dsp, std::string & str);
+	void raw_command(int32 dev, int32 dsp, const char * cmds, int32 size);
+
+	/* obter dados 'cacheados' */
+	
+	inline unsigned int device_count(void)
+	{
+		return _device_count;
+	}
+
+	inline unsigned int channel_count(unsigned int dev)
+	{
+		if (!valid_device(dev))
+			throw invalid_device(dev);
+
+		return _channel_count[dev];
+	}
+
+	inline unsigned int link_count(unsigned int dev)
+	{
+		if (!valid_device(dev))
+			throw invalid_device(dev);
+
+		return _link_count[dev];
+	}
+
+	KDeviceType device_type(unsigned int dev)
+	{
+		if (!valid_device(dev))
+			throw invalid_device(dev);
+		
+		return _device_type[dev];
+	}
+	
+
+	K3L_DEVICE_CONFIG & device_config(unsigned int dev)
+	{
+		if (!valid_device(dev))
+			throw invalid_device(dev);
+
+		return _device_config[dev];
+	}
+
+	K3L_CHANNEL_CONFIG & channel_config(unsigned int dev, unsigned int obj)
+	{
+		if (!valid_channel(dev, obj))
+			throw invalid_channel(dev, obj);
+
+		return _channel_config[dev][obj];
+	}
+
+	K3L_LINK_CONFIG & link_config(unsigned int dev, unsigned int obj)
+	{
+		if (!valid_channel(dev, obj))
+			throw invalid_channel(dev, obj);
+
+		return _link_config[dev][obj];
+	}
+
+	/* pega valores em strings de eventos */
+
+	KLibraryStatus get_param(K3L_EVENT *ev, const char *name, std::string &res);
+	std::string get_param(K3L_EVENT *ev, const char *name);
+
+	/* inicializa valores em cache */
+
+	void init(void);
+
+ protected:
+
+	unsigned int           _device_count;
+	unsigned int *        _channel_count;
+	unsigned int *           _link_count;
+	
+	     device_conf_type *   _device_config;
+	channel_ptr_conf_type *  _channel_config;
+	   link_ptr_conf_type *     _link_config;
+	          KDeviceType *     _device_type;
+};
+
+#endif /* INCLUDED_K3LAPI_HPP */

jmesquita/mod_khomp/commons/k3lapi.cpp

+#include <k3lapi.hpp>
+
+K3LAPI::K3LAPI()
+: _device_count(0),  _channel_count(0),  _link_count(0),
+  _device_config(0), _channel_config(0), _link_config(0)
+{}
+
+K3LAPI::~K3LAPI()
+{
+	_device_count = 0;
+		
+	if (_device_type)    { delete[] _device_type;       _device_type = NULL; }
+	if (_device_config)  { delete[] _device_config;   _device_config = NULL; }
+	if (_channel_config) { delete[] _channel_config; _channel_config = NULL; }
+	if (_link_config)    { delete[] _link_config;       _link_config = NULL; }
+	if (_channel_count)  { delete[] _channel_count;   _channel_count = NULL; }
+	if (_link_count)     { delete[] _link_count;         _link_count = NULL; }
+}
+
+/* initialize the whole thing! */
+	
+void K3LAPI::start(void)
+{
+	/* tie the used k3l to the compiled k3l version */
+	char *ret = k3lStart(k3lApiMajorVersion, k3lApiMinorVersion, 0); //k3lApiBuildVersion);
+	
+	if (ret && *ret)
+		throw start_failed(ret);
+			
+	/* call init automagically */
+	init();
+}
+
+void K3LAPI::stop(void)
+{
+	k3lStop();
+}
+
+/* envio de comandos para placa */
+	
+void K3LAPI::mixer(int32 dev, int32 obj, byte track, KMixerSource src, int32 index)
+{
+   	KMixerCommand mix;
+
+    mix.Track = track;
+   	mix.Source = src;
+    mix.SourceIndex = index;
+
+   	command(dev, obj, CM_MIXER, (const char *) &mix);
+}
+
+void K3LAPI::mixerCTbus(int32 dev, int32 obj, byte track, KMixerSource src, int32 index)
+{
+   	KMixerCommand mix;
+
+    mix.Track = track;
+   	mix.Source = src;
+    mix.SourceIndex = index;
+
+   	command(dev, obj, CM_MIXER_CTBUS, (const char *) &mix);
+}
+
+void K3LAPI::command(int32 dev, int32 obj, int32 code, std::string & str)
+{
+	command(dev, obj, code, str.c_str());
+}
+
+void K3LAPI::command (int32 dev, int32 obj, int32 code, const char * parms)
+{
+    K3L_COMMAND cmd;
+
+   	cmd.Cmd = code;
+    cmd.Object = obj;
+   	cmd.Params = (byte *)parms;
+
+	int32 rc = k3lSendCommand(dev, &cmd);
+		
+	if (rc != ksSuccess)
+		throw failed_command(code, dev, obj, rc);
+}
+
+void K3LAPI::raw_command(int32 dev, int32 dsp, std::string & str)
+{
+	raw_command(dev, dsp, str.data(), str.size());
+}
+
+void K3LAPI::raw_command(int32 dev, int32 dsp, const char * cmds, int32 size)
+{
+    std::string str(cmds, size);
+
+	int32 rc = k3lSendRawCommand(dev, dsp, (void *)cmds, size);
+
+	if (rc != ksSuccess)
+		throw failed_raw_command(dev, dsp, rc);
+}
+
+KLibraryStatus K3LAPI::get_param(K3L_EVENT *ev, const char *name, std::string &res)
+{
+	char tmp_param[256];
+	memset((void*)tmp_param, 0, sizeof(tmp_param));
+
+	int32 rc = k3lGetEventParam (ev, (sbyte *)name, (sbyte *)tmp_param, sizeof(tmp_param)-1);
+		
+	if (rc != ksSuccess)
+		return (KLibraryStatus)rc;
+
+	res.append(tmp_param, strlen(tmp_param));
+	return ksSuccess;
+}
+	
+std::string K3LAPI::get_param(K3L_EVENT *ev, const char *name)
+{
+	std::string res;
+
+	KLibraryStatus rc = get_param(ev, name, res);
+
+	if (rc != ksSuccess)
+		throw get_param_failed(name, rc);
+			
+	return res;
+}
+
+void K3LAPI::init(void)
+{
+	if (_device_count != 0) return;
+
+	_device_count = k3lGetDeviceCount();
+
+	_device_type	= new KDeviceType[_device_count];
+	_device_config  = new device_conf_type[_device_count];
+	_channel_config = new channel_ptr_conf_type[_device_count];
+	_link_config    = new link_ptr_conf_type[_device_count];
+	_channel_count	= new unsigned int[_device_count];
+	_link_count		= new unsigned int[_device_count];
+		
+	for (unsigned int dev = 0; dev < _device_count; dev++)
+	{
+		_device_type[dev] = (KDeviceType) k3lGetDeviceType(dev);
+			
+		/* caches each device config */
+		if (k3lGetDeviceConfig(dev, ksoDevice + dev, &(_device_config[dev]), sizeof(_device_config[dev])) != ksSuccess)
+			throw start_failed("k3lGetDeviceConfig(device)");
+
+		/* adjust channel/link count for device */
+		_channel_count[dev] = _device_config[dev].ChannelCount;
+		_link_count[dev] = _device_config[dev].LinkCount;
+			
+		/* caches each channel config */
+		_channel_config[dev] = new channel_conf_type[_channel_count[dev]];
+
+		for (unsigned int obj = 0; obj < _channel_count[dev]; obj++)
+		{
+			if (k3lGetDeviceConfig(dev, ksoChannel + obj, &(_channel_config[dev][obj]), 
+									sizeof(_channel_config[dev][obj])) != ksSuccess)
+				throw start_failed("k3lGetDeviceConfig(channel)");
+		}
+
+		/* adjust link count for device */
+		_link_count[dev] = _device_config[dev].LinkCount;
+			
+		/* caches each link config */
+		_link_config[dev] = new link_conf_type[_link_count[dev]];
+
+		for (unsigned int obj = 0; obj < _link_count[dev]; obj++)
+		{
+			if (k3lGetDeviceConfig(dev, ksoLink + obj, &(_link_config[dev][obj]), 
+									sizeof(_link_config[dev][obj])) != ksSuccess)
+				throw start_failed("k3lGetDeviceConfig(link)");
+		}
+	}
+}