smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2026-01-25 22:57:37 +01:00
Code Issues Projects Releases Wiki Activity

Merge branch 'cairocanvas' of git.ardour.org:ardour/ardour into cairocanvas

Browse source
This commit is contained in:
Carl Hetherington 2014-04-29 12:42:49 +01:00
commit 152935e736
67 changed files with 2689 additions and 78 deletions
Download patch file Download diff file Expand all files Collapse all files

2
export/wscript
View file

@ -11,7 +11,7 @@ def configure(conf):
def build(bld):
presets = bld.path.ant_glob ('*.preset')
formats = bld.path.ant_glob ('*.format')
bld.install_files (os.path.join(bld.env['DATADIR'], 'ardour3', 'export'),
bld.install_files (os.path.join(bld.env['DATADIR'], 'export'),
presets + formats)
def options(opt):

2
gtk2_ardour/ardev_common.sh.in
View file

@ -17,7 +17,7 @@ export ARDOUR_DATA_PATH=$TOP:$TOP/build:$TOP/gtk2_ardour:$TOP/build/gtk2_ardour:
export ARDOUR_MIDIMAPS_PATH=$TOP/midi_maps:.
export ARDOUR_MCP_PATH=$TOP/mcp:.
export ARDOUR_EXPORT_FORMATS_PATH=$TOP/export:.
export ARDOUR_BACKEND_PATH=$libs/backends/jack:$libs/backends/wavesaudio
export ARDOUR_BACKEND_PATH=$libs/backends/jack:$libs/backends/wavesaudio:$libs/backends/dummy
#
# even though we set the above variables, ardour requires that these

2
gtk2_ardour/ardour.menus.in
View file

@ -288,6 +288,7 @@
<menuitem action='nudge-backward'/>
<menuitem action='nudge-forward-by-capture-offset'/>
<menuitem action='nudge-backward-by-capture-offset'/>
<menuitem action='sequence-regions'/>
</menu>
<menu action='RegionMenuTrim'>
<menuitem action='trim-front'/>
@ -647,6 +648,7 @@
<menuitem action='nudge-backward'/>
<menuitem action='nudge-forward-by-capture-offset'/>
<menuitem action='nudge-backward-by-capture-offset'/>
<menuitem action='sequence-regions'/>
</menu>
<menu action='RegionMenuTrim'>
<menuitem action='trim-front'/>

2
gtk2_ardour/editor.h
View file

@ -319,6 +319,8 @@ class Editor : public PublicEditor, public PBD::ScopedConnectionList, public ARD
void nudge_forward_capture_offset ();
void nudge_backward_capture_offset ();
void sequence_regions ();
/* playhead/screen stuff */
void set_stationary_playhead (bool yn);

2
gtk2_ardour/editor_actions.cc
View file

@ -1897,6 +1897,8 @@ Editor::register_region_actions ()
reg_sens (_region_actions, "nudge-forward", _("Nudge Later"), sigc::bind (sigc::mem_fun (*this, &Editor::nudge_forward), false, false));
reg_sens (_region_actions, "nudge-backward", _("Nudge Earlier"), sigc::bind (sigc::mem_fun (*this, &Editor::nudge_backward), false, false));
reg_sens (_region_actions, "sequence-regions", _("Sequence Regions"), sigc::mem_fun (*this, &Editor::sequence_regions));
reg_sens (
_region_actions,
"nudge-forward-by-capture-offset",

54
gtk2_ardour/editor_ops.cc
View file

@ -512,6 +512,60 @@ Editor::nudge_backward_capture_offset ()
commit_reversible_command ();
}
struct RegionSelectionPositionSorter {
bool operator() (RegionView* a, RegionView* b) {
return a->region()->position() < b->region()->position();
}
};
void
Editor::sequence_regions ()
{
framepos_t r_end;
framepos_t r_end_prev;
int iCount=0;
if (!_session) {
return;
}
RegionSelection rs = get_regions_from_selection_and_entered ();
rs.sort(RegionSelectionPositionSorter());
if (!rs.empty()) {
begin_reversible_command (_("sequence regions"));
for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
boost::shared_ptr<Region> r ((*i)->region());
r->clear_changes();
if(r->locked())
{
continue;
}
if(r->position_locked())
{
continue;
}
if(iCount>0)
{
r_end_prev=r_end;
r->set_position(r_end_prev);
}
_session->add_command (new StatefulDiffCommand (r));
r_end=r->position() + r->length();
iCount++;
}
commit_reversible_command ();
}
}
/* DISPLAY MOTION */
void

2
headless/wscript
View file

@ -57,7 +57,7 @@ def build(bld):
'CONFIG_DIR="' + os.path.normpath(bld.env['SYSCONFDIR']) + '"',
'LOCALEDIR="' + os.path.join(os.path.normpath(bld.env['DATADIR']), 'locale') + '"',
]
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
obj.install_path = bld.env['LIBDIR']
obj.uselib = 'UUID FLAC FONTCONFIG GLIBMM GTHREAD OGG CURL DL'
obj.uselib += ' FFTW3F'
obj.uselib += ' AUDIOUNITS OSX LO '

6
libs/ardour/ardour/async_midi_port.h
View file

