ardour/ardour
ardour/ardour
13
1
Fork 0
Code Pull Requests Releases Activity

Move EventRingBuffer to libardour.

Browse Source 
This is not used anywhere in Evoral and is just a wrapper around the PBD
RingBuffer anyway.  Towards a (once again?) independently buildable/testable
Evoral and fewer cross-dependencies.
This commit is contained in:
David Robillard 2014-11-30 18:51:24 -05:00
parent cf537b97f5
commit 1693e57e0e
12 changed files with 50 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libs/ardour/MSVClibardour/ardour.vcproj
View File

@ -1521,6 +1521,10 @@
RelativePath="..\ardour\element_importer.h"
>
</File>
<File
RelativePath="..\ardour\event_ring_buffer.h"
>
</File>
<File
RelativePath="..\ardour\event_type_map.h"
>

4
libs/ardour/ardour/async_midi_port.h
View File

@ -30,13 +30,13 @@
#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 {
@ -88,7 +88,7 @@ class LIBARDOUR_API AsyncMIDIPort : public ARDOUR::MidiPort, public MIDI::Port {
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;

70
libs/evoral/evoral/EventRingBuffer.hpp → libs/ardour/ardour/event_ring_buffer.h
View File

@ -1,34 +1,34 @@
/* 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
*/
/*
Copyright (C) 2006-2014 Paul Davis
Author: David Robillard
#ifndef EVORAL_EVENT_RING_BUFFER_HPP
#define EVORAL_EVENT_RING_BUFFER_HPP
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/visibility.h"
#include "evoral/EventSink.hpp"
#include "evoral/types.hpp"
using namespace std;
namespace Evoral {
namespace ARDOUR {
/** A RingBuffer of events (generic time-stamped binary "blobs").
*
@ -40,7 +40,8 @@ namespace Evoral {
* possible interpretation of uint8_t.
*/
template<typename Time>
class /*LIBEVORAL_API*/ EventRingBuffer : public PBD::RingBufferNPT<uint8_t>, public Evoral::EventSink<Time> {
class EventRingBuffer : public PBD::RingBufferNPT<uint8_t>
, public Evoral::EventSink<Time> {
public:
/** @param capacity Ringbuffer capacity in bytes.
@ -60,8 +61,8 @@ public:
*/
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);
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>
@ -77,7 +78,7 @@ EventRingBuffer<Time>::peek (uint8_t* buf, size_t size)
}
if (vec.len[0] > 0) {
memcpy (buf, vec.buf[0], min (vec.len[0], size));
memcpy (buf, vec.buf[0], std::min (vec.len[0], size));
}
if (vec.len[0] < size) {
@ -91,13 +92,13 @@ EventRingBuffer<Time>::peek (uint8_t* buf, size_t size)
template<typename Time>
inline bool
EventRingBuffer<Time>::read(Time* time, EventType* type, uint32_t* size, uint8_t* buf)
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(EventType)) != sizeof (EventType)) {
if (PBD::RingBufferNPT<uint8_t>::read ((uint8_t*)type, sizeof(Evoral::EventType)) != sizeof (Evoral::EventType)) {
return false;
}
@ -112,24 +113,21 @@ EventRingBuffer<Time>::read(Time* time, EventType* type, uint32_t* size, uint8_t
return true;
}
template<typename Time>
inline uint32_t
EventRingBuffer<Time>::write(Time time, EventType type, uint32_t size, const uint8_t* buf)
EventRingBuffer<Time>::write(Time time, Evoral::EventType type, uint32_t size, const uint8_t* buf)
{
if (!buf || write_space() < (sizeof(Time) + sizeof(EventType) + sizeof(uint32_t) + size)) {
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(EventType));
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
} // namespace Evoral
#endif // EVORAL_EVENT_RING_BUFFER_HPP
#endif // __ardour_event_ring_buffer_h__

3
libs/ardour/ardour/midi_diskstream.h
View File

@ -36,8 +36,8 @@
#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;
@ -48,6 +48,7 @@ class IO;
class MidiEngine;
class MidiPort;
class MidiRingbuffer;
class MidiSource;
class SMFSource;
class Send;
class Session;

1
libs/ardour/ardour/midi_model.h
View File

@ -30,7 +30,6 @@
#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"

11
libs/ardour/ardour/midi_ring_buffer.h
View File

@ -22,8 +22,7 @@
#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"
@ -41,12 +40,10 @@ class MidiBuffer;
* [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);

4
libs/ardour/async_midi_port.cc
View File

@ -37,10 +37,6 @@ using namespace ARDOUR;
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()

1
libs/ardour/midi_diskstream.cc
View File

@ -47,6 +47,7 @@
#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"

1
libs/ardour/midi_playlist.cc
View File

@ -31,6 +31,7 @@
#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"

2
libs/ardour/midi_source.cc
View File

@ -34,6 +34,8 @@
#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"

4
libs/evoral/MSVCevoral/evoral.vcproj
View File

@ -483,10 +483,6 @@
RelativePath="..\evoral\EventList.hpp"
>
</File>
<File
RelativePath="..\evoral\EventRingBuffer.hpp"
>
</File>
<File
RelativePath="..\evoral\EventSink.hpp"
>

2
libs/evoral/evoral/OldSMF.hpp
View File

@ -24,8 +24,6 @@
namespace Evoral {
template<typename Time> class Event;
template<typename Time> class EventRingBuffer;
/** Standard Midi File (Type 0)
*/