00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "alsaevent.h"
00021
00033 namespace drumstick {
00034
00100 SequencerEvent::SequencerEvent() : QEvent(SequencerEventType)
00101 {
00102 snd_seq_ev_clear( &m_event );
00103 }
00104
00109 SequencerEvent::SequencerEvent(snd_seq_event_t* event) : QEvent(SequencerEventType)
00110 {
00111 snd_seq_ev_clear( &m_event );
00112 m_event = *event;
00113 }
00114
00119 SequencerEvent::SequencerEvent(const SequencerEvent& other) : QEvent(SequencerEventType)
00120 {
00121 snd_seq_ev_clear( &m_event );
00122 m_event = other.m_event;
00123 }
00124
00130 SequencerEvent&
00131 SequencerEvent::operator=(const SequencerEvent& other)
00132 {
00133 m_event = other.m_event;
00134 return *this;
00135 }
00136
00142 bool
00143 SequencerEvent::isSubscription(const SequencerEvent* event)
00144 {
00145 snd_seq_event_type_t te = event->getSequencerType();
00146 return ( te == SND_SEQ_EVENT_PORT_SUBSCRIBED ||
00147 te == SND_SEQ_EVENT_PORT_UNSUBSCRIBED );
00148 }
00149
00155 bool
00156 SequencerEvent::isPort(const SequencerEvent* event)
00157 {
00158 snd_seq_event_type_t te = event->getSequencerType();
00159 return ( te == SND_SEQ_EVENT_PORT_START ||
00160 te == SND_SEQ_EVENT_PORT_EXIT ||
00161 te == SND_SEQ_EVENT_PORT_CHANGE );
00162 }
00163
00169 bool
00170 SequencerEvent::isClient(const SequencerEvent* event)
00171 {
00172 snd_seq_event_type_t te = event->getSequencerType();
00173 return ( te == SND_SEQ_EVENT_CLIENT_START ||
00174 te == SND_SEQ_EVENT_CLIENT_EXIT ||
00175 te == SND_SEQ_EVENT_CLIENT_CHANGE );
00176 }
00177
00183 bool
00184 SequencerEvent::isConnectionChange(const SequencerEvent* event)
00185 {
00186 snd_seq_event_type_t te = event->getSequencerType();
00187 return ( te == SND_SEQ_EVENT_PORT_START ||
00188 te == SND_SEQ_EVENT_PORT_EXIT ||
00189 te == SND_SEQ_EVENT_PORT_CHANGE ||
00190 te == SND_SEQ_EVENT_CLIENT_START ||
00191 te == SND_SEQ_EVENT_CLIENT_EXIT ||
00192 te == SND_SEQ_EVENT_CLIENT_CHANGE ||
00193 te == SND_SEQ_EVENT_PORT_SUBSCRIBED ||
00194 te == SND_SEQ_EVENT_PORT_UNSUBSCRIBED );
00195 }
00196
00203 bool
00204 SequencerEvent::isChannel(const SequencerEvent* event)
00205 {
00206 snd_seq_event_type_t te = event->getSequencerType();
00207 return ( te == SND_SEQ_EVENT_NOTEOFF ||
00208 te == SND_SEQ_EVENT_NOTEON ||
00209 te == SND_SEQ_EVENT_NOTE ||
00210 te == SND_SEQ_EVENT_KEYPRESS ||
00211 te == SND_SEQ_EVENT_CONTROLLER ||
00212 te == SND_SEQ_EVENT_CONTROL14 ||
00213 te == SND_SEQ_EVENT_PGMCHANGE ||
00214 te == SND_SEQ_EVENT_CHANPRESS ||
00215 te == SND_SEQ_EVENT_PITCHBEND );
00216 }
00217
00222 void SequencerEvent::setSequencerType(const snd_seq_event_type_t eventType)
00223 {
00224 m_event.type = eventType;
00225 }
00226
00233 void SequencerEvent::setDestination(const unsigned char client, const unsigned char port)
00234 {
00235 snd_seq_ev_set_dest(&m_event, client, port);
00236 }
00237
00243 void SequencerEvent::setSource(const unsigned char port)
00244 {
00245 snd_seq_ev_set_source(&m_event, port);
00246 }
00247
00251 void SequencerEvent::setSubscribers()
00252 {
00253 snd_seq_ev_set_subs(&m_event);
00254 }
00255
00259 void SequencerEvent::setBroadcast()
00260 {
00261 snd_seq_ev_set_broadcast(&m_event);
00262 }
00263
00268 void SequencerEvent::setDirect()
00269 {
00270 snd_seq_ev_set_direct(&m_event);
00271 }
00272
00279 void SequencerEvent::scheduleTick(int queue, int tick, bool relative)
00280 {
00281 snd_seq_ev_schedule_tick(&m_event, queue, relative, tick);
00282 }
00283
00291 void SequencerEvent::scheduleReal(int queue, ulong secs, ulong nanos, bool relative)
00292 {
00293 snd_seq_real_time_t rtime;
00294 rtime.tv_sec = secs;
00295 rtime.tv_nsec = nanos;
00296 snd_seq_ev_schedule_real(&m_event, queue, relative, &rtime);
00297 }
00298
00305 void SequencerEvent::setPriority(const bool high)
00306 {
00307 snd_seq_ev_set_priority(&m_event, high);
00308 }
00309
00315 void SequencerEvent::setTag(const unsigned char aTag)
00316 {
00317 #if SND_LIB_VERSION > 0x010008
00318 snd_seq_ev_set_tag(&m_event, aTag);
00319 #else
00320 m_event.tag = aTag;
00321 #endif
00322 }
00323
00330 unsigned int SequencerEvent::getRaw32(const unsigned int n) const
00331 {
00332 if (n < 3) return m_event.data.raw32.d[n];
00333 return 0;
00334 }
00335
00341 void SequencerEvent::setRaw32(const unsigned int n, const unsigned int value)
00342 {
00343 if (n < 3) m_event.data.raw32.d[n] = value;
00344 }
00345
00352 unsigned char SequencerEvent::getRaw8(const unsigned int n) const
00353 {
00354 if (n < 12) return m_event.data.raw8.d[n];
00355 return 0;
00356 }
00357
00363 void SequencerEvent::setRaw8(const unsigned int n, const unsigned char value)
00364 {
00365 if (n < 12) m_event.data.raw8.d[n] = value;
00366 }
00367
00372 void SequencerEvent::free()
00373 {
00374 snd_seq_free_event(&m_event);
00375 }
00376
00381 int SequencerEvent::getEncodedLength()
00382 {
00383 return snd_seq_event_length(&m_event);
00384 }
00385
00393 NoteEvent::NoteEvent(int ch, int key, int vel, int dur) : KeyEvent()
00394 {
00395 snd_seq_ev_set_note(&m_event, ch, key, vel, dur);
00396 }
00397
00404 NoteOnEvent::NoteOnEvent(int ch, int key, int vel) : KeyEvent()
00405 {
00406 snd_seq_ev_set_noteon(&m_event, ch, key, vel);
00407 }
00408
00415 NoteOffEvent::NoteOffEvent(int ch, int key, int vel) : KeyEvent()
00416 {
00417 snd_seq_ev_set_noteoff(&m_event, ch, key, vel);
00418 }
00419
00426 KeyPressEvent::KeyPressEvent(int ch, int key, int vel) : KeyEvent()
00427 {
00428 snd_seq_ev_set_keypress(&m_event, ch, key, vel);
00429 }
00430
00437 ControllerEvent::ControllerEvent(int ch, int cc, int val) : ChannelEvent()
00438 {
00439 snd_seq_ev_set_controller(&m_event, ch, cc, val);
00440 }
00441
00447 ProgramChangeEvent::ProgramChangeEvent(int ch, int val) : ChannelEvent()
00448 {
00449 snd_seq_ev_set_pgmchange(&m_event, ch, val);
00450 }
00451
00457 PitchBendEvent::PitchBendEvent(int ch, int val) : ChannelEvent()
00458 {
00459 snd_seq_ev_set_pitchbend(&m_event, ch, val);
00460 }
00461
00467 ChanPressEvent::ChanPressEvent(int ch, int val) : ChannelEvent()
00468 {
00469 snd_seq_ev_set_chanpress(&m_event, ch, val);
00470 }
00471
00475 VariableEvent::VariableEvent()
00476 : SequencerEvent()
00477 {
00478 m_data.clear();
00479 snd_seq_ev_set_variable ( &m_event, m_data.size(), m_data.data() );
00480 }
00481
00486 VariableEvent::VariableEvent(snd_seq_event_t* event)
00487 : SequencerEvent(event)
00488 {
00489 m_data = QByteArray((char *) event->data.ext.ptr,
00490 event->data.ext.len);
00491 snd_seq_ev_set_variable ( &m_event, m_data.size(), m_data.data() );
00492 }
00493
00498 VariableEvent::VariableEvent(const QByteArray& data)
00499 : SequencerEvent()
00500 {
00501 m_data = data;
00502 snd_seq_ev_set_variable ( &m_event, m_data.size(), m_data.data() );
00503 }
00504
00509 VariableEvent::VariableEvent(const VariableEvent& other)
00510 : SequencerEvent()
00511 {
00512 m_data = other.m_data;
00513 snd_seq_ev_set_variable ( &m_event, m_data.size(), m_data.data() );
00514 }
00515
00521 VariableEvent::VariableEvent(const unsigned int datalen, char* dataptr)
00522 : SequencerEvent()
00523 {
00524 m_data = QByteArray(dataptr, datalen);
00525 snd_seq_ev_set_variable( &m_event, m_data.size(), m_data.data() );
00526 }
00527
00533 VariableEvent& VariableEvent::operator=(const VariableEvent& other)
00534 {
00535 m_event = other.m_event;
00536 m_data = other.m_data;
00537 snd_seq_ev_set_variable ( &m_event, m_data.size(), m_data.data() );
00538 return *this;
00539 }
00540
00544 SysExEvent::SysExEvent()
00545 : VariableEvent()
00546 {
00547 snd_seq_ev_set_sysex( &m_event, m_data.size(), m_data.data() );
00548 }
00549
00554 SysExEvent::SysExEvent(snd_seq_event_t* event)
00555 : VariableEvent(event)
00556 {
00557 snd_seq_ev_set_sysex( &m_event, m_data.size(), m_data.data() );
00558 }
00559
00564 SysExEvent::SysExEvent(const QByteArray& data)
00565 : VariableEvent(data)
00566 {
00567 snd_seq_ev_set_sysex( &m_event, m_data.size(), m_data.data() );
00568 }
00569
00574 SysExEvent::SysExEvent(const SysExEvent& other)
00575 : VariableEvent(other)
00576 {
00577 snd_seq_ev_set_sysex( &m_event, m_data.size(), m_data.data() );
00578 }
00579
00585 SysExEvent::SysExEvent(const unsigned int datalen, char* dataptr)
00586 : VariableEvent( datalen, dataptr )
00587 {
00588 snd_seq_ev_set_sysex( &m_event, m_data.size(), m_data.data() );
00589 }
00590
00594 TextEvent::TextEvent()
00595 : VariableEvent(), m_textType(1)
00596 {
00597 setSequencerType(SND_SEQ_EVENT_USR_VAR0);
00598 }
00599
00604 TextEvent::TextEvent(snd_seq_event_t* event)
00605 : VariableEvent(event), m_textType(1)
00606 {
00607 setSequencerType(SND_SEQ_EVENT_USR_VAR0);
00608 }
00609
00615 TextEvent::TextEvent(const QString& text, const int textType)
00616 : VariableEvent(text.toUtf8()), m_textType(textType)
00617 {
00618 setSequencerType(SND_SEQ_EVENT_USR_VAR0);
00619 }
00620
00625 TextEvent::TextEvent(const TextEvent& other)
00626 : VariableEvent(other)
00627 {
00628 setSequencerType(SND_SEQ_EVENT_USR_VAR0);
00629 m_textType = other.getTextType();
00630 }
00631
00637 TextEvent::TextEvent(const unsigned int datalen, char* dataptr)
00638 : VariableEvent(datalen, dataptr), m_textType(1)
00639 {
00640 setSequencerType(SND_SEQ_EVENT_USR_VAR0);
00641 }
00642
00647 QString TextEvent::getText() const
00648 {
00649 return QString::fromUtf8(m_data.data(), m_data.size());
00650 }
00651
00656 int TextEvent::getTextType() const
00657 {
00658 return m_textType;
00659 }
00660
00665 SystemEvent::SystemEvent(const snd_seq_event_type_t type) : SequencerEvent()
00666 {
00667 snd_seq_ev_set_fixed(&m_event);
00668 setSequencerType(type);
00669 }
00670
00677 QueueControlEvent::QueueControlEvent(snd_seq_event_type_t type, int queue, int value)
00678 : SequencerEvent()
00679 {
00680 snd_seq_ev_set_queue_control(&m_event, type, queue, value);
00681 }
00682
00688 ValueEvent::ValueEvent(const snd_seq_event_type_t type, int val) : SequencerEvent()
00689 {
00690 snd_seq_ev_set_fixed(&m_event);
00691 setSequencerType(type);
00692 setValue(val);
00693 }
00694
00700 TempoEvent::TempoEvent(int queue, int tempo) : QueueControlEvent()
00701 {
00702 snd_seq_ev_set_queue_tempo(&m_event, queue, tempo);
00703 }
00704
00708 RemoveEvents::RemoveEvents()
00709 {
00710 snd_seq_remove_events_malloc(&m_Info);
00711 }
00712
00717 RemoveEvents::RemoveEvents(const RemoveEvents& other)
00718 {
00719 snd_seq_remove_events_malloc(&m_Info);
00720 snd_seq_remove_events_copy(m_Info, other.m_Info);
00721 }
00722
00727 RemoveEvents::RemoveEvents(snd_seq_remove_events_t* other)
00728 {
00729 snd_seq_remove_events_malloc(&m_Info);
00730 snd_seq_remove_events_copy(m_Info, other);
00731 }
00732
00736 RemoveEvents::~RemoveEvents()
00737 {
00738 snd_seq_remove_events_free(m_Info);
00739 }
00740
00745 RemoveEvents*
00746 RemoveEvents::clone()
00747 {
00748 return new RemoveEvents(m_Info);
00749 }
00750
00756 RemoveEvents&
00757 RemoveEvents::operator=(const RemoveEvents& other)
00758 {
00759 snd_seq_remove_events_copy(m_Info, other.m_Info);
00760 return *this;
00761 }
00762
00767 int
00768 RemoveEvents::getSizeOfInfo() const
00769 {
00770 return snd_seq_remove_events_sizeof();
00771 }
00772
00778 int
00779 RemoveEvents::getChannel()
00780 {
00781 return snd_seq_remove_events_get_channel(m_Info);
00782 }
00783
00789 unsigned int
00790 RemoveEvents::getCondition()
00791 {
00792 return snd_seq_remove_events_get_condition(m_Info);
00793 }
00794
00800 const snd_seq_addr_t*
00801 RemoveEvents::getDest()
00802 {
00803 return snd_seq_remove_events_get_dest(m_Info);
00804 }
00805
00811 int
00812 RemoveEvents::getEventType()
00813 {
00814 return snd_seq_remove_events_get_event_type(m_Info);
00815 }
00816
00822 int
00823 RemoveEvents::getQueue()
00824 {
00825 return snd_seq_remove_events_get_queue(m_Info);
00826 }
00827
00833 int
00834 RemoveEvents::getTag()
00835 {
00836 return snd_seq_remove_events_get_tag(m_Info);
00837 }
00838
00844 const snd_seq_timestamp_t*
00845 RemoveEvents::getTime()
00846 {
00847 return snd_seq_remove_events_get_time(m_Info);
00848 }
00849
00855 void
00856 RemoveEvents::setChannel(int chan)
00857 {
00858 snd_seq_remove_events_set_channel(m_Info, chan);
00859 }
00860
00879 void
00880 RemoveEvents::setCondition(unsigned int cond)
00881 {
00882 snd_seq_remove_events_set_condition(m_Info, cond);
00883 }
00884
00890 void
00891 RemoveEvents::setDest(const snd_seq_addr_t* dest)
00892 {
00893 snd_seq_remove_events_set_dest(m_Info, dest);
00894 }
00895
00901 void
00902 RemoveEvents::setEventType(int type)
00903 {
00904 snd_seq_remove_events_set_event_type(m_Info, type);
00905 }
00906
00912 void
00913 RemoveEvents::setQueue(int queue)
00914 {
00915 snd_seq_remove_events_set_queue(m_Info, queue);
00916 }
00917
00923 void
00924 RemoveEvents::setTag(int tag)
00925 {
00926 snd_seq_remove_events_set_tag(m_Info, tag);
00927 }
00928
00934 void
00935 RemoveEvents::setTime(const snd_seq_timestamp_t* time)
00936 {
00937 snd_seq_remove_events_set_time(m_Info, time);
00938 }
00939
00945 MidiCodec::MidiCodec( int bufsize, QObject* parent ) : QObject(parent)
00946 {
00947 CHECK_ERROR(snd_midi_event_new(bufsize, &m_Info));
00948 }
00949
00953 MidiCodec::~MidiCodec()
00954 {
00955 snd_midi_event_free(m_Info);
00956 }
00957
00961 void
00962 MidiCodec::init()
00963 {
00964 snd_midi_event_init(m_Info);
00965 }
00966
00974 long
00975 MidiCodec::decode(unsigned char *buf,
00976 long count,
00977 const snd_seq_event_t *ev)
00978 {
00979 return CHECK_WARNING(snd_midi_event_decode(m_Info, buf, count, ev));
00980 }
00981
00989 long
00990 MidiCodec::encode(const unsigned char *buf,
00991 long count,
00992 snd_seq_event_t *ev)
00993 {
00994 return CHECK_WARNING(snd_midi_event_encode(m_Info, buf, count, ev));
00995 }
00996
01003 long
01004 MidiCodec::encode(int c,
01005 snd_seq_event_t *ev)
01006 {
01007 return CHECK_WARNING(snd_midi_event_encode_byte(m_Info, c, ev));
01008 }
01009
01014 void
01015 MidiCodec::enableRunningStatus(bool enable)
01016 {
01017 snd_midi_event_no_status(m_Info, enable ? 0 : 1);
01018 }
01019
01023 void
01024 MidiCodec::resetDecoder()
01025 {
01026 snd_midi_event_reset_decode(m_Info);
01027 }
01028
01032 void
01033 MidiCodec::resetEncoder()
01034 {
01035 snd_midi_event_reset_encode(m_Info);
01036 }
01037
01042 void
01043 MidiCodec::resizeBuffer(int bufsize)
01044 {
01045 CHECK_WARNING(snd_midi_event_resize_buffer(m_Info, bufsize));
01046 }
01047
01048 }