00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "alsaqueue.h"
00021 #include "alsaclient.h"
00022 #include "alsaevent.h"
00023 #include "alsatimer.h"
00024 #include <cmath>
00025
00031 namespace drumstick {
00032
00060 QueueInfo::QueueInfo()
00061 {
00062 snd_seq_queue_info_malloc(&m_Info);
00063 }
00064
00069 QueueInfo::QueueInfo(snd_seq_queue_info_t* other)
00070 {
00071 snd_seq_queue_info_malloc(&m_Info);
00072 snd_seq_queue_info_copy(m_Info, other);
00073 }
00074
00079 QueueInfo::QueueInfo(const QueueInfo& other)
00080 {
00081 snd_seq_queue_info_malloc(&m_Info);
00082 snd_seq_queue_info_copy(m_Info, other.m_Info);
00083 }
00084
00088 QueueInfo::~QueueInfo()
00089 {
00090 snd_seq_queue_info_free(m_Info);
00091 }
00092
00097 QueueInfo* QueueInfo::clone()
00098 {
00099 return new QueueInfo(m_Info);
00100 }
00101
00107 QueueInfo& QueueInfo::operator=(const QueueInfo& other)
00108 {
00109 snd_seq_queue_info_copy(m_Info, other.m_Info);
00110 return *this;
00111 }
00112
00117 int QueueInfo::getId()
00118 {
00119 return snd_seq_queue_info_get_queue(m_Info);
00120 }
00121
00126 QString QueueInfo::getName()
00127 {
00128 return QString(snd_seq_queue_info_get_name(m_Info));
00129 }
00130
00135 int QueueInfo::getOwner()
00136 {
00137 return snd_seq_queue_info_get_owner(m_Info);
00138 }
00139
00144 bool QueueInfo::isLocked()
00145 {
00146 return (snd_seq_queue_info_get_locked(m_Info) != 0);
00147 }
00148
00153 unsigned int QueueInfo::getFlags()
00154 {
00155 return snd_seq_queue_info_get_flags(m_Info);
00156 }
00157
00162 void QueueInfo::setName(QString value)
00163 {
00164 snd_seq_queue_info_set_name(m_Info, value.toLocal8Bit().data());
00165 }
00166
00171 void QueueInfo::setOwner(int value)
00172 {
00173 snd_seq_queue_info_set_owner(m_Info, value);
00174 }
00175
00180 void QueueInfo::setFlags(unsigned int value)
00181 {
00182 snd_seq_queue_info_set_flags(m_Info, value);
00183 }
00184
00189 void QueueInfo::setLocked(bool locked)
00190 {
00191 snd_seq_queue_info_set_locked(m_Info, locked ? 1 : 0);
00192 }
00193
00198 int QueueInfo::getInfoSize() const
00199 {
00200 return snd_seq_queue_info_sizeof();
00201 }
00202
00203
00207 QueueStatus::QueueStatus()
00208 {
00209 snd_seq_queue_status_malloc(&m_Info);
00210 }
00211
00216 QueueStatus::QueueStatus(snd_seq_queue_status_t* other)
00217 {
00218 snd_seq_queue_status_malloc(&m_Info);
00219 snd_seq_queue_status_copy(m_Info, other);
00220 }
00221
00226 QueueStatus::QueueStatus(const QueueStatus& other)
00227 {
00228 snd_seq_queue_status_malloc(&m_Info);
00229 snd_seq_queue_status_copy(m_Info, other.m_Info);
00230 }
00231
00235 QueueStatus::~QueueStatus()
00236 {
00237 snd_seq_queue_status_free(m_Info);
00238 }
00239
00244 QueueStatus* QueueStatus::clone()
00245 {
00246 return new QueueStatus(m_Info);
00247 }
00248
00254 QueueStatus& QueueStatus::operator=(const QueueStatus& other)
00255 {
00256 snd_seq_queue_status_copy(m_Info, other.m_Info);
00257 return *this;
00258 }
00259
00264 int QueueStatus::getId()
00265 {
00266 return snd_seq_queue_status_get_queue(m_Info);
00267 }
00268
00273 int QueueStatus::getEvents()
00274 {
00275 return snd_seq_queue_status_get_events(m_Info);
00276 }
00277
00282 const snd_seq_real_time_t* QueueStatus::getRealtime()
00283 {
00284 return snd_seq_queue_status_get_real_time(m_Info);
00285 }
00286
00291 unsigned int QueueStatus::getStatusBits()
00292 {
00293 return snd_seq_queue_status_get_status(m_Info);
00294 }
00295
00300 snd_seq_tick_time_t QueueStatus::getTickTime()
00301 {
00302 return snd_seq_queue_status_get_tick_time(m_Info);
00303 }
00304
00309 int QueueStatus::getInfoSize() const
00310 {
00311 return snd_seq_queue_status_sizeof();
00312 }
00313
00318 bool QueueStatus::isRunning()
00319 {
00320 return (snd_seq_queue_status_get_status(m_Info) != 0);
00321 }
00322
00327 double QueueStatus::getClockTime()
00328 {
00329 const snd_seq_real_time_t* time = snd_seq_queue_status_get_real_time(m_Info);
00330 return (time->tv_sec * 1.0) + (time->tv_nsec * 1.0e-9);
00331 }
00332
00336 QueueTempo::QueueTempo()
00337 {
00338 snd_seq_queue_tempo_malloc(&m_Info);
00339 }
00340
00345 QueueTempo::QueueTempo(snd_seq_queue_tempo_t* other)
00346 {
00347 snd_seq_queue_tempo_malloc(&m_Info);
00348 snd_seq_queue_tempo_copy(m_Info, other);
00349 }
00350
00355 QueueTempo::QueueTempo(const QueueTempo& other)
00356 {
00357 snd_seq_queue_tempo_malloc(&m_Info);
00358 snd_seq_queue_tempo_copy(m_Info, other.m_Info);
00359 }
00360
00364 QueueTempo::~QueueTempo()
00365 {
00366 snd_seq_queue_tempo_free(m_Info);
00367 }
00368
00373 QueueTempo* QueueTempo::clone()
00374 {
00375 return new QueueTempo(m_Info);
00376 }
00377
00383 QueueTempo& QueueTempo::operator=(const QueueTempo& other)
00384 {
00385 snd_seq_queue_tempo_copy(m_Info, other.m_Info);
00386 return *this;
00387 }
00388
00393 int QueueTempo::getId()
00394 {
00395 return snd_seq_queue_tempo_get_queue(m_Info);
00396 }
00397
00402 int QueueTempo::getPPQ()
00403 {
00404 return snd_seq_queue_tempo_get_ppq(m_Info);
00405 }
00406
00413 unsigned int QueueTempo::getSkewValue()
00414 {
00415 return snd_seq_queue_tempo_get_skew(m_Info);
00416 }
00417
00424 unsigned int QueueTempo::getSkewBase()
00425 {
00426 return snd_seq_queue_tempo_get_skew_base(m_Info);
00427 }
00428
00433 unsigned int QueueTempo::getTempo()
00434 {
00435 return snd_seq_queue_tempo_get_tempo(m_Info);
00436 }
00437
00442 void QueueTempo::setPPQ(int value)
00443 {
00444 snd_seq_queue_tempo_set_ppq(m_Info, value);
00445 }
00446
00453 void QueueTempo::setSkewValue(unsigned int value)
00454 {
00455 snd_seq_queue_tempo_set_skew(m_Info, value);
00456 }
00457
00465 void QueueTempo::setSkewBase(unsigned int value)
00466 {
00467 snd_seq_queue_tempo_set_skew_base(m_Info, value);
00468 }
00469
00474 void QueueTempo::setTempo(unsigned int value)
00475 {
00476 snd_seq_queue_tempo_set_tempo(m_Info, value);
00477 }
00478
00483 float QueueTempo::getNominalBPM()
00484 {
00485 int itempo = getTempo();
00486 if (itempo != 0)
00487 return 6.0e7f / itempo;
00488 return 0.0f;
00489 }
00490
00496 float QueueTempo::getRealBPM()
00497 {
00498 float tempo = getNominalBPM();
00499 return tempo * getSkewValue() / SKEW_BASE;
00500 }
00501
00506 void QueueTempo::setTempoFactor(float value)
00507 {
00508 setSkewValue(floor(SKEW_BASE * value));
00509 setSkewBase(SKEW_BASE);
00510 }
00511
00516 void QueueTempo::setNominalBPM(float value)
00517 {
00518 setTempo(floor(6.0e7f / value));
00519 }
00520
00525 int QueueTempo::getInfoSize() const
00526 {
00527 return snd_seq_queue_tempo_sizeof();
00528 }
00529
00533 QueueTimer::QueueTimer()
00534 {
00535 snd_seq_queue_timer_malloc(&m_Info);
00536 }
00537
00542 QueueTimer::QueueTimer(snd_seq_queue_timer_t* other)
00543 {
00544 snd_seq_queue_timer_malloc(&m_Info);
00545 snd_seq_queue_timer_copy(m_Info, other);
00546 }
00547
00552 QueueTimer::QueueTimer(const QueueTimer& other)
00553 {
00554 snd_seq_queue_timer_malloc(&m_Info);
00555 snd_seq_queue_timer_copy(m_Info, other.m_Info);
00556 }
00557
00561 QueueTimer::~QueueTimer()
00562 {
00563 snd_seq_queue_timer_free(m_Info);
00564 }
00565
00570 QueueTimer* QueueTimer::clone()
00571 {
00572 return new QueueTimer(m_Info);
00573 }
00574
00580 QueueTimer& QueueTimer::operator=(const QueueTimer& other)
00581 {
00582 snd_seq_queue_timer_copy(m_Info, other.m_Info);
00583 return *this;
00584 }
00585
00590 int QueueTimer::getQueueId()
00591 {
00592 return snd_seq_queue_timer_get_queue(m_Info);
00593 }
00594
00607 snd_seq_queue_timer_type_t QueueTimer::getType()
00608 {
00609 return snd_seq_queue_timer_get_type(m_Info);
00610 }
00611
00616 const snd_timer_id_t* QueueTimer::getId()
00617 {
00618 return snd_seq_queue_timer_get_id(m_Info);
00619 }
00620
00625 unsigned int QueueTimer::getResolution()
00626 {
00627 return snd_seq_queue_timer_get_resolution(m_Info);
00628 }
00629
00641 void QueueTimer::setType(snd_seq_queue_timer_type_t value)
00642 {
00643 snd_seq_queue_timer_set_type(m_Info, value);
00644 }
00645
00650 void QueueTimer::setId(snd_timer_id_t* value)
00651 {
00652 snd_seq_queue_timer_set_id(m_Info, value);
00653 }
00654
00659 void QueueTimer::setId(const TimerId& id)
00660 {
00661 setId(id.m_Info);
00662 }
00663
00668 void QueueTimer::setResolution(unsigned int value)
00669 {
00670 snd_seq_queue_timer_set_resolution(m_Info, value);
00671 }
00672
00677 int QueueTimer::getInfoSize() const
00678 {
00679 return snd_seq_queue_timer_sizeof();
00680 }
00681
00687 MidiQueue::MidiQueue(MidiClient* seq, QObject* parent)
00688 : QObject(parent)
00689 {
00690 m_MidiClient = seq;
00691 m_Id = CHECK_ERROR(snd_seq_alloc_queue(m_MidiClient->getHandle()));
00692 m_allocated = !(m_Id < 0);
00693 }
00694
00701 MidiQueue::MidiQueue(MidiClient* seq, const QueueInfo& info, QObject* parent)
00702 : QObject(parent)
00703 {
00704 m_MidiClient = seq;
00705 m_Info = info;
00706 m_Id = CHECK_ERROR(snd_seq_create_queue(m_MidiClient->getHandle(), m_Info.m_Info));
00707 m_allocated = !(m_Id < 0);
00708 }
00709
00716 MidiQueue::MidiQueue(MidiClient* seq, const QString name, QObject* parent)
00717 : QObject(parent)
00718 {
00719 m_MidiClient = seq;
00720 m_Id = CHECK_ERROR(snd_seq_alloc_named_queue(m_MidiClient->getHandle(), name.toLocal8Bit().data()));
00721 m_allocated = !(m_Id < 0);
00722 }
00723
00732 MidiQueue::MidiQueue(MidiClient* seq, const int queue_id, QObject* parent)
00733 : QObject(parent)
00734 {
00735 m_MidiClient = seq;
00736 m_Id = queue_id;
00737 m_allocated = false;
00738 }
00739
00743 MidiQueue::~MidiQueue()
00744 {
00745 if ( m_allocated && (m_MidiClient->getHandle() != NULL) )
00746 {
00747 CHECK_ERROR(snd_seq_free_queue(m_MidiClient->getHandle(), m_Id));
00748 }
00749 }
00750
00755 QueueInfo& MidiQueue::getInfo()
00756 {
00757 CHECK_WARNING(snd_seq_get_queue_info(m_MidiClient->getHandle(), m_Id, m_Info.m_Info));
00758 return m_Info;
00759 }
00760
00765 QueueStatus& MidiQueue::getStatus()
00766 {
00767 CHECK_WARNING(snd_seq_get_queue_status(m_MidiClient->getHandle(), m_Id, m_Status.m_Info));
00768 return m_Status;
00769 }
00770
00775 QueueTempo& MidiQueue::getTempo()
00776 {
00777 CHECK_WARNING(snd_seq_get_queue_tempo(m_MidiClient->getHandle(), m_Id, m_Tempo.m_Info));
00778 return m_Tempo;
00779 }
00780
00785 QueueTimer& MidiQueue::getTimer()
00786 {
00787 CHECK_WARNING(snd_seq_get_queue_timer(m_MidiClient->getHandle(), m_Id, m_Timer.m_Info));
00788 return m_Timer;
00789 }
00790
00795 void MidiQueue::setInfo(const QueueInfo& value)
00796 {
00797 m_Info = value;
00798 CHECK_WARNING(snd_seq_set_queue_info(m_MidiClient->getHandle(), m_Id, m_Info.m_Info));
00799 }
00800
00805 void MidiQueue::setTempo(const QueueTempo& value)
00806 {
00807 m_Tempo = value;
00808 CHECK_WARNING(snd_seq_set_queue_tempo(m_MidiClient->getHandle(), m_Id, m_Tempo.m_Info));
00809 }
00810
00815 void MidiQueue::setTimer(const QueueTimer& value)
00816 {
00817 m_Timer = value;
00818 CHECK_WARNING(snd_seq_set_queue_timer(m_MidiClient->getHandle(), m_Id, m_Timer.m_Info));
00819 }
00820
00826 int MidiQueue::getUsage()
00827 {
00828 return CHECK_WARNING(snd_seq_get_queue_usage(m_MidiClient->getHandle(), m_Id));
00829 }
00830
00836 void MidiQueue::setUsage(int used)
00837 {
00838 CHECK_WARNING(snd_seq_set_queue_usage(m_MidiClient->getHandle(), m_Id, used));
00839 }
00840
00846 void MidiQueue::start()
00847 {
00848 CHECK_WARNING(snd_seq_start_queue(m_MidiClient->getHandle(), m_Id, NULL));
00849 CHECK_WARNING(snd_seq_drain_output(m_MidiClient->getHandle()));
00850 }
00851
00857 void MidiQueue::stop()
00858 {
00859 if (m_MidiClient != NULL && m_MidiClient->getHandle() != NULL) {
00860 CHECK_WARNING(snd_seq_stop_queue(m_MidiClient->getHandle(), m_Id, NULL));
00861 CHECK_WARNING(snd_seq_drain_output(m_MidiClient->getHandle()));
00862 }
00863 }
00864
00870 void MidiQueue::continueRunning()
00871 {
00872 CHECK_WARNING(snd_seq_continue_queue(m_MidiClient->getHandle(), m_Id, NULL));
00873 CHECK_WARNING(snd_seq_drain_output(m_MidiClient->getHandle()));
00874 }
00875
00879 void MidiQueue::clear()
00880 {
00881 if (m_MidiClient != NULL && m_MidiClient->getHandle() != NULL)
00882 snd_seq_drop_output(m_MidiClient->getHandle());
00883 }
00884
00889 void MidiQueue::setTickPosition(snd_seq_tick_time_t pos)
00890 {
00891 SystemEvent event(SND_SEQ_EVENT_SETPOS_TICK);
00892 snd_seq_ev_set_queue_pos_tick(event.getHandle(), m_Id, pos);
00893 event.setDirect();
00894 m_MidiClient->outputDirect(&event);
00895 }
00896
00901 void MidiQueue::setRealTimePosition(snd_seq_real_time_t* pos)
00902 {
00903 SystemEvent event(SND_SEQ_EVENT_SETPOS_TIME);
00904 snd_seq_ev_set_queue_pos_real(event.getHandle(), m_Id, pos);
00905 event.setDirect();
00906 m_MidiClient->outputDirect(&event);
00907 }
00908
00909 }