drumstick  0.5.0
alsaqueue.cpp
Go to the documentation of this file.
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 */