/usr/include/drumstick/alsaclient.h is in libdrumstick-dev 0.5.0-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 | /*
MIDI Sequencer C++ library
Copyright (C) 2006-2010, Pedro Lopez-Cabanillas <plcl@users.sf.net>
This library is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef DRUMSTICK_ALSACLIENT_H
#define DRUMSTICK_ALSACLIENT_H
#include "alsaport.h"
#include <QPointer>
#include <QThread>
#include <QReadWriteLock>
/**
* @file alsaclient.h
* Classes managing ALSA Sequencer clients
*
* @defgroup ALSAClient ALSA Sequencer Clients
* @{
*/
namespace drumstick {
class MidiQueue;
class MidiClient;
class SequencerEvent;
class SequencerInputThread;
class RemoveEvents;
/**
* Client information
*
* This class is used to retrieve, hold and set some data from
* sequencer clients, like the name or id.
*/
class DRUMSTICK_EXPORT ClientInfo
{
friend class MidiClient;
public:
ClientInfo();
ClientInfo(const ClientInfo& other);
ClientInfo(snd_seq_client_info_t* other);
ClientInfo(MidiClient* seq, int id);
virtual ~ClientInfo();
ClientInfo* clone();
ClientInfo& operator=(const ClientInfo& other);
int getSizeOfInfo() const;
int getClientId();
snd_seq_client_type_t getClientType();
QString getName();
bool getBroadcastFilter();
bool getErrorBounce();
int getNumPorts();
int getEventLost();
void setClient(int client);
void setName(QString name);
void setBroadcastFilter(bool val);
void setErrorBounce(bool val);
PortInfoList getPorts() const;
#if SND_LIB_VERSION > 0x010010
void addFilter(int eventType);
bool isFiltered(int eventType);
void clearFilter();
void removeFilter(int eventType);
#endif
protected:
void readPorts(MidiClient* seq);
void freePorts();
const unsigned char* getEventFilter() __attribute__((deprecated));
void setEventFilter(unsigned char* filter) __attribute__((deprecated));
private:
snd_seq_client_info_t* m_Info;
PortInfoList m_Ports;
};
/**
* List of sequencer client information
*/
typedef QList<ClientInfo> ClientInfoList;
/**
* System information
*
* This class is used to retrieve and hold some data about the
* whole sequencer subsystem.
*/
class DRUMSTICK_EXPORT SystemInfo
{
friend class MidiClient;
public:
SystemInfo();
SystemInfo(const SystemInfo& other);
SystemInfo(snd_seq_system_info_t* other);
SystemInfo(MidiClient* seq);
virtual ~SystemInfo();
SystemInfo* clone();
SystemInfo& operator=(const SystemInfo& other);
int getSizeOfInfo() const;
int getMaxClients();
int getMaxPorts();
int getMaxQueues();
int getMaxChannels();
int getCurrentQueues();
int getCurrentClients();
private:
snd_seq_system_info_t* m_Info;
};
/**
* Sequencer Pool information
*
* This class is used to get and set the size of the input and output pool
* buffers for a sequencer client.
*/
class DRUMSTICK_EXPORT PoolInfo
{
friend class MidiClient;
public:
PoolInfo();
PoolInfo(const PoolInfo& other);
PoolInfo(snd_seq_client_pool_t* other);
PoolInfo(MidiClient* seq);
virtual ~PoolInfo();
PoolInfo* clone();
PoolInfo& operator=(const PoolInfo& other);
int getSizeOfInfo() const;
int getClientId();
int getInputFree();
int getInputPool();
int getOutputFree();
int getOutputPool();
int getOutputRoom();
void setInputPool(int size);
void setOutputPool(int size);
void setOutputRoom(int size);
private:
snd_seq_client_pool_t* m_Info;
};
/**
* Sequencer events handler
*
* This abstract class is used to define an interface that other class can
* implement to receive sequencer events. It is one of the three methods of
* delivering events offered by this library.
*
* @see ALSAClient
*/
class DRUMSTICK_EXPORT SequencerEventHandler
{
public:
/** Destructor */
virtual ~SequencerEventHandler() {}
/**
* Callback function to be implemented by the derived class.
* It will be invoked by the client to deliver received events to the
* registered listener.
*
* @param ev A pointer to the received SequencerEvent
* @see MidiClient::setHandler(), MidiClient::startSequencerInput(),
* MidiClient::stopSequencerInput(), MidiClient::doEvents()
*/
virtual void handleSequencerEvent(SequencerEvent* ev) = 0;
};
/**
* Client management.
*
* This class represents an ALSA sequencer client
*/
class DRUMSTICK_EXPORT MidiClient : public QObject
{
Q_OBJECT
public:
MidiClient( QObject* parent = 0 );
virtual ~MidiClient();
void open( const QString deviceName = "default",
const int openMode = SND_SEQ_OPEN_DUPLEX,
const bool blockMode = false );
void open( snd_config_t* conf,
const QString deviceName = "default",
const int openMode = SND_SEQ_OPEN_DUPLEX,
const bool blockMode = false );
void close();
void startSequencerInput();
void stopSequencerInput();
MidiPort* createPort();
MidiQueue* createQueue();
MidiQueue* createQueue(QString const& name);
MidiQueue* getQueue();
MidiQueue* useQueue(int queue_id);
MidiQueue* useQueue(const QString& name);
MidiQueue* useQueue(MidiQueue* queue);
void portAttach(MidiPort* port);
void portDetach(MidiPort* port);
void detachAllPorts();
void addEventFilter(int evtype);
void output(SequencerEvent* ev, bool async = false, int timeout = -1);
void outputDirect(SequencerEvent* ev, bool async = false, int timeout = -1);
void outputBuffer(SequencerEvent* ev);
void drainOutput(bool async = false, int timeout = -1);
void synchronizeOutput();
int getClientId();
snd_seq_type_t getSequencerType();
/** Returns the sequencer handler managed by ALSA */
snd_seq_t* getHandle() { return m_SeqHandle; }
/** Returns true if the sequencer is opened */
bool isOpened() { return (m_SeqHandle != NULL); }
size_t getOutputBufferSize();
void setOutputBufferSize(size_t newSize);
size_t getInputBufferSize();
void setInputBufferSize(size_t newSize);
/** Returns the name of the sequencer device */
QString getDeviceName() { return m_DeviceName; }
/** Returns the last open mode used in open() */
int getOpenMode() { return m_OpenMode; }
/** Returns the last block mode used in open() */
bool getBlockMode() { return m_BlockMode; }
void setBlockMode(bool newValue);
QString getClientName();
QString getClientName(const int clientId);
void setClientName(QString const& newName);
bool getBroadcastFilter();
void setBroadcastFilter(bool newValue);
bool getErrorBounce();
void setErrorBounce(bool newValue);
ClientInfo& getThisClientInfo();
void setThisClientInfo(const ClientInfo& val);
MidiPortList getMidiPorts() const;
ClientInfoList getAvailableClients();
PortInfoList getAvailableInputs();
PortInfoList getAvailableOutputs();
SystemInfo& getSystemInfo();
QList<int> getAvailableQueues();
PoolInfo& getPoolInfo();
void setPoolInfo(const PoolInfo& info);
void setPoolInput(int size);
void setPoolOutput(int size);
void setPoolOutputRoom(int size);
void resetPoolInput();
void resetPoolOutput();
void dropInput();
void dropInputBuffer();
void dropOutput();
void dropOutputBuffer();
void removeEvents(const RemoveEvents* spec);
SequencerEvent* extractOutput();
int outputPending();
int inputPending(bool fetch);
int getQueueId(const QString& name);
void addListener(QObject* listener);
void removeListener(QObject* listener);
void setEventsEnabled(const bool bEnabled);
/** Returns true if the events mode of delivery has been enabled */
bool getEventsEnabled() const { return m_eventsEnabled; }
/** Sets a sequencer event handler enabling the callback delivery mode */
void setHandler(SequencerEventHandler* handler) { m_handler = handler; }
bool parseAddress( const QString& straddr, snd_seq_addr& result );
void setRealTimeInput(bool enabled);
bool realTimeInputEnabled();
signals:
/** Signal emitted when an event is received */
void eventReceived(SequencerEvent* ev);
protected:
void doEvents();
void applyClientInfo();
void readClients();
void freeClients();
void updateAvailablePorts();
PortInfoList filterPorts(unsigned int filter);
/* low level public functions */
const char * _getDeviceName();
int getPollDescriptorsCount(short events);
int pollDescriptors(struct pollfd *pfds, unsigned int space, short events);
unsigned short pollDescriptorsRevents(struct pollfd *pfds, unsigned int nfds);
/* mid level functions */
void _setClientName( const char *name );
int createSimplePort( const char *name,
unsigned int caps,
unsigned int type );
void deleteSimplePort( int port );
void connectFrom(int myport, int client, int port);
void connectTo(int myport, int client, int port);
void disconnectFrom(int myport, int client, int port);
void disconnectTo(int myport, int client, int port);
private:
class SequencerInputThread;
bool m_eventsEnabled;
bool m_BlockMode;
bool m_NeedRefreshClientList;
int m_OpenMode;
QString m_DeviceName;
snd_seq_t* m_SeqHandle;
QPointer<SequencerInputThread> m_Thread;
QPointer<MidiQueue> m_Queue;
SequencerEventHandler* m_handler;
ClientInfo m_Info;
ClientInfoList m_ClientList;
MidiPortList m_Ports;
PortInfoList m_OutputsAvail;
PortInfoList m_InputsAvail;
QObjectList m_listeners;
SystemInfo m_sysInfo;
PoolInfo m_poolInfo;
};
#if SND_LIB_VERSION > 0x010004
DRUMSTICK_EXPORT QString getRuntimeALSALibraryVersion();
DRUMSTICK_EXPORT int getRuntimeALSALibraryNumber();
#endif
DRUMSTICK_EXPORT QString getRuntimeALSADriverVersion();
DRUMSTICK_EXPORT int getRuntimeALSADriverNumber();
} /* namespace drumstick */
/** @} */
#endif // DRUMSTICK_ALSACLIENT_H
|