1 /* This file is part of Evoral.
2 * Copyright (C) 2008 Dave Robillard <http://drobilla.net>
3 * Copyright (C) 2000-2008 Paul Davis
5 * Evoral is free software; you can redistribute it and/or modify it under the
6 * terms of the GNU General Public License as published by the Free Software
7 * Foundation; either version 2 of the License, or (at your option) any later
10 * Evoral is distributed in the hope that it will be useful, but WITHOUT ANY
11 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for details.
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 #ifndef EVORAL_EVENT_HPP
20 #define EVORAL_EVENT_HPP
27 #include "evoral/types.hpp"
30 /** If this is not defined, all methods of MidiEvent are RT safe
31 * but MidiEvent will never deep copy and (depending on the scenario)
32 * may not be usable in STL containers, signals, etc.
34 #define EVORAL_EVENT_ALLOC 1
39 /** An event (much like a type generic jack_midi_event_t)
41 * Template parameter Time is the type of the time stamp used for this event.
43 template<typename Time>
45 #ifdef EVORAL_EVENT_ALLOC
46 Event(EventType type=0, Time timestamp=0, uint32_t size=0, uint8_t* buffer=NULL, bool alloc=false);
50 * If \a alloc is true, the buffer will be copied and this method
51 * is NOT REALTIME SAFE. Otherwise both events share a buffer and
52 * memory management semantics are the caller's problem.
54 Event(const Event& copy, bool alloc);
58 inline const Event& operator=(const Event& copy) {
63 if (copy._size > _size) {
64 _buf = (uint8_t*)::realloc(_buf, copy._size);
66 memcpy(_buf, copy._buf, copy._size);
79 inline void shallow_copy(const Event& copy) {
92 inline void set(uint8_t* buf, uint32_t size, Time t) {
95 _buf = (uint8_t*) ::realloc(_buf, size);
97 memcpy (_buf, buf, size);
106 inline bool operator==(const Event& other) const {
107 if (_type != other._type)
110 if (_time != other._time)
113 if (_size != other._size)
116 if (_buf == other._buf)
119 for (uint32_t i=0; i < _size; ++i)
120 if (_buf[i] != other._buf[i])
126 inline bool operator!=(const Event& other) const { return ! operator==(other); }
128 inline bool owns_buffer() const { return _owns_buf; }
130 inline void set_buffer(uint32_t size, uint8_t* buf, bool own) {
140 inline void realloc(uint32_t size) {
143 _buf = (uint8_t*) ::realloc(_buf, size);
145 _buf = (uint8_t*) ::malloc(size);
152 inline void clear() {
161 inline void set_buffer(uint8_t* buf) { _buf = buf; }
163 #endif // EVORAL_EVENT_ALLOC
165 inline EventType event_type() const { return _type; }
166 inline void set_event_type(EventType t) { _type = t; }
167 inline Time time() const { return _time; }
168 inline Time& time() { return _time; }
169 inline uint32_t size() const { return _size; }
170 inline uint32_t& size() { return _size; }
172 inline const uint8_t* buffer() const { return _buf; }
173 inline uint8_t*& buffer() { return _buf; }
176 EventType _type; /**< Type of event (application relative, NOT MIDI 'type') */
177 Time _time; /**< Sample index (or beat time) at which event is valid */
178 uint32_t _size; /**< Number of uint8_ts of data in \a buffer */
179 uint8_t* _buf; /**< Raw MIDI data */
181 #ifdef EVORAL_EVENT_ALLOC
182 bool _owns_buf; /**< Whether buffer is locally allocated */
187 } // namespace Evoral
189 #endif // EVORAL_EVENT_HPP