drumstick
0.5.0
|
00001 /* 00002 MIDI Sequencer C++ library 00003 Copyright (C) 2006-2010, Pedro Lopez-Cabanillas <plcl@users.sf.net> 00004 00005 This library is free software; you can redistribute it and/or modify 00006 it under the terms of the GNU General Public License as published by 00007 the Free Software Foundation; either version 2 of the License, or 00008 (at your option) any later version. 00009 00010 This library is distributed in the hope that it will be useful, 00011 but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00013 GNU General Public License for more details. 00014 00015 You should have received a copy of the GNU General Public License along 00016 with this program; if not, write to the Free Software Foundation, Inc., 00017 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 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 00660 void QueueTimer::setId(const TimerId& id) 00661 { 00662 setId(id.m_Info); 00663 } 00664 00669 void QueueTimer::setResolution(unsigned int value) 00670 { 00671 snd_seq_queue_timer_set_resolution(m_Info, value); 00672 } 00673 00678 int QueueTimer::getInfoSize() const 00679 { 00680 return snd_seq_queue_timer_sizeof(); 00681 } 00682 00688 MidiQueue::MidiQueue(MidiClient* seq, QObject* parent) 00689 : QObject(parent) 00690 { 00691 m_MidiClient = seq; 00692 m_Id = CHECK_ERROR(snd_seq_alloc_queue(m_MidiClient->getHandle())); 00693 m_allocated = !(m_Id < 0); 00694 } 00695 00702 MidiQueue::MidiQueue(MidiClient* seq, const QueueInfo& info, QObject* parent) 00703 : QObject(parent) 00704 { 00705 m_MidiClient = seq; 00706 m_Info = info; 00707 m_Id = CHECK_ERROR(snd_seq_create_queue(m_MidiClient->getHandle(), m_Info.m_Info)); 00708 m_allocated = !(m_Id < 0); 00709 } 00710 00717 MidiQueue::MidiQueue(MidiClient* seq, const QString name, QObject* parent) 00718 : QObject(parent) 00719 { 00720 m_MidiClient = seq; 00721 m_Id = CHECK_ERROR(snd_seq_alloc_named_queue(m_MidiClient->getHandle(), name.toLocal8Bit().data())); 00722 m_allocated = !(m_Id < 0); 00723 } 00724 00733 MidiQueue::MidiQueue(MidiClient* seq, const int queue_id, QObject* parent) 00734 : QObject(parent) 00735 { 00736 m_MidiClient = seq; 00737 m_Id = queue_id; 00738 m_allocated = false; 00739 } 00740 00744 MidiQueue::~MidiQueue() 00745 { 00746 if ( m_allocated && (m_MidiClient->getHandle() != NULL) ) 00747 { 00748 CHECK_ERROR(snd_seq_free_queue(m_MidiClient->getHandle(), m_Id)); 00749 } 00750 } 00751 00756 QueueInfo& MidiQueue::getInfo() 00757 { 00758 CHECK_WARNING(snd_seq_get_queue_info(m_MidiClient->getHandle(), m_Id, m_Info.m_Info)); 00759 return m_Info; 00760 } 00761 00766 QueueStatus& MidiQueue::getStatus() 00767 { 00768 CHECK_WARNING(snd_seq_get_queue_status(m_MidiClient->getHandle(), m_Id, m_Status.m_Info)); 00769 return m_Status; 00770 } 00771 00776 QueueTempo& MidiQueue::getTempo() 00777 { 00778 CHECK_WARNING(snd_seq_get_queue_tempo(m_MidiClient->getHandle(), m_Id, m_Tempo.m_Info)); 00779 return m_Tempo; 00780 } 00781 00786 QueueTimer& MidiQueue::getTimer() 00787 { 00788 CHECK_WARNING(snd_seq_get_queue_timer(m_MidiClient->getHandle(), m_Id, m_Timer.m_Info)); 00789 return m_Timer; 00790 } 00791 00796 void MidiQueue::setInfo(const QueueInfo& value) 00797 { 00798 m_Info = value; 00799 CHECK_WARNING(snd_seq_set_queue_info(m_MidiClient->getHandle(), m_Id, m_Info.m_Info)); 00800 } 00801 00806 void MidiQueue::setTempo(const QueueTempo& value) 00807 { 00808 m_Tempo = value; 00809 CHECK_WARNING(snd_seq_set_queue_tempo(m_MidiClient->getHandle(), m_Id, m_Tempo.m_Info)); 00810 } 00811 00816 void MidiQueue::setTimer(const QueueTimer& value) 00817 { 00818 m_Timer = value; 00819 CHECK_WARNING(snd_seq_set_queue_timer(m_MidiClient->getHandle(), m_Id, m_Timer.m_Info)); 00820 } 00821 00827 int MidiQueue::getUsage() 00828 { 00829 return CHECK_WARNING(snd_seq_get_queue_usage(m_MidiClient->getHandle(), m_Id)); 00830 } 00831 00837 void MidiQueue::setUsage(int used) 00838 { 00839 CHECK_WARNING(snd_seq_set_queue_usage(m_MidiClient->getHandle(), m_Id, used)); 00840 } 00841 00847 void MidiQueue::start() 00848 { 00849 CHECK_WARNING(snd_seq_start_queue(m_MidiClient->getHandle(), m_Id, NULL)); 00850 CHECK_WARNING(snd_seq_drain_output(m_MidiClient->getHandle())); 00851 } 00852 00858 void MidiQueue::stop() 00859 { 00860 if (m_MidiClient != NULL && m_MidiClient->getHandle() != NULL) { 00861 CHECK_WARNING(snd_seq_stop_queue(m_MidiClient->getHandle(), m_Id, NULL)); 00862 CHECK_WARNING(snd_seq_drain_output(m_MidiClient->getHandle())); 00863 } 00864 } 00865 00871 void MidiQueue::continueRunning() 00872 { 00873 CHECK_WARNING(snd_seq_continue_queue(m_MidiClient->getHandle(), m_Id, NULL)); 00874 CHECK_WARNING(snd_seq_drain_output(m_MidiClient->getHandle())); 00875 } 00876 00880 void MidiQueue::clear() 00881 { 00882 if (m_MidiClient != NULL && m_MidiClient->getHandle() != NULL) 00883 snd_seq_drop_output(m_MidiClient->getHandle()); 00884 } 00885 00890 void MidiQueue::setTickPosition(snd_seq_tick_time_t pos) 00891 { 00892 SystemEvent event(SND_SEQ_EVENT_SETPOS_TICK); 00893 snd_seq_ev_set_queue_pos_tick(event.getHandle(), m_Id, pos); 00894 event.setDirect(); 00895 m_MidiClient->outputDirect(&event); 00896 } 00897 00902 void MidiQueue::setRealTimePosition(snd_seq_real_time_t* pos) 00903 { 00904 SystemEvent event(SND_SEQ_EVENT_SETPOS_TIME); 00905 snd_seq_ev_set_queue_pos_real(event.getHandle(), m_Id, pos); 00906 event.setDirect(); 00907 m_MidiClient->outputDirect(&event); 00908 } 00909 00910 } /* namespace drumstick */