drumstick  2.3.1
alsatimer.cpp
Go to the documentation of this file.
1 /*
2  MIDI Sequencer C++ library
3  Copyright (C) 2006-2021, 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 3 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
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18 
19 #include "errorcheck.h"
20 #include <QReadLocker>
21 #include <QWriteLocker>
22 #include <cmath>
23 #include <cstdio>
24 #include <drumstick/alsatimer.h>
30 namespace drumstick {
31 namespace ALSA {
32 
89 {
90  snd_timer_info_malloc(&m_Info);
91 }
92 
97 TimerInfo::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 
125 TimerInfo*
127 {
128  return new TimerInfo(m_Info);
129 }
130 
136 TimerInfo&
138 {
139  if (this == &other)
140  return *this;
141  snd_timer_info_copy(m_Info, other.m_Info);
142  return *this;
143 }
144 
149 bool
151 {
152  return (snd_timer_info_is_slave(m_Info) != 0);
153 }
154 
159 int
161 {
162  return snd_timer_info_get_card(m_Info);
163 }
164 
169 QString
171 {
172  return QString(snd_timer_info_get_id(m_Info));
173 }
174 
179 QString
181 {
182  return QString(snd_timer_info_get_name(m_Info));
183 }
184 
189 long
191 {
192  return snd_timer_info_get_resolution(m_Info);
193 }
194 
199 long
201 {
202  long res = getResolution();
203  if (res > 0)
204  {
205  return 1000000000L / res;
206  }
207  return 0;
208 }
209 
214 int
216 {
217  return snd_timer_info_sizeof();
218 }
219 
225 long
227 {
228  return snd_timer_info_get_ticks(m_Info);
229 }
230 
235 {
236  snd_timer_id_malloc(&m_Info);
237 }
238 
243 TimerId::TimerId(const snd_timer_id_t *other)
244 {
245  snd_timer_id_malloc(&m_Info);
246  snd_timer_id_copy(m_Info, other);
247  if (getCard() < 0)
248  setCard(0);
249  if (getDevice() < 0)
250  setDevice(0);
251  if (getSubdevice() < 0)
252  setSubdevice(0);
253 }
254 
260 {
261  snd_timer_id_malloc(&m_Info);
262  snd_timer_id_copy(m_Info, other.m_Info);
263  if (getCard() < 0)
264  setCard(0);
265  if (getDevice() < 0)
266  setDevice(0);
267  if (getSubdevice() < 0)
268  setSubdevice(0);
269 }
270 
279 TimerId::TimerId(int cls, int scls, int card, int dev, int sdev)
280 {
281  snd_timer_id_malloc(&m_Info);
282  setClass(cls);
283  setSlaveClass(scls);
284  setCard(card);
285  setDevice(dev);
286  setSubdevice(sdev);
287 }
288 
293 {
294  snd_timer_id_free(m_Info);
295 }
296 
301 TimerId*
303 {
304  return new TimerId(m_Info);
305 }
306 
312 TimerId&
314 {
315  if (this == &other)
316  return *this;
317  snd_timer_id_copy(m_Info, other.m_Info);
318  if (getCard() < 0)
319  setCard(0);
320  if (getDevice() < 0)
321  setDevice(0);
322  if (getSubdevice() < 0)
323  setSubdevice(0);
324  return *this;
325 }
326 
337 void
338 TimerId::setClass(int devclass)
339 {
340  snd_timer_id_set_class(m_Info, devclass);
341 }
342 
348 int
350 {
351  return snd_timer_id_get_class(m_Info);
352 }
353 
358 void
360 {
361  snd_timer_id_set_sclass(m_Info, devsclass);
362 }
363 
368 int
370 {
371  return snd_timer_id_get_sclass(m_Info);
372 }
373 
378 void
380 {
381  snd_timer_id_set_card(m_Info, card);
382 }
383 
388 int
390 {
391  return snd_timer_id_get_card(m_Info);
392 }
393 
398 void
400 {
401  snd_timer_id_set_device(m_Info, device);
402 }
403 
408 int
410 {
411  return snd_timer_id_get_device(m_Info);
412 }
413 
418 void
419 TimerId::setSubdevice(int subdevice)
420 {
421  snd_timer_id_set_subdevice (m_Info, subdevice);
422 }
423 
428 int
430 {
431  return snd_timer_id_get_subdevice(m_Info);
432 }
433 
438 int
440 {
441  return snd_timer_id_sizeof();
442 }
443 
449 TimerQuery::TimerQuery(const QString& deviceName, int openMode)
450 {
451  DRUMSTICK_ALSA_CHECK_WARNING( snd_timer_query_open( &m_Info,
452  deviceName.toLocal8Bit().data(),
453  openMode ));
454  readTimers();
455 }
456 
463 TimerQuery::TimerQuery( const QString& deviceName, int openMode,
464  snd_config_t* conf )
465 {
466  DRUMSTICK_ALSA_CHECK_WARNING( snd_timer_query_open_lconf( &m_Info,
467  deviceName.toLocal8Bit().data(),
468  openMode, conf ));
469  readTimers();
470 }
471 
476 {
477  freeTimers();
478  snd_timer_query_close(m_Info);
479 }
480 
484 void
486 {
487  TimerId tid;
488  snd_timer_id_set_class(tid.m_Info, SND_TIMER_CLASS_NONE);
489  for(;;)
490  {
491  int rc = snd_timer_query_next_device(m_Info, tid.m_Info);
492  if ((rc < 0) || (tid.getClass() < 0)) {
493  break;
494  }
495  m_timers.append(tid);
496  }
497 }
498 
502 void
504 {
505  m_timers.clear();
506 }
507 
514 {
515  snd_timer_query_info(m_Info, m_GlobalInfo.m_Info);
516  return m_GlobalInfo;
517 }
518 
523 void
524 TimerQuery::setGlobalParams(snd_timer_gparams_t* params)
525 {
526  snd_timer_query_params(m_Info, params);
527 }
528 
533 void
534 TimerQuery::getGlobalParams(snd_timer_gparams_t* params)
535 {
536  snd_timer_query_params(m_Info, params);
537 }
538 
543 void
544 TimerQuery::getGlobalStatus(snd_timer_gstatus_t *status)
545 {
546  snd_timer_query_status(m_Info, status);
547 }
548 
553 {
554  snd_timer_ginfo_malloc(&m_Info);
555 }
556 
561 TimerGlobalInfo::TimerGlobalInfo(const snd_timer_ginfo_t* other)
562 {
563  snd_timer_ginfo_malloc(&m_Info);
564  snd_timer_ginfo_copy(m_Info, other);
565 }
566 
572 {
573  snd_timer_ginfo_malloc(&m_Info);
574  snd_timer_ginfo_copy(m_Info, other.m_Info);
575 }
576 
581 {
582  snd_timer_ginfo_free(m_Info);
583 }
584 
591 {
592  return new TimerGlobalInfo(m_Info);
593 }
594 
602 {
603  if (this == &other)
604  return *this;
605  snd_timer_ginfo_copy(m_Info, other.m_Info);
606  return *this;
607 }
608 
613 void
615 {
616  m_Id = tid;
617  snd_timer_ginfo_set_tid (m_Info, m_Id.m_Info);
618 }
619 
624 TimerId&
626 {
627  m_Id = TimerId(snd_timer_ginfo_get_tid (m_Info));
628  return m_Id;
629 }
630 
635 unsigned int
637 {
638  return snd_timer_ginfo_get_flags (m_Info);
639 }
640 
645 int
647 {
648  return snd_timer_ginfo_get_card (m_Info);
649 }
650 
655 QString
657 {
658  return QString(snd_timer_ginfo_get_id (m_Info));
659 }
660 
665 QString
667 {
668  return QString(snd_timer_ginfo_get_name (m_Info));
669 }
670 
675 unsigned long
677 {
678  return snd_timer_ginfo_get_resolution (m_Info);
679 }
680 
685 unsigned long
687 {
688  return snd_timer_ginfo_get_resolution_min (m_Info);
689 }
690 
695 unsigned long
697 {
698  return snd_timer_ginfo_get_resolution_max(m_Info);
699 }
700 
705 unsigned int
707 {
708  return snd_timer_ginfo_get_clients(m_Info);
709 }
710 
715 int
717 {
718  return snd_timer_ginfo_sizeof();
719 }
720 
725 {
726  snd_timer_params_malloc (&m_Info);
727 }
728 
733 TimerParams::TimerParams(const snd_timer_params_t *other)
734 {
735  snd_timer_params_malloc (&m_Info);
736  snd_timer_params_copy (m_Info, other);
737 }
738 
744 {
745  snd_timer_params_malloc (&m_Info);
746  snd_timer_params_copy (m_Info, other.m_Info);
747 }
748 
754 {
755  snd_timer_params_free (m_Info);
756 }
757 
764 {
765  return new TimerParams(m_Info);
766 }
767 
775 {
776  if (this == &other)
777  return *this;
778  snd_timer_params_copy (m_Info, other.m_Info);
779  return *this;
780 }
781 
786 void
788 {
789  snd_timer_params_set_auto_start (m_Info, auto_start ? 1 : 0);
790 }
791 
796 bool
798 {
799  return (snd_timer_params_get_auto_start (m_Info) != 0);
800 }
801 
806 void
808 {
809  snd_timer_params_set_exclusive (m_Info, exclusive ? 1 : 0);
810 }
811 
816 bool
818 {
819  return (snd_timer_params_get_exclusive (m_Info) != 0);
820 }
821 
826 void
827 TimerParams::setEarlyEvent(bool early_event)
828 {
829  snd_timer_params_set_early_event (m_Info, early_event ? 1 : 0);
830 }
831 
836 bool
838 {
839  return (snd_timer_params_get_early_event (m_Info) != 0);
840 }
841 
846 void
848 {
849  snd_timer_params_set_ticks (m_Info, ticks);
850 }
851 
856 long
858 {
859  return snd_timer_params_get_ticks (m_Info);
860 }
861 
866 void
868 {
869  snd_timer_params_set_queue_size (m_Info, queue_size);
870 }
871 
876 long
878 {
879  return snd_timer_params_get_queue_size (m_Info);
880 }
881 
886 void
887 TimerParams::setFilter(unsigned int filter)
888 {
889  snd_timer_params_set_filter (m_Info, filter);
890 }
891 
896 unsigned int
898 {
899  return snd_timer_params_get_filter (m_Info);
900 }
901 
906 int
908 {
909  return snd_timer_params_sizeof();
910 }
911 
916 {
917  snd_timer_status_malloc (&m_Info);
918 }
919 
924 TimerStatus::TimerStatus(const snd_timer_status_t *other)
925 {
926  snd_timer_status_malloc (&m_Info);
927  snd_timer_status_copy (m_Info, other);
928 }
929 
935 {
936  snd_timer_status_malloc (&m_Info);
937  snd_timer_status_copy (m_Info, other.m_Info);
938 }
939 
944 {
945  snd_timer_status_free (m_Info);
946 }
947 
954 {
955  return new TimerStatus(m_Info);
956 }
957 
965 {
966  if (this == &other)
967  return *this;
968  snd_timer_status_copy (m_Info, other.m_Info);
969  return *this;
970 }
971 
976 snd_htimestamp_t
978 {
979  return snd_timer_status_get_timestamp (m_Info);
980 }
981 
986 long
988 {
989  return snd_timer_status_get_resolution (m_Info);
990 }
991 
996 long
998 {
999  return snd_timer_status_get_lost (m_Info);
1000 }
1001 
1006 long
1008 {
1009  return snd_timer_status_get_overrun (m_Info);
1010 }
1011 
1016 long
1018 {
1019  return snd_timer_status_get_queue (m_Info);
1020 }
1021 
1026 int
1028 {
1029  return snd_timer_status_sizeof();
1030 }
1031 
1043 Timer::Timer( const QString& deviceName, int openMode, QObject* parent )
1044  : QObject(parent),
1045  m_asyncHandler(nullptr),
1046  m_handler(nullptr),
1047  m_thread(nullptr),
1048  m_deviceName(deviceName)
1049 {
1050  DRUMSTICK_ALSA_CHECK_ERROR( snd_timer_open( &m_Info, m_deviceName.toLocal8Bit().data(),
1051  openMode ));
1052 }
1053 
1066 Timer::Timer( const QString& deviceName, int openMode, snd_config_t* conf,
1067  QObject* parent )
1068  : QObject(parent),
1069  m_asyncHandler(nullptr),
1070  m_handler(nullptr),
1071  m_thread(nullptr),
1072  m_deviceName(deviceName)
1073 {
1074  DRUMSTICK_ALSA_CHECK_ERROR( snd_timer_open_lconf( &m_Info,
1075  m_deviceName.toLocal8Bit().data(),
1076  openMode, conf ));
1077 }
1078 
1090 Timer::Timer( TimerId& id, int openMode, QObject* parent )
1091  : QObject(parent),
1092  m_asyncHandler(nullptr),
1093  m_handler(nullptr),
1094  m_thread(nullptr)
1095 {
1096  m_deviceName = QString("hw:CLASS=%1,SCLASS=%2,CARD=%3,DEV=%4,SUBDEV=%5")
1097  .arg(id.getClass())
1098  .arg(id.getSlaveClass())
1099  .arg(id.getCard())
1100  .arg(id.getDevice())
1101  .arg(id.getSubdevice());
1102  DRUMSTICK_ALSA_CHECK_ERROR( snd_timer_open( &m_Info,
1103  m_deviceName.toLocal8Bit().data(),
1104  openMode ));
1105 }
1106 
1122 Timer::Timer( int cls, int scls, int card, int dev, int sdev,
1123  int openMode, QObject* parent )
1124  : QObject(parent),
1125  m_asyncHandler(nullptr),
1126  m_handler(nullptr),
1127  m_thread(nullptr)
1128 {
1129  m_deviceName = QString("hw:CLASS=%1,SCLASS=%2,CARD=%3,DEV=%4,SUBDEV=%5")
1130  .arg(cls)
1131  .arg(scls)
1132  .arg(card)
1133  .arg(dev)
1134  .arg(sdev);
1135  DRUMSTICK_ALSA_CHECK_ERROR( snd_timer_open( &m_Info,
1136  m_deviceName.toLocal8Bit().data(),
1137  openMode ));
1138 }
1139 
1144 {
1145  stopEvents();
1146  if (m_thread != nullptr)
1147  delete m_thread;
1148  DRUMSTICK_ALSA_CHECK_WARNING(snd_timer_close(m_Info));
1149 }
1150 
1156 void
1157 Timer::addAsyncTimerHandler(snd_async_callback_t callback, void *private_data)
1158 {
1159  DRUMSTICK_ALSA_CHECK_WARNING(snd_async_add_timer_handler(&m_asyncHandler, m_Info, callback, private_data));
1160 }
1161 
1166 snd_timer_t*
1168 {
1169  return snd_async_handler_get_timer(m_asyncHandler);
1170 }
1171 
1176 int
1178 {
1179  return snd_timer_poll_descriptors_count(m_Info);
1180 }
1181 
1187 void
1188 Timer::pollDescriptors(struct pollfd *pfds, unsigned int space)
1189 {
1190  DRUMSTICK_ALSA_CHECK_WARNING(snd_timer_poll_descriptors(m_Info, pfds, space));
1191 }
1192 
1199 void
1200 Timer::pollDescriptorsRevents(struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
1201 {
1202  DRUMSTICK_ALSA_CHECK_WARNING(snd_timer_poll_descriptors_revents(m_Info, pfds, nfds, revents));
1203 }
1204 
1209 TimerInfo&
1211 {
1212  snd_timer_info (m_Info, m_TimerInfo.m_Info);
1213  return m_TimerInfo;
1214 }
1215 
1220 void
1222 {
1223  DRUMSTICK_ALSA_CHECK_WARNING( snd_timer_params(m_Info, params.m_Info) );
1224 }
1225 
1230 TimerStatus&
1232 {
1233  DRUMSTICK_ALSA_CHECK_WARNING( snd_timer_status(m_Info, m_TimerStatus.m_Info) );
1234  return m_TimerStatus;
1235 }
1236 
1240 void
1242 {
1243  DRUMSTICK_ALSA_CHECK_WARNING(snd_timer_start(m_Info));
1244 }
1245 
1249 void
1251 {
1252  DRUMSTICK_ALSA_CHECK_WARNING(snd_timer_stop(m_Info));
1253 }
1254 
1258 void
1260 {
1261  DRUMSTICK_ALSA_CHECK_WARNING(snd_timer_continue(m_Info));
1262 }
1263 
1270 ssize_t
1271 Timer::read(void *buffer, size_t size)
1272 {
1273  return snd_timer_read(m_Info, buffer, size);
1274 }
1275 
1284 void
1286 {
1287  snd_timer_tread_t tr;
1288  while ( read(&tr, sizeof(tr)) == sizeof(tr) ) {
1289  int msecs = ((tr.tstamp.tv_sec - m_last_time.tv_sec) * 1000) +
1290  round((tr.tstamp.tv_nsec - m_last_time.tv_nsec) / 1000000.0);
1291  m_last_time = tr.tstamp;
1292  if ( m_handler != nullptr )
1293  m_handler->handleTimerEvent(tr.val, msecs);
1294  else
1295  emit timerExpired(tr.val, msecs);
1296  }
1297 }
1298 
1303 {
1304  m_last_time = getTimerStatus().getTimestamp();
1305  if (m_thread == nullptr) {
1306  m_thread = new TimerInputThread(this, 500);
1307  m_thread->start();
1308  }
1309 }
1310 
1315 {
1316  int counter = 0;
1317  if (m_thread != nullptr) {
1318  m_thread->stop();
1319  while (!m_thread->wait(500) && (counter < 10)) {
1320  counter++;
1321  }
1322  if (!m_thread->isFinished()) {
1323  m_thread->terminate();
1324  }
1325  delete m_thread;
1326  }
1327 }
1328 
1335 TimerId
1337 {
1338  TimerId id;
1339  snd_timer_t* timer;
1340  snd_timer_info_t* info;
1341  long res, best_res = LONG_MAX;
1342  char timername[64];
1343  int test_devs[] = {
1344  SND_TIMER_GLOBAL_SYSTEM
1345  , SND_TIMER_GLOBAL_RTC
1346 #ifdef SND_TIMER_GLOBAL_HPET
1347  , SND_TIMER_GLOBAL_HPET
1348 #endif
1349 #ifdef SND_TIMER_GLOBAL_HRTIMER
1350  , SND_TIMER_GLOBAL_HRTIMER
1351 #endif
1352  };
1353  int max_global_timers = sizeof(test_devs)/sizeof(int);
1354  int clas = SND_TIMER_CLASS_GLOBAL;
1355  int scls = SND_TIMER_SCLASS_NONE;
1356  int card = 0;
1357  int dev = SND_TIMER_GLOBAL_SYSTEM;
1358  int sdev = 0;
1359  int err = 0;
1360  int is_slave = 0;
1361  int i;
1362  snd_timer_info_alloca(&info);
1363  // default system timer
1364  id.setClass(clas);
1365  id.setSlaveClass(scls);
1366  id.setCard(card);
1367  id.setDevice(dev);
1368  id.setSubdevice(sdev);
1369  // select a non slave timer with the lowest resolution value
1370  for( i = 0; i < max_global_timers; ++i )
1371  {
1372  dev = test_devs[i];
1373  sprintf( timername, "hw:CLASS=%i,SCLASS=%i,CARD=%i,DEV=%i,SUBDEV=%i",
1374  clas, scls, card, dev, sdev );
1375  err = snd_timer_open(&timer, timername, SND_TIMER_OPEN_NONBLOCK);
1376  if (err < 0) continue;
1377  err = snd_timer_info(timer, info);
1378  if (err == 0) {
1379  is_slave = snd_timer_info_is_slave(info);
1380  res = snd_timer_info_get_resolution(info);
1381  if ((is_slave == 0) && (best_res > res)) {
1382  best_res = res;
1383  id.setDevice(dev);
1384  }
1385  }
1386  snd_timer_close(timer);
1387  }
1388  return id;
1389 }
1390 
1398 Timer*
1399 Timer::bestGlobalTimer(int openMode, QObject* parent)
1400 {
1401  TimerId id = bestGlobalTimerId();
1402  return new Timer(id, openMode, parent);
1403 }
1404 
1408 void
1409 Timer::TimerInputThread::run()
1410 {
1411  int err, count;
1412  struct pollfd *fds;
1413  if (m_timer == nullptr) return;
1414 
1415  count = m_timer->getPollDescriptorsCount();
1416  fds = (pollfd *) calloc(count, sizeof(struct pollfd));
1417  if (fds == nullptr) {
1418  qWarning() << "allocation error!";
1419  return;
1420  }
1421  fds->events = POLLIN;
1422  fds->revents = 0;
1423 
1424  try {
1425  while (!stopped() && (m_timer != nullptr)) {
1426  m_timer->pollDescriptors(fds, count);
1427  if ((err = poll(fds, count, m_Wait)) < 0) {
1428  qWarning() << "poll error " << err << "(" << strerror(err) << ")";
1429  free(fds);
1430  return;
1431  }
1432  if (err == 0) {
1433  qWarning() << "timer time out";
1434  free(fds);
1435  return;
1436  }
1437  m_timer->doEvents();
1438  }
1439  } catch (...) {
1440  qWarning() << "exception in input thread";
1441  }
1442  free(fds);
1443 }
1444 
1449 bool
1450 Timer::TimerInputThread::stopped()
1451 {
1452  QReadLocker locker(&m_mutex);
1453  return m_Stopped;
1454 }
1455 
1459 void
1460 Timer::TimerInputThread::stop()
1461 {
1462  QWriteLocker locker(&m_mutex);
1463  m_Stopped = true;
1464 }
1465 
1466 } // namespace ALSA
1467 } // namespace drumstick
1468 
Classes managing ALSA Timers.
The QObject class is the base class of all Qt objects.
virtual void handleTimerEvent(int ticks, int msecs)=0
Timer event handler.
Global timer information container.
Definition: alsatimer.h:127
unsigned int getFlags()
Gets the flags.
Definition: alsatimer.cpp:636
TimerGlobalInfo()
Default constructor.
Definition: alsatimer.cpp:552
unsigned int getClients()
Gets current timer clients.
Definition: alsatimer.cpp:706
int getSizeOfInfo() const
Gets the size of the ALSA timer global info object.
Definition: alsatimer.cpp:716
TimerGlobalInfo & operator=(const TimerGlobalInfo &other)
Assignment operator.
Definition: alsatimer.cpp:601
QString getId()
Gets the timer ID string.
Definition: alsatimer.cpp:656
unsigned long getMinResolution()
Gets timer minimal resolution in ns.
Definition: alsatimer.cpp:686
void setTimerId(const TimerId &tid)
Sets the timer identifier.
Definition: alsatimer.cpp:614
TimerGlobalInfo * clone()
Copy the current object.
Definition: alsatimer.cpp:590
virtual ~TimerGlobalInfo()
Destructor.
Definition: alsatimer.cpp:580
TimerId & getTimerId()
Gets the timer identifier.
Definition: alsatimer.cpp:625
unsigned long getMaxResolution()
Gets timer maximal resolution in ns.
Definition: alsatimer.cpp:696
QString getName()
Gets the timer name.
Definition: alsatimer.cpp:666
int getCard()
Gets the card number.
Definition: alsatimer.cpp:646
unsigned long getResolution()
Gets the timer resolution in ns.
Definition: alsatimer.cpp:676
ALSA Timer identifier container.
Definition: alsatimer.h:86
int getDevice()
Gets the device number.
Definition: alsatimer.cpp:409
int getSlaveClass()
Gets the slave class.
Definition: alsatimer.cpp:369
int getSizeOfInfo() const
Gets the size of the ALSA timer ID object.
Definition: alsatimer.cpp:439
void setSubdevice(int subdevice)
Sets the subdevice number.
Definition: alsatimer.cpp:419
TimerId * clone()
Copy the object.
Definition: alsatimer.cpp:302
void setCard(int card)
Sets the card number.
Definition: alsatimer.cpp:379
int getClass()
Gets the class identifier.
Definition: alsatimer.cpp:349
TimerId & operator=(const TimerId &other)
Assignment operator.
Definition: alsatimer.cpp:313
int getSubdevice()
Gets the subdevice number.
Definition: alsatimer.cpp:429
void setClass(int devclass)
Set the class identifier.
Definition: alsatimer.cpp:338
void setSlaveClass(int devsclass)
Sets the Slave class.
Definition: alsatimer.cpp:359
int getCard()
Gets the card number.
Definition: alsatimer.cpp:389
virtual ~TimerId()
Destructor.
Definition: alsatimer.cpp:292
void setDevice(int device)
Sets the device number.
Definition: alsatimer.cpp:399
ALSA Timer information container.
Definition: alsatimer.h:54
long getTicks() __attribute__((deprecated))
Gets the maximum timer ticks.
Definition: alsatimer.cpp:226
int getSizeOfInfo() const
Gets the size of the ALSA timer info object.
Definition: alsatimer.cpp:215
bool isSlave()
Check if the timer is slave (depends on another device)
Definition: alsatimer.cpp:150
virtual ~TimerInfo()
Destructor.
Definition: alsatimer.cpp:116
QString getId()
Gets the string identifier.
Definition: alsatimer.cpp:170
long getResolution()
Gets the timer resolution (timer period in nanoseconds)
Definition: alsatimer.cpp:190
QString getName()
Gets the timer name.
Definition: alsatimer.cpp:180
TimerInfo & operator=(const TimerInfo &other)
Assignment operator.
Definition: alsatimer.cpp:137
int getCard()
Gets the card number.
Definition: alsatimer.cpp:160
long getFrequency()
Gets the timer frequency in Hz.
Definition: alsatimer.cpp:200
TimerInfo * clone()
Copy the current object.
Definition: alsatimer.cpp:126
ALSA Timer parameters container.
Definition: alsatimer.h:192
void setFilter(unsigned int filter)
Sets the event filter.
Definition: alsatimer.cpp:887
void setEarlyEvent(bool early_event)
Sets the timer early event.
Definition: alsatimer.cpp:827
virtual ~TimerParams()
Destructor.
Definition: alsatimer.cpp:753
int getSizeOfInfo() const
Gets the size of the ALSA timer parameters object.
Definition: alsatimer.cpp:907
TimerParams & operator=(const TimerParams &other)
Assignment operator.
Definition: alsatimer.cpp:774
void setAutoStart(bool auto_start)
Sets the automatic start flag.
Definition: alsatimer.cpp:787
bool getExclusive()
Gets the timer's exclusive flag.
Definition: alsatimer.cpp:817
long getQueueSize()
Gets the queue size.
Definition: alsatimer.cpp:877
TimerParams()
Default constructor.
Definition: alsatimer.cpp:724
bool getEarlyEvent()
Gets the timer early event.
Definition: alsatimer.cpp:837
void setExclusive(bool exclusive)
Sets the exclusive flag.
Definition: alsatimer.cpp:807
bool getAutoStart()
Gets the automatic start flag.
Definition: alsatimer.cpp:797
void setTicks(long ticks)
Sets the timer ticks.
Definition: alsatimer.cpp:847
long getTicks()
Gets the timer ticks.
Definition: alsatimer.cpp:857
TimerParams * clone()
Copy the current object.
Definition: alsatimer.cpp:763
unsigned int getFilter()
Gets the event filter.
Definition: alsatimer.cpp:897
void setQueueSize(long queue_size)
Sets the queue size (32-1024)
Definition: alsatimer.cpp:867
void getGlobalStatus(snd_timer_gstatus_t *status)
Gets the global timer status.
Definition: alsatimer.cpp:544
virtual ~TimerQuery()
Destructor.
Definition: alsatimer.cpp:475
void readTimers()
Enumerate the available timers storing the results into an internal list.
Definition: alsatimer.cpp:485
TimerQuery(const QString &deviceName, int openMode)
Constructor.
Definition: alsatimer.cpp:449
void freeTimers()
Release the internal list of timers.
Definition: alsatimer.cpp:503
TimerGlobalInfo & getGlobalInfo()
Get a TimerGlobalInfo object.
Definition: alsatimer.cpp:513
void setGlobalParams(snd_timer_gparams_t *params)
Sets the global parameters.
Definition: alsatimer.cpp:524
void getGlobalParams(snd_timer_gparams_t *params)
Gets the global timer parameters.
Definition: alsatimer.cpp:534
ALSA Timer status container.
Definition: alsatimer.h:227
long getLost()
Gets the master tick lost count.
Definition: alsatimer.cpp:997
virtual ~TimerStatus()
Destructor.
Definition: alsatimer.cpp:943
TimerStatus()
Default constructor.
Definition: alsatimer.cpp:915
int getSizeOfInfo() const
Gets the size of the ALSA timer status object.
Definition: alsatimer.cpp:1027
long getOverrun()
Gets the overrun count.
Definition: alsatimer.cpp:1007
long getResolution()
Gets the resolution in us.
Definition: alsatimer.cpp:987
TimerStatus & operator=(const TimerStatus &other)
Assignment operator.
Definition: alsatimer.cpp:964
TimerStatus * clone()
Copy the current object.
Definition: alsatimer.cpp:953
snd_htimestamp_t getTimestamp()
Gets the high resolution time-stamp.
Definition: alsatimer.cpp:977
long getQueue()
Gets the count of used queue elements.
Definition: alsatimer.cpp:1017
ALSA Timer management.
Definition: alsatimer.h:274
void stopEvents()
Stops the events dispatching thread.
Definition: alsatimer.cpp:1314
Timer(int cls, int scls, int card, int dev, int sdev, int openMode, QObject *parent=nullptr)
Constructor.
Definition: alsatimer.cpp:1122
static TimerId bestGlobalTimerId()
Check and return the best available global TimerId in the system, meaning the timer with higher frequ...
Definition: alsatimer.cpp:1336
int getPollDescriptorsCount()
Gets the count of poll descriptors.
Definition: alsatimer.cpp:1177
void continueRunning()
Continue rolling the timer.
Definition: alsatimer.cpp:1259
TimerStatus & getTimerStatus()
Gets the timer status.
Definition: alsatimer.cpp:1231
void timerExpired(int ticks, int msecs)
This signal is emitted when the timer has expired, if there is not an event hander installed.
static Timer * bestGlobalTimer(int openMode, QObject *parent=nullptr)
Check and return the best available global Timer in the system, meaning the timer with higher frequen...
Definition: alsatimer.cpp:1399
virtual ~Timer()
Destructor.
Definition: alsatimer.cpp:1143
snd_timer_t * getTimerHandle()
Gets the ALSA timer handle.
Definition: alsatimer.cpp:1167
void start()
Start rolling the timer.
Definition: alsatimer.cpp:1241
void setTimerParams(const TimerParams &params)
Sets the timer parameters.
Definition: alsatimer.cpp:1221
void stop()
Stop rolling the timer.
Definition: alsatimer.cpp:1250
void addAsyncTimerHandler(snd_async_callback_t callback, void *private_data)
Adds an asynchronous timer handler function.
Definition: alsatimer.cpp:1157
ssize_t read(void *buffer, size_t size)
Read bytes from the timer handle.
Definition: alsatimer.cpp:1271
TimerInfo & getTimerInfo()
Gets the timer info object.
Definition: alsatimer.cpp:1210
void doEvents()
Internal function to deliver the timer events using one of the two available methods:
Definition: alsatimer.cpp:1285
void startEvents()
Starts the events dispatching thread.
Definition: alsatimer.cpp:1302
void pollDescriptorsRevents(struct pollfd *pfds, unsigned int nfds, unsigned short *revents)
Gets returned events from poll descriptors.
Definition: alsatimer.cpp:1200
void pollDescriptors(struct pollfd *pfds, unsigned int space)
Gets poll descriptors.
Definition: alsatimer.cpp:1188
Error checking functions and macros.
#define DRUMSTICK_ALSA_CHECK_WARNING(x)
This macro calls the check warning function.
Definition: errorcheck.h:86
#define DRUMSTICK_ALSA_CHECK_ERROR(x)
This macro calls the check error function.
Definition: errorcheck.h:80
Drumstick common.
Definition: alsaclient.cpp:68