#ifndef __ardour_amp_h__
#define __ardour_amp_h__
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/chan_count.h"
#include "ardour/processor.h"
/** Applies a declick operation to all audio inputs, passing the same number of
* audio outputs, and passing through any other types unchanged.
*/
-class Amp : public Processor {
+class LIBARDOUR_API Amp : public Processor {
public:
Amp(Session& s);
#include <glibmm/threads.h>
#include <boost/shared_ptr.hpp>
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
class AudioFileSource;
class Source;
class TransientDetector;
-class Analyser {
+class LIBARDOUR_API Analyser {
public:
Analyser();
#include "pbd/locale_guard.h"
#include "pbd/stateful.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/libardour_visibility.h"
#include <boost/function.hpp>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/audioengine.h"
#include "ardour/port_engine.h"
namespace ARDOUR {
-class AudioBackend : public PortEngine {
+class LIBARDOUR_API AudioBackend : public PortEngine {
public:
AudioBackend (AudioEngine& e) : PortEngine (e), engine (e) {}
AudioEngine& engine;
};
-struct AudioBackendInfo {
+struct LIBARDOUR_API AudioBackendInfo {
const char* name;
/** Using arg1 and arg2, initialize this audiobackend.
namespace ARDOUR {
/** Buffer containing audio data. */
-class AudioBuffer : public Buffer
+class LIBARDOUR_API AudioBuffer : public Buffer
{
public:
AudioBuffer(size_t capacity);
#include "ardour/port.h"
#include "ardour/interpolation.h"
-struct tm;
+struct LIBARDOUR_API tm;
namespace ARDOUR {
class AudioFileSource;
class IO;
-class AudioDiskstream : public Diskstream
+class LIBARDOUR_API AudioDiskstream : public Diskstream
{
public:
AudioDiskstream (Session &, const std::string& name, Diskstream::Flag f = Recordable);
#include <map>
#include <vector>
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
-class AudioLibrary
+class LIBARDOUR_API AudioLibrary
{
public:
AudioLibrary ();
class AudioPlaylistImporter;
class Session;
-class AudioPlaylistImportHandler : public ElementImportHandler
+class LIBARDOUR_API AudioPlaylistImportHandler : public ElementImportHandler
{
public:
typedef boost::shared_ptr<AudioPlaylistImporter> PlaylistPtr;
AudioRegionImportHandler & region_handler;
};
-class UnusedAudioPlaylistImportHandler : public AudioPlaylistImportHandler
+class LIBARDOUR_API UnusedAudioPlaylistImportHandler : public AudioPlaylistImportHandler
{
public:
UnusedAudioPlaylistImportHandler (XMLTree const & source, Session & session, AudioRegionImportHandler & region_handler) :
std::string get_info () const;
};
-class AudioPlaylistImporter : public ElementImporter
+class LIBARDOUR_API AudioPlaylistImporter : public ElementImporter
{
public:
AudioPlaylistImporter (XMLTree const & source, Session & session, AudioPlaylistImportHandler & handler, XMLNode const & node);
class AudioPlaylist;
-class AudioPlaylistSource : public PlaylistSource, public AudioSource {
+class LIBARDOUR_API AudioPlaylistSource : public PlaylistSource, public AudioSource {
public:
virtual ~AudioPlaylistSource ();
namespace ARDOUR {
-class AudioPort : public Port
+class LIBARDOUR_API AudioPort : public Port
{
public:
~AudioPort ();
class Session;
class Source;
-class AudioRegionImportHandler : public ElementImportHandler
+class LIBARDOUR_API AudioRegionImportHandler : public ElementImportHandler
{
public:
// Inerface implementation
IdMap id_map;
};
-class AudioRegionImporter : public ElementImporter
+class LIBARDOUR_API AudioRegionImporter : public ElementImporter
{
public:
AudioRegionImporter (XMLTree const & source, Session & session, AudioRegionImportHandler & handler, XMLNode const & node);
class RouteGroup;
class AudioFileSource;
-class AudioTrack : public Track
+class LIBARDOUR_API AudioTrack : public Track
{
public:
AudioTrack (Session&, std::string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal);
class AudioPlaylistImportHandler;
class AudioPlaylistImporter;
-class AudioTrackImportHandler : public ElementImportHandler
+class LIBARDOUR_API AudioTrackImportHandler : public ElementImportHandler
{
public:
AudioTrackImportHandler (XMLTree const & source, Session & session, AudioPlaylistImportHandler & pl_handler);
};
-class AudioTrackImporter : public ElementImporter
+class LIBARDOUR_API AudioTrackImporter : public ElementImporter
{
public:
AudioTrackImporter (XMLTree const & source,
class CAComponent;
class CAAudioUnit;
class CAComponentDescription;
-struct AudioBufferList;
+struct LIBARDOUR_API AudioBufferList;
namespace ARDOUR {
class AudioEngine;
class Session;
-struct AUParameterDescriptor : public Plugin::ParameterDescriptor {
+struct LIBARDOUR_API AUParameterDescriptor : public Plugin::ParameterDescriptor {
// additional fields to make operations more efficient
AudioUnitParameterID id;
AudioUnitScope scope;
AudioUnitParameterUnit unit;
};
-class AUPlugin : public ARDOUR::Plugin
+class LIBARDOUR_API AUPlugin : public ARDOUR::Plugin
{
public:
AUPlugin (AudioEngine& engine, Session& session, boost::shared_ptr<CAComponent> comp);
typedef boost::shared_ptr<AUPlugin> AUPluginPtr;
-struct AUPluginCachedInfo {
+struct LIBARDOUR_API AUPluginCachedInfo {
std::vector<std::pair<int,int> > io_configs;
};
-class AUPluginInfo : public PluginInfo {
+class LIBARDOUR_API AUPluginInfo : public PluginInfo {
public:
AUPluginInfo (boost::shared_ptr<CAComponentDescription>);
~AUPluginInfo ();
#include <fstream>
#include <boost/utility.hpp>
#include "vamp-sdk/Plugin.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
class Readable;
class Session;
-class AudioAnalyser : public boost::noncopyable {
+class LIBARDOUR_API AudioAnalyser : public boost::noncopyable {
public:
typedef Vamp::Plugin AnalysisPlugin;
#include "ardour/ardour.h"
#include "ardour/data_type.h"
#include "ardour/session_handle.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/chan_count.h"
#include "ardour/port_manager.h"
class AudioBackend;
class AudioBackendInfo;
-class AudioEngine : public SessionHandlePtr, public PortManager
+class LIBARDOUR_API AudioEngine : public SessionHandlePtr, public PortManager
{
public:
#include "taglib/taglib.h"
#include "taglib/xiphcomment.h"
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR
{
class SessionMetadata;
/// Class with static functions for tagging audiofiles
-class AudiofileTagger
+class LIBARDOUR_API AudiofileTagger
{
public:
namespace ARDOUR {
-struct SoundFileInfo {
+struct LIBARDOUR_API SoundFileInfo {
float samplerate;
uint16_t channels;
int64_t length;
int64_t timecode;
};
-class AudioFileSource : public AudioSource, public FileSource {
+class LIBARDOUR_API AudioFileSource : public AudioSource, public FileSource {
public:
virtual ~AudioFileSource ();
class Region;
class AudioRegion;
class Source;
-
class AudioPlaylist;
-class AudioPlaylist : public ARDOUR::Playlist
+class LIBARDOUR_API AudioPlaylist : public ARDOUR::Playlist
{
public:
AudioPlaylist (Session&, const XMLNode&, bool hidden = false);
namespace ARDOUR {
namespace Properties {
- extern PBD::PropertyDescriptor<bool> envelope_active;
- extern PBD::PropertyDescriptor<bool> default_fade_in;
- extern PBD::PropertyDescriptor<bool> default_fade_out;
- extern PBD::PropertyDescriptor<bool> fade_in_active;
- extern PBD::PropertyDescriptor<bool> fade_out_active;
- extern PBD::PropertyDescriptor<float> scale_amplitude;
- extern PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > fade_in;
- extern PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > inverse_fade_in;
- extern PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > fade_out;
- extern PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > inverse_fade_out;
- extern PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > envelope;
+ LIBARDOUR_API extern PBD::PropertyDescriptor<bool> envelope_active;
+ LIBARDOUR_API extern PBD::PropertyDescriptor<bool> default_fade_in;
+ LIBARDOUR_API extern PBD::PropertyDescriptor<bool> default_fade_out;
+ LIBARDOUR_API extern PBD::PropertyDescriptor<bool> fade_in_active;
+ LIBARDOUR_API extern PBD::PropertyDescriptor<bool> fade_out_active;
+ LIBARDOUR_API extern PBD::PropertyDescriptor<float> scale_amplitude;
+
LIBARDOUR_API extern PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > fade_in;
+
LIBARDOUR_API extern PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > inverse_fade_in;
+
LIBARDOUR_API extern PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > fade_out;
+
LIBARDOUR_API extern PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > inverse_fade_out;
+
LIBARDOUR_API extern PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > envelope;
}
class Playlist;
class AudioSource;
-class AudioRegion : public Region
+class LIBARDOUR_API AudioRegion : public Region
{
public:
static void make_property_quarks ();
namespace ARDOUR {
-class AudioSource : virtual public Source,
+class LIBARDOUR_API AudioSource : virtual public Source,
public ARDOUR::Readable,
public boost::enable_shared_from_this<ARDOUR::AudioSource>
{
class AudioRegion;
class AudioPlaylist;
-class Auditioner : public AudioTrack
+class LIBARDOUR_API Auditioner : public AudioTrack
{
public:
Auditioner (Session&);
namespace ARDOUR {
-class AutoBundle : public Bundle {
+class LIBARDOUR_API AutoBundle : public Bundle {
public:
AutoBundle (bool i = true);
#include <boost/shared_ptr.hpp>
#include "pbd/signals.h"
#include "evoral/ControlSet.hpp"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
class XMLNode;
/* The inherited ControlSet is virtual because AutomatableSequence inherits
* from this AND EvoralSequence, which is also a ControlSet
*/
-class Automatable : virtual public Evoral::ControlSet
+class LIBARDOUR_API Automatable : virtual public Evoral::ControlSet
{
public:
Automatable(Session&);
/** Contains notes and controllers */
template<typename T>
-class AutomatableSequence : public Automatable, public Evoral::Sequence<T> {
+class LIBARDOUR_API AutomatableSequence : public Automatable, public Evoral::Sequence<T> {
public:
AutomatableSequence(Session& s)
: Evoral::ControlSet()
#include "pbd/controllable.h"
#include "evoral/Control.hpp"
+
+#include "ardour/libardour_visibility.h"
#include "ardour/automation_list.h"
namespace ARDOUR {
/** A PBD::Controllable with associated automation data (AutomationList)
*/
-class AutomationControl : public PBD::Controllable, public Evoral::Control, public boost::enable_shared_from_this<AutomationControl>
+class
LIBARDOUR_API AutomationControl : public PBD::Controllable, public Evoral::Control, public boost::enable_shared_from_this<AutomationControl>
{
public:
AutomationControl(ARDOUR::Session&,
class AutomationList;
/** A SharedStatefulProperty for AutomationLists */
-class AutomationListProperty : public PBD::SharedStatefulProperty<AutomationList>
+class
LIBARDOUR_API AutomationListProperty : public PBD::SharedStatefulProperty<AutomationList>
{
public:
AutomationListProperty (PBD::PropertyDescriptor<boost::shared_ptr<AutomationList> > d, Ptr p)
AutomationListProperty& operator= (AutomationListProperty const &);
};
-class AutomationList : public PBD::StatefulDestructible, public Evoral::ControlList
+class LIBARDOUR_API AutomationList : public PBD::StatefulDestructible, public Evoral::ControlList
{
public:
AutomationList (Evoral::Parameter id);
class AutomationControl;
-class AutomationWatch : public sigc::trackable, public ARDOUR::SessionHandlePtr, public PBD::ScopedConnectionList {
+class LIBARDOUR_API AutomationWatch : public sigc::trackable, public ARDOUR::SessionHandlePtr, public PBD::ScopedConnectionList {
public:
static AutomationWatch& instance();
*/
#include "evoral/TimeConverter.hpp"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#ifndef __ardour_beats_frames_converter_h__
* from some origin (supplied to the constructor in frames), and converts
* them to the opposite unit, taking tempo changes into account.
*/
-class BeatsFramesConverter : public Evoral::TimeConverter<double,framepos_t> {
+class LIBARDOUR_API BeatsFramesConverter : public Evoral::TimeConverter<double,framepos_t> {
public:
BeatsFramesConverter (TempoMap& tempo_map, framepos_t origin)
: Evoral::TimeConverter<double, framepos_t> (origin)
#include <string>
+#include "ardour/libardour_visibility.h"
#include "audiographer/broadcast_info.h"
namespace ARDOUR
class Session;
-class BroadcastInfo : public AudioGrapher::BroadcastInfo
+class LIBARDOUR_API BroadcastInfo : public AudioGrapher::BroadcastInfo
{
public:
BroadcastInfo ();
#include <boost/utility.hpp>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/data_type.h"
*
* To actually read/write buffer contents, use the appropriate derived class.
*/
-class Buffer : public boost::noncopyable
+class LIBARDOUR_API Buffer : public boost::noncopyable
{
public:
virtual ~Buffer() {}
class ThreadBuffers;
-class BufferManager
+class LIBARDOUR_API BufferManager
{
public:
static void init (uint32_t);
#include <vector>
#include "ardour/chan_count.h"
#include "ardour/data_type.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#if defined VST_SUPPORT || defined LXVST_SUPPORT
#include "evoral/MIDIEvent.hpp"
-struct _VstEvents;
+struct LIBARDOUR_API _VstEvents;
typedef struct _VstEvents VstEvents;
-struct _VstMidiEvent;
+struct LIBARDOUR_API _VstMidiEvent;
typedef struct _VstMidiEvent VstMidiEvent;
#endif
* others the form of their output (eg what they did to the BufferSet).
* Setting the use counts is realtime safe.
*/
-class BufferSet
+class LIBARDOUR_API BufferSet
{
public:
BufferSet();
* `Channel' is a rather overloaded term but I can't think of a better
* one right now.
*/
-class Bundle : public PBD::ScopedConnectionList
+class LIBARDOUR_API Bundle : public PBD::ScopedConnectionList
{
public:
Change _pending_change;
};
-class BundleChannel
+class LIBARDOUR_API BundleChannel
{
public:
BundleChannel () : channel (-1) {}
#include "pbd/ringbuffer.h"
#include "pbd/pool.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/session_handle.h"
* are empty they are deleted.
*/
-class Butler : public SessionHandleRef
+class LIBARDOUR_API Butler : public SessionHandleRef
{
public:
Butler (Session& session);
#define __ardour_ca_importable_source_h__
#include "pbd/failed_constructor.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/importable_source.h"
namespace ARDOUR {
-class CAImportableSource : public ImportableSource {
+class LIBARDOUR_API CAImportableSource : public ImportableSource {
public:
CAImportableSource (const std::string& path);
virtual ~CAImportableSource();
namespace ARDOUR {
-class CapturingProcessor : public Processor
+class LIBARDOUR_API CapturingProcessor : public Processor
{
public:
CapturingProcessor (Session & session);
* Operators are defined so this may safely be used as if it were a simple
* (single-typed) integer count of channels.
*/
-class ChanCount {
+class LIBARDOUR_API ChanCount {
public:
ChanCount(const XMLNode& node);
ChanCount() { reset(); }
/** A mapping from one set of channels to another
* (e.g. how to 'connect' two BufferSets).
*/
-class ChanMapping {
+class LIBARDOUR_API ChanMapping {
public:
ChanMapping() {}
ChanMapping(ARDOUR::ChanCount identity);
#include <list>
#include "pbd/pool.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/io.h"
namespace ARDOUR {
-class Click {
+class LIBARDOUR_API Click {
public:
framepos_t start;
framecnt_t duration;
static Pool pool;
};
-class ClickIO : public IO
+class LIBARDOUR_API ClickIO : public IO
{
public:
ClickIO (Session& s, const std::string& name) : IO (s, name, IO::Output) {}
#ifndef __ardour_comparable_shared_ptr_h__
#define __ardour_comparable_shared_ptr_h__
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
template<typename T>
-class ComparableSharedPtr : public boost::shared_ptr<T>
+class LIBARDOUR_API ComparableSharedPtr : public boost::shared_ptr<T>
, public boost::less_than_comparable<ComparableSharedPtr<T> >
{
public:
namespace ARDOUR {
-class Configuration : public PBD::Stateful
+class LIBARDOUR_API Configuration : public PBD::Stateful
{
public:
Configuration();
#include "pbd/xml++.h"
#include "pbd/convert.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/utils.h"
namespace ARDOUR {
-class ConfigVariableBase {
+class LIBARDOUR_API ConfigVariableBase {
public:
ConfigVariableBase (std::string str) : _name (str) {}
};
template<class T>
-class ConfigVariable : public ConfigVariableBase
+class LIBARDOUR_API ConfigVariable : public ConfigVariableBase
{
public:
/** Specialisation of ConfigVariable for std::string to cope with whitespace properly */
template<>
-class ConfigVariable<std::string> : public ConfigVariableBase
+class LIBARDOUR_API ConfigVariable<std::string> : public ConfigVariableBase
{
public:
};
template<>
-class ConfigVariable<bool> : public ConfigVariableBase
+class LIBARDOUR_API ConfigVariable<bool> : public ConfigVariableBase
{
public:
};
template<class T>
-class ConfigVariableWithMutation : public ConfigVariable<T>
+class LIBARDOUR_API ConfigVariableWithMutation : public ConfigVariable<T>
{
public:
ConfigVariableWithMutation (std::string name, T val, T (*m)(T))
};
template<>
-class ConfigVariableWithMutation<std::string> : public ConfigVariable<std::string>
+class LIBARDOUR_API ConfigVariableWithMutation<std::string> : public ConfigVariable<std::string>
{
public:
ConfigVariableWithMutation (std::string name, std::string val, std::string (*m)(std::string))
class ControlProtocolDescriptor;
class Session;
-class ControlProtocolInfo {
+class LIBARDOUR_API ControlProtocolInfo {
public:
ControlProtocolDescriptor* descriptor;
ControlProtocol* protocol;
~ControlProtocolInfo() { delete state; }
};
-class ControlProtocolManager : public PBD::Stateful, public ARDOUR::SessionHandlePtr
+class LIBARDOUR_API ControlProtocolManager : public PBD::Stateful, public ARDOUR::SessionHandlePtr
{
public:
~ControlProtocolManager ();
namespace ARDOUR {
-class CoreAudioSource : public AudioFileSource {
+class LIBARDOUR_API CoreAudioSource : public AudioFileSource {
public:
CoreAudioSource (ARDOUR::Session&, const XMLNode&);
CoreAudioSource (ARDOUR::Session&, const string& path, int chn, Flag);
#include <iostream>
#include <cstdlib>
+#include "ardour/libardour_visibility.h"
#include "ardour/cycles.h"
#include "ardour/debug.h"
float get_mhz ();
-class CycleTimer {
+class LIBARDOUR_API CycleTimer {
private:
static float cycles_per_usec;
#ifndef NDEBUG
}
};
-class StoringTimer
+class LIBARDOUR_API StoringTimer
{
public:
StoringTimer (int);
#include <stdint.h>
#include <glib.h>
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
/** A type of Data Ardour is capable of processing.
* other type representations, simple comparison between then, etc. This code
* is deliberately 'ugly' so other code doesn't have to be.
*/
-class DataType
+class LIBARDOUR_API DataType
{
public:
/** Numeric symbol for this DataType.
#include <string>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/chan_count.h"
#include "ardour/io_processor.h"
class Panner;
class Pannable;
-class Delivery : public IOProcessor
+class LIBARDOUR_API Delivery : public IOProcessor
{
public:
enum Role {
#include "ardour/ardour.h"
#include "ardour/chan_count.h"
#include "ardour/session_object.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/utils.h"
#include "ardour/public_diskstream.h"
/** Parent class for classes which can stream data to and from disk.
* These are used by Tracks to get playback and put recorded data.
*/
-class Diskstream : public SessionObject, public PublicDiskstream
+class LIBARDOUR_API Diskstream : public SessionObject, public PublicDiskstream
{
public:
enum Flag {
#include <boost/shared_ptr.hpp>
-class XMLTree;
+#include "ardour/libardour_visibility.h"
+#include "pbd/libpbd_visibility.h"
+
+class LIBPBD_API XMLTree;
namespace ARDOUR {
class ElementImporter;
/// Virtual interface class for element import handlers
-class ElementImportHandler
+class LIBARDOUR_API ElementImportHandler
{
public:
typedef boost::shared_ptr<ElementImporter> ElementPtr;
#include <utility>
#include "pbd/signals.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
class XMLTree;
class ImportStatus;
/// Virtual interface class for element importers
-class ElementImporter
+class LIBARDOUR_API ElementImporter
{
public:
#include "evoral/TypeMap.hpp"
#include "evoral/ControlList.hpp"
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
/** This is the interface Ardour provides to Evoral about what
* parameter and event types/ranges/names etc. to use.
*/
-class EventTypeMap : public Evoral::TypeMap {
+class LIBARDOUR_API EventTypeMap : public Evoral::TypeMap {
public:
bool type_is_midi(uint32_t type) const;
uint8_t parameter_midi_type(const Evoral::Parameter& param) const;
class CapturingProcessor;
/// Export channel base class interface for different source types
-class ExportChannel : public boost::less_than_comparable<ExportChannel>
+class LIBARDOUR_API ExportChannel : public boost::less_than_comparable<ExportChannel>
{
public:
};
/// Basic export channel that reads from AudioPorts
-class PortExportChannel : public ExportChannel
+class LIBARDOUR_API PortExportChannel : public ExportChannel
{
public:
typedef std::set<boost::weak_ptr<AudioPort> > PortSet;
/// Handles RegionExportChannels and does actual reading from region
-class RegionExportChannelFactory
+class LIBARDOUR_API RegionExportChannelFactory
{
public:
enum Type {
};
/// Export channel that reads from region channel
-class RegionExportChannel : public ExportChannel
+class LIBARDOUR_API RegionExportChannel : public ExportChannel
{
friend class RegionExportChannelFactory;
};
/// Export channel for exporting from different positions in a route
-class RouteExportChannel : public ExportChannel
+class LIBARDOUR_API RouteExportChannel : public ExportChannel
{
class ProcessorRemover; // fwd declaration
class Session;
-class ExportChannelConfiguration : public boost::enable_shared_from_this<ExportChannelConfiguration>
+class LIBARDOUR_API ExportChannelConfiguration : public boost::enable_shared_from_this<ExportChannelConfiguration>
{
private:
#include <exception>
#include <string>
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR
{
-class ExportFailed : public std::exception
+class LIBARDOUR_API ExportFailed : public std::exception
{
public:
ExportFailed (std::string const &);
class Session;
-class ExportFilename {
+class LIBARDOUR_API ExportFilename {
public:
enum DateFormat {
#include <samplerate.h>
#include "pbd/signals.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "audiographer/general/sample_format_converter.h"
namespace ARDOUR
{
-class ExportFormatBase {
+class LIBARDOUR_API ExportFormatBase {
public:
enum Type {
{
/// Allows adding to all sets. A format should be able to test if it is compatible with this
-class ExportFormatCompatibility : public ExportFormatBase, public ExportFormatBase::SelectableCompatible {
+class LIBARDOUR_API ExportFormatCompatibility : public ExportFormatBase, public ExportFormatBase::SelectableCompatible {
private:
public:
class ExportFormatSpecification;
class AnyTime;
-class ExportFormatManager : public PBD::ScopedConnectionList
+class LIBARDOUR_API ExportFormatManager : public PBD::ScopedConnectionList
{
public:
#include "pbd/uuid.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/export_format_base.h"
class ExportFormatCompatibility;
class Session;
-class ExportFormatSpecification : public ExportFormatBase {
+class LIBARDOUR_API ExportFormatSpecification : public ExportFormatBase {
private:
namespace ARDOUR
{
-class ExportFormatIncompatible : public failed_constructor {
+class LIBARDOUR_API ExportFormatIncompatible : public failed_constructor {
public:
virtual const char *what() const throw() { return "Export format constructor failed: Format incompatible with system"; }
};
/// Base class for formats
-class ExportFormat : public ExportFormatBase, public ExportFormatBase::SelectableCompatible {
+class LIBARDOUR_API ExportFormat : public ExportFormatBase, public ExportFormatBase::SelectableCompatible {
public:
ExportFormat () {};
};
/// Class to be inherited by export formats that have a selectable sample format
-class HasSampleFormat : public PBD::ScopedConnectionList {
+class LIBARDOUR_API HasSampleFormat : public PBD::ScopedConnectionList {
public:
class SampleFormatState : public ExportFormatBase::SelectableCompatible {
ExportFormatBase::SampleFormatSet & _sample_formats;
};
-class ExportFormatLinear : public ExportFormat, public HasSampleFormat {
+class LIBARDOUR_API ExportFormatLinear : public ExportFormat, public HasSampleFormat {
public:
ExportFormatLinear (std::string name, FormatId format_id);
SampleFormat _default_sample_format;
};
-class ExportFormatOggVorbis : public ExportFormat {
+class LIBARDOUR_API ExportFormatOggVorbis : public ExportFormat {
public:
ExportFormatOggVorbis ();
~ExportFormatOggVorbis () {};
virtual bool supports_tagging () const { return true; }
};
-class ExportFormatFLAC : public ExportFormat, public HasSampleFormat {
+class LIBARDOUR_API ExportFormatFLAC : public ExportFormat, public HasSampleFormat {
public:
ExportFormatFLAC ();
~ExportFormatFLAC () {};
virtual bool supports_tagging () const { return true; }
};
-class ExportFormatBWF : public ExportFormat, public HasSampleFormat {
+class LIBARDOUR_API ExportFormatBWF : public ExportFormat, public HasSampleFormat {
public:
ExportFormatBWF ();
~ExportFormatBWF () {};
class ExportTimespan;
class Session;
-class ExportGraphBuilder
+class LIBARDOUR_API ExportGraphBuilder
{
private:
typedef ExportHandler::FileSpec FileSpec;
#include "ardour/export_pointers.h"
#include "ardour/session.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace AudioGrapher {
class ExportGraphBuilder;
class Location;
-class ExportElementFactory
+class LIBARDOUR_API ExportElementFactory
{
public:
Session & session;
};
-class ExportHandler : public ExportElementFactory
+class LIBARDOUR_API ExportHandler : public ExportElementFactory
{
public:
struct FileSpec {
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
+#include "ardour/libardour_visibility.h"
#include "ardour/comparable_shared_ptr.h"
namespace AudioGrapher {
#include "pbd/uuid.h"
#include "pbd/xml++.h"
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR
{
class Session;
-class ExportPreset {
+class LIBARDOUR_API ExportPreset {
public:
ExportPreset (std::string filename, Session & s);
~ExportPreset ();
#include "ardour/filesystem_paths.h"
#include "ardour/location.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/export_handler.h"
class Session;
/// Manages (de)serialization of export profiles and related classes
-class ExportProfileManager
+class LIBARDOUR_API ExportProfileManager
{
public:
#include <stdint.h>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "pbd/signals.h"
namespace ARDOUR
{
-class ExportStatus {
+class LIBARDOUR_API ExportStatus {
public:
ExportStatus ();
void init ();
#include <boost/shared_ptr.hpp>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR
class ExportChannel;
class ExportTempFile;
-class ExportTimespan
+class LIBARDOUR_API ExportTimespan
{
private:
typedef boost::shared_ptr<ExportStatus> ExportStatusPtr;
namespace ARDOUR {
-class MissingSource : public std::exception
+class LIBARDOUR_API MissingSource : public std::exception
{
public:
MissingSource (const std::string& p, DataType t) throw ()
};
/** A source associated with a file on disk somewhere */
-class FileSource : virtual public Source {
+class LIBARDOUR_API FileSource : virtual public Source {
public:
virtual ~FileSource () {}
#include <vector>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
class Session;
class Progress;
-class Filter {
+class LIBARDOUR_API Filter {
public:
virtual ~Filter() {}
#include "pbd/semutils.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/audio_backend.h"
#include "ardour/session_handle.h"
typedef std::list< node_ptr_t > node_list_t;
typedef std::set< node_ptr_t > node_set_t;
-class Graph : public SessionHandleRef
+class LIBARDOUR_API Graph : public SessionHandleRef
{
public:
Graph (Session & session);
typedef std::list< node_ptr_t > node_list_t;
/** A node on our processing graph, ie a Route */
-class GraphNode
+class LIBARDOUR_API GraphNode
{
public:
GraphNode( boost::shared_ptr<Graph> Graph );
#ifndef __IEC1PPMDSP_H
#define __IEC1PPMDSP_H
+#include "ardour/libardour_visibility.h"
-class Iec1ppmdsp
+class LIBARDOUR_API Iec1ppmdsp
{
public:
#ifndef __IEC2PPMDSP_H
#define __IEC2PPMDSP_H
+#include "ardour/libardour_visibility.h"
-class Iec2ppmdsp
+class LIBARDOUR_API Iec2ppmdsp
{
public:
#include <stdint.h>
#include "ardour/interthread_info.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
-class ImportStatus : public InterThreadInfo {
+class LIBARDOUR_API ImportStatus : public InterThreadInfo {
public:
std::string doing_what;
#define __ardour_importable_source_h__
#include "pbd/failed_constructor.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
-class ImportableSource {
+class LIBARDOUR_API ImportableSource {
public:
ImportableSource () {}
virtual ~ImportableSource() {}
#include "evoral/Parameter.hpp"
+#include "midi++/libmidi_visibility.h"
+#include "ardour/libardour_visibility.h"
+
namespace MIDI {
-namespace Name {
-class ChannelNameSet;
-class Patch;
-typedef std::list<boost::shared_ptr<Patch> > PatchNameList;
-}
+ namespace Name {
+ class LIBMIDIPP_API ChannelNameSet;
+ class LIBMIDIPP_API Patch;
+
typedef std::list<boost::shared_ptr<Patch> > PatchNameList;
+ }
}
namespace ARDOUR {
class Processor;
-class InstrumentInfo {
+class LIBARDOUR_API InstrumentInfo {
public:
InstrumentInfo();
~InstrumentInfo ();
class InternalSend;
-class InternalReturn : public Return
+class LIBARDOUR_API InternalReturn : public Return
{
public:
InternalReturn (Session&);
namespace ARDOUR {
-class InternalSend : public Send
+class LIBARDOUR_API InternalSend : public Send
{
public:
InternalSend (Session&, boost::shared_ptr<Pannable>, boost::shared_ptr<MuteMaster>, boost::shared_ptr<Route> send_to, Delivery::Role role);
#include <math.h>
#include <samplerate.h>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#ifndef __interpolation_h__
namespace ARDOUR {
-class Interpolation {
+class LIBARDOUR_API Interpolation {
protected:
double _speed;
double _target_speed;
}
};
-class LinearInterpolation : public Interpolation {
+class LIBARDOUR_API LinearInterpolation : public Interpolation {
public:
framecnt_t interpolate (int channel, framecnt_t nframes, Sample* input, Sample* output);
};
-class CubicInterpolation : public Interpolation {
+class LIBARDOUR_API CubicInterpolation : public Interpolation {
public:
framecnt_t interpolate (int channel, framecnt_t nframes, Sample* input, Sample* output);
};
#include <pthread.h>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/process_thread.h"
#include "ardour/latent.h"
#include "ardour/port_set.h"
#include "ardour/session_object.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/utils.h"
#include "ardour/buffer_set.h"
* An IO can contain ports of varying types, making routes/inserts/etc with
* varied combinations of types (eg MIDI and audio) possible.
*/
-class IO : public SessionObject, public Latent
+class LIBARDOUR_API IO : public SessionObject, public Latent
{
public:
static const std::string state_node_name;
/** A mixer strip element (Processor) with 1 or 2 IO elements.
*/
-class IOProcessor : public Processor
+class LIBARDOUR_API IOProcessor : public Processor
{
public:
IOProcessor (Session&, bool with_input, bool with_output,
#ifndef __KMETERDSP_H
#define __KMETERDSP_H
-class Kmeterdsp
+#include "ardour/libardour_visibility.h"
+
+class LIBARDOUR_API Kmeterdsp
{
public:
class AudioEngine;
class Session;
-class LadspaPlugin : public ARDOUR::Plugin
+class LIBARDOUR_API LadspaPlugin : public ARDOUR::Plugin
{
public:
LadspaPlugin (void *module, ARDOUR::AudioEngine&, ARDOUR::Session&, uint32_t index, framecnt_t sample_rate);
void add_state (XMLNode *) const;
};
-class LadspaPluginInfo : public PluginInfo {
+class LIBARDOUR_API LadspaPluginInfo : public PluginInfo {
public:
LadspaPluginInfo ();
~LadspaPluginInfo () { };
#ifndef __ardour_latent_h__
#define __ardour_latent_h__
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
-class Latent {
+class LIBARDOUR_API Latent {
public:
Latent() : _user_latency (0) {}
virtual ~Latent() {}
#define LIBARDOUR_DLL_IMPORT
#define LIBARDOUR_DLL_EXPORT
#define LIBARDOUR_DLL_LOCAL
- #define LIBARDOUR_DLL_IMPORT_CLASS
- #define LIBARDOUR_DLL_EXPORT_CLASS
#endif
#endif
namespace ARDOUR {
-class Location : public SessionHandleRef, public PBD::StatefulDestructible
+class LIBARDOUR_API Location : public SessionHandleRef, public PBD::StatefulDestructible
{
public:
enum Flags {
void recompute_bbt_from_frames ();
};
-class Locations : public SessionHandleRef, public PBD::StatefulDestructible
+class LIBARDOUR_API Locations : public SessionHandleRef, public PBD::StatefulDestructible
{
public:
typedef std::list<Location *> LocationList;
class Location;
class Session;
-class LocationImportHandler : public ElementImportHandler
+class LIBARDOUR_API LocationImportHandler : public ElementImportHandler
{
public:
LocationImportHandler (XMLTree const & source, Session & session);
std::string get_info () const;
};
-class LocationImporter : public ElementImporter
+class LIBARDOUR_API LocationImporter : public ElementImporter
{
public:
LocationImporter (XMLTree const & source, Session & session, LocationImportHandler & handler, XMLNode const & node);
namespace ARDOUR {
-class LogCurve {
+class LIBARDOUR_API LogCurve {
public:
LogCurve (float steepness = 0.2, uint32_t len = 0) {
l = len;
uint32_t l;
};
-class LogCurveIn : public LogCurve
+class LIBARDOUR_API LogCurveIn : public LogCurve
{
public:
LogCurveIn (float steepness = 0.2, uint32_t len = 0)
}
};
-class LogCurveOut : public LogCurve
+class LIBARDOUR_API LogCurveOut : public LogCurve
{
public:
LogCurveOut (float steepness = 0.2, uint32_t len = 0)
class AudioEngine;
class Session;
-class LV2Plugin : public ARDOUR::Plugin, public ARDOUR::Workee
+class LIBARDOUR_API LV2Plugin : public ARDOUR::Plugin, public ARDOUR::Workee
{
public:
LV2Plugin (ARDOUR::AudioEngine& engine,
};
-class LV2PluginInfo : public PluginInfo {
+class LIBARDOUR_API LV2PluginInfo : public PluginInfo {
public:
LV2PluginInfo (const void* c_plugin);
~LV2PluginInfo ();
#include "ardour/vst_plugin.h"
-struct _VSTHandle;
+struct LIBARDOUR_API _VSTHandle;
typedef struct _VSTHandle VSTHandle;
namespace ARDOUR {
class AudioEngine;
class Session;
-class LXVSTPlugin : public VSTPlugin
+class LIBARDOUR_API LXVSTPlugin : public VSTPlugin
{
public:
LXVSTPlugin (AudioEngine &, Session &, VSTHandle *);
std::string state_node_name () const { return "lxvst"; }
};
-class LXVSTPluginInfo : public PluginInfo
+class LIBARDOUR_API LXVSTPluginInfo : public PluginInfo
{
public:
LXVSTPluginInfo ();
#define __ardour_meter_h__
#include <vector>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/processor.h"
#include "pbd/fastlog.h"
class ChanCount;
class Session;
-class Metering {
+class LIBARDOUR_API Metering {
public:
static void update_meters ();
static PBD::Signal0<void> Meter;
/** Meters peaks on the input and stores them for access.
*/
-class PeakMeter : public Processor {
+class LIBARDOUR_API PeakMeter : public Processor {
public:
PeakMeter(Session& s, const std::string& name);
~PeakMeter();
class AutomationList;
/** A class for late-binding a MidiSource and a Parameter to an AutomationList */
-class MidiAutomationListBinder : public MementoCommandBinder<ARDOUR::AutomationList>
+class
LIBARDOUR_API MidiAutomationListBinder : public MementoCommandBinder<ARDOUR::AutomationList>
{
public:
MidiAutomationListBinder (boost::shared_ptr<ARDOUR::MidiSource>, Evoral::Parameter);
/** Buffer containing 8-bit unsigned char (MIDI) data. */
-class MidiBuffer : public Buffer
+class LIBARDOUR_API MidiBuffer : public Buffer
{
public:
typedef framepos_t TimeType;
#include "ardour/midi_ring_buffer.h"
#include "ardour/utils.h"
-struct tm;
+struct LIBARDOUR_API tm;
namespace ARDOUR {
class Send;
class Session;
-class MidiDiskstream : public Diskstream
+class LIBARDOUR_API MidiDiskstream : public Diskstream
{
public:
MidiDiskstream (Session &, const string& name, Diskstream::Flag f = Recordable);
#include <boost/utility.hpp>
#include <glibmm/threads.h>
#include "pbd/command.h"
+#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 "evoral/Note.hpp"
#include "evoral/Sequence.hpp"
* Because of this MIDI controllers and automatable controllers/widgets/etc
* are easily interchangeable.
*/
-class MidiModel : public AutomatableSequence<Evoral::MusicalTime> {
+class LIBARDOUR_API MidiModel : public AutomatableSequence<Evoral::MusicalTime> {
public:
typedef Evoral::MusicalTime TimeType;
class MidiModel;
-class MidiOperator {
+class LIBARDOUR_API MidiOperator {
public:
MidiOperator () {}
virtual ~MidiOperator() {}
namespace Name
{
-class MidiPatchManager : public PBD::ScopedConnectionList, public ARDOUR::SessionHandlePtr
+class LIBARDOUR_API MidiPatchManager : public PBD::ScopedConnectionList, public ARDOUR::SessionHandlePtr
{
/// Singleton
private:
class Source;
template<typename T> class MidiRingBuffer;
-class MidiPlaylist : public ARDOUR::Playlist
+class LIBARDOUR_API MidiPlaylist : public ARDOUR::Playlist
{
public:
MidiPlaylist (Session&, const XMLNode&, bool hidden = false);
class MidiPlaylist;
-class MidiPlaylistSource : public MidiSource, public PlaylistSource {
+class LIBARDOUR_API MidiPlaylistSource : public MidiSource, public PlaylistSource {
public:
virtual ~MidiPlaylistSource ();
class MidiEngine;
-class MidiPort : public Port {
+class LIBARDOUR_API MidiPort : public Port {
public:
~MidiPort();
class MidiModel;
class MidiSource;
class MidiStateTracker;
+
template<typename T> class MidiRingBuffer;
-class MidiRegion : public Region
+class LIBARDOUR_API MidiRegion : public Region
{
public:
static void make_property_quarks ();
#include "evoral/EventRingBuffer.hpp"
+#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 MidiRingBuffer : public Evoral::EventRingBuffer<T> {
+class LIBARDOUR_API MidiRingBuffer : public Evoral::EventRingBuffer<T> {
public:
/** @param size Size in bytes.
*/
class MidiStateTracker;
class MidiModel;
+
template<typename T> class MidiRingBuffer;
/** Source for MIDI data */
-class MidiSource : virtual public Source, public boost::enable_shared_from_this<MidiSource>
+class LIBARDOUR_API MidiSource : virtual public Source, public boost::enable_shared_from_this<MidiSource>
{
public:
typedef double TimeType;
}
namespace ARDOUR {
+
class MidiSource;
/** Tracks played notes, so they can be resolved in potential stuck note
* situations (e.g. looping, transport stop, etc).
*/
-class MidiStateTracker
+class LIBARDOUR_API MidiStateTracker
{
public:
MidiStateTracker();
namespace ARDOUR {
-class MidiStretch : public Filter {
+class LIBARDOUR_API MidiStretch : public Filter {
public:
MidiStretch (ARDOUR::Session&, const TimeFXRequest&);
~MidiStretch ();
class SMFSource;
class Session;
-class MidiTrack : public Track
+class LIBARDOUR_API MidiTrack : public Track
{
public:
MidiTrack (Session&, string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal);
certain types of requests to the MIDI UI
*/
-struct MidiUIRequest : public BaseUI::BaseRequestObject {
+struct LIBARDOUR_API MidiUIRequest : public BaseUI::BaseRequestObject {
public:
MidiUIRequest () { }
~MidiUIRequest() { }
};
-class MidiControlUI : public AbstractUI<MidiUIRequest>
+class LIBARDOUR_API MidiControlUI : public AbstractUI<MidiUIRequest>
{
public:
MidiControlUI (Session& s);
#include "midi++/types.h"
#include "midi++/port.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
class MidiPort;
class Port;
-class MidiPortManager {
+class LIBARDOUR_API MidiPortManager {
public:
MidiPortManager();
virtual ~MidiPortManager ();
#ifndef __ardour_mix_h__
#define __ardour_mix_h__
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/utils.h"
#include "pbd/compose.h"
#include "pbd/controllable.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/processor.h"
class Session;
template<typename T>
-class MPControl : public PBD::Controllable {
+class LIBARDOUR_API MPControl : public PBD::Controllable {
public:
MPControl (T initial, const std::string& name, PBD::Controllable::Flag flag,
float lower = 0.0f, float upper = 1.0f)
T _upper;
};
-class MonitorProcessor : public Processor
+class LIBARDOUR_API MonitorProcessor : public Processor
{
public:
MonitorProcessor (Session&);
namespace ARDOUR {
-class Movable {
+class LIBARDOUR_API Movable {
public:
Movable() {}
#include <stddef.h>
-class MTDM
+#include "ardour/libardour_visibility.h"
+
+class LIBARDOUR_API MTDM
{
public:
class Session;
-class MuteMaster : public SessionHandleRef, public PBD::Stateful
+class LIBARDOUR_API MuteMaster : public SessionHandleRef, public PBD::Stateful
{
public:
/** deliveries to mute when the channel is "muted" */
class AudioSource;
class Session;
-class OnsetDetector : public AudioAnalyser
+class LIBARDOUR_API OnsetDetector : public AudioAnalyser
{
public:
OnsetDetector (float sample_rate);
class Session;
class Pannable;
-class PanControllable : public AutomationControl
+class LIBARDOUR_API PanControllable : public AutomationControl
{
public:
PanControllable (Session& s, std::string name, Pannable* o, Evoral::Parameter param)
class AutomationControl;
class Panner;
-class Pannable : public PBD::Stateful, public Automatable, public SessionHandleRef
+class LIBARDOUR_API Pannable : public PBD::Stateful, public Automatable, public SessionHandleRef
{
public:
Pannable (Session& s);
#include "pbd/signals.h"
#include "pbd/stateful.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/automation_control.h"
#include "ardour/automatable.h"
class AudioBuffer;
class Speakers;
-class Panner : public PBD::Stateful, public PBD::ScopedConnectionList
+class LIBARDOUR_API Panner : public PBD::Stateful, public PBD::ScopedConnectionList
{
public:
Panner (boost::shared_ptr<Pannable>);
} // namespace
extern "C" {
-struct PanPluginDescriptor {
+struct LIBARDOUR_API PanPluginDescriptor {
std::string name;
int32_t in;
int32_t out;
namespace ARDOUR {
-struct PannerInfo {
+struct LIBARDOUR_API PannerInfo {
PanPluginDescriptor descriptor;
void* module;
}
};
-class PannerManager : public ARDOUR::SessionHandlePtr
+class LIBARDOUR_API PannerManager : public ARDOUR::SessionHandlePtr
{
public:
~PannerManager ();
#include "pbd/cartesian.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/session_object.h"
/** Class to manage panning by instantiating and controlling
* an appropriate Panner object for a given in/out configuration.
*/
-class PannerShell : public SessionObject
+class LIBARDOUR_API PannerShell : public SessionObject
{
public:
PannerShell (std::string name, Session&, boost::shared_ptr<Pannable>);
#define __ardour_peak_h__
#include <cmath>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/utils.h"
#ifndef __libardour_pi_controller__
#define __libardour_pi_controller__
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
-class PIController {
+class LIBARDOUR_API PIController {
public:
PIController (double resample_factor, int fir_size);
~PIController();
#define ESTIMATOR_SIZE 16
-class PIChaser {
+class LIBARDOUR_API PIChaser {
public:
PIChaser();
~PIChaser();
namespace ARDOUR {
-class Pitch : public RBEffect {
+class LIBARDOUR_API Pitch : public RBEffect {
public:
Pitch (ARDOUR::Session&, TimeFXRequest&);
~Pitch () {}
namespace ARDOUR {
-class Pitch : public Filter {
+class LIBARDOUR_API Pitch : public Filter {
public:
Pitch (ARDOUR::Session&, TimeFXRequest&);
~Pitch () {}
extern PBD::PropertyDescriptor<bool> regions;
}
-class RegionListProperty : public PBD::SequenceProperty<std::list<boost::shared_ptr<Region> > >
+class LIBARDOUR_API RegionListProperty : public PBD::SequenceProperty<std::list<boost::shared_ptr<Region> > >
{
public:
RegionListProperty (Playlist&);
Playlist& _playlist;
};
-class Playlist : public SessionObject , public boost::enable_shared_from_this<Playlist>
+class
LIBARDOUR_API Playlist : public SessionObject , public boost::enable_shared_from_this<Playlist>
{
public:
static void make_property_quarks ();
class Session;
-class PlaylistFactory {
+class LIBARDOUR_API PlaylistFactory {
public:
static PBD::Signal2<void,boost::shared_ptr<Playlist>, bool> PlaylistCreated;
class Playlist;
-class PlaylistSource : virtual public Source {
+class LIBARDOUR_API PlaylistSource : virtual public Source {
public:
virtual ~PlaylistSource ();
#include "ardour/cycles.h"
#include "ardour/latent.h"
#include "ardour/plugin_insert.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/midi_state_tracker.h"
typedef boost::shared_ptr<Plugin> PluginPtr;
-class PluginInfo {
+class LIBARDOUR_API PluginInfo {
public:
PluginInfo () { }
virtual ~PluginInfo () { }
typedef boost::shared_ptr<PluginInfo> PluginInfoPtr;
typedef std::list<PluginInfoPtr> PluginInfoList;
-class Plugin : public PBD::StatefulDestructible, public Latent
+class LIBARDOUR_API Plugin : public PBD::StatefulDestructible, public Latent
{
public:
Plugin (ARDOUR::AudioEngine&, ARDOUR::Session&);
#include <boost/weak_ptr.hpp>
#include "ardour/ardour.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/processor.h"
#include "ardour/automation_control.h"
/** Plugin inserts: send data through a plugin
*/
-class PluginInsert : public Processor
+class LIBARDOUR_API PluginInsert : public Processor
{
public:
PluginInsert (Session&, boost::shared_ptr<Plugin> = boost::shared_ptr<Plugin>());
#include <set>
#include <boost/utility.hpp>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/plugin.h"
class Plugin;
-class PluginManager : public boost::noncopyable {
+class LIBARDOUR_API PluginManager : public boost::noncopyable {
public:
static PluginManager& instance();
#include "ardour/data_type.h"
#include "ardour/port_engine.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
class AudioEngine;
class Buffer;
-class Port : public boost::noncopyable
+class LIBARDOUR_API Port : public boost::noncopyable
{
public:
virtual ~Port ();
#include <stdint.h>
#include "ardour/data_type.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
* documentation, on which this entire object is based.
*/
-class PortEngine {
+class LIBARDOUR_API PortEngine {
public:
PortEngine (PortManager& pm) : manager (pm) {}
virtual ~PortEngine() {}
#include "ardour/ardour.h"
#include "ardour/io_processor.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
class XMLNode;
/** Port inserts: send output to a Jack port, pick up input at a Jack port
*/
-class PortInsert : public IOProcessor
+class LIBARDOUR_API PortInsert : public IOProcessor
{
public:
PortInsert (Session&, boost::shared_ptr<Pannable>, boost::shared_ptr<MuteMaster> mm);
class PortEngine;
class AudioBackend;
-class PortManager
+class LIBARDOUR_API PortManager
{
public:
typedef std::map<std::string,boost::shared_ptr<Port> > Ports;
* and once in a vector of all port (_all_ports). This is to speed up the
* fairly common case of iterating over all ports.
*/
-class PortSet : public boost::noncopyable {
+class LIBARDOUR_API PortSet : public boost::noncopyable {
public:
PortSet();
#include <glibmm/threads.h>
#include "ardour/chan_count.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
class ThreadBuffers;
class BufferSet;
-class ProcessThread
+class LIBARDOUR_API ProcessThread
{
public:
ProcessThread ();
#include "ardour/buffer_set.h"
#include "ardour/latent.h"
#include "ardour/session_object.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/automatable.h"
class Route;
/** A mixer strip element - plugin, send, meter, etc */
-class Processor : public SessionObject, public Automatable, public Latent
+class LIBARDOUR_API Processor : public SessionObject, public Automatable, public Latent
{
public:
static const std::string state_node_name;
#include <boost/dynamic_bitset.hpp>
#include <stdint.h>
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
-class RuntimeProfile {
+class LIBARDOUR_API RuntimeProfile {
public:
enum Element {
SmallScreen,
#include <list>
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
/** A class to handle reporting of progress of something */
-class Progress
+class LIBARDOUR_API Progress
{
public:
Progress ();
so that it can be used like a regular Controllable, bound to MIDI, OSC etc.
*/
-class ProxyControllable : public PBD::Controllable {
+class LIBARDOUR_API ProxyControllable : public PBD::Controllable {
public:
ProxyControllable (const std::string& name, PBD::Controllable::Flag flags,
boost::function1<bool,double> setter,
class Location;
/** Public interface to a Diskstream */
-class PublicDiskstream
+class LIBARDOUR_API PublicDiskstream
{
public:
virtual ~PublicDiskstream() {}
#ifndef __ardour_quantize_h__
#define __ardour_quantize_h__
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/midi_operator.h"
class Session;
-class Quantize : public MidiOperator {
+class LIBARDOUR_API Quantize : public MidiOperator {
public:
Quantize (ARDOUR::Session&, bool snap_start, bool snap_end,
double start_grid, double end_grid,
class AudioRegion;
-class RBEffect : public Filter {
+class LIBARDOUR_API RBEffect : public Filter {
public:
RBEffect (ARDOUR::Session&, TimeFXRequest&);
~RBEffect ();
#include <map>
#include <string>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/utils.h"
#include "ardour/configuration.h"
namespace ARDOUR {
-class RCConfiguration : public Configuration
+class LIBARDOUR_API RCConfiguration : public Configuration
{
public:
RCConfiguration();
#ifndef __ardour_readable_h__
#define __ardour_readable_h__
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
-class Readable {
+class LIBARDOUR_API Readable {
public:
Readable () {}
virtual ~Readable() {}
class XMLNode;
-
namespace ARDOUR {
namespace Properties {
class ExportSpecification;
class Progress;
-enum RegionEditState {
+enum LIBARDOUR_API RegionEditState {
EditChangesNothing = 0,
EditChangesName = 1,
EditChangesID = 2
};
-class Region
+class LIBARDOUR_API Region
: public SessionObject
, public boost::enable_shared_from_this<Region>
, public Readable
#include "pbd/property_list.h"
#include "pbd/signals.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
class XMLNode;
class Session;
class AudioRegion;
-class RegionFactory {
+class LIBARDOUR_API RegionFactory {
public:
typedef std::map<PBD::ID,boost::shared_ptr<Region> > RegionMap;
namespace ARDOUR {
-struct RegionSortByPosition {
+struct LIBARDOUR_API RegionSortByPosition {
bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
return a->position() < b->position();
}
};
-struct RegionSortByLayer {
+struct LIBARDOUR_API RegionSortByLayer {
bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
return a->layer() < b->layer();
}
#include <samplerate.h>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/importable_source.h"
namespace ARDOUR {
-class ResampledImportableSource : public ImportableSource
+class LIBARDOUR_API ResampledImportableSource : public ImportableSource
{
public:
ResampledImportableSource (boost::shared_ptr<ImportableSource>, framecnt_t rate, SrcQuality);
class PeakMeter;
-class Return : public IOProcessor
+class LIBARDOUR_API Return : public IOProcessor
{
public:
Return (Session&, bool internal = false);
namespace ARDOUR {
-class Reverse : public Filter {
+class LIBARDOUR_API Reverse : public Filter {
public:
Reverse (ARDOUR::Session&);
~Reverse ();
#include "ardour/ardour.h"
#include "ardour/instrument_info.h"
#include "ardour/io.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/mute_master.h"
#include "ardour/route_group_member.h"
class CapturingProcessor;
class InternalSend;
-class Route : public SessionObject, public Automatable, public RouteGroupMember, public GraphNode, public boost::enable_shared_from_this<Route>
+class LIBARDOUR_API Route : public SessionObject, public Automatable, public RouteGroupMember, public GraphNode, public boost::enable_shared_from_this<Route>
{
public:
*
* This may be a premature optimisation...
*/
-class GraphEdges
+class LIBARDOUR_API GraphEdges
{
public:
typedef std::map<GraphVertex, std::set<GraphVertex> > EdgeMap;
#include "pbd/stateful.h"
#include "pbd/signals.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/session_object.h"
class AudioTrack;
class Session;
-class RouteGroup : public SessionObject
+class LIBARDOUR_API RouteGroup : public SessionObject
{
public:
static void make_property_quarks();
class RouteGroup;
-class RouteGroupMember
+class LIBARDOUR_API RouteGroupMember
{
public:
RouteGroupMember () : _route_group (0) {}
#ifndef __ardour_runtime_functions_h__
#define __ardour_runtime_functions_h__
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
class PeakMeter;
class Amp;
-class Send : public Delivery
+class LIBARDOUR_API Send : public Delivery
{
public:
Send (Session&, boost::shared_ptr<Pannable> pannable, boost::shared_ptr<MuteMaster>, Delivery::Role r = Delivery::Send);
extern void setup_enum_writer ();
-class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager
+class LIBARDOUR_API LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager
{
public:
enum RecordState {
namespace ARDOUR {
-class SessionConfiguration : public Configuration
+class LIBARDOUR_API SessionConfiguration : public Configuration
{
public:
SessionConfiguration ();
#include <string>
#include <vector>
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
-class SessionDirectory
+class LIBARDOUR_API SessionDirectory
{
public:
#include "pbd/ringbuffer.h"
#include "pbd/event_loop.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
class Slave;
class Region;
-class SessionEvent {
+class LIBARDOUR_API SessionEvent {
public:
enum Type {
SetTransportSpeed,
friend class Butler;
};
-class SessionEventManager {
+class LIBARDOUR_API SessionEventManager {
public:
SessionEventManager () : pending_events (2048),
auto_loop_event(0), punch_out_event(0), punch_in_event(0) {}
#include "pbd/signals.h"
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
class Session;
-class SessionHandleRef : public PBD::ScopedConnectionList
+class LIBARDOUR_API SessionHandleRef : public PBD::ScopedConnectionList
{
public:
SessionHandleRef (ARDOUR::Session& s);
virtual void insanity_check ();
};
-class SessionHandlePtr
+class LIBARDOUR_API SessionHandlePtr
{
public:
SessionHandlePtr (ARDOUR::Session* s);
#include "pbd/statefuldestructible.h"
#include "pbd/xml++.h"
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
/** Represents metadata associated to a Session
* Metadata can be accessed and edited via this class.
* Exported files can also be tagged with this data.
*/
-class SessionMetadata : public PBD::StatefulDestructible
+class LIBARDOUR_API SessionMetadata : public PBD::StatefulDestructible
{
public:
//singleton instance:
expected to be destroyed before the session calls drop_references().
*/
-class SessionObject : public SessionHandleRef, public PBD::StatefulDestructible
+class LIBARDOUR_API SessionObject : public SessionHandleRef, public PBD::StatefulDestructible
{
public:
static void make_property_quarks ();
class Crossfade;
class Track;
-class SessionPlaylists : public PBD::ScopedConnectionList
+class LIBARDOUR_API SessionPlaylists : public PBD::ScopedConnectionList
{
public:
~SessionPlaylists ();
namespace ARDOUR {
-class SilentFileSource : public AudioFileSource {
+class LIBARDOUR_API SilentFileSource : public AudioFileSource {
public:
int update_header (framepos_t /*when*/, struct tm&, time_t) { return 0; }
int flush_header () { return 0; }
#include "timecode/time.h"
#include "ltc/ltc.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "midi++/parser.h"
#include "midi++/types.h"
* Therefore it is rather that class, that makes ARDOUR a slave by connecting it
* to its external time master.
*/
-class Slave {
+class LIBARDOUR_API Slave {
public:
Slave() { }
virtual ~Slave() {}
};
/// We need this wrapper for testability, it's just too hard to mock up a session class
-class ISlaveSessionProxy {
+class LIBARDOUR_API ISlaveSessionProxy {
public:
virtual ~ISlaveSessionProxy() {}
virtual TempoMap& tempo_map() const { return *((TempoMap *) 0); }
/// The Session Proxy for use in real Ardour
-class SlaveSessionProxy : public ISlaveSessionProxy {
+class LIBARDOUR_API SlaveSessionProxy : public ISlaveSessionProxy {
Session& session;
public:
void request_transport_speed (double speed);
};
-struct SafeTime {
+struct LIBARDOUR_API SafeTime {
volatile int guard1;
framepos_t position;
framepos_t timestamp;
}
};
-class TimecodeSlave : public Slave {
+class LIBARDOUR_API TimecodeSlave : public Slave {
public:
TimecodeSlave () {}
bool timecode_negative_offset;
};
-class MTC_Slave : public TimecodeSlave {
+class LIBARDOUR_API MTC_Slave : public TimecodeSlave {
public:
MTC_Slave (Session&, MidiPort&);
~MTC_Slave ();
void parameter_changed(std::string const & p);
};
-class LTC_Slave : public TimecodeSlave {
+class LIBARDOUR_API LTC_Slave : public TimecodeSlave {
public:
LTC_Slave (Session&);
~LTC_Slave ();
double b, c; ///< DLL filter coefficients
};
-class MIDIClock_Slave : public Slave {
+class LIBARDOUR_API MIDIClock_Slave : public Slave {
public:
MIDIClock_Slave (Session&, MidiPort&, int ppqn = 24);
bool _starting;
};
-class Engine_Slave : public Slave
+class LIBARDOUR_API Engine_Slave : public Slave
{
public:
Engine_Slave (AudioEngine&);
template<typename T> class MidiRingBuffer;
/** Standard Midi File (Type 0) Source */
-class SMFSource : public MidiSource, public FileSource, public Evoral::SMF {
+class LIBARDOUR_API SMFSource : public MidiSource, public FileSource, public Evoral::SMF {
public:
/** Constructor for existing external-to-session files */
SMFSource (Session& session, const std::string& path,
#include <boost/shared_ptr.hpp>
#include <sndfile.h>
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/importable_source.h"
namespace ARDOUR {
-class SndFileImportableSource : public ImportableSource {
+class LIBARDOUR_API SndFileImportableSource : public ImportableSource {
public:
SndFileImportableSource (const std::string& path);
virtual ~SndFileImportableSource();
namespace ARDOUR {
-class SndFileSource : public AudioFileSource {
+class LIBARDOUR_API SndFileSource : public AudioFileSource {
public:
/** Constructor to be called for existing external-to-session files */
SndFileSource (Session&, const std::string& path, int chn, Flag flags);
typedef gint16 peak_datum;
-struct peak_data_t {
+struct LIBARDOUR_API peak_data_t {
peak_datum min;
peak_datum max;
};
const uint32_t frames_per_peak = 2048;
-class Sound : public EDL::Piece {
+class LIBARDOUR_API Sound : public EDL::Piece {
public:
int peak (peak_data_t& pk, uint32_t start, uint32_t cnt);
int read_peaks (peak_data_t *, uint32_t npeaks, uint32_t start, uint32_t cnt);
int build_peak (uint32_t first_frame, uint32_t cnt);
};
-class SoundPlaylist : public EDL::Playlist {
+class LIBARDOUR_API SoundPlaylist : public EDL::Playlist {
public:
int read_peaks (peak_data_t *, uint32_t npeaks, uint32_t start, uint32_t cnt);
};
class Session;
-class Source : public SessionObject
+class LIBARDOUR_API Source : public SessionObject
{
public:
enum Flag {
class AudioSource;
class Playlist;
-class SourceFactory {
+class LIBARDOUR_API SourceFactory {
public:
static void init ();
#include "pbd/cartesian.h"
#include "pbd/signals.h"
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
-class Speaker {
+class LIBARDOUR_API Speaker {
public:
Speaker (int, const PBD::AngularVector& position);
Speaker (const Speaker &);
namespace ARDOUR {
-class Speakers : public PBD::Stateful {
+class LIBARDOUR_API Speakers : public PBD::Stateful {
public:
Speakers ();
Speakers (const Speakers&);
typedef struct _spline Spline;
typedef struct _spline_point SplinePoint;
-struct _spline_point
+struct LIBARDOUR_API _spline_point
{
float x;
float y;
float spline_get_max_x (Spline *);
float spline_get_min_x (Spline *);
-struct _spline
+struct LIBARDOUR_API _spline
{
float *deriv2;
float *x;
namespace ARDOUR {
-class RBStretch : public RBEffect {
+class LIBARDOUR_API RBStretch : public RBEffect {
public:
RBStretch (ARDOUR::Session&, TimeFXRequest&);
~RBStretch() {}
namespace ARDOUR {
-class STStretch : public Filter {
+class LIBARDOUR_API STStretch : public Filter {
public:
STStretch (ARDOUR::Session&, TimeFXRequest&);
~STStretch ();
namespace ARDOUR {
/// A filter to strip silence from regions
-class StripSilence : public Filter
+class LIBARDOUR_API StripSilence : public Filter
{
public:
StripSilence (Session &, const AudioIntervalMap&, framecnt_t fade_length);
#include <regex.h>
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
-class TapeFileMatcher
+class LIBARDOUR_API TapeFileMatcher
{
public:
class TempoMap;
/** Tempo, the speed at which musical time progresses (BPM). */
-class Tempo {
+class LIBARDOUR_API Tempo {
public:
Tempo (double bpm, double type=4.0) // defaulting to quarter note
: _beats_per_minute (bpm), _note_type(type) {}
};
/** Meter, or time signature (beats per bar, and which note type is a beat). */
-class Meter {
+class LIBARDOUR_API Meter {
public:
Meter (double dpb, double bt)
: _divisions_per_bar (dpb), _note_type (bt) {}
};
/** A section of timeline with a certain Tempo or Meter. */
-class MetricSection {
+class LIBARDOUR_API MetricSection {
public:
MetricSection (const Timecode::BBT_Time& start)
: _start (start), _frame (0), _movable (true) {}
};
/** A section of timeline with a certain Meter. */
-class MeterSection : public MetricSection, public Meter {
+class LIBARDOUR_API MeterSection : public MetricSection, public Meter {
public:
MeterSection (const Timecode::BBT_Time& start, double bpb, double note_type)
: MetricSection (start), Meter (bpb, note_type) {}
};
/** A section of timeline with a certain Tempo. */
-class TempoSection : public MetricSection, public Tempo {
+class LIBARDOUR_API TempoSection : public MetricSection, public Tempo {
public:
TempoSection (const Timecode::BBT_Time& start, double qpm, double note_type)
: MetricSection (start), Tempo (qpm, note_type), _bar_offset (-1.0) {}
/** Helper class to keep track of the Meter *AND* Tempo in effect
at a given point in time.
*/
-class TempoMetric {
+class LIBARDOUR_API TempoMetric {
public:
TempoMetric (const Meter& m, const Tempo& t)
: _meter (&m), _tempo (&t), _frame (0) {}
Timecode::BBT_Time _start;
};
-class TempoMap : public PBD::StatefulDestructible
+class LIBARDOUR_API TempoMap : public PBD::StatefulDestructible
{
public:
TempoMap (framecnt_t frame_rate);
class Session;
-class TempoMapImportHandler : public ElementImportHandler
+class LIBARDOUR_API TempoMapImportHandler : public ElementImportHandler
{
public:
TempoMapImportHandler (XMLTree const & source, Session & session);
std::string get_info () const;
};
-class TempoMapImporter : public ElementImporter
+class LIBARDOUR_API TempoMapImporter : public ElementImporter
{
private:
typedef boost::shared_ptr<XMLNode> XMLNodePtr;
#include <glibmm/threads.h>
#include "ardour/chan_count.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
namespace ARDOUR {
class BufferSet;
-class ThreadBuffers {
+class LIBARDOUR_API ThreadBuffers {
public:
ThreadBuffers ();
~ThreadBuffers ();
#include "pbd/signals.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/session_handle.h"
class Session;
class MidiPort;
-class MidiClockTicker : public SessionHandlePtr, boost::noncopyable
+class LIBARDOUR_API MidiClockTicker : public SessionHandlePtr, boost::noncopyable
{
public:
MidiClockTicker ();
class Diskstream;
class IO;
-class Track : public Route, public PublicDiskstream
+class LIBARDOUR_API Track : public Route, public PublicDiskstream
{
public:
Track (Session&, std::string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal, DataType default_type = DataType::AUDIO);
class Readable;
class Session;
-class TransientDetector : public AudioAnalyser
+class LIBARDOUR_API TransientDetector : public AudioAnalyser
{
public:
TransientDetector (float sample_rate);
namespace ARDOUR {
-class Trimmable {
+class LIBARDOUR_API Trimmable {
public:
Trimmable() {}
virtual ~Trimmable() {}
* session on a machine without a particular plugin will not corrupt
* the session.
*/
-class UnknownProcessor : public Processor
+class LIBARDOUR_API UnknownProcessor : public Processor
{
public:
UnknownProcessor (Session &, XMLNode const &);
#include "lv2/lv2plug.in/ns/ext/uri-map/uri-map.h"
#include "lv2/lv2plug.in/ns/ext/urid/urid.h"
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
/** Implementation of the LV2 uri-map and urid extensions.
* This just uses a pair of std::map and is not so great in the space overhead
* department, but it's fast enough and not really performance critical anyway.
*/
-class URIMap : public boost::noncopyable {
+class LIBARDOUR_API URIMap : public boost::noncopyable {
public:
URIMap();
class Session;
-class UserBundle : public Bundle, public PBD::Stateful {
+class LIBARDOUR_API UserBundle : public Bundle, public PBD::Stateful {
public:
UserBundle (std::string const &);
#include <CoreFoundation/CoreFoundation.h>
#endif /* __APPLE__ */
+#include "ardour/libardour_visibility.h"
#include "ardour/ardour.h"
#include "ardour/data_type.h"
#include "ardour/dB.h"
class XMLNode;
-std::string legalize_for_path (const std::string& str);
-std::string legalize_for_universal_path (const std::string& str);
-std::string legalize_for_uri (const std::string& str);
-std::string legalize_for_path_2X (const std::string& str);
-XMLNode* find_named_node (const XMLNode& node, std::string name);
-std::string bool_as_string (bool);
+LIBARDOUR_API std::string legalize_for_path (const std::string& str);
+LIBARDOUR_API std::string legalize_for_universal_path (const std::string& str);
+LIBARDOUR_API std::string legalize_for_uri (const std::string& str);
+LIBARDOUR_API std::string legalize_for_path_2X (const std::string& str);
+LIBARDOUR_API XMLNode* find_named_node (const XMLNode& node, std::string name);
+LIBARDOUR_API std::string bool_as_string (bool);
static inline float f_max(float x, float a) {
x -= a;
return (x);
}
-std::string bump_name_once(const std::string& s, char delimiter);
+LIBARDOUR_API std::string bump_name_once(const std::string& s, char delimiter);
-int cmp_nocase (const std::string& s, const std::string& s2);
+LIBARDOUR_API int cmp_nocase (const std::string& s, const std::string& s2);
-int touch_file(std::string path);
+LIBARDOUR_API int touch_file(std::string path);
-std::string region_name_from_path (std::string path, bool strip_channels, bool add_channel_suffix = false, uint32_t total = 0, uint32_t this_one = 0);
-bool path_is_paired (std::string path, std::string& pair_base);
+LIBARDOUR_API std::string region_name_from_path (std::string path, bool strip_channels, bool add_channel_suffix = false, uint32_t total = 0, uint32_t this_one = 0);
+LIBARDOUR_API bool path_is_paired (std::string path, std::string& pair_base);
-void compute_equal_power_fades (ARDOUR::framecnt_t nframes, float* in, float* out);
+LIBARDOUR_API void compute_equal_power_fades (ARDOUR::framecnt_t nframes, float* in, float* out);
-const char* sync_source_to_string (ARDOUR::SyncSource src, bool sh = false);
-ARDOUR::SyncSource string_to_sync_source (std::string str);
+LIBARDOUR_API const char* sync_source_to_string (ARDOUR::SyncSource src, bool sh = false);
+LIBARDOUR_API ARDOUR::SyncSource string_to_sync_source (std::string str);
-const char* edit_mode_to_string (ARDOUR::EditMode);
-ARDOUR::EditMode string_to_edit_mode (std::string);
+LIBARDOUR_API const char* edit_mode_to_string (ARDOUR::EditMode);
+LIBARDOUR_API ARDOUR::EditMode string_to_edit_mode (std::string);
#undef OLD_GAIN_MATH
#define OLD_GAIN_MATH
}
#undef OLD_GAIN_MATH
-double gain_to_slider_position_with_max (double g, double max_gain = 2.0);
-double slider_position_to_gain_with_max (double g, double max_gain = 2.0);
+LIBARDOUR_API double gain_to_slider_position_with_max (double g, double max_gain = 2.0);
+LIBARDOUR_API double slider_position_to_gain_with_max (double g, double max_gain = 2.0);
/* I don't really like hard-coding these falloff rates here
* Probably should use a map of some kind that could be configured
#define METER_FALLOFF_FASTER 46.0f
#define METER_FALLOFF_FASTEST 70.0f
-float meter_falloff_to_float (ARDOUR::MeterFalloff);
-ARDOUR::MeterFalloff meter_falloff_from_float (float);
-float meter_falloff_to_db_per_sec (float);
+LIBARDOUR_API float meter_falloff_to_float (ARDOUR::MeterFalloff);
+LIBARDOUR_API ARDOUR::MeterFalloff meter_falloff_from_float (float);
+LIBARDOUR_API float meter_falloff_to_db_per_sec (float);
-const char* native_header_format_extension (ARDOUR::HeaderFormat, const ARDOUR::DataType& type);
-bool matching_unsuffixed_filename_exists_in (const std::string& dir, const std::string& name);
+LIBARDOUR_API const char* native_header_format_extension (ARDOUR::HeaderFormat, const ARDOUR::DataType& type);
+LIBARDOUR_API bool matching_unsuffixed_filename_exists_in (const std::string& dir, const std::string& name);
-uint32_t how_many_dsp_threads ();
+LIBARDOUR_API uint32_t how_many_dsp_threads ();
#if __APPLE__
-std::string CFStringRefToStdString(CFStringRef stringRef);
+LIBARDOUR_API std::string CFStringRefToStdString(CFStringRef stringRef);
#endif // __APPLE__
#endif /* __ardour_utils_h__ */
#include "ardour/plugin.h"
-struct _AEffect;
+struct LIBARDOUR_API _AEffect;
typedef struct _AEffect AEffect;
-struct _VSTHandle;
+struct LIBARDOUR_API _VSTHandle;
typedef struct _VSTHandle VSTHandle;
-struct _VSTState;
+struct LIBARDOUR_API _VSTState;
typedef struct _VSTState VSTState;
namespace ARDOUR {
/** Parent class for VST plugins of both Windows and Linux varieties */
-class VSTPlugin : public Plugin
+class LIBARDOUR_API VSTPlugin : public Plugin
{
public:
VSTPlugin (AudioEngine &, Session &, VSTHandle *);
#ifndef __ardour_vst_types_h__
#define __ardour_vst_types_h__
+#include "ardour/libardour_visibility.h"
#include "ardour/vestige/aeffectx.h"
-struct _VSTKey
+struct LIBARDOUR_API _VSTKey
{
/** virtual-key code, or 0 if this _VSTFXKey is a `character' key */
int special;
typedef struct _VSTKey VSTKey;
-struct _VSTInfo
+struct LIBARDOUR_API _VSTInfo
{
char *name;
char *creator;
typedef AEffect * (* main_entry_t) (audioMasterCallback);
-struct _VSTHandle
+struct LIBARDOUR_API _VSTHandle
{
void* dll;
char* name;
typedef struct _VSTHandle VSTHandle;
-struct _VSTState
+struct LIBARDOUR_API _VSTState
{
AEffect* plugin;
#ifndef __VUMETERDSP_H
#define __VUMETERDSP_H
+#include "ardour/libardour_visibility.h"
-class Vumeterdsp
+class LIBARDOUR_API Vumeterdsp
{
public:
#include "ardour/vst_plugin.h"
-struct _VSTHandle;
+struct LIBARDOUR_API _VSTHandle;
typedef struct _VSTHandle VSTHandle;
namespace ARDOUR {
class AudioEngine;
class Session;
-class WindowsVSTPlugin : public VSTPlugin
+class LIBARDOUR_API WindowsVSTPlugin : public VSTPlugin
{
public:
WindowsVSTPlugin (AudioEngine &, Session &, VSTHandle *);
std::string state_node_name () const { return "windows-vst"; }
};
-class WindowsVSTPluginInfo : public PluginInfo
+class LIBARDOUR_API WindowsVSTPluginInfo : public PluginInfo
{
public:
WindowsVSTPluginInfo ();
#include "pbd/ringbuffer.h"
#include "pbd/semaphore.h"
+#include "ardour/libardour_visibility.h"
+
namespace ARDOUR {
/**
An object that needs to schedule non-RT work in the audio thread.
*/
-class Workee {
+class LIBARDOUR_API Workee {
public:
virtual ~Workee() {}
/**
A worker thread for non-realtime tasks scheduled in the audio thread.
*/
-class Worker
+class LIBARDOUR_API Worker
{
public:
Worker(Workee* workee, uint32_t ring_size);
#include "pbd/error.h"
#include "ardour/cycle_timer.h"
+#include "ardour/libardour_visibility.h"
+
#include "i18n.h"
using namespace std;
*/
+#include "ardour/libardour_visibility.h"
#include "ardour/element_import_handler.h"
#include <algorithm>
*/
#include <string>
-#include "ardour/export_filename.h"
#include <glibmm/miscutils.h>
#include <glibmm/fileutils.h>
#include "pbd/convert.h"
#include "pbd/enumwriter.h"
+#include "ardour/libardour_visibility.h"
#include "ardour/session.h"
#include "ardour/session_directory.h"
-#include "ardour/export_timespan.h"
+#include "ardour/export_filename.h"
#include "ardour/export_format_specification.h"
#include "ardour/export_channel_configuration.h"
+#include "ardour/export_timespan.h"
#include "ardour/utils.h"
#include "i18n.h"
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
+#include "ardour/libardour_visibility.h"
#include "ardour/route_group_member.h"
using namespace ARDOUR;
#include "pbd/libpbd_visibility.h"
-LIBPBD_API static inline float fast_log2 (float val)
+static inline float fast_log2 (float val)
{
/* don't use reinterpret_cast<> because that prevents this
from being used by pure C code (for example, GnomeCanvasItems)
return (val + log_2);
}
-LIBPBD_API static inline float fast_log (const float val)
+static inline float fast_log (const float val)
{
return (fast_log2 (val) * 0.69314718f);
}
-LIBPBD_API static inline float fast_log10 (const float val)
+static inline float fast_log10 (const float val)
{
return fast_log2(val) / 3.312500f;
}
-LIBPBD_API static inline float minus_infinity(void) { return -HUGE_VAL; }
+static inline float minus_infinity(void) { return -HUGE_VAL; }
#endif /* __pbd_fastlog_h__ */
/* Note: ULPS = Units in the Last Place */
-LIBPBD_API static inline bool floateq (float a, float b, int max_ulps_diff)
+static inline bool floateq (float a, float b, int max_ulps_diff)
{
Float_t ua (a);
Float_t ub (b);
* references to non-existant crossfades. To get around this, CrossfadeBinder
* can do `just-in-time' binding from the crossfade ID.
*/
-template <class obj_T> LIBPBD_API
-class MementoCommandBinder : public PBD::Destructible
+template <class obj_T>
+class LIBPBD_API MementoCommandBinder : public PBD::Destructible
{
public:
/** @return Stateful object to operate on */
};
/** A simple MementoCommandBinder which binds directly to an object */
-template <class obj_T> LIBPBD_API
-class SimpleMementoCommandBinder : public MementoCommandBinder<obj_T>
+template <class obj_T>
+class LIBPBD_API SimpleMementoCommandBinder : public MementoCommandBinder<obj_T>
{
public:
SimpleMementoCommandBinder (obj_T& o)
* (from Stateful::get_state()), so undo becomes restoring the before
* memento, and redo is restoring the after memento.
*/
-template <class obj_T> LIBPBD_API
-class MementoCommand : public Command
+template <class obj_T>
+class LIBPBD_API MementoCommand : public Command
{
public:
MementoCommand (obj_T& a_object, XMLNode* a_before, XMLNode* a_after)
namespace PBD
{
-class LIBPBD_API StatefulDestructible;
-class LIBPBD_API PropertyList;
+class StatefulDestructible;
+class PropertyList;
/** A Command which stores its action as the differences between the before and after
* state of a Stateful object.
projects / ardour.git / commitdiff