@ -22,6 +22,8 @@
#include <string>
#include <iostream>
#include <boost/function.hpp>
#include "pbd/xml++.h"
#include "pbd/crossthread.h"
#include "pbd/signals.h"
@ -64,6 +66,8 @@ class LIBARDOUR_API AsyncMIDIPort : public ARDOUR::MidiPort, public MIDI::Port {
#endif
}
void set_timer (boost::function<framecnt_t (void)>&);
static void set_process_thread (pthread_t);
static pthread_t get_process_thread () { return _process_thread; }
static bool is_process_thread();
@ -71,6 +75,8 @@ class LIBARDOUR_API AsyncMIDIPort : public ARDOUR::MidiPort, public MIDI::Port {
private:
bool _currently_in_cycle;
MIDI::timestamp_t _last_write_timestamp;
bool have_timer;
boost::function<framecnt_t (void)> timer;
RingBuffer< Evoral::Event<double> > output_fifo;
Evoral::EventRingBuffer<MIDI::timestamp_t> input_fifo;
Glib::Threads::Mutex output_fifo_lock;

11
libs/ardour/ardour/location.h
View file

@ -34,10 +34,13 @@
#include "pbd/statefuldestructible.h"
#include "ardour/ardour.h"
#include "ardour/scene_change.h"
#include "ardour/session_handle.h"
namespace ARDOUR {
class SceneChange;
class LIBARDOUR_API Location : public SessionHandleRef, public PBD::StatefulDestructible
{
public:
@ -93,6 +96,9 @@ class LIBARDOUR_API Location : public SessionHandleRef, public PBD::StatefulDest
Flags flags () const { return _flags; }
boost::shared_ptr<SceneChange> scene_change() const { return _scene_change; }
void set_scene_change (boost::shared_ptr<SceneChange>);
PBD::Signal1<void,Location*> name_changed;
PBD::Signal1<void,Location*> end_changed;
PBD::Signal1<void,Location*> start_changed;
@ -116,6 +122,8 @@ class LIBARDOUR_API Location : public SessionHandleRef, public PBD::StatefulDest
void set_position_lock_style (PositionLockStyle ps);
void recompute_frames_from_bbt ();
static PBD::Signal0<void> scene_changed;
private:
std::string _name;
framepos_t _start;
@ -125,6 +133,7 @@ class LIBARDOUR_API Location : public SessionHandleRef, public PBD::StatefulDest
Flags _flags;
bool _locked;
PositionLockStyle _position_lock_style;
boost::shared_ptr<SceneChange> _scene_change;
void set_mark (bool yn);
bool set_flag_internal (bool yn, Flags flag);
@ -161,6 +170,8 @@ class LIBARDOUR_API Locations : public SessionHandleRef, public PBD::StatefulDes
int set_current (Location *, bool want_lock = true);
Location *current () const { return current_location; }
Location* mark_at (framepos_t, framecnt_t slop = 0) const;
framepos_t first_mark_before (framepos_t, bool include_special_ranges = false);
framepos_t first_mark_after (framepos_t, bool include_special_ranges = false);

63
libs/ardour/ardour/midi_scene_change.h Normal file
View file

@ -0,0 +1,63 @@
/*
Copyright (C) 2014 Paul Davis
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 __libardour_midi_scene_change_h__
#define __libardour_midi_scene_change_h__
#include "evoral/PatchChange.hpp"
#include "ardour/scene_change.h"
namespace ARDOUR
{
class MidiPort;
class MIDISceneChange : public SceneChange
{
public:
MIDISceneChange (framepos_t time, int channel, int bank = -1, int program = -1);
MIDISceneChange (const XMLNode&, int version);
~MIDISceneChange ();
void set_channel (int channel);
void set_program (int program);
void set_bank (int bank);
int channel () const { return _channel; }
int program () const { return _program; }
int bank () const { return _bank; }
size_t get_bank_msb_message (uint8_t* buf, size_t size) const;
size_t get_bank_lsb_message (uint8_t* buf, size_t size) const;
size_t get_program_message (uint8_t* buf, size_t size) const;
XMLNode& get_state();
int set_state (const XMLNode&, int version);
private:
int _bank;
int _program;
uint8_t _channel;
};
} /* namespace */
#endif /* __libardour_scene_change_h__ */

72
libs/ardour/ardour/midi_scene_changer.h Normal file
View file

@ -0,0 +1,72 @@
/*
Copyright (C) 2014 Paul Davis
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 __libardour_midi_scene_changer_h__
#define __libardour_midi_scene_changer_h__
#include "ardour/scene_changer.h"
namespace ARDOUR
{
class MIDISceneChanger : public SceneChanger
{
public:
MIDISceneChanger (Session&);
~MIDISceneChanger ();
void run (framepos_t start, framepos_t end);
void set_input_port (MIDI::Port*);
void set_output_port (boost::shared_ptr<MidiPort>);
uint8_t bank_at (framepos_t, uint8_t channel);
uint8_t program_at (framepos_t, uint8_t channel);
void set_recording (bool);
void locate (framepos_t);
private:
typedef std::multimap<framepos_t,boost::shared_ptr<MIDISceneChange> > Scenes;
MIDI::Port* input_port;
boost::shared_ptr<MidiPort> output_port;
Scenes scenes;
bool _recording;
framepos_t last_bank_message_time;
framepos_t last_program_message_time;
unsigned short current_bank;
int last_delivered_program;
int last_delivered_bank;
void gather ();
bool recording () const;
void jump_to (int bank, int program);
void deliver (MidiBuffer&, framepos_t, boost::shared_ptr<MIDISceneChange>);
void bank_change_input (MIDI::Parser&, unsigned short);
void program_change_input (MIDI::Parser&, MIDI::byte);
void locations_changed (Locations::Change);
PBD::ScopedConnection incoming_bank_change_connection;
PBD::ScopedConnection incoming_program_change_connection;
};
} // namespace
#endif /* __libardour_midi_scene_changer_h__ */

12
libs/ardour/ardour/midiport_manager.h
View file

@ -30,6 +30,7 @@
#include "midi++/port.h"
#include "ardour/libardour_visibility.h"
#include "ardour/midi_port.h"
#include "ardour/types.h"
namespace ARDOUR {
@ -56,7 +57,12 @@ class LIBARDOUR_API MidiPortManager {
MIDI::Port* midi_output_port () const { return _midi_output_port; }
MIDI::Port* mmc_input_port () const { return _mmc_input_port; }
MIDI::Port* mmc_output_port () const { return _mmc_output_port; }
MIDI::Port* scene_input_port () const { return _scene_input_port; }
MIDI::Port* scene_output_port () const { return _scene_output_port; }
boost::shared_ptr<MidiPort> scene_in() const { return boost::dynamic_pointer_cast<MidiPort>(_scene_in); }
boost::shared_ptr<MidiPort> scene_out() const { return boost::dynamic_pointer_cast<MidiPort>(_scene_out); }
/* Ports used for synchronization. These have their I/O handled inside the
* process callback.
*/
@ -77,13 +83,17 @@ class LIBARDOUR_API MidiPortManager {
MIDI::Port* _midi_output_port;
MIDI::Port* _mmc_input_port;
MIDI::Port* _mmc_output_port;
/* these point to the same objects as the 4 members above,
MIDI::Port* _scene_input_port;
MIDI::Port* _scene_output_port;
/* these point to the same objects as the members above,
but cast to their ARDOUR::Port base class
*/
boost::shared_ptr<Port> _midi_in;
boost::shared_ptr<Port> _midi_out;
boost::shared_ptr<Port> _mmc_in;
boost::shared_ptr<Port> _mmc_out;
boost::shared_ptr<Port> _scene_in;
boost::shared_ptr<Port> _scene_out;
/* synchronously handled ports: ARDOUR::MidiPort */
boost::shared_ptr<MidiPort> _mtc_input_port;

1
libs/ardour/ardour/rc_configuration_vars.h
View file

@ -44,6 +44,7 @@ CONFIG_VARIABLE (int32_t, mmc_receive_device_id, "mmc-receive-device-id", 0x7f)
CONFIG_VARIABLE (int32_t, mmc_send_device_id, "mmc-send-device-id", 0)
CONFIG_VARIABLE (int32_t, initial_program_change, "initial-program-change", -1)
CONFIG_VARIABLE (bool, first_midi_bank_is_zero, "display-first-midi-bank-as-zero", false)
CONFIG_VARIABLE (int32_t, inter_scene_gap_msecs, "inter-scene-gap-msecs", 1)
/* Timecode and related */

49
libs/ardour/ardour/scene_change.h Normal file
View file

@ -0,0 +1,49 @@
/*
Copyright (C) 2014 Paul Davis
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 __libardour_scene_change_h__
#define __libardour_scene_change_h__
#include "pbd/stateful.h"
#include "ardour/types.h"
namespace ARDOUR
{
class SceneChange : public PBD::Stateful
{
public:
SceneChange (framepos_t t) : _time (t) {};
virtual ~SceneChange () {};
void set_time (framepos_t);
framepos_t time() const { return _time; }
static boost::shared_ptr<SceneChange> factory (const XMLNode&, int version);
static std::string xml_node_name;
private:
framepos_t _time;
};
} /* namespace */
#endif /* __libardour_scene_change_h__ */

56
libs/ardour/ardour/scene_changer.h Normal file
View file

@ -0,0 +1,56 @@
/*
Copyright (C) 2014 Paul Davis
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 __libardour_scene_changer_h__
#define __libardour_scene_changer_h__
#include <map>
#include "pbd/signals.h"
#include "ardour/location.h"
#include "ardour/midi_scene_change.h"
#include "ardour/session_handle.h"
#include "ardour/types.h"
namespace MIDI
{
class Parser;
class Port;
}
namespace ARDOUR
{
class Session;
class AsyncMidiPort;
class SceneChanger : public SessionHandleRef
{
public:
SceneChanger (Session& s) : SessionHandleRef (s) {}
virtual ~SceneChanger () {};
virtual void run (framepos_t start, framepos_t end) = 0;
};
} /* namespace */
#endif /* __libardour_scene_change_h__ */

50
libs/ardour/ardour/session.h
View file

@ -129,6 +129,7 @@ class Route;
class RouteGroup;
class SMFSource;
class Send;
class SceneChanger;
class SessionDirectory;
class SessionMetadata;
class SessionPlaylists;
@ -868,23 +869,31 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
*/
static PBD::Signal2<void,std::string,std::string> VersionMismatch;
SceneChanger* scene_changer() const { return _scene_changer; }
boost::shared_ptr<Port> ltc_input_port() const;
boost::shared_ptr<Port> ltc_output_port() const;
boost::shared_ptr<IO> ltc_input_io() { return _ltc_input; }
boost::shared_ptr<IO> ltc_output_io() { return _ltc_output; }
MIDI::Port* midi_input_port () const;
MIDI::Port* midi_output_port () const;
MIDI::Port* mmc_output_port () const;
MIDI::Port* mmc_input_port () const;
MIDI::Port* midi_input_port () const;
MIDI::Port* midi_output_port () const;
MIDI::Port* mmc_output_port () const;
MIDI::Port* mmc_input_port () const;
boost::shared_ptr<MidiPort> midi_clock_output_port () const;
boost::shared_ptr<MidiPort> midi_clock_input_port () const;
boost::shared_ptr<MidiPort> mtc_output_port () const;
boost::shared_ptr<MidiPort> mtc_input_port () const;
MIDI::Port* scene_input_port () const;
MIDI::Port* scene_output_port () const;
MIDI::MachineControl& mmc() { return *_mmc; }
boost::shared_ptr<MidiPort> scene_in () const;
boost::shared_ptr<MidiPort> scene_out () const;
boost::shared_ptr<MidiPort> midi_clock_output_port () const;
boost::shared_ptr<MidiPort> midi_clock_input_port () const;
boost::shared_ptr<MidiPort> mtc_output_port () const;
boost::shared_ptr<MidiPort> mtc_input_port () const;
MIDI::MachineControl& mmc() { return *_mmc; }
protected:
friend class AudioEngine;
@ -1607,16 +1616,19 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
void reconnect_ltc_input ();
void reconnect_ltc_output ();
/* persistent, non-track related MIDI ports */
MidiPortManager* _midi_ports;
MIDI::MachineControl* _mmc;
void setup_ltc ();
void setup_click ();
void setup_click_state (const XMLNode*);
void setup_bundles ();
static int get_session_info_from_path (XMLTree& state_tree, const std::string& xmlpath);
/* Scene Changing */
SceneChanger* _scene_changer;
/* persistent, non-track related MIDI ports */
MidiPortManager* _midi_ports;
MIDI::MachineControl* _mmc;
void setup_ltc ();
void setup_click ();
void setup_click_state (const XMLNode*);
void setup_bundles ();
static int get_session_info_from_path (XMLTree& state_tree, const std::string& xmlpath);
};
} // namespace ARDOUR

19
libs/ardour/async_midi_port.cc
View file

@ -50,6 +50,7 @@ AsyncMIDIPort::AsyncMIDIPort (string const & name, PortFlags flags)
, MIDI::Port (name, MIDI::Port::Flags (0))
, _currently_in_cycle (false)
, _last_write_timestamp (0)
, have_timer (false)
, output_fifo (512)
, input_fifo (1024)
#ifndef PLATFORM_WINDOWS
@ -62,6 +63,13 @@ AsyncMIDIPort::~AsyncMIDIPort ()
{
}
void
AsyncMIDIPort::set_timer (boost::function<framecnt_t (void)>& f)
{
timer = f;
have_timer = true;
}
void
AsyncMIDIPort::flush_output_fifo (MIDI::pframes_t nframes)
{
@ -113,9 +121,18 @@ AsyncMIDIPort::cycle_start (MIDI::pframes_t nframes)
if (ARDOUR::Port::receives_input()) {
MidiBuffer& mb (get_midi_buffer (nframes));
pframes_t when = AudioEngine::instance()->sample_time_at_cycle_start();
framecnt_t when;
if (have_timer) {
when = timer ();
} else {
when = AudioEngine::instance()->sample_time_at_cycle_start();
}
for (MidiBuffer::iterator b = mb.begin(); b != mb.end(); ++b) {
if (!have_timer) {
when += (*b).time();
}
input_fifo.write (when, (Evoral::EventType) 0, (*b).size(), (*b).buffer());
}

74
libs/ardour/location.cc
View file

@ -30,6 +30,7 @@
#include "pbd/enumwriter.h"
#include "ardour/location.h"
#include "ardour/midi_scene_change.h"
#include "ardour/session.h"
#include "ardour/audiofilesource.h"
#include "ardour/tempo.h"
@ -42,6 +43,8 @@ using namespace std;
using namespace ARDOUR;
using namespace PBD;
PBD::Signal0<void> Location::scene_changed;
Location::Location (Session& s)
: SessionHandleRef (s)
, _start (0)
@ -87,6 +90,8 @@ Location::Location (const Location& other)
assert (_start >= 0);
assert (_end >= 0);
/* scene change is NOT COPIED */
}
Location::Location (Session& s, const XMLNode& node)
@ -134,6 +139,8 @@ Location::operator= (const Location& other)
_bbt_end = other._bbt_end;
_flags = other._flags;
_position_lock_style = other._position_lock_style;
/* XXX need to copy scene change */
/* copy is not locked even if original was */
@ -431,11 +438,15 @@ Location::get_state ()
node->add_property ("locked", (_locked ? "yes" : "no"));
node->add_property ("position-lock-style", enum_2_string (_position_lock_style));
if (_scene_change) {
node->add_child_nocopy (_scene_change->get_state());
}
return *node;
}
int
Location::set_state (const XMLNode& node, int /*version*/)
Location::set_state (const XMLNode& node, int version)
{
const XMLProperty *prop;
@ -521,6 +532,16 @@ Location::set_state (const XMLNode& node, int /*version*/)
_position_lock_style = PositionLockStyle (string_2_enum (prop->value(), _position_lock_style));
}
XMLNode* scene_child = find_named_node (node, SceneChange::xml_node_name);
if (scene_child) {
_scene_change = SceneChange::factory (*scene_child, version);
if (_scene_change) {
_scene_change->set_time (_start);
}
}
recompute_bbt_from_frames ();
changed (this); /* EMIT SIGNAL */
@ -581,6 +602,14 @@ Location::unlock ()
LockChanged (this);
}
void
Location::set_scene_change (boost::shared_ptr<SceneChange> sc)
{
_scene_change = sc;
scene_changed (); /* EMIT SIGNAL */
}
/*---------------------------------------------------------------------- */
Locations::Locations (Session& s)
@ -675,6 +704,7 @@ Locations::clear ()
++tmp;
if (!(*i)->is_session_range()) {
delete *i;
locations.erase (i);
}
@ -700,6 +730,7 @@ Locations::clear_markers ()
++tmp;
if ((*i)->is_mark() && !(*i)->is_session_range()) {
delete *i;
locations.erase (i);
}
@ -723,6 +754,7 @@ Locations::clear_ranges ()
++tmp;
if (!(*i)->is_mark()) {
delete *i;
locations.erase (i);
}
@ -779,6 +811,7 @@ Locations::remove (Location *loc)
for (i = locations.begin(); i != locations.end(); ++i) {
if ((*i) == loc) {
delete *i;
locations.erase (i);
was_removed = true;
if (current_location == loc) {
@ -972,6 +1005,44 @@ Locations::first_mark_before (framepos_t frame, bool include_special_ranges)
return -1;
}
Location*
Locations::mark_at (framepos_t pos, framecnt_t slop) const
{
Glib::Threads::Mutex::Lock lm (lock);
Location* closest = 0;
frameoffset_t mindelta = max_framepos;
frameoffset_t delta;
/* locations are not necessarily stored in linear time order so we have
* to iterate across all of them to find the one closest to a give point.
*/
for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
if ((*i)->is_mark()) {
if (pos > (*i)->start()) {
delta = pos - (*i)->start();
} else {
delta = (*i)->start() - pos;
}
if (slop == 0 && delta == 0) {
/* special case: no slop, and direct hit for position */
return *i;
}
if (delta <= slop) {
if (delta < mindelta) {
closest = *i;
mindelta = delta;
}
}
}
}
return closest;
}
framepos_t
Locations::first_mark_after (framepos_t frame, bool include_special_ranges)
{
@ -1146,3 +1217,4 @@ Locations::find_all_between (framepos_t start, framepos_t end, LocationList& ll,
}
}
}

144
libs/ardour/midi_scene_change.cc Normal file
View file

@ -0,0 +1,144 @@
/*
Copyright (C) 2014 Paul Davis
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.
*/
#include "pbd/error.h"
#include "pbd/compose.h"
#include "ardour/midi_port.h"
#include "ardour/midi_scene_change.h"
#include "i18n.h"
using namespace PBD;
using namespace ARDOUR;
MIDISceneChange::MIDISceneChange (framepos_t time, int c, int b, int p)
: SceneChange (time)
, _bank (b)
, _program (p)
, _channel (c & 0xf)
{
if (_bank > 16384) {
_bank = -1;
}
if (_program > 128) {
_program = -1;
}
}
MIDISceneChange::MIDISceneChange (const XMLNode& node, int version)
: SceneChange (0)
, _bank (-1)
, _program (-1)
, _channel (-1)
{
set_state (node, version);
}
MIDISceneChange::~MIDISceneChange ()
{
}
size_t
MIDISceneChange::get_bank_msb_message (uint8_t* buf, size_t size) const
{
if (size < 3 || _bank < 0) {
return 0;
}
buf[0] = 0xB0 | (_channel & 0xf);
buf[1] = 0x0;
buf[2] = (_bank & 0xf700) >> 8;
return 3;
}
size_t
MIDISceneChange::get_bank_lsb_message (uint8_t* buf, size_t size) const
{
if (size < 3 || _bank < 0) {
return 0;
}
buf[0] = 0xB0 | (_channel & 0xf);
buf[1] = 0x20;
buf[2] = (_bank & 0xf7);
return 3;
}
size_t
MIDISceneChange::get_program_message (uint8_t* buf, size_t size) const
{
if (size < 2 || _program < 0) {
return 0;
}
buf[0] = 0xC0 | (_channel & 0xf);
buf[1] = _program & 0xf7;
return 2;
}
XMLNode&
MIDISceneChange::get_state ()
{
char buf[32];
XMLNode* node = new XMLNode (SceneChange::xml_node_name);
node->add_property (X_("type"), X_("MIDI"));
snprintf (buf, sizeof (buf), "%d", (int) _program);
node->add_property (X_("id"), id().to_s());
snprintf (buf, sizeof (buf), "%d", (int) _program);
node->add_property (X_("program"), buf);
snprintf (buf, sizeof (buf), "%d", (int) _bank);
node->add_property (X_("bank"), buf);
snprintf (buf, sizeof (buf), "%d", (int) _channel);
node->add_property (X_("channel"), buf);
return *node;
}
int
MIDISceneChange::set_state (const XMLNode& node, int /* version-ignored */)
{
if (!set_id (node)) {
return -1;
}
const XMLProperty* prop;
if ((prop = node.property (X_("program"))) == 0) {
return -1;
}
_program = atoi (prop->value());
if ((prop = node.property (X_("bank"))) == 0) {
return -1;
}
_bank = atoi (prop->value());
if ((prop = node.property (X_("channel"))) == 0) {
return -1;
}
_channel = atoi (prop->value());
return 0;
}

279
libs/ardour/midi_scene_changer.cc Normal file
View file

@ -0,0 +1,279 @@
/*
Copyright (C) 2014 Paul Davis
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.
*/
#include "evoral/MIDIEvent.hpp"
#include "midi++/parser.h"
#include "midi++/port.h"
#include "ardour/event_type_map.h"
#include "ardour/midi_port.h"
#include "ardour/midi_scene_change.h"
#include "ardour/midi_scene_changer.h"
#include "ardour/session.h"
#include "i18n.h"
using namespace ARDOUR;
MIDISceneChanger::MIDISceneChanger (Session& s)
: SceneChanger (s)
, _recording (true)
, last_bank_message_time (-1)
, last_program_message_time (-1)
, last_delivered_program (-1)
, last_delivered_bank (-1)
{
_session.locations()->changed.connect_same_thread (*this, boost::bind (&MIDISceneChanger::locations_changed, this, _1));
Location::scene_changed.connect_same_thread (*this, boost::bind (&MIDISceneChanger::gather, this));
}
MIDISceneChanger::~MIDISceneChanger ()
{
}
void
MIDISceneChanger::locations_changed (Locations::Change)
{
gather ();
}
/** Use the session's list of locations to collect all patch changes.
*
* This is called whenever the locations change in anyway.
*/
void
MIDISceneChanger::gather ()
{
const Locations::LocationList& locations (_session.locations()->list());
boost::shared_ptr<SceneChange> sc;
scenes.clear ();
for (Locations::LocationList::const_iterator l = locations.begin(); l != locations.end(); ++l) {
if ((sc = (*l)->scene_change()) != 0) {
boost::shared_ptr<MIDISceneChange> msc = boost::dynamic_pointer_cast<MIDISceneChange> (sc);
if (msc) {
scenes.insert (std::make_pair (msc->time(), msc));
}
}
}
}
void
MIDISceneChanger::deliver (MidiBuffer& mbuf, framepos_t when, boost::shared_ptr<MIDISceneChange> msc)
{
uint8_t buf[4];
size_t cnt;
if ((cnt = msc->get_bank_msb_message (buf, sizeof (buf))) > 0) {
mbuf.push_back (when, cnt, buf);
if ((cnt = msc->get_bank_lsb_message (buf, sizeof (buf))) > 0) {
mbuf.push_back (when, cnt, buf);
}
last_delivered_bank = msc->bank();
}
if ((cnt = msc->get_program_message (buf, sizeof (buf))) > 0) {
mbuf.push_back (when, cnt, buf);
last_delivered_program = msc->program();
}
}
void
MIDISceneChanger::run (framepos_t start, framepos_t end)
{
if (!output_port || recording()) {
return;
}
/* get lower bound of events to consider */
Scenes::const_iterator i = scenes.lower_bound (start);
MidiBuffer& mbuf (output_port->get_midi_buffer (end-start));
while (i != scenes.end()) {
if (i->first >= end) {
break;
}
deliver (mbuf, i->first - start, i->second);
++i;
}
}
void
MIDISceneChanger::locate (framepos_t pos)
{
Scenes::const_iterator i = scenes.upper_bound (pos);
if (i == scenes.end()) {
return;
}
if (i->second->program() != last_delivered_program || i->second->bank() != last_delivered_bank) {
// MidiBuffer& mbuf (output_port->get_midi_buffer (end-start));
// deliver (mbuf, i->first, i->second);
}
}
void
MIDISceneChanger::set_input_port (MIDI::Port* mp)
{
input_port = mp;
incoming_bank_change_connection.disconnect ();
incoming_program_change_connection.disconnect ();
if (input_port) {
/* midi port is asynchronous. MIDI parsing will be carried out
* by the MIDI UI thread which will emit the relevant signals
* and thus invoke our callbacks as necessary.
*/
input_port->parser()->bank_change.connect_same_thread (incoming_bank_change_connection, boost::bind (&MIDISceneChanger::bank_change_input, this, _1, _2));
input_port->parser()->program_change.connect_same_thread (incoming_program_change_connection, boost::bind (&MIDISceneChanger::program_change_input, this, _1, _2));
}
}
void
MIDISceneChanger::set_output_port (boost::shared_ptr<MidiPort> mp)
{
output_port = mp;
}
void
MIDISceneChanger::set_recording (bool yn)
{
_recording = yn;
}
bool
MIDISceneChanger::recording() const
{
return _session.transport_rolling() && _session.get_record_enabled();
}
void
MIDISceneChanger::bank_change_input (MIDI::Parser& parser, unsigned short bank)
{
if (!recording()) {
return;
}
last_bank_message_time = parser.get_timestamp ();
current_bank = bank;
}
void
MIDISceneChanger::program_change_input (MIDI::Parser& parser, MIDI::byte program)
{
framecnt_t time = parser.get_timestamp ();
frameoffset_t delta = time - last_program_message_time;
last_program_message_time = time;
if (!recording()) {
jump_to (current_bank, program);
return;
}
Locations* locations (_session.locations ());
Location* loc;
bool new_mark = false;
framecnt_t slop = (framecnt_t) floor ((Config->get_inter_scene_gap_msecs() / 1000.0) * _session.frame_rate());
/* check for marker at current location */
loc = locations->mark_at (time, slop);
if (!loc) {
/* create a new marker at the desired position */
std::string new_name;
if (!locations->next_available_name (new_name, _("Scene "))) {
std::cerr << "No new marker name available\n";
return;
}
loc = new Location (_session, time, time, new_name, Location::IsMark);
new_mark = true;
}
uint8_t bank;
uint8_t channel = (program & 0xf0) >> 8;
/* if we received a bank change message within the last 2 msec, use the
* current bank value, otherwise lookup the current bank number and use
* that.
*/
if (time - last_bank_message_time < (2 * _session.frame_rate() / 1000.0)) {
bank = current_bank;
} else {
bank = -1;
}
MIDISceneChange* msc =new MIDISceneChange (loc->start(), channel, bank, program & 0x7f);
loc->set_scene_change (boost::shared_ptr<MIDISceneChange> (msc));
/* this will generate a "changed" signal to be emitted by locations,
and we will call ::gather() to update our list of MIDI events.
*/
if (new_mark) {
locations->add (loc);
}
}
void
MIDISceneChanger::jump_to (int bank, int program)
{
const Locations::LocationList& locations (_session.locations()->list());
boost::shared_ptr<SceneChange> sc;
framepos_t where = max_framepos;
for (Locations::LocationList::const_iterator l = locations.begin(); l != locations.end(); ++l) {
if ((sc = (*l)->scene_change()) != 0) {
boost::shared_ptr<MIDISceneChange> msc = boost::dynamic_pointer_cast<MIDISceneChange> (sc);
if (msc->bank() == bank && msc->program() == program && (*l)->start() < where) {
where = (*l)->start();
}
}
}
if (where != max_framepos) {
_session.request_locate (where);
}
}

4
libs/ardour/midi_ui.cc
View file

@ -122,6 +122,10 @@ MidiControlUI::reset_ports ()
if ((p = dynamic_cast<AsyncMIDIPort*> (_session.mmc_input_port()))) {
ports.push_back (p);
}
if ((p = dynamic_cast<AsyncMIDIPort*> (_session.scene_input_port()))) {
ports.push_back (p);
}
if (ports.empty()) {
return;

22
libs/ardour/midiport_manager.cc
View file

@ -40,8 +40,14 @@ MidiPortManager::~MidiPortManager ()
if (_midi_in) {
AudioEngine::instance()->unregister_port (_midi_in);
}
if (_midi_in) {
AudioEngine::instance()->unregister_port (_midi_in);
if (_midi_out) {
AudioEngine::instance()->unregister_port (_midi_out);
}
if (_scene_in) {
AudioEngine::instance()->unregister_port (_scene_in);
}
if (_scene_out) {
AudioEngine::instance()->unregister_port (_scene_out);
}
if (_mtc_input_port) {
AudioEngine::instance()->unregister_port (_mtc_input_port);
@ -73,7 +79,10 @@ MidiPortManager::create_ports ()
_mmc_in = AudioEngine::instance()->register_input_port (DataType::MIDI, X_("MMC in"), true);
_mmc_out = AudioEngine::instance()->register_output_port (DataType::MIDI, X_("MMC out"), true);
_scene_in = AudioEngine::instance()->register_input_port (DataType::MIDI, X_("Scene in"), true);
_scene_out = AudioEngine::instance()->register_output_port (DataType::MIDI, X_("Scene out"), true);
/* XXX nasty type conversion needed because of the mixed inheritance
* required to integrate MIDI::IPMidiPort and ARDOUR::AsyncMIDIPort.
*
@ -88,6 +97,9 @@ MidiPortManager::create_ports ()
_mmc_input_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(_mmc_in).get();
_mmc_output_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(_mmc_out).get();
_scene_input_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(_scene_in).get();
_scene_output_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(_scene_out).get();
/* Now register ports used for sync (MTC and MIDI Clock)
*/
@ -129,6 +141,8 @@ MidiPortManager::set_midi_port_states (const XMLNodeList&nodes)
ports.insert (make_pair (_midi_output_port->name(), _midi_out));
ports.insert (make_pair (_mmc_input_port->name(), _mmc_in));
ports.insert (make_pair (_mmc_output_port->name(), _mmc_out));
ports.insert (make_pair (_scene_output_port->name(), _scene_out));
ports.insert (make_pair (_scene_input_port->name(), _scene_in));
for (XMLNodeList::const_iterator n = nodes.begin(); n != nodes.end(); ++n) {
if ((prop = (*n)->property (X_("name"))) == 0) {
@ -159,6 +173,8 @@ MidiPortManager::get_midi_port_states () const
ports.insert (make_pair (_midi_output_port->name(), _midi_out));
ports.insert (make_pair (_mmc_input_port->name(), _mmc_in));
ports.insert (make_pair (_mmc_output_port->name(), _mmc_out));
ports.insert (make_pair (_scene_output_port->name(), _scene_out));
ports.insert (make_pair (_scene_input_port->name(), _scene_in));
for (PortMap::const_iterator p = ports.begin(); p != ports.end(); ++p) {
s.push_back (&p->second->get_state());

45
libs/ardour/scene_change.cc Normal file
View file

@ -0,0 +1,45 @@
/*
Copyright (C) 2014 Paul Davis
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.
*/
#include "ardour/midi_scene_change.h"
#include "i18n.h"
using namespace PBD;
using namespace ARDOUR;
std::string SceneChange::xml_node_name = X_("SceneChange");
boost::shared_ptr<SceneChange>
SceneChange::factory (const XMLNode& node, int version)
{
const XMLProperty* prop = node.property (X_("type"));
if (prop->value() == X_("MIDI")) {
return boost::shared_ptr<SceneChange> (new MIDISceneChange (node, version));
}
return boost::shared_ptr<SceneChange>();
}
void
SceneChange::set_time (framepos_t t)
{
_time = t;
}

4
libs/ardour/session.cc
View file

@ -68,6 +68,7 @@
#include "ardour/filename_extensions.h"
#include "ardour/graph.h"
#include "ardour/midiport_manager.h"
#include "ardour/scene_changer.h"
#include "ardour/midi_track.h"
#include "ardour/midi_ui.h"
#include "ardour/operations.h"
@ -260,6 +261,7 @@ Session::Session (AudioEngine &eng,
, _speakers (new Speakers)
, _order_hint (0)
, ignore_route_processor_changes (false)
, _scene_changer (0)
, _midi_ports (0)
, _mmc (0)
{
@ -547,6 +549,8 @@ Session::destroy ()
/* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
playlists.reset ();
delete _scene_changer; _scene_changer = 0;
delete _mmc; _mmc = 0;
delete _midi_ports; _midi_ports = 0;
delete _locations; _locations = 0;

24
libs/ardour/session_midi.cc
View file

@ -644,3 +644,27 @@ Session::mmc_input_port () const
{
return _midi_ports->mmc_input_port ();
}
MIDI::Port*
Session::scene_output_port () const
{
return _midi_ports->scene_output_port ();
}
MIDI::Port*
Session::scene_input_port () const
{
return _midi_ports->scene_input_port ();
}
boost::shared_ptr<MidiPort>
Session::scene_in () const
{
return _midi_ports->scene_in ();
}
boost::shared_ptr<MidiPort>
Session::scene_out () const
{
return _midi_ports->scene_out ();
}

4
libs/ardour/session_process.cc
View file

@ -35,6 +35,7 @@
#include "ardour/graph.h"
#include "ardour/port.h"
#include "ardour/process_thread.h"
#include "ardour/scene_changer.h"
#include "ardour/session.h"
#include "ardour/slave.h"
#include "ardour/ticker.h"
@ -86,6 +87,9 @@ Session::process (pframes_t nframes)
if (!_silent && !_engine.freewheeling() && Config->get_send_midi_clock() && (transport_speed() == 1.0f || transport_speed() == 0.0f) && midi_clock->has_midi_port()) {
midi_clock->tick (transport_at_start, nframes);
}
_scene_changer->run (transport_at_start, transport_at_start + nframes);
} catch (...) {
/* don't bother with a message */
}

12
libs/ardour/session_state.cc
View file

@ -77,6 +77,7 @@
#include "pbd/localtime_r.h"
#include "ardour/amp.h"
#include "ardour/async_midi_port.h"
#include "ardour/audio_diskstream.h"
#include "ardour/audio_track.h"
#include "ardour/audioengine.h"
@ -92,6 +93,7 @@
#include "ardour/midi_model.h"
#include "ardour/midi_patch_manager.h"
#include "ardour/midi_region.h"
#include "ardour/midi_scene_changer.h"
#include "ardour/midi_source.h"
#include "ardour/midi_track.h"
#include "ardour/pannable.h"
@ -207,6 +209,16 @@ Session::post_engine_init ()
BootMessage (_("Using configuration"));
_midi_ports = new MidiPortManager;
MIDISceneChanger* msc;
_scene_changer = msc = new MIDISceneChanger (*this);
msc->set_input_port (scene_input_port());
msc->set_output_port (scene_out());
boost::function<framecnt_t(void)> timer_func (boost::bind (&Session::audible_frame, this));
boost::dynamic_pointer_cast<AsyncMIDIPort>(scene_in())->set_timer (timer_func);
setup_midi_machine_control ();
if (_butler->start_thread()) {

7
libs/ardour/wscript
View file

@ -119,6 +119,8 @@ libardour_sources = [
'midi_port.cc',
'midi_region.cc',
'midi_ring_buffer.cc',
'midi_scene_change.cc',
'midi_scene_changer.cc',
'midi_source.cc',
'midi_state_tracker.cc',
'midi_stretch.cc',
@ -164,6 +166,7 @@ libardour_sources = [
'route_group.cc',
'route_group_member.cc',
'rb_effect.cc',
'scene_change.cc',
'search_paths.cc',
'send.cc',
'session.cc',
@ -352,7 +355,7 @@ def build(bld):
obj.use.extend(['librubberband', 'libltc_includes', 'libltc'])
obj.vnum = LIBARDOUR_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
obj.install_path = bld.env['LIBDIR']
obj.defines += [
'PACKAGE="' + I18N_PACKAGE + '"',
'DATA_DIR="' + os.path.normpath(bld.env['DATADIR']) + '"',
@ -566,7 +569,7 @@ def create_ardour_test_program(bld, includes, name, target, sources):
testobj.name = name
testobj.target = target
# not sure about install path
testobj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
testobj.install_path = bld.env['LIBDIR']
testobj.defines = [
'PACKAGE="libardour3test"',
'DATA_DIR="' + os.path.normpath(bld.env['DATADIR']) + '"',

2
libs/audiographer/wscript
View file

@ -82,7 +82,7 @@ def build(bld):
audiographer.uselib = 'GLIB GLIBMM GTHREAD SAMPLERATE SNDFILE'
audiographer.use = 'libpbd'
audiographer.vnum = AUDIOGRAPHER_LIB_VERSION
audiographer.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
audiographer.install_path = bld.env['LIBDIR']
if bld.env['BUILD_TESTS'] and bld.is_defined('HAVE_CPPUNIT'):

1271
libs/backends/dummy/dummy_audiobackend.cc Normal file
View file

File diff suppressed because it is too large Load diff

328
libs/backends/dummy/dummy_audiobackend.h Normal file
View file

@ -0,0 +1,328 @@
/*
* Copyright (C) 2014 Robin Gareus <robin@gareus.org>
* Copyright (C) 2013 Paul Davis
*
* 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 __libbackend_dummy_audiobackend_h__
#define __libbackend_dummy_audiobackend_h__
#include <string>
#include <vector>
#include <map>
#include <set>
#include <stdint.h>
#include <pthread.h>
#include <boost/shared_ptr.hpp>
#include "ardour/types.h"
#include "ardour/audio_backend.h"
namespace ARDOUR {
class DummyMidiEvent {
public:
DummyMidiEvent (const pframes_t timestamp, const uint8_t* data, size_t size);
DummyMidiEvent (const DummyMidiEvent& other);
~DummyMidiEvent ();
size_t size () const { return _size; };
pframes_t timestamp () const { return _timestamp; };
const unsigned char* const_data () const { return _data; };
unsigned char* data () { return _data; };
bool operator< (const DummyMidiEvent &other) const { return timestamp () < other.timestamp (); };
private:
size_t _size;
pframes_t _timestamp;
uint8_t *_data;
};
typedef std::vector<boost::shared_ptr<DummyMidiEvent> > DummyMidiBuffer;
class DummyPort {
protected:
DummyPort (const std::string&, PortFlags);
public:
virtual ~DummyPort ();
const std::string& name () const { return _name; }
PortFlags flags () const { return _flags; }
int set_name (const std::string &name) { _name = name; return 0; }
virtual DataType type () const = 0;
bool is_input () const { return flags () & IsInput; }
bool is_output () const { return flags () & IsOutput; }
bool is_physical () const { return flags () & IsPhysical; }
bool is_terminal () const { return flags () & IsTerminal; }
bool is_connected () const { return _connections.size () != 0; }
bool is_connected (const DummyPort *port) const;
bool is_physically_connected () const;
const std::vector<DummyPort *>& get_connections () const { return _connections; }
int connect (DummyPort *port);
int disconnect (DummyPort *port);
void disconnect_all ();
virtual void* get_buffer (pframes_t nframes) = 0;
const LatencyRange& latency_range (bool for_playback) const
{
return for_playback ? _playback_latency_range : _capture_latency_range;
}
void set_latency_range (const LatencyRange &latency_range, bool for_playback)
{
if (for_playback)
{
_playback_latency_range = latency_range;
}
else
{
_capture_latency_range = latency_range;
}
}
private:
std::string _name;
const PortFlags _flags;
LatencyRange _capture_latency_range;
LatencyRange _playback_latency_range;
std::vector<DummyPort*> _connections;
void _connect (DummyPort* , bool);
void _disconnect (DummyPort* , bool);
}; // class DummyPort
class DummyAudioPort : public DummyPort {
public:
DummyAudioPort (const std::string&, PortFlags);
~DummyAudioPort ();
DataType type () const { return DataType::AUDIO; };
Sample* buffer () { return _buffer; }
const Sample* const_buffer () const { return _buffer; }
void* get_buffer (pframes_t nframes);
private:
Sample _buffer[8192];
}; // class DummyAudioPort
class DummyMidiPort : public DummyPort {
public:
DummyMidiPort (const std::string&, PortFlags);
~DummyMidiPort ();
DataType type () const { return DataType::MIDI; };
void* get_buffer (pframes_t nframes);
const DummyMidiBuffer const_buffer () const { return _buffer; }
private:
DummyMidiBuffer _buffer;
}; // class DummyMidiPort
class DummyAudioBackend : public AudioBackend {
public:
DummyAudioBackend (AudioEngine& e);
~DummyAudioBackend ();
/* AUDIOBACKEND API */
std::string name () const;
bool is_realtime () const;
std::vector<DeviceStatus> enumerate_devices () const;
std::vector<float> available_sample_rates (const std::string& device) const;
std::vector<uint32_t> available_buffer_sizes (const std::string& device) const;
uint32_t available_input_channel_count (const std::string& device) const;
uint32_t available_output_channel_count (const std::string& device) const;
bool can_change_sample_rate_when_running () const;
bool can_change_buffer_size_when_running () const;
int set_device_name (const std::string&);
int set_sample_rate (float);
int set_buffer_size (uint32_t);
int set_interleaved (bool yn);
int set_input_channels (uint32_t);
int set_output_channels (uint32_t);
int set_systemic_input_latency (uint32_t);
int set_systemic_output_latency (uint32_t);
/* Retrieving parameters */
std::string device_name () const;
float sample_rate () const;
uint32_t buffer_size () const;
bool interleaved () const;
uint32_t input_channels () const;
uint32_t output_channels () const;
uint32_t systemic_input_latency () const;
uint32_t systemic_output_latency () const;
/* External control app */
std::string control_app_name () const { return std::string (); }
void launch_control_app () {}
/* MIDI */
std::vector<std::string> enumerate_midi_options () const;
int set_midi_option (const std::string&);
std::string midi_option () const;
/* State Control */
protected:
int _start (bool for_latency_measurement);
public:
int stop ();
int freewheel (bool);
float dsp_load () const;
size_t raw_buffer_size (DataType t);
/* Process time */
pframes_t sample_time ();
pframes_t sample_time_at_cycle_start ();
pframes_t samples_since_cycle_start ();
int create_process_thread (boost::function<void()> func);
int join_process_threads ();
bool in_process_thread ();
uint32_t process_thread_count ();
void update_latencies ();
/* PORTENGINE API */
void* private_handle () const;
const std::string& my_name () const;
bool available () const;
uint32_t port_name_size () const;
int set_port_name (PortHandle, const std::string&);
std::string get_port_name (PortHandle) const;
PortHandle get_port_by_name (const std::string&) const;
int get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector<std::string>&) const;
DataType port_data_type (PortHandle) const;
PortHandle register_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
void unregister_port (PortHandle);
int connect (const std::string& src, const std::string& dst);
int disconnect (const std::string& src, const std::string& dst);
int connect (PortHandle, const std::string&);
int disconnect (PortHandle, const std::string&);
int disconnect_all (PortHandle);
bool connected (PortHandle, bool process_callback_safe);
bool connected_to (PortHandle, const std::string&, bool process_callback_safe);
bool physically_connected (PortHandle, bool process_callback_safe);
int get_connections (PortHandle, std::vector<std::string>&, bool process_callback_safe);
/* MIDI */
int midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index);
int midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size);
uint32_t get_midi_event_count (void* port_buffer);
void midi_clear (void* port_buffer);
/* Monitoring */
bool can_monitor_input () const;
int request_input_monitoring (PortHandle, bool);
int ensure_input_monitoring (PortHandle, bool);
bool monitoring_input (PortHandle);
/* Latency management */
void set_latency_range (PortHandle, bool for_playback, LatencyRange);
LatencyRange get_latency_range (PortHandle, bool for_playback);
/* Discovering physical ports */
bool port_is_physical (PortHandle) const;
void get_physical_outputs (DataType type, std::vector<std::string>&);
void get_physical_inputs (DataType type, std::vector<std::string>&);
ChanCount n_physical_outputs () const;
ChanCount n_physical_inputs () const;
/* Getting access to the data buffer for a port */
void* get_buffer (PortHandle, pframes_t);
void* main_process_thread ();
private:
std::string _instance_name;
bool _running;
bool _freewheeling;
float _samplerate;
size_t _samples_per_period;
float _dsp_load;
static size_t _max_buffer_size;
uint32_t _n_inputs;
uint32_t _n_outputs;
uint32_t _systemic_input_latency;
uint32_t _systemic_output_latency;
uint64_t _processed_samples;
pthread_t _main_thread;
/* process threads */
static void* dummy_process_thread (void *);
std::vector<pthread_t> _threads;
struct ThreadData {
DummyAudioBackend* engine;
boost::function<void ()> f;
size_t stacksize;
ThreadData (DummyAudioBackend* e, boost::function<void ()> fp, size_t stacksz)
: engine (e) , f (fp) , stacksize (stacksz) {}
};
/* port engine */
PortHandle add_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
int register_system_ports ();
void unregister_system_ports ();
std::vector<DummyPort *> _ports;
bool valid_port (PortHandle port) const {
return std::find (_ports.begin (), _ports.end (), (DummyPort*)port) != _ports.end ();
}
DummyPort * find_port (const std::string& port_name) const {
for (std::vector<DummyPort*>::const_iterator it = _ports.begin (); it != _ports.end (); ++it) {
if ((*it)->name () == port_name) {
return *it;
}
}
return NULL;
}
}; // class DummyAudioBackend
} // namespace
#endif /* __libbackend_dummy_audiobackend_h__ */

37
libs/backends/dummy/wscript Normal file
View file

@ -0,0 +1,37 @@
#!/usr/bin/env python
from waflib.extras import autowaf as autowaf
import os
import sys
import re
# Library version (UNIX style major, minor, micro)
# major increment <=> incompatible changes
# minor increment <=> compatible changes (additions)
# micro increment <=> no interface changes
DUMMYBACKEND_VERSION = '0.0.1'
I18N_PACKAGE = 'dummy-backend'
# Mandatory variables
top = '.'
out = 'build'
def options(opt):
autowaf.set_options(opt)
def configure(conf):
autowaf.configure(conf)
def build(bld):
obj = bld(features = 'cxx cxxshlib')
obj.source = [
'dummy_audiobackend.cc',
]
obj.includes = ['.']
obj.name = 'dummy_audiobackend'
obj.target = 'dummy_audiobackend'
obj.use = 'libardour libpbd'
obj.vnum = DUMMYBACKEND_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'backends')
obj.defines = ['PACKAGE="' + I18N_PACKAGE + '"',
'ARDOURBACKEND_DLL_EXPORTS'
]

2
libs/backends/jack/wscript
View file

@ -51,7 +51,7 @@ def build(bld):
obj.uselib = [ 'JACK' ]
obj.use = 'libardour libpbd'
obj.vnum = JACKBACKEND_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'backends')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'backends')
obj.defines = ['PACKAGE="' + I18N_PACKAGE + '"',
'ARDOURBACKEND_DLL_EXPORTS'
]

2
libs/backends/wavesaudio/wscript
View file

@ -67,7 +67,7 @@ def build(bld):
obj.target = 'waves_audiobackend'
obj.use = [ 'libardour', 'libpbd' ]
obj.vnum = WAVESAUDIOBACKEND_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'backends')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'backends')
obj.defines = ['PACKAGE="' + I18N_PACKAGE + '"',
'__MACOS__',
'ARDOURBACKEND_DLL_EXPORTS'

2
libs/backends/wscript
View file

@ -7,7 +7,7 @@ import sys
top = '.'
out = 'build'
backends = [ 'jack' ]
backends = [ 'jack', 'dummy' ]
if sys.platform == 'darwin':
backends += ['wavesaudio' ]

2
libs/canvas/wscript
View file

@ -85,7 +85,7 @@ def build(bld):
obj.name = 'libcanvas'
obj.target = 'canvas'
obj.vnum = CANVAS_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
obj.install_path = bld.env['LIBDIR']
obj.defines += [ 'PACKAGE="' + I18N_PACKAGE + '"' ]
if bld.env['BUILD_TESTS'] and bld.env['HAVE_CPPUNIT']:

2
libs/clearlooks-newer/wscript
View file

@ -35,7 +35,7 @@ def build(bld):
obj.target = 'clearlooks'
obj.uselib = 'GTK'
obj.includes = '.'
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'engines')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'engines')
autowaf.ensure_visible_symbols (obj, True)
if sys.platform == 'darwin':

4
libs/evoral/wscript
View file

@ -73,7 +73,7 @@ def build(bld):
libsmf.uselib = 'GLIB'
libsmf.cxxflags = [ '-fPIC' ]
libsmf.cflags = [ '-fPIC' ]
libsmf.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
libsmf.install_path = bld.env['LIBDIR']
lib_source = '''
src/Control.cpp
@ -108,7 +108,7 @@ def build(bld):
obj.uselib = 'GLIBMM GTHREAD SMF'
obj.use = 'libsmf libpbd'
obj.vnum = EVORAL_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
obj.install_path = bld.env['LIBDIR']
obj.defines += [ 'PACKAGE="libevoral"', 'EVORAL_MIDI_XML=1' ]
if bld.env['BUILD_TESTS'] and bld.is_defined('HAVE_CPPUNIT'):

4
libs/fst/wscript
View file

@ -51,7 +51,7 @@ def build(bld):
obj.source = 'scanner.wine'
obj.target = 'ardour-vst-scanner'
obj.chmod = Utils.O755
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3/fst')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'fst')
obj.dict = {
'VERSION' : bld.env['VERSION'],
}
@ -83,4 +83,4 @@ def build(bld):
'VST_SCANNER_APP',
'PACKAGE="' + I18N_PACKAGE + '"',
]
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3/fst')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'fst')

2
libs/gtkmm2ext/wscript
View file

@ -101,7 +101,7 @@ def build(bld):
obj.uselib = 'GTKMM GTK GTKOSX OSX GDK'
obj.use = [ 'libpbd' ]
obj.vnum = GTKMM2EXT_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
obj.install_path = bld.env['LIBDIR']
obj.defines += [
'PACKAGE="' + I18N_PACKAGE + '"',
'LOCALEDIR="' + os.path.join(

19
libs/midi++2/channel.cc
View file

@ -115,7 +115,7 @@ Channel::process_controller (Parser & /*parser*/, EventTwoBytes *tb)
all changes *are* atomic.
*/
if (tb->controller_number <= 31) { /* unsigned: no test for >= 0 */
if (tb->controller_number < 32) { /* unsigned: no test for >= 0 */
/* if this controller is already known to use 14 bits,
then treat this value as the MSB, and combine it
@ -128,7 +128,7 @@ Channel::process_controller (Parser & /*parser*/, EventTwoBytes *tb)
cv = (unsigned short) _controller_val[tb->controller_number];
if (_controller_14bit[tb->controller_number]) {
cv = ((tb->value << 7) | (cv & 0x7f));
cv = ((tb->value & 0x7f) << 7) | (cv & 0x7f);
} else {
cv = tb->value;
}
@ -160,8 +160,14 @@ Channel::process_controller (Parser & /*parser*/, EventTwoBytes *tb)
cv = (cv & 0x3f80) | (tb->value & 0x7f);
}
_controller_val[tb->controller_number] =
(controller_value_t) cv;
/* update the 14 bit value */
_controller_val[cn] = (controller_value_t) cv;
/* also store the "raw" 7 bit value in the incoming controller
value store
*/
_controller_val[tb->controller_number] = (controller_value_t) tb->value;
} else {
/* controller can only take 7 bit values */
@ -173,12 +179,11 @@ Channel::process_controller (Parser & /*parser*/, EventTwoBytes *tb)
/* bank numbers are special, in that they have their own signal
*/
if (tb->controller_number == 0) {
_bank_number = (unsigned short) _controller_val[0];
if (tb->controller_number == 0 || tb->controller_number == 0x20) {
_bank_number = _controller_val[0];
_port.parser()->bank_change (*_port.parser(), _bank_number);
_port.parser()->channel_bank_change[_channel_number] (*_port.parser(), _bank_number);
}
}
void

4
libs/midi++2/midi++/channel.h
View file

@ -42,7 +42,7 @@ class LIBMIDIPP_API Channel : public PBD::ScopedConnectionList {
Port &midi_port() { return _port; }
byte channel() { return _channel_number; }
byte program() { return _program_number; }
byte bank() { return _bank_number; }
unsigned short bank() { return _bank_number; }
byte pressure () { return _chanpress; }
byte poly_pressure (byte n) { return _polypress[n]; }
@ -117,7 +117,7 @@ class LIBMIDIPP_API Channel : public PBD::ScopedConnectionList {
/* Current channel values */
byte _channel_number;
byte _bank_number;
unsigned short _bank_number;
byte _program_number;
byte _rpn_msb;
byte _rpn_lsb;

5
libs/midi++2/midi++/parser.h
View file

@ -34,6 +34,7 @@ class Port;
class Parser;
typedef PBD::Signal1<void,Parser&> ZeroByteSignal;
typedef PBD::Signal2<void,Parser&,unsigned short> BankSignal;
typedef PBD::Signal2<void,Parser&,framecnt_t> TimestampedSignal;
typedef PBD::Signal2<void,Parser&, byte> OneByteSignal;
typedef PBD::Signal2<void,Parser &, EventTwoBytes *> TwoByteSignal;
@ -55,7 +56,7 @@ class LIBMIDIPP_API Parser {
/* signals that anyone can connect to */
OneByteSignal bank_change;
BankSignal bank_change;
TwoByteSignal note_on;
TwoByteSignal note_off;
TwoByteSignal poly_pressure;
@ -64,7 +65,7 @@ class LIBMIDIPP_API Parser {
PitchBendSignal pitchbend;
TwoByteSignal controller;
OneByteSignal channel_bank_change[16];
BankSignal channel_bank_change[16];
TwoByteSignal channel_note_on[16];
TwoByteSignal channel_note_off[16];
TwoByteSignal channel_poly_pressure[16];

2
libs/midi++2/wscript
View file

@ -75,7 +75,7 @@ def build(bld):
obj.uselib = 'GLIBMM SIGCPP XML OSX'
obj.use = 'libpbd libevoral libtimecode'
obj.vnum = LIBMIDIPP_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
obj.install_path = bld.env['LIBDIR']
if bld.env['BUILD_TESTS'] and bld.is_defined('HAVE_CPPUNIT'):
# Unit tests

2
libs/panners/1in2out/wscript
View file

@ -29,7 +29,7 @@ def build(bld):
obj.target = 'pan1in2out'
obj.use = 'libardour libardour_cp libpbd'
obj.vnum = LIBARDOUR_PAN1IN2OUT_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'panners')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'panners')
def shutdown():
autowaf.shutdown()

2
libs/panners/2in2out/wscript
View file

@ -29,7 +29,7 @@ def build(bld):
obj.target = 'pan2in2out'
obj.use = 'libardour libardour_cp libpbd'
obj.vnum = LIBARDOUR_PAN2IN2OUT_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'panners')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'panners')
def shutdown():
autowaf.shutdown()

2
libs/panners/stereobalance/wscript
View file

@ -29,7 +29,7 @@ def build(bld):
obj.target = 'panbalance'
obj.use = 'libardour libardour_cp libpbd'
obj.vnum = LIBARDOUR_PAN2IN2OUT_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'panners')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'panners')
def shutdown():
autowaf.shutdown()

2
libs/panners/vbap/wscript
View file

@ -29,7 +29,7 @@ def build(bld):
obj.target = 'panvbap'
obj.use = 'libardour libardour_cp libpbd'
obj.vnum = LIBARDOUR_PANVBAP_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'panners')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'panners')
def shutdown():
autowaf.shutdown()

2
libs/pbd/wscript
View file

@ -146,7 +146,7 @@ def build(bld):
obj.source += [ 'cocoa_open_uri.mm' ]
obj.uselib += ' OSX'
obj.vnum = LIBPBD_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
obj.install_path = bld.env['LIBDIR']
obj.defines += [ 'PACKAGE="' + I18N_PACKAGE + '"',
]

2
libs/qm-dsp/wscript
View file

@ -53,7 +53,7 @@ def build(bld):
obj.name = 'libqmdsp'
obj.target = 'qmdsp'
obj.vnum = QM_DSP_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
obj.install_path = bld.env['LIBDIR']
def shutdown():
autowaf.shutdown()

2
libs/surfaces/control_protocol/wscript
View file

@ -41,7 +41,7 @@ def build(bld):
obj.target = 'ardourcp'
obj.use = 'libardour'
obj.vnum = LIBARDOUR_CP_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
obj.install_path = bld.env['LIBDIR']
def shutdown():
autowaf.shutdown()

2
libs/surfaces/frontier/wscript
View file

@ -41,7 +41,7 @@ def build(bld):
obj.target = 'generic_midi'
obj.use = 'libardour libardourcp'
obj.vnum = LIBSURFACES_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'surfaces')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'surfaces')
def shutdown():
autowaf.shutdown()

2
libs/surfaces/generic_midi/wscript
View file

@ -38,7 +38,7 @@ def build(bld):
obj.uselib = 'GTKMM GTK GDK'
obj.use = 'libardour libardour_cp libgtkmm2ext libpbd'
obj.vnum = LIBARDOUR_GENERIC_MIDI_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'surfaces')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'surfaces')
def shutdown():
autowaf.shutdown()

2
libs/surfaces/mackie/wscript
View file

@ -50,7 +50,7 @@ def build(bld):
obj.uselib = 'GTKMM'
obj.use = 'libardour libardour_cp libgtkmm2ext'
obj.vnum = LIBARDOUR_MCP_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'surfaces')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'surfaces')
def shutdown():
autowaf.shutdown()

2
libs/surfaces/osc/wscript
View file

@ -35,7 +35,7 @@ def build(bld):
obj.uselib = ' LO '
obj.use = 'libardour libardour_cp libpbd'
obj.vnum = LIBARDOUR_OSC_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'surfaces')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'surfaces')
def shutdown():
autowaf.shutdown()

2
libs/surfaces/tranzport/wscript
View file

@ -46,7 +46,7 @@ def build(bld):
obj.target = 'ardour_tranzport'
obj.use = 'libardour libardour_cp'
obj.vnum = LIBARDOUR_TRANZPORT_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'surfaces')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'surfaces')
def shutdown():
autowaf.shutdown()

2
libs/surfaces/wiimote/wscript
View file

@ -33,7 +33,7 @@ def build(bld):
obj.uselib = 'GTKMM CWIID'
obj.use = 'libardour libardour_cp libgtkmm2ext'
obj.vnum = LIBARDOUR_WIIMOTE_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'surfaces')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'surfaces')
def shutdown():
autowaf.shutdown()

2
libs/vamp-plugins/wscript
View file

@ -55,7 +55,7 @@ def build(bld):
obj.source += ' Onset.cpp '
obj.uselib += ' AUBIO '
obj.vnum = LIBARDOURVAMPPLUGINS_LIB_VERSION
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3', 'vamp')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'vamp')
def shutdown():
autowaf.shutdown()

2
libs/vfork/wscript
View file

@ -21,7 +21,7 @@ def build(bld):
obj = bld (features = 'c cprogram')
obj.source = 'exec_wrapper.c'
obj.target = 'ardour-exec-wrapper'
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3/vfork')
obj.install_path = os.path.join(bld.env['LIBDIR'], 'vfork')
obj.defines = [
'_POSIX_SOURCE',
'_XOPEN_SOURCE=500',

4
mcp/wscript
View file

@ -11,8 +11,8 @@ def configure(conf):
def build(bld):
devinfo = bld.path.ant_glob ('*.device')
profiles = bld.path.ant_glob ('*.profile')
bld.install_files (os.path.join(bld.env['DATADIR'], 'ardour3', 'mcp'), devinfo)
bld.install_files (os.path.join(bld.env['DATADIR'], 'ardour3', 'mcp'), profiles)
bld.install_files (os.path.join(bld.env['DATADIR'], 'mcp'), devinfo)
bld.install_files (os.path.join(bld.env['DATADIR'], 'mcp'), profiles)
def options(opt):
pass

2
midi_maps/wscript
View file

@ -10,7 +10,7 @@ def configure(conf):
def build(bld):
maps = bld.path.ant_glob ('*.map')
bld.install_files (os.path.join(bld.env['DATADIR'], 'ardour3', 'midi_maps'),
bld.install_files (os.path.join(bld.env['DATADIR'], 'midi_maps'),
maps)
def options(opt):

2
patchfiles/wscript
View file

@ -10,7 +10,7 @@ def configure(conf):
def build(bld):
patchfiles = bld.path.ant_glob ('*.midnam')
bld.install_files (os.path.join(bld.env['DATADIR'], 'ardour3', 'patchfiles'), patchfiles)
bld.install_files (os.path.join(bld.env['DATADIR'], 'patchfiles'), patchfiles)
def options(opt):
pass

2
templates/wscript
View file

@ -35,7 +35,7 @@ def build(bld):
name = 'template',
source = [ t ],
target = [ os.path.join(dir_name, file_name) ],
install_path = os.path.join(bld.env['DATADIR'], 'ardour3', os.path.join('templates', dir_name)))
install_path = os.path.join(bld.env['DATADIR'], os.path.join('templates', dir_name)))
def options(opt):
pass

4
tools/linux_packaging/build
View file

@ -389,7 +389,9 @@ done
cp $BUILD_ROOT/libs/panners/*/lib*.so* $Panners
# Backends
cp $BUILD_ROOT/libs/backends/*/lib*.so* $Backends
for backend in jack wavesaudio ; do
cp $BUILD_ROOT/libs/backends/$backend/lib*.so* $Backends
done
# VAMP plugins that we use
cp $BUILD_ROOT/libs/vamp-plugins/libardourvampplugins.so* $Libraries

4
tools/osx_packaging/osx_build
View file

@ -337,7 +337,9 @@ cp $BUILD_ROOT/libs/surfaces/control_protocol/libardourcp*.dylib $Frameworks
cp $BUILD_ROOT/libs/panners/*/lib*.dylib $Panners
# Backends
cp $BUILD_ROOT/libs/backends/*/lib*.dylib $Backends
for backend in jack wavesaudio ; do
cp $BUILD_ROOT/libs/backends/$backend/lib*.dylib $Backends
done
# Export Formats/Presets
for f in $BUILD_ROOT/../export/*.preset $BUILD_ROOT/../export/*.format ; do

2
tools/sanity_check/wscript
View file

@ -20,4 +20,4 @@ def build(bld):
obj.source = [ 'main.cpp', 'systemtest.cpp' ]
obj.target = 'sanityCheck'
obj.name = 'sanityCheck'
obj.install_path = os.path.join(bld.env['LIBDIR'], 'ardour3')
obj.install_path = bld.env['LIBDIR']

5
wscript
View file

@ -874,8 +874,9 @@ def build(bld):
bld.env['CONFDIR'] = os.path.join(bld.env['SYSCONFDIR'], lwrcase_dirname)
# data files loaded at run time go here
bld.env['DATADIR'] = os.path.join(bld.env['DATADIR'], lwrcase_dirname)
# shared objects loaded at runtime go here
# shared objects loaded at runtime go here (two aliases)
bld.env['DLLDIR'] = os.path.join(bld.env['LIBDIR'], lwrcase_dirname)
bld.env['LIBDIR'] = bld.env['DLLDIR']
autowaf.set_recursive()
@ -890,7 +891,7 @@ def build(bld):
for i in children:
bld.recurse(i)
bld.install_files (os.path.join(bld.env['SYSCONFDIR'], 'ardour3', ), 'ardour_system.rc')
bld.install_files (bld.env['SYSCONFDIR'], 'ardour_system.rc')
if bld.env['RUN_TESTS']:
bld.add_post_fun(test)