RelativePath="..\ardour\element_importer.h"
>
</File>
+ <File
+ RelativePath="..\ardour\event_ring_buffer.h"
+ >
+ </File>
<File
RelativePath="..\ardour\event_type_map.h"
>
#include "pbd/ringbuffer.h"
#include "evoral/Event.hpp"
-#include "evoral/EventRingBuffer.hpp"
#include "midi++/types.h"
#include "midi++/parser.h"
#include "midi++/port.h"
#include "ardour/libardour_visibility.h"
+#include "ardour/event_ring_buffer.h"
#include "ardour/midi_port.h"
namespace ARDOUR {
bool have_timer;
boost::function<framecnt_t (void)> timer;
RingBuffer< Evoral::Event<double> > output_fifo;
- Evoral::EventRingBuffer<MIDI::timestamp_t> input_fifo;
+ EventRingBuffer<MIDI::timestamp_t> input_fifo;
Glib::Threads::Mutex output_fifo_lock;
#ifndef PLATFORM_WINDOWS
CrossThreadChannel xthread;
--- /dev/null
+/*
+ Copyright (C) 2006-2014 Paul Davis
+ Author: David Robillard
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __ardour_event_ring_buffer_h__
+#define __ardour_event_ring_buffer_h__
+
+#include <algorithm>
+#include <iostream>
+
+#include "pbd/ringbufferNPT.h"
+
+#include "evoral/EventSink.hpp"
+#include "evoral/types.hpp"
+
+namespace ARDOUR {
+
+/** A RingBuffer of events (generic time-stamped binary "blobs").
+ *
+ * This packs a timestamp, size, and size bytes of data flat into the buffer.
+ * Useful for MIDI events, OSC messages, etc.
+ *
+ * Note: the uint8_t template argument to RingBufferNPT<> indicates "byte
+ * oriented data", not anything particular linked to MIDI or any other
+ * possible interpretation of uint8_t.
+ */
+template<typename Time>
+class EventRingBuffer : public PBD::RingBufferNPT<uint8_t>
+ , public Evoral::EventSink<Time> {
+public:
+
+ /** @param capacity Ringbuffer capacity in bytes.
+ */
+ EventRingBuffer(size_t capacity) : PBD::RingBufferNPT<uint8_t>(capacity)
+ {}
+
+ inline size_t capacity() const { return bufsize(); }
+
+ /** Peek at the ringbuffer (read w/o advancing read pointer).
+ * @return how much has been peeked (wraps around if read exceeds
+ * the end of the buffer):
+ * <pre>
+ * |===========--------------R=============================|
+ * read-pointer---^
+ * </pre>
+ */
+ inline bool peek (uint8_t*, size_t size);
+
+ inline uint32_t write(Time time, Evoral::EventType type, uint32_t size, const uint8_t* buf);
+ inline bool read (Time* time, Evoral::EventType* type, uint32_t* size, uint8_t* buf);
+};
+
+template<typename Time>
+inline bool
+EventRingBuffer<Time>::peek (uint8_t* buf, size_t size)
+{
+ PBD::RingBufferNPT<uint8_t>::rw_vector vec;
+
+ get_read_vector (&vec);
+
+ if (vec.len[0] + vec.len[1] < size) {
+ return false;
+ }
+
+ if (vec.len[0] > 0) {
+ memcpy (buf, vec.buf[0], std::min (vec.len[0], size));
+ }
+
+ if (vec.len[0] < size) {
+ if (vec.len[1]) {
+ memcpy (buf + vec.len[0], vec.buf[1], size - vec.len[0]);
+ }
+ }
+
+ return true;
+}
+
+template<typename Time>
+inline bool
+EventRingBuffer<Time>::read(Time* time, Evoral::EventType* type, uint32_t* size, uint8_t* buf)
+{
+ if (PBD::RingBufferNPT<uint8_t>::read ((uint8_t*)time, sizeof (Time)) != sizeof (Time)) {
+ return false;
+ }
+
+ if (PBD::RingBufferNPT<uint8_t>::read ((uint8_t*)type, sizeof(Evoral::EventType)) != sizeof (Evoral::EventType)) {
+ return false;
+ }
+
+ if (PBD::RingBufferNPT<uint8_t>::read ((uint8_t*)size, sizeof(uint32_t)) != sizeof (uint32_t)) {
+ return false;
+ }
+
+ if (PBD::RingBufferNPT<uint8_t>::read (buf, *size) != *size) {
+ return false;
+ }
+
+ return true;
+}
+
+template<typename Time>
+inline uint32_t
+EventRingBuffer<Time>::write(Time time, Evoral::EventType type, uint32_t size, const uint8_t* buf)
+{
+ if (!buf || write_space() < (sizeof(Time) + sizeof(Evoral::EventType) + sizeof(uint32_t) + size)) {
+ return 0;
+ } else {
+ PBD::RingBufferNPT<uint8_t>::write ((uint8_t*)&time, sizeof(Time));
+ PBD::RingBufferNPT<uint8_t>::write ((uint8_t*)&type, sizeof(Evoral::EventType));
+ PBD::RingBufferNPT<uint8_t>::write ((uint8_t*)&size, sizeof(uint32_t));
+ PBD::RingBufferNPT<uint8_t>::write (buf, size);
+ return size;
+ }
+}
+
+} // namespace ARDOUR
+
+#endif // __ardour_event_ring_buffer_h__
#include "ardour/ardour.h"
#include "ardour/diskstream.h"
+#include "ardour/midi_buffer.h"
#include "ardour/midi_playlist.h"
-#include "ardour/midi_ring_buffer.h"
#include "ardour/utils.h"
struct tm;
class MidiEngine;
class MidiPort;
class MidiRingbuffer;
+class MidiSource;
class SMFSource;
class Send;
class Session;
#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/midi_buffer.h"
-#include "ardour/midi_ring_buffer.h"
#include "ardour/automatable_sequence.h"
#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include <iostream>
#include <algorithm>
-#include "evoral/EventRingBuffer.hpp"
-
+#include "ardour/event_ring_buffer.h"
#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/midi_state_tracker.h"
* [timestamp][type][size][size bytes of raw MIDI][timestamp][type][size](etc...)
*/
template<typename T>
-class /*LIBARDOUR_API*/ MidiRingBuffer : public Evoral::EventRingBuffer<T> {
+class /*LIBARDOUR_API*/ MidiRingBuffer : public EventRingBuffer<T> {
public:
- /** @param size Size in bytes.
- */
- MidiRingBuffer(size_t size)
- : Evoral::EventRingBuffer<T>(size) {}
+ /** @param size Size in bytes. */
+ MidiRingBuffer(size_t size) : EventRingBuffer<T>(size) {}
inline bool read_prefix(T* time, Evoral::EventType* type, uint32_t* size);
inline bool read_contents(uint32_t size, uint8_t* buf);
using namespace std;
using namespace PBD;
-namespace Evoral {
- template class EventRingBuffer<MIDI::timestamp_t>;
-}
-
pthread_t AsyncMIDIPort::_process_thread;
#define port_engine AudioEngine::instance()->port_engine()
#include "ardour/midi_playlist.h"
#include "ardour/midi_port.h"
#include "ardour/midi_region.h"
+#include "ardour/midi_ring_buffer.h"
#include "ardour/playlist_factory.h"
#include "ardour/region_factory.h"
#include "ardour/session.h"
#include "ardour/midi_model.h"
#include "ardour/midi_playlist.h"
#include "ardour/midi_region.h"
+#include "ardour/midi_state_tracker.h"
#include "ardour/types.h"
#include "i18n.h"
#include "pbd/pthread_utils.h"
#include "pbd/basename.h"
+#include "evoral/EventSink.hpp"
+
#include "ardour/debug.h"
#include "ardour/midi_model.h"
#include "ardour/midi_state_tracker.h"
RelativePath="..\evoral\EventList.hpp"
>
</File>
- <File
- RelativePath="..\evoral\EventRingBuffer.hpp"
- >
- </File>
<File
RelativePath="..\evoral\EventSink.hpp"
>
+++ /dev/null
-/* This file is part of Evoral.
- * Copyright (C) 2008 David Robillard <http://drobilla.net>
- *
- * Evoral is free software; you can redistribute it and/or modify it under the
- * terms of the GNU General Public License as published by the Free Software
- * Foundation; either version 2 of the License, or (at your option) any later
- * version.
- *
- * Evoral is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE. See the GNU General Public License for details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef EVORAL_EVENT_RING_BUFFER_HPP
-#define EVORAL_EVENT_RING_BUFFER_HPP
-
-#include <iostream>
-
-#include "pbd/ringbufferNPT.h"
-
-#include "evoral/visibility.h"
-#include "evoral/EventSink.hpp"
-#include "evoral/types.hpp"
-
-using namespace std;
-
-namespace Evoral {
-
-/** A RingBuffer of events (generic time-stamped binary "blobs").
- *
- * This packs a timestamp, size, and size bytes of data flat into the buffer.
- * Useful for MIDI events, OSC messages, etc.
- *
- * Note: the uint8_t template argument to RingBufferNPT<> indicates "byte
- * oriented data", not anything particular linked to MIDI or any other
- * possible interpretation of uint8_t.
- */
-template<typename Time>
-class /*LIBEVORAL_API*/ EventRingBuffer : public PBD::RingBufferNPT<uint8_t>, public Evoral::EventSink<Time> {
-public:
-
- /** @param capacity Ringbuffer capacity in bytes.
- */
- EventRingBuffer(size_t capacity) : PBD::RingBufferNPT<uint8_t>(capacity)
- {}
-
- inline size_t capacity() const { return bufsize(); }
-
- /** Peek at the ringbuffer (read w/o advancing read pointer).
- * @return how much has been peeked (wraps around if read exceeds
- * the end of the buffer):
- * <pre>
- * |===========--------------R=============================|
- * read-pointer---^
- * </pre>
- */
- inline bool peek (uint8_t*, size_t size);
-
- inline uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf);
- inline bool read (Time* time, EventType* type, uint32_t* size, uint8_t* buf);
-};
-
-template<typename Time>
-inline bool
-EventRingBuffer<Time>::peek (uint8_t* buf, size_t size)
-{
- PBD::RingBufferNPT<uint8_t>::rw_vector vec;
-
- get_read_vector (&vec);
-
- if (vec.len[0] + vec.len[1] < size) {
- return false;
- }
-
- if (vec.len[0] > 0) {
- memcpy (buf, vec.buf[0], min (vec.len[0], size));
- }
-
- if (vec.len[0] < size) {
- if (vec.len[1]) {
- memcpy (buf + vec.len[0], vec.buf[1], size - vec.len[0]);
- }
- }
-
- return true;
-}
-
-template<typename Time>
-inline bool
-EventRingBuffer<Time>::read(Time* time, EventType* type, uint32_t* size, uint8_t* buf)
-{
- if (PBD::RingBufferNPT<uint8_t>::read ((uint8_t*)time, sizeof (Time)) != sizeof (Time)) {
- return false;
- }
-
- if (PBD::RingBufferNPT<uint8_t>::read ((uint8_t*)type, sizeof(EventType)) != sizeof (EventType)) {
- return false;
- }
-
- if (PBD::RingBufferNPT<uint8_t>::read ((uint8_t*)size, sizeof(uint32_t)) != sizeof (uint32_t)) {
- return false;
- }
-
- if (PBD::RingBufferNPT<uint8_t>::read (buf, *size) != *size) {
- return false;
- }
-
- return true;
-}
-
-
-template<typename Time>
-inline uint32_t
-EventRingBuffer<Time>::write(Time time, EventType type, uint32_t size, const uint8_t* buf)
-{
- if (!buf || write_space() < (sizeof(Time) + sizeof(EventType) + sizeof(uint32_t) + size)) {
- return 0;
- } else {
- PBD::RingBufferNPT<uint8_t>::write ((uint8_t*)&time, sizeof(Time));
- PBD::RingBufferNPT<uint8_t>::write ((uint8_t*)&type, sizeof(EventType));
- PBD::RingBufferNPT<uint8_t>::write ((uint8_t*)&size, sizeof(uint32_t));
- PBD::RingBufferNPT<uint8_t>::write (buf, size);
- return size;
- }
-}
-
-
-} // namespace Evoral
-
-#endif // EVORAL_EVENT_RING_BUFFER_HPP
-
namespace Evoral {
template<typename Time> class Event;
-template<typename Time> class EventRingBuffer;
-
/** Standard Midi File (Type 0)
*/
projects / ardour.git / commitdiff