drumstick 0.5.0
alsatimer.cpp
Go to the documentation of this file.
1/*
2 MIDI Sequencer C++ library
3 Copyright (C) 2006-2010, Pedro Lopez-Cabanillas <plcl@users.sf.net>
4
5 This library is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18*/
19
20#include "alsatimer.h"
21#include <QReadLocker>
22#include <QWriteLocker>
23#include <cmath>
24#include <cstdio>
25
30
31namespace drumstick {
32
84
89{
90 snd_timer_info_malloc(&m_Info);
91}
92
97TimerInfo::TimerInfo(const snd_timer_info_t *other)
98{
99 snd_timer_info_malloc(&m_Info);
100 snd_timer_info_copy(m_Info, other);
101}
102
108{
109 snd_timer_info_malloc(&m_Info);
110 snd_timer_info_copy(m_Info, other.m_Info);
111}
112
117{
118 snd_timer_info_free(m_Info);
119}
120
127{
128 return new TimerInfo(m_Info);
129}
130
137{
138 snd_timer_info_copy(m_Info, other.m_Info);
139 return *this;
140}
141
146bool
148{
149 return (snd_timer_info_is_slave(m_Info) != 0);
150}
151
156int
158{
159 return snd_timer_info_get_card(m_Info);
160}
161
166QString
168{
169 return QString(snd_timer_info_get_id(m_Info));
170}
171
176QString
178{
179 return QString(snd_timer_info_get_name(m_Info));
180}
181
186long
188{
189 return snd_timer_info_get_resolution(m_Info);
190}
191
196long
198{
199 long res = getResolution();
200 if (res > 0)
201 {
202 return 1000000000L / res;
203 }
204 return 0;
205}
206
211int
213{
214 return snd_timer_info_sizeof();
215}
216
222long
224{
225 return snd_timer_info_get_ticks(m_Info);
226}
227
232{
233 snd_timer_id_malloc(&m_Info);
234}
235
240TimerId::TimerId(const snd_timer_id_t *other)
241{
242 snd_timer_id_malloc(&m_Info);
243 snd_timer_id_copy(m_Info, other);
244 if (getCard() < 0)
245 setCard(0);
246 if (getDevice() < 0)
247 setDevice(0);
248 if (getSubdevice() < 0)
249 setSubdevice(0);
250}
251
257{
258 snd_timer_id_malloc(&m_Info);
259 snd_timer_id_copy(m_Info, other.m_Info);
260 if (getCard() < 0)
261 setCard(0);
262 if (getDevice() < 0)
263 setDevice(0);
264 if (getSubdevice() < 0)
265 setSubdevice(0);
266}
267
276TimerId::TimerId(int cls, int scls, int card, int dev, int sdev)
277{
278 snd_timer_id_malloc(&m_Info);
279 setClass(cls);
280 setSlaveClass(scls);
281 setCard(card);
282 setDevice(dev);
283 setSubdevice(sdev);
284}
285
290{
291 snd_timer_id_free(m_Info);
292}
293
298TimerId*
300{
301 return new TimerId(m_Info);
302}
303
309TimerId&
311{
312 snd_timer_id_copy(m_Info, other.m_Info);
313 if (getCard() < 0)
314 setCard(0);
315 if (getDevice() < 0)
316 setDevice(0);
317 if (getSubdevice() < 0)
318 setSubdevice(0);
319 return *this;
320}
321
332void
333TimerId::setClass(int devclass)
334{
335 snd_timer_id_set_class(m_Info, devclass);
336}
337
343int
345{
346 return snd_timer_id_get_class(m_Info);
347}
348
353void
355{
356 snd_timer_id_set_sclass(m_Info, devsclass);
357}
358
363int
365{
366 return snd_timer_id_get_sclass(m_Info);
367}
368
373void
375{
376 snd_timer_id_set_card(m_Info, card);
377}
378
383int
385{
386 return snd_timer_id_get_card(m_Info);
387}
388
393void
395{
396 snd_timer_id_set_device(m_Info, device);
397}
398
403int
405{
406 return snd_timer_id_get_device(m_Info);
407}
408
413void
415{
416 snd_timer_id_set_subdevice (m_Info, subdevice);
417}
418
423int
425{
426 return snd_timer_id_get_subdevice(m_Info);
427}
428
433int
435{
436 return snd_timer_id_sizeof();
437}
438
444TimerQuery::TimerQuery(const QString& deviceName, int openMode)
445{
446 CHECK_WARNING( snd_timer_query_open( &m_Info,
447 deviceName.toLocal8Bit().data(),
448 openMode ));
449 readTimers();
450}
451
458TimerQuery::TimerQuery( const QString& deviceName, int openMode,
459 snd_config_t* conf )
460{
461 CHECK_WARNING( snd_timer_query_open_lconf( &m_Info,
462 deviceName.toLocal8Bit().data(),
463 openMode, conf ));
464 readTimers();
465}
466
471{
472 freeTimers();
473 snd_timer_query_close(m_Info);
474}
475
479void
481{
482 TimerId tid;
483 snd_timer_id_set_class(tid.m_Info, SND_TIMER_CLASS_NONE);
484 for(;;)
485 {
486 int rc = snd_timer_query_next_device(m_Info, tid.m_Info);
487 if ((rc < 0) || (tid.getClass() < 0)) {
488 break;
489 }
490 m_timers.append(tid);
491 }
492}
493
497void
499{
500 m_timers.clear();
501}
502
509{
510 snd_timer_query_info(m_Info, m_GlobalInfo.m_Info);
511 return m_GlobalInfo;
512}
513
518void
519TimerQuery::setGlobalParams(snd_timer_gparams_t* params)
520{
521 snd_timer_query_params(m_Info, params);
522}
523
528void
529TimerQuery::getGlobalParams(snd_timer_gparams_t* params)
530{
531 snd_timer_query_params(m_Info, params);
532}
533
538void
539TimerQuery::getGlobalStatus(snd_timer_gstatus_t *status)
540{
541 snd_timer_query_status(m_Info, status);
542}
543
548{
549 snd_timer_ginfo_malloc(&m_Info);
550}
551
556TimerGlobalInfo::TimerGlobalInfo(const snd_timer_ginfo_t* other)
557{
558 snd_timer_ginfo_malloc(&m_Info);
559 snd_timer_ginfo_copy(m_Info, other);
560}
561
567{
568 snd_timer_ginfo_malloc(&m_Info);
569 snd_timer_ginfo_copy(m_Info, other.m_Info);
570}
571
576{
577 snd_timer_ginfo_free(m_Info);
578}
579
586{
587 return new TimerGlobalInfo(m_Info);
588}
589
597{
598 snd_timer_ginfo_copy(m_Info, other.m_Info);
599 return *this;
600}
601
606void
608{
609 m_Id = tid;
610 snd_timer_ginfo_set_tid (m_Info, m_Id.m_Info);
611}
612
617TimerId&
619{
620 m_Id = TimerId(snd_timer_ginfo_get_tid (m_Info));
621 return m_Id;
622}
623
628unsigned int
630{
631 return snd_timer_ginfo_get_flags (m_Info);
632}
633
638int
640{
641 return snd_timer_ginfo_get_card (m_Info);
642}
643
648QString
650{
651 return QString(snd_timer_ginfo_get_id (m_Info));
652}
653
658QString
660{
661 return QString(snd_timer_ginfo_get_name (m_Info));
662}
663
668unsigned long
670{
671 return snd_timer_ginfo_get_resolution (m_Info);
672}
673
678unsigned long
680{
681 return snd_timer_ginfo_get_resolution_min (m_Info);
682}
683
688unsigned long
690{
691 return snd_timer_ginfo_get_resolution_max(m_Info);
692}
693
698unsigned int
700{
701 return snd_timer_ginfo_get_clients(m_Info);
702}
703
708int
710{
711 return snd_timer_ginfo_sizeof();
712}
713
718{
719 snd_timer_params_malloc (&m_Info);
720}
721
726TimerParams::TimerParams(const snd_timer_params_t *other)
727{
728 snd_timer_params_malloc (&m_Info);
729 snd_timer_params_copy (m_Info, other);
730}
731
737{
738 snd_timer_params_malloc (&m_Info);
739 snd_timer_params_copy (m_Info, other.m_Info);
740}
741
747{
748 snd_timer_params_free (m_Info);
749}
750
757{
758 return new TimerParams(m_Info);
759}
760
768{
769 snd_timer_params_copy (m_Info, other.m_Info);
770 return *this;
771}
772
777void
779{
780 snd_timer_params_set_auto_start (m_Info, auto_start ? 1 : 0);
781}
782
787bool
789{
790 return (snd_timer_params_get_auto_start (m_Info) != 0);
791}
792
797void
799{
800 snd_timer_params_set_exclusive (m_Info, exclusive ? 1 : 0);
801}
802
807bool
809{
810 return (snd_timer_params_get_exclusive (m_Info) != 0);
811}
812
817void
819{
820 snd_timer_params_set_early_event (m_Info, early_event ? 1 : 0);
821}
822
827bool
829{
830 return (snd_timer_params_get_early_event (m_Info) != 0);
831}
832
837void
839{
840 snd_timer_params_set_ticks (m_Info, ticks);
841}
842
847long
849{
850 return snd_timer_params_get_ticks (m_Info);
851}
852
857void
859{
860 snd_timer_params_set_queue_size (m_Info, queue_size);
861}
862
867long
869{
870 return snd_timer_params_get_queue_size (m_Info);
871}
872
877void
878TimerParams::setFilter(unsigned int filter)
879{
880 snd_timer_params_set_filter (m_Info, filter);
881}
882
887unsigned int
889{
890 return snd_timer_params_get_filter (m_Info);
891}
892
897int
899{
900 return snd_timer_params_sizeof();
901}
902
907{
908 snd_timer_status_malloc (&m_Info);
909}
910
915TimerStatus::TimerStatus(const snd_timer_status_t *other)
916{
917 snd_timer_status_malloc (&m_Info);
918 snd_timer_status_copy (m_Info, other);
919}
920
926{
927 snd_timer_status_malloc (&m_Info);
928 snd_timer_status_copy (m_Info, other.m_Info);
929}
930
935{
936 snd_timer_status_free (m_Info);
937}
938
945{
946 return new TimerStatus(m_Info);
947}
948
956{
957 snd_timer_status_copy (m_Info, other.m_Info);
958 return *this;
959}
960
965snd_htimestamp_t
967{
968 return snd_timer_status_get_timestamp (m_Info);
969}
970
975long
977{
978 return snd_timer_status_get_resolution (m_Info);
979}
980
985long
987{
988 return snd_timer_status_get_lost (m_Info);
989}
990
995long
997{
998 return snd_timer_status_get_overrun (m_Info);
999}
1000
1005long
1007{
1008 return snd_timer_status_get_queue (m_Info);
1009}
1010
1015int
1017{
1018 return snd_timer_status_sizeof();
1019}
1020
1032Timer::Timer( const QString& deviceName, int openMode, QObject* parent )
1033 : QObject(parent),
1034 m_asyncHandler(NULL),
1035 m_handler(NULL),
1036 m_thread(NULL),
1037 m_deviceName(deviceName)
1038{
1039 CHECK_ERROR( snd_timer_open( &m_Info, m_deviceName.toLocal8Bit().data(),
1040 openMode ));
1041}
1042
1055Timer::Timer( const QString& deviceName, int openMode, snd_config_t* conf,
1056 QObject* parent )
1057 : QObject(parent),
1058 m_asyncHandler(NULL),
1059 m_handler(NULL),
1060 m_thread(NULL),
1061 m_deviceName(deviceName)
1062{
1063 CHECK_ERROR( snd_timer_open_lconf( &m_Info,
1064 m_deviceName.toLocal8Bit().data(),
1065 openMode, conf ));
1066}
1067
1079Timer::Timer( TimerId& id, int openMode, QObject* parent )
1080 : QObject(parent),
1081 m_asyncHandler(NULL),
1082 m_handler(NULL),
1083 m_thread(NULL)
1084{
1085 m_deviceName = QString("hw:CLASS=%1,SCLASS=%2,CARD=%3,DEV=%4,SUBDEV=%5")
1086 .arg(id.getClass())
1087 .arg(id.getSlaveClass())
1088 .arg(id.getCard())
1089 .arg(id.getDevice())
1090 .arg(id.getSubdevice());
1091 CHECK_ERROR( snd_timer_open( &m_Info,
1092 m_deviceName.toLocal8Bit().data(),
1093 openMode ));
1094}
1095
1111Timer::Timer( int cls, int scls, int card, int dev, int sdev,
1112 int openMode, QObject* parent )
1113 : QObject(parent),
1114 m_asyncHandler(NULL),
1115 m_handler(NULL),
1116 m_thread(NULL)
1117{
1118 m_deviceName = QString("hw:CLASS=%1,SCLASS=%2,CARD=%3,DEV=%4,SUBDEV=%5")
1119 .arg(cls)
1120 .arg(scls)
1121 .arg(card)
1122 .arg(dev)
1123 .arg(sdev);
1124 CHECK_ERROR( snd_timer_open( &m_Info,
1125 m_deviceName.toLocal8Bit().data(),
1126 openMode ));
1127}
1128
1133{
1134 stopEvents();
1135 if (m_thread != NULL)
1136 delete m_thread;
1137 CHECK_WARNING(snd_timer_close(m_Info));
1138}
1139
1145void
1146Timer::addAsyncTimerHandler(snd_async_callback_t callback, void *private_data)
1147{
1148 CHECK_WARNING(snd_async_add_timer_handler(&m_asyncHandler, m_Info, callback, private_data));
1149}
1150
1155snd_timer_t*
1157{
1158 return snd_async_handler_get_timer(m_asyncHandler);
1159}
1160
1165int
1167{
1168 return snd_timer_poll_descriptors_count(m_Info);
1169}
1170
1176void
1177Timer::pollDescriptors(struct pollfd *pfds, unsigned int space)
1178{
1179 CHECK_WARNING(snd_timer_poll_descriptors(m_Info, pfds, space));
1180}
1181
1188void
1189Timer::pollDescriptorsRevents(struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
1190{
1191 CHECK_WARNING(snd_timer_poll_descriptors_revents(m_Info, pfds, nfds, revents));
1192}
1193
1198TimerInfo&
1200{
1201 snd_timer_info (m_Info, m_TimerInfo.m_Info);
1202 return m_TimerInfo;
1203}
1204
1209void
1211{
1212 CHECK_WARNING( snd_timer_params(m_Info, params.m_Info) );
1213}
1214
1221{
1222 CHECK_WARNING( snd_timer_status(m_Info, m_TimerStatus.m_Info) );
1223 return m_TimerStatus;
1224}
1225
1229void
1231{
1232 CHECK_WARNING(snd_timer_start(m_Info));
1233}
1234
1238void
1240{
1241 CHECK_WARNING(snd_timer_stop(m_Info));
1242}
1243
1247void
1249{
1250 CHECK_WARNING(snd_timer_continue(m_Info));
1251}
1252
1259ssize_t
1260Timer::read(void *buffer, size_t size)
1261{
1262 return snd_timer_read(m_Info, buffer, size);
1263}
1264
1273void
1275{
1276 snd_timer_tread_t tr;
1277 while ( read(&tr, sizeof(tr)) == sizeof(tr) ) {
1278 int msecs = ((tr.tstamp.tv_sec - m_last_time.tv_sec) * 1000) +
1279 round((tr.tstamp.tv_nsec - m_last_time.tv_nsec) / 1000000.0);
1280 m_last_time = tr.tstamp;
1281 if ( m_handler != NULL )
1282 m_handler->handleTimerEvent(tr.val, msecs);
1283 else
1284 emit timerExpired(tr.val, msecs);
1285 }
1286}
1287
1292{
1293 m_last_time = getTimerStatus().getTimestamp();
1294 if (m_thread == NULL) {
1295 m_thread = new TimerInputThread(this, 500);
1296 m_thread->start();
1297 }
1298}
1299
1304{
1305 int counter = 0;
1306 if (m_thread != NULL) {
1307 m_thread->stop();
1308 while (!m_thread->wait(500) && (counter < 10)) {
1309 counter++;
1310 }
1311 if (!m_thread->isFinished()) {
1312 m_thread->terminate();
1313 }
1314 delete m_thread;
1315 }
1316}
1317
1324TimerId
1326{
1327 TimerId id;
1328 snd_timer_t* timer;
1329 snd_timer_info_t* info;
1330 long res, best_res = LONG_MAX;
1331 char timername[64];
1332 int test_devs[] = {
1333 SND_TIMER_GLOBAL_SYSTEM
1334 , SND_TIMER_GLOBAL_RTC
1335#ifdef SND_TIMER_GLOBAL_HPET
1336 , SND_TIMER_GLOBAL_HPET
1337#endif
1338#ifdef SND_TIMER_GLOBAL_HRTIMER
1339 , SND_TIMER_GLOBAL_HRTIMER
1340#endif
1341 };
1342 int max_global_timers = sizeof(test_devs)/sizeof(int);
1343 int clas = SND_TIMER_CLASS_GLOBAL;
1344 int scls = SND_TIMER_SCLASS_NONE;
1345 int card = 0;
1346 int dev = SND_TIMER_GLOBAL_SYSTEM;
1347 int sdev = 0;
1348 int err = 0;
1349 int is_slave = 0;
1350 int i;
1351 snd_timer_info_alloca(&info);
1352 // default system timer
1353 id.setClass(clas);
1354 id.setSlaveClass(scls);
1355 id.setCard(card);
1356 id.setDevice(dev);
1357 id.setSubdevice(sdev);
1358 // select a non slave timer with the lowest resolution value
1359 for( i = 0; i < max_global_timers; ++i )
1360 {
1361 dev = test_devs[i];
1362 sprintf( timername, "hw:CLASS=%i,SCLASS=%i,CARD=%i,DEV=%i,SUBDEV=%i",
1363 clas, scls, card, dev, sdev );
1364 err = snd_timer_open(&timer, timername, SND_TIMER_OPEN_NONBLOCK);
1365 if (err < 0) continue;
1366 err = snd_timer_info(timer, info);
1367 if (err == 0) {
1368 is_slave = snd_timer_info_is_slave(info);
1369 res = snd_timer_info_get_resolution(info);
1370 if ((is_slave == 0) && (best_res > res)) {
1371 best_res = res;
1372 id.setDevice(dev);
1373 }
1374 }
1375 snd_timer_close(timer);
1376 }
1377 return id;
1378}
1379
1387Timer*
1388Timer::bestGlobalTimer(int openMode, QObject* parent)
1389{
1391 return new Timer(id, openMode, parent);
1392}
1393
1397void
1398Timer::TimerInputThread::run()
1399{
1400 int err, count;
1401 struct pollfd *fds;
1402 if (m_timer == NULL) return;
1403
1404 count = m_timer->getPollDescriptorsCount();
1405 fds = (pollfd *) calloc(count, sizeof(struct pollfd));
1406 if (fds == NULL) {
1407 qWarning() << "allocation error!";
1408 return;
1409 }
1410 fds->events = POLLIN;
1411 fds->revents = 0;
1412
1413 try {
1414 while (!stopped() && (m_timer != NULL)) {
1415 m_timer->pollDescriptors(fds, count);
1416 if ((err = poll(fds, count, m_Wait)) < 0) {
1417 qWarning() << "poll error " << err << "(" << strerror(err) << ")";
1418 return;
1419 }
1420 if (err == 0) {
1421 qWarning() << "timer time out";
1422 return;
1423 }
1424 m_timer->doEvents();
1425 }
1426 } catch (...) {
1427 qWarning() << "exception in input thread";
1428 }
1429 free(fds);
1430}
1431
1436bool
1437Timer::TimerInputThread::stopped()
1438{
1439 QReadLocker locker(&m_mutex);
1440 return m_Stopped;
1441}
1442
1446void
1447Timer::TimerInputThread::stop()
1448{
1449 QWriteLocker locker(&m_mutex);
1450 m_Stopped = true;
1451}
1452
1453} /* namespace drumstick */
Classes managing ALSA Timers.
The QObject class is the base class of all Qt objects.
Global timer information container.
Definition alsatimer.h:121
unsigned int getFlags()
Gets the flags.
TimerGlobalInfo()
Default constructor.
unsigned int getClients()
Gets current timer clients.
int getSizeOfInfo() const
Gets the size of the ALSA timer global info object.
TimerGlobalInfo & operator=(const TimerGlobalInfo &other)
Assignment operator.
QString getId()
Gets the timer ID string.
unsigned long getMinResolution()
Gets timer minimal resolution in ns.
void setTimerId(const TimerId &tid)
Sets the timer identifier.
TimerGlobalInfo * clone()
Copy the current object.
virtual ~TimerGlobalInfo()
Destructor.
TimerId & getTimerId()
Gets the timer identifier.
unsigned long getMaxResolution()
Gets timer maximal resolution in ns.
QString getName()
Gets the timer name.
int getCard()
Gets the card number.
unsigned long getResolution()
Gets the timer resolution in ns.
ALSA Timer identifier container.
Definition alsatimer.h:80
int getDevice()
Gets the device number.
int getSlaveClass()
Gets the slave class.
int getSizeOfInfo() const
Gets the size of the ALSA timer ID object.
TimerId()
Constructor.
void setSubdevice(int subdevice)
Sets the subdevice number.
TimerId * clone()
Copy the object.
void setCard(int card)
Sets the card number.
int getClass()
Gets the class identifier.
TimerId & operator=(const TimerId &other)
Assignment operator.
int getSubdevice()
Gets the subdevice number.
void setClass(int devclass)
Set the class identifier.
void setSlaveClass(int devsclass)
Sets the Slave class.
int getCard()
Gets the card number.
virtual ~TimerId()
Destructor.
void setDevice(int device)
Sets the device number.
ALSA Timer information container.
Definition alsatimer.h:48
long getTicks() __attribute__((deprecated))
Gets the maximum timer ticks.
int getSizeOfInfo() const
Gets the size of the ALSA timer info object.
bool isSlave()
Check if the timer is slave (depends on another device)
virtual ~TimerInfo()
Destructor.
QString getId()
Gets the string identifier.
TimerInfo()
Constructor.
Definition alsatimer.cpp:88
long getResolution()
Gets the timer resolution (timer period in nanoseconds)
QString getName()
Gets the timer name.
TimerInfo & operator=(const TimerInfo &other)
Assignment operator.
int getCard()
Gets the card number.
long getFrequency()
Gets the timer frequency in Hz.
TimerInfo * clone()
Copy the current object.
ALSA Timer parameters container.
Definition alsatimer.h:186
void setFilter(unsigned int filter)
Sets the event filter.
void setEarlyEvent(bool early_event)
Sets the timer early event.
virtual ~TimerParams()
Destructor.
int getSizeOfInfo() const
Gets the size of the ALSA timer parameters object.
TimerParams & operator=(const TimerParams &other)
Assignment operator.
void setAutoStart(bool auto_start)
Sets the automatic start flag.
bool getExclusive()
Gets the timer's exclusive flag.
long getQueueSize()
Gets the queue size.
TimerParams()
Default constructor.
bool getEarlyEvent()
Gets the timer early event.
void setExclusive(bool exclusive)
Sets the exclusive flag.
bool getAutoStart()
Gets the automatic start flag.
void setTicks(long ticks)
Sets the timer ticks.
long getTicks()
Gets the timer ticks.
TimerParams * clone()
Copy the current object.
unsigned int getFilter()
Gets the event filter.
void setQueueSize(long queue_size)
Sets the queue size (32-1024)
void getGlobalStatus(snd_timer_gstatus_t *status)
Gets the global timer status.
virtual ~TimerQuery()
Destructor.
void readTimers()
Enumerate the available timers storing the results into an internal list.
TimerQuery(const QString &deviceName, int openMode)
Constructor.
void freeTimers()
Release the internal list of timers.
TimerGlobalInfo & getGlobalInfo()
Get a TimerGlobalInfo object.
void setGlobalParams(snd_timer_gparams_t *params)
Sets the global parameters.
void getGlobalParams(snd_timer_gparams_t *params)
Gets the global timer parameters.
ALSA Timer status container.
Definition alsatimer.h:221
long getLost()
Gets the master tick lost count.
virtual ~TimerStatus()
Destructor.
TimerStatus()
Default constructor.
int getSizeOfInfo() const
Gets the size of the ALSA timer status object.
long getOverrun()
Gets the overrun count.
long getResolution()
Gets the resolution in us.
TimerStatus & operator=(const TimerStatus &other)
Assignment operator.
TimerStatus * clone()
Copy the current object.
snd_htimestamp_t getTimestamp()
Gets the high resolution time-stamp.
long getQueue()
Gets the count of used queue elements.
ALSA Timer management.
Definition alsatimer.h:268
void stopEvents()
Stops the events dispatching thread.
static TimerId bestGlobalTimerId()
Check and return the best available global TimerId in the system, meaning the timer with higher frequ...
static Timer * bestGlobalTimer(int openMode, QObject *parent=0)
Check and return the best available global Timer in the system, meaning the timer with higher frequen...
int getPollDescriptorsCount()
Gets the count of poll descriptors.
void continueRunning()
Continue rolling the timer.
TimerStatus & getTimerStatus()
Gets the timer status.
void timerExpired(int ticks, int msecs)
This signal is emitted when the timer has expired, if there is not an event hander installed.
virtual ~Timer()
Destructor.
snd_timer_t * getTimerHandle()
Gets the ALSA timer handle.
void start()
Start rolling the timer.
void setTimerParams(const TimerParams &params)
Sets the timer parameters.
void stop()
Stop rolling the timer.
Timer(int cls, int scls, int card, int dev, int sdev, int openMode, QObject *parent=0)
Constructor.
void addAsyncTimerHandler(snd_async_callback_t callback, void *private_data)
Adds an asynchronous timer handler function.
ssize_t read(void *buffer, size_t size)
Read bytes from the timer handle.
TimerInfo & getTimerInfo()
Gets the timer info object.
void doEvents()
Internal function to deliver the timer events using one of the two available methods:
void startEvents()
Starts the events dispatching thread.
void pollDescriptorsRevents(struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
Gets returned events from poll descriptors.
void pollDescriptors(struct pollfd *pfds, unsigned int space)
Gets poll descriptors.
#define CHECK_ERROR(x)
This macro calls the check error function.
#define CHECK_WARNING(x)
This macro calls the check warning function.