smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-11 00:56:33 +01:00
Code Issues Projects Releases Wiki Activity

Trim include dependency graph, especially for io.h and session.h.

Browse source 
Clean up some stuff and other such gruntwork in the process.


git-svn-id: svn://localhost/ardour2/branches/3.0@4468 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
David Robillard 2009-01-30 20:18:31 +00:00
parent a384dab130
commit aaa91db6d9
58 changed files with 425 additions and 387 deletions
Download patch file Download diff file Expand all files Collapse all files

4
SConstruct
View file

@ -677,9 +677,9 @@ env = conf.Finish()
opt_flags = [] opt_flags = []
if env['GPROFILE'] == 1: if env['GPROFILE'] == 1:
debug_flags = [ '-g', '-pg' ] debug_flags = [ '-O0', '-g', '-pg' ]
else: else:
debug_flags = [ '-g' ] debug_flags = [ '-O0', '-g' ]
# guess at the platform, used to define compiler flags # guess at the platform, used to define compiler flags

2
gtk2_ardour/automation_region_view.cc
View file

@ -18,6 +18,8 @@
*/ */
#include <pbd/memento_command.h> #include <pbd/memento_command.h>
#include <ardour/session.h>
#include <ardour/automation_control.h>
#include "automation_region_view.h" #include "automation_region_view.h"
#include "public_editor.h" #include "public_editor.h"

11
gtk2_ardour/editor.cc
View file

@ -46,19 +46,20 @@
#include <gtkmm2ext/window_title.h> #include <gtkmm2ext/window_title.h>
#include <gtkmm2ext/choice.h> #include <gtkmm2ext/choice.h>
#include <ardour/audio_track.h>
#include <ardour/audio_diskstream.h> #include <ardour/audio_diskstream.h>
#include <ardour/plugin_manager.h> #include <ardour/audio_track.h>
#include <ardour/location.h>
#include <ardour/audioplaylist.h> #include <ardour/audioplaylist.h>
#include <ardour/audioregion.h> #include <ardour/audioregion.h>
#include <ardour/location.h>
#include <ardour/midi_region.h> #include <ardour/midi_region.h>
#include <ardour/session_route.h> #include <ardour/plugin_manager.h>
#include <ardour/profile.h>
#include <ardour/route_group.h>
#include <ardour/session_directory.h> #include <ardour/session_directory.h>
#include <ardour/session_route.h>
#include <ardour/session_state_utils.h> #include <ardour/session_state_utils.h>
#include <ardour/tempo.h> #include <ardour/tempo.h>
#include <ardour/utils.h> #include <ardour/utils.h>
#include <ardour/profile.h>
#include <control_protocol/control_protocol.h> #include <control_protocol/control_protocol.h>

3
gtk2_ardour/export_channel_selector.cc
View file

@ -24,12 +24,13 @@
#include <pbd/convert.h> #include <pbd/convert.h>
#include <ardour/audio_port.h>
#include <ardour/audio_track.h>
#include <ardour/audioengine.h> #include <ardour/audioengine.h>
#include <ardour/export_channel_configuration.h> #include <ardour/export_channel_configuration.h>
#include <ardour/export_handler.h> #include <ardour/export_handler.h>
#include <ardour/io.h> #include <ardour/io.h>
#include <ardour/route.h> #include <ardour/route.h>
#include <ardour/audio_port.h>
#include <ardour/session.h> #include <ardour/session.h>
#include <sstream> #include <sstream>

7
gtk2_ardour/gain_meter.cc
View file

@ -924,3 +924,10 @@ GainMeter::meter_metrics_expose (GdkEventExpose *ev)
return true; return true;
} }
boost::shared_ptr<PBD::Controllable>
GainMeterBase::get_controllable()
{
return _io->gain_control();
}

2
gtk2_ardour/gain_meter.h
View file

@ -74,7 +74,7 @@ class GainMeterBase : virtual public sigc::trackable
virtual void setup_meters (int len=0); virtual void setup_meters (int len=0);
boost::shared_ptr<PBD::Controllable> get_controllable() { return _io->gain_control(); } boost::shared_ptr<PBD::Controllable> get_controllable();
LevelMeter& get_level_meter() const { return *level_meter; } LevelMeter& get_level_meter() const { return *level_meter; }
Gtkmm2ext::SliderController& get_gain_slider() const { return *gain_slider; } Gtkmm2ext::SliderController& get_gain_slider() const { return *gain_slider; }

3
gtk2_ardour/level_meter.h
View file

@ -21,7 +21,6 @@
#define __ardour_gtk_track_meter_h__ #define __ardour_gtk_track_meter_h__
#include <vector> #include <vector>
#include <map>
#include <gtkmm/box.h> #include <gtkmm/box.h>
#include <gtkmm/adjustment.h> #include <gtkmm/adjustment.h>
@ -93,7 +92,7 @@ class LevelMeter : public Gtk::HBox
guint16 regular_meter_width; guint16 regular_meter_width;
static const guint16 thin_meter_width = 2; static const guint16 thin_meter_width = 2;
vector<MeterInfo> meters; std::vector<MeterInfo> meters;
float max_peak; float max_peak;
void hide_all_meters (); void hide_all_meters ();

1
gtk2_ardour/mixer_strip.cc
View file

@ -36,6 +36,7 @@
#include <ardour/session.h> #include <ardour/session.h>
#include <ardour/audioengine.h> #include <ardour/audioengine.h>
#include <ardour/route.h> #include <ardour/route.h>
#include <ardour/route_group.h>
#include <ardour/audio_track.h> #include <ardour/audio_track.h>
#include <ardour/audio_diskstream.h> #include <ardour/audio_diskstream.h>
#include <ardour/panner.h> #include <ardour/panner.h>

2
gtk2_ardour/mixer_strip.h
View file

@ -42,9 +42,7 @@
#include <ardour/types.h> #include <ardour/types.h>
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/io.h>
#include <ardour/processor.h> #include <ardour/processor.h>
#include <ardour/io_processor.h>
#include <pbd/fastlog.h> #include <pbd/fastlog.h>

7
gtk2_ardour/mixer_ui.cc
View file

@ -30,11 +30,12 @@
#include <gtkmm2ext/stop_signal.h> #include <gtkmm2ext/stop_signal.h>
#include <gtkmm2ext/window_title.h> #include <gtkmm2ext/window_title.h>
#include <ardour/session.h>
#include <ardour/audio_track.h>
#include <ardour/session_route.h>
#include <ardour/audio_diskstream.h> #include <ardour/audio_diskstream.h>
#include <ardour/audio_track.h>
#include <ardour/plugin_manager.h> #include <ardour/plugin_manager.h>
#include <ardour/route_group.h>
#include <ardour/session.h>
#include <ardour/session_route.h>
#include "keyboard.h" #include "keyboard.h"
#include "mixer_ui.h" #include "mixer_ui.h"

1
gtk2_ardour/mixer_ui.h
View file

@ -35,7 +35,6 @@
#include <pbd/stateful.h> #include <pbd/stateful.h>
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/io.h>
#include "route_processor_selection.h" #include "route_processor_selection.h"
#include "enums.h" #include "enums.h"

2
gtk2_ardour/panner2d.cc
View file

@ -633,7 +633,7 @@ Panner2d::on_button_release_event (GdkEventButton *ev)
for (Targets::iterator i = pucks.begin(); i != pucks.end(); ++i) { for (Targets::iterator i = pucks.begin(); i != pucks.end(); ++i) {
Target* puck = i->second; //Target* puck = i->second;
/* XXX DO SOMETHING TO SET PUCK BACK TO "normal" */ /* XXX DO SOMETHING TO SET PUCK BACK TO "normal" */
} }

4
gtk2_ardour/panner_ui.h
View file

@ -114,8 +114,8 @@ class PannerUI : public Gtk::HBox
void panning_link_direction_clicked (); void panning_link_direction_clicked ();
vector<Gtk::Adjustment*> pan_adjustments; std::vector<Gtk::Adjustment*> pan_adjustments;
vector<PannerBar*> pan_bars; std::vector<PannerBar*> pan_bars;
void pan_adjustment_changed (uint32_t which); void pan_adjustment_changed (uint32_t which);
void pan_value_changed (uint32_t which); void pan_value_changed (uint32_t which);

20
gtk2_ardour/port_group.cc
View file

@ -17,17 +17,21 @@
*/ */
#include <cstring>
#include <boost/shared_ptr.hpp>
#include "ardour/audio_track.h"
#include "ardour/audioengine.h"
#include "ardour/bundle.h"
#include "ardour/io_processor.h"
#include "ardour/midi_track.h"
#include "ardour/port.h"
#include "ardour/session.h"
#include "port_group.h" #include "port_group.h"
#include "port_matrix.h" #include "port_matrix.h"
#include "i18n.h" #include "i18n.h"
#include "ardour/session.h"
#include "ardour/audio_track.h"
#include "ardour/midi_track.h"
#include "ardour/audioengine.h"
#include "ardour/port.h"
#include "ardour/bundle.h"
#include <boost/shared_ptr.hpp>
#include <cstring>
using namespace std; using namespace std;
using namespace Gtk; using namespace Gtk;

2
gtk2_ardour/processor_box.h
View file

@ -36,7 +36,6 @@
#include <ardour/types.h> #include <ardour/types.h>
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/io.h>
#include <ardour/plugin_insert.h> #include <ardour/plugin_insert.h>
#include <ardour/port_insert.h> #include <ardour/port_insert.h>
#include <ardour/processor.h> #include <ardour/processor.h>
@ -56,6 +55,7 @@ class RouteRedirectSelection;
namespace ARDOUR { namespace ARDOUR {
class Connection; class Connection;
class IO;
class Insert; class Insert;
class Plugin; class Plugin;
class PluginInsert; class PluginInsert;

2
gtk2_ardour/route_params_ui.h
View file

@ -35,8 +35,6 @@
#include <pbd/stateful.h> #include <pbd/stateful.h>
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/io.h>
#include <ardour/io_processor.h>
#include "io_selector.h" #include "io_selector.h"
#include "ardour_dialog.h" #include "ardour_dialog.h"

7
gtk2_ardour/route_time_axis.cc
View file

@ -40,19 +40,20 @@
#include <gtkmm2ext/bindable_button.h> #include <gtkmm2ext/bindable_button.h>
#include <gtkmm2ext/utils.h> #include <gtkmm2ext/utils.h>
#include <ardour/playlist.h>
#include <ardour/audioplaylist.h> #include <ardour/audioplaylist.h>
#include <ardour/diskstream.h> #include <ardour/diskstream.h>
#include <ardour/processor.h>
#include <ardour/ladspa_plugin.h> #include <ardour/ladspa_plugin.h>
#include <ardour/location.h> #include <ardour/location.h>
#include <ardour/panner.h> #include <ardour/panner.h>
#include <ardour/playlist.h> #include <ardour/playlist.h>
#include <ardour/playlist.h>
#include <ardour/processor.h>
#include <ardour/profile.h>
#include <ardour/route_group.h>
#include <ardour/session.h> #include <ardour/session.h>
#include <ardour/session_playlist.h> #include <ardour/session_playlist.h>
#include <ardour/utils.h> #include <ardour/utils.h>
#include <evoral/Parameter.hpp> #include <evoral/Parameter.hpp>
#include <ardour/profile.h>
#include "ardour_ui.h" #include "ardour_ui.h"
#include "route_time_axis.h" #include "route_time_axis.h"

6
gtk2_ardour/route_time_axis.h
View file

@ -20,6 +20,9 @@
#ifndef __ardour_route_time_axis_h__ #ifndef __ardour_route_time_axis_h__
#define __ardour_route_time_axis_h__ #define __ardour_route_time_axis_h__
#include <list>
#include <set>
#include <gtkmm/table.h> #include <gtkmm/table.h>
#include <gtkmm/button.h> #include <gtkmm/button.h>
#include <gtkmm/box.h> #include <gtkmm/box.h>
@ -31,7 +34,6 @@
#include <gtkmm2ext/selector.h> #include <gtkmm2ext/selector.h>
#include <gtkmm2ext/slider_controller.h> #include <gtkmm2ext/slider_controller.h>
#include <list>
#include <ardour/playlist.h> #include <ardour/playlist.h>
#include <ardour/types.h> #include <ardour/types.h>
@ -305,7 +307,7 @@ protected:
ProcessorAutomationCurves processor_automation_curves; ProcessorAutomationCurves processor_automation_curves;
// Set from XML so context menu automation buttons can be correctly initialized // Set from XML so context menu automation buttons can be correctly initialized
set<Evoral::Parameter> _show_automation; std::set<Evoral::Parameter> _show_automation;
AutomationTracks _automation_tracks; AutomationTracks _automation_tracks;

4
gtk2_ardour/send_ui.cc
View file

@ -17,9 +17,11 @@
*/ */
#include <ardour/send.h>
#include <gtkmm2ext/doi.h> #include <gtkmm2ext/doi.h>
#include <ardour/io.h>
#include <ardour/send.h>
#include "utils.h" #include "utils.h"
#include "send_ui.h" #include "send_ui.h"
#include "io_selector.h" #include "io_selector.h"

5
libs/ardour/ardour/audio_diskstream.h
View file

@ -36,9 +36,6 @@
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/configuration.h> #include <ardour/configuration.h>
#include <ardour/session.h>
#include <ardour/route_group.h>
#include <ardour/route.h>
#include <ardour/utils.h> #include <ardour/utils.h>
#include <ardour/diskstream.h> #include <ardour/diskstream.h>
#include <ardour/audioplaylist.h> #include <ardour/audioplaylist.h>
@ -261,7 +258,7 @@ class AudioDiskstream : public Diskstream
void process_varispeed_playback(nframes_t nframes, boost::shared_ptr<ChannelList> c); void process_varispeed_playback(nframes_t nframes, boost::shared_ptr<ChannelList> c);
/* The two central butler operations */ /* The two central butler operations */
int do_flush (Session::RunContext context, bool force = false); int do_flush (RunContext context, bool force = false);
int do_refill () { return _do_refill(_mixdown_buffer, _gain_buffer); } int do_refill () { return _do_refill(_mixdown_buffer, _gain_buffer); }
int do_refill_with_alloc (); int do_refill_with_alloc ();

3
libs/ardour/ardour/automatable.h
View file

@ -23,9 +23,6 @@
#include <set> #include <set>
#include <map> #include <map>
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <ardour/session_object.h>
#include <ardour/automation_list.h>
#include <ardour/automation_control.h>
#include <ardour/event_type_map.h> #include <ardour/event_type_map.h>
#include <evoral/ControlSet.hpp> #include <evoral/ControlSet.hpp>
#include <evoral/Sequence.hpp> #include <evoral/Sequence.hpp>

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

@ -28,7 +28,6 @@
namespace ARDOUR { namespace ARDOUR {
class AutomationList;
class Session; class Session;
class Automatable; class Automatable;

24
libs/ardour/ardour/diskstream.h
View file

@ -20,16 +20,17 @@
#ifndef __ardour_diskstream_h__ #ifndef __ardour_diskstream_h__
#define __ardour_diskstream_h__ #define __ardour_diskstream_h__
#include <sigc++/signal.h>
#include <cmath>
#include <string> #include <string>
#include <queue> #include <queue>
#include <map> #include <map>
#include <vector> #include <vector>
#include <cmath>
#include <time.h> #include <time.h>
#include <sigc++/signal.h>
#include <evoral/types.hpp>
#include <pbd/fastlog.h> #include <pbd/fastlog.h>
#include <pbd/ringbufferNPT.h> #include <pbd/ringbufferNPT.h>
#include <pbd/stateful.h> #include <pbd/stateful.h>
@ -37,20 +38,23 @@
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/configuration.h> #include <ardour/configuration.h>
#include <ardour/session.h> #include <ardour/location.h>
#include <ardour/route_group.h> #include <ardour/session_object.h>
#include <ardour/route.h> #include <ardour/types.h>
#include <ardour/utils.h> #include <ardour/utils.h>
#include <ardour/chan_count.h>
struct tm; struct tm;
namespace ARDOUR { namespace ARDOUR {
class AudioEngine; class AudioEngine;
class IO;
class Playlist;
class Processor;
class Region;
class Send; class Send;
class Session; class Session;
class Playlist;
class IO;
class Diskstream : public SessionObject class Diskstream : public SessionObject
{ {
@ -195,7 +199,7 @@ class Diskstream : public SessionObject
}; };
/* The two central butler operations */ /* The two central butler operations */
virtual int do_flush (Session::RunContext context, bool force = false) = 0; virtual int do_flush (RunContext context, bool force = false) = 0;
virtual int do_refill () = 0; virtual int do_refill () = 0;
/** For non-butler contexts (allocates temporary working buffers) */ /** For non-butler contexts (allocates temporary working buffers) */

3
libs/ardour/ardour/export_channel.h
View file

@ -22,7 +22,6 @@
#define __ardour_export_channel_h__ #define __ardour_export_channel_h__
#include <ardour/audioregion.h> #include <ardour/audioregion.h>
#include <ardour/audio_track.h>
#include <ardour/buffer_set.h> #include <ardour/buffer_set.h>
#include <set> #include <set>
@ -33,6 +32,8 @@
namespace ARDOUR { namespace ARDOUR {
class Session; class Session;
class AudioTrack;
class AudioPort;
/// Export channel base class interface for different source types /// Export channel base class interface for different source types
class ExportChannel class ExportChannel

3
libs/ardour/ardour/export_filename.h
View file

@ -21,11 +21,10 @@
#ifndef __ardour_export_filename_h__ #ifndef __ardour_export_filename_h__
#define __ardour_export_filename_h__ #define __ardour_export_filename_h__
#include <boost/shared_ptr.hpp>
#include <glibmm/ustring.h> #include <glibmm/ustring.h>
#include <pbd/statefuldestructible.h> #include <pbd/statefuldestructible.h>
#include <ardour/session.h>
using Glib::ustring; using Glib::ustring;
namespace ARDOUR namespace ARDOUR

2
libs/ardour/ardour/export_handler.h
View file

@ -28,8 +28,8 @@
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/session.h>
#include <ardour/types.h> #include <ardour/types.h>
#include <ardour/session.h>
namespace ARDOUR namespace ARDOUR
{ {

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

@ -22,7 +22,6 @@
#include "ardour.h" #include "ardour.h"
#include "automation_list.h" #include "automation_list.h"
#include <evoral/Curve.hpp>
namespace ARDOUR { namespace ARDOUR {

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

@ -27,7 +27,6 @@
#include <pbd/stateful.h> #include <pbd/stateful.h>
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/audioengine.h> #include <ardour/audioengine.h>
#include <ardour/io.h>
#include <ardour/io_processor.h> #include <ardour/io_processor.h>
namespace ARDOUR { namespace ARDOUR {

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

@ -42,6 +42,7 @@
#include <ardour/chan_count.h> #include <ardour/chan_count.h>
#include <ardour/latent.h> #include <ardour/latent.h>
#include <ardour/automation_control.h> #include <ardour/automation_control.h>
#include <ardour/session_object.h>
using std::string; using std::string;
using std::vector; using std::vector;

22
libs/ardour/ardour/io_processor.h
View file

@ -21,9 +21,6 @@
#define __ardour_redirect_h__ #define __ardour_redirect_h__
#include <string> #include <string>
#include <vector>
#include <set>
#include <map>
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <sigc++/signal.h> #include <sigc++/signal.h>
@ -33,19 +30,15 @@
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/processor.h> #include <ardour/processor.h>
#include <ardour/io.h>
#include <ardour/automation_list.h>
using std::map;
using std::set;
using std::string; using std::string;
using std::vector;
class XMLNode; class XMLNode;
namespace ARDOUR { namespace ARDOUR {
class Session; class Session;
class IO;
/** A mixer strip element (Processor) with Jack ports (IO). /** A mixer strip element (Processor) with Jack ports (IO).
*/ */
@ -59,17 +52,18 @@ class IOProcessor : public Processor
IOProcessor (const IOProcessor&); IOProcessor (const IOProcessor&);
virtual ~IOProcessor (); virtual ~IOProcessor ();
virtual ChanCount output_streams() const { return _io->n_outputs(); } virtual ChanCount output_streams() const;
virtual ChanCount input_streams () const { return _io->n_inputs(); } virtual ChanCount input_streams () const;
virtual ChanCount natural_output_streams() const { return _io->n_outputs(); } virtual ChanCount natural_output_streams() const;
virtual ChanCount natural_input_streams () const { return _io->n_inputs(); } virtual ChanCount natural_input_streams () const;
boost::shared_ptr<IO> io() { return _io; } boost::shared_ptr<IO> io() { return _io; }
boost::shared_ptr<const IO> io() const { return _io; } boost::shared_ptr<const IO> io() const { return _io; }
virtual void automation_snapshot (nframes_t now, bool force) { _io->automation_snapshot(now, force); } virtual void automation_snapshot (nframes_t now, bool force);
virtual void run_in_place (BufferSet& in, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset) = 0; virtual void run_in_place (BufferSet& in, nframes_t start, nframes_t end,
nframes_t nframes, nframes_t offset) = 0;
void silence (nframes_t nframes, nframes_t offset); void silence (nframes_t nframes, nframes_t offset);

14
libs/ardour/ardour/midi_diskstream.h
View file

@ -37,25 +37,23 @@
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/configuration.h> #include <ardour/configuration.h>
#include <ardour/session.h>
#include <ardour/route_group.h>
#include <ardour/route.h>
#include <ardour/utils.h>
#include <ardour/diskstream.h> #include <ardour/diskstream.h>
#include <ardour/midi_playlist.h> #include <ardour/midi_playlist.h>
#include <ardour/midi_ring_buffer.h> #include <ardour/midi_ring_buffer.h>
#include <ardour/midi_state_tracker.h> #include <ardour/midi_state_tracker.h>
#include <ardour/utils.h>
struct tm; struct tm;
namespace ARDOUR { namespace ARDOUR {
class IO;
class MidiEngine; class MidiEngine;
class MidiPort;
class MidiRingbuffer;
class SMFSource;
class Send; class Send;
class Session; class Session;
class MidiPlaylist;
class SMFSource;
class IO;
class MidiDiskstream : public Diskstream class MidiDiskstream : public Diskstream
{ {
@ -145,7 +143,7 @@ class MidiDiskstream : public Diskstream
private: private:
/* The two central butler operations */ /* The two central butler operations */
int do_flush (Session::RunContext context, bool force = false); int do_flush (RunContext context, bool force = false);
int do_refill (); int do_refill ();
int do_refill_with_alloc(); int do_refill_with_alloc();

19
libs/ardour/ardour/mix.h
View file

@ -21,26 +21,25 @@
#include <ardour/types.h> #include <ardour/types.h>
#include <ardour/utils.h> #include <ardour/utils.h>
#include <ardour/io.h>
#if defined (ARCH_X86) && defined (BUILD_SSE_OPTIMIZATIONS) #if defined (ARCH_X86) && defined (BUILD_SSE_OPTIMIZATIONS)
extern "C" { extern "C" {
/* SSE functions */ /* SSE functions */
float x86_sse_compute_peak (const ARDOUR::Sample * buf, nframes_t nsamples, float current); float x86_sse_compute_peak (const ARDOUR::Sample * buf, nframes_t nsamples, float current);
void x86_sse_apply_gain_to_buffer (ARDOUR::Sample * buf, nframes_t nframes, float gain); void x86_sse_apply_gain_to_buffer (ARDOUR::Sample * buf, nframes_t nframes, float gain);
void x86_sse_mix_buffers_with_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain); void x86_sse_mix_buffers_with_gain(ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain);
void x86_sse_mix_buffers_no_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes); void x86_sse_mix_buffers_no_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes);
} }
void x86_sse_find_peaks (const ARDOUR::Sample * buf, nframes_t nsamples, float *min, float *max); void x86_sse_find_peaks (const ARDOUR::Sample * buf, nframes_t nsamples, float *min, float *max);
/* debug wrappers for SSE functions */ /* debug wrappers for SSE functions */
float debug_compute_peak (const ARDOUR::Sample * buf, nframes_t nsamples, float current); float debug_compute_peak (const ARDOUR::Sample * buf, nframes_t nsamples, float current);
void debug_apply_gain_to_buffer (ARDOUR::Sample * buf, nframes_t nframes, float gain); void debug_apply_gain_to_buffer (ARDOUR::Sample * buf, nframes_t nframes, float gain);
void debug_mix_buffers_with_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain); void debug_mix_buffers_with_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain);
void debug_mix_buffers_no_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes); void debug_mix_buffers_no_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes);
#endif #endif

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

@ -33,7 +33,6 @@
#include <ardour/types.h> #include <ardour/types.h>
#include <ardour/automation_control.h> #include <ardour/automation_control.h>
#include <ardour/processor.h> #include <ardour/processor.h>
#include <ardour/session.h>
using std::istream; using std::istream;
using std::ostream; using std::ostream;

2
libs/ardour/ardour/plugin_insert.h
View file

@ -29,7 +29,7 @@
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/types.h> #include <ardour/types.h>
#include <ardour/processor.h> #include <ardour/processor.h>
#include <ardour/automation_list.h> #include <ardour/automation_control.h>
class XMLNode; class XMLNode;

10
libs/ardour/ardour/port.h
View file

@ -20,13 +20,13 @@
#ifndef __ardour_port_h__ #ifndef __ardour_port_h__
#define __ardour_port_h__ #define __ardour_port_h__
#include <set>
#include <string>
#include <vector>
#include <jack/jack.h>
#include <sigc++/trackable.h>
#include "ardour/data_type.h" #include "ardour/data_type.h"
#include "ardour/types.h" #include "ardour/types.h"
#include <sigc++/trackable.h>
#include <jack/jack.h>
#include <string>
#include <set>
#include <vector>
namespace ARDOUR { namespace ARDOUR {

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

@ -33,6 +33,7 @@
#include <ardour/buffer_set.h> #include <ardour/buffer_set.h>
#include <ardour/automatable.h> #include <ardour/automatable.h>
#include <ardour/latent.h> #include <ardour/latent.h>
#include <ardour/session_object.h>
class XMLNode; class XMLNode;

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

@ -30,6 +30,7 @@
#include <ardour/data_type.h> #include <ardour/data_type.h>
#include <ardour/automatable.h> #include <ardour/automatable.h>
#include <ardour/readable.h> #include <ardour/readable.h>
#include <ardour/session_object.h>
class XMLNode; class XMLNode;

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

@ -28,6 +28,7 @@ class XMLNode;
namespace ARDOUR { namespace ARDOUR {
class Session; class Session;
class AudioRegion;
class RegionFactory { class RegionFactory {

8
libs/ardour/ardour/route.h
View file

@ -27,6 +27,7 @@
#include <string> #include <string>
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <pbd/fastlog.h> #include <pbd/fastlog.h>
#include <glibmm/thread.h> #include <glibmm/thread.h>
@ -38,13 +39,12 @@
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/io.h> #include <ardour/io.h>
#include <ardour/session.h>
#include <ardour/io_processor.h>
#include <ardour/types.h> #include <ardour/types.h>
namespace ARDOUR { namespace ARDOUR {
class Processor; class Processor;
class IOProcessor;
class Send; class Send;
class RouteGroup; class RouteGroup;
@ -154,7 +154,7 @@ class Route : public IO
ProcessorList::iterator i; ProcessorList::iterator i;
for (i = _processors.begin(); i != _processors.end() && n; ++i, --n); for (i = _processors.begin(); i != _processors.end() && n; ++i, --n);
if (i == _processors.end()) { if (i == _processors.end()) {
return boost::shared_ptr<IOProcessor> (); return boost::shared_ptr<Processor> ();
} else { } else {
return *i; return *i;
} }
@ -227,7 +227,7 @@ class Route : public IO
IO* control_outs() { return _control_outs; } IO* control_outs() { return _control_outs; }
bool feeds (boost::shared_ptr<Route>); bool feeds (boost::shared_ptr<Route>);
set<boost::shared_ptr<Route> > fed_by; std::set<boost::shared_ptr<Route> > fed_by;
struct ToggleControllable : public PBD::Controllable { struct ToggleControllable : public PBD::Controllable {
enum ToggleType { enum ToggleType {

2
libs/ardour/ardour/route_group_specialized.h
View file

@ -21,7 +21,7 @@
#define __ardour_route_group_specialized_h__ #define __ardour_route_group_specialized_h__
#include <ardour/route_group.h> #include <ardour/route_group.h>
#include <ardour/audio_track.h> #include <ardour/track.h>
namespace ARDOUR { namespace ARDOUR {

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

@ -27,7 +27,6 @@
#include <pbd/stateful.h> #include <pbd/stateful.h>
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/audioengine.h> #include <ardour/audioengine.h>
#include <ardour/io.h>
#include <ardour/io_processor.h> #include <ardour/io_processor.h>
namespace ARDOUR { namespace ARDOUR {

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

@ -20,41 +20,38 @@
#ifndef __ardour_session_h__ #ifndef __ardour_session_h__
#define __ardour_session_h__ #define __ardour_session_h__
#include <string>
#include <list> #include <list>
#include <map> #include <map>
#include <vector>
#include <set> #include <set>
#include <stack> #include <stack>
#include <string>
#include <vector>
#include <stdint.h>
#include <boost/dynamic_bitset.hpp>
#include <boost/scoped_ptr.hpp> #include <boost/scoped_ptr.hpp>
#include <boost/weak_ptr.hpp> #include <boost/weak_ptr.hpp>
#include <boost/dynamic_bitset.hpp>
#include <stdint.h>
#include <sndfile.h> #include <sndfile.h>
#include <glibmm/thread.h> #include <glibmm/thread.h>
#include <pbd/error.h> #include <pbd/error.h>
#include <pbd/undo.h>
#include <pbd/pool.h> #include <pbd/pool.h>
#include <pbd/rcu.h> #include <pbd/rcu.h>
#include <pbd/statefuldestructible.h> #include <pbd/statefuldestructible.h>
#include <pbd/undo.h>
#include <midi++/types.h>
#include <midi++/mmc.h> #include <midi++/mmc.h>
#include <midi++/types.h>
#include <pbd/stateful.h>
#include <pbd/destructible.h> #include <pbd/destructible.h>
#include <pbd/stateful.h>
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/chan_count.h>
#include <ardour/configuration.h> #include <ardour/configuration.h>
#include <ardour/location.h> #include <ardour/location.h>
#include <ardour/gain.h>
#include <ardour/chan_count.h>
#include <ardour/smpte.h> #include <ardour/smpte.h>
class XMLTree; class XMLTree;
@ -69,51 +66,50 @@ namespace PBD {
class Controllable; class Controllable;
} }
namespace Evoral {
class Curve;
}
namespace ARDOUR { namespace ARDOUR {
class Port;
class AudioEngine;
class Slave;
class Diskstream;
class Route;
class AuxInput;
class Source;
class AudioSource;
class BufferSet;
class IO;
class Diskstream;
class AudioDiskstream; class AudioDiskstream;
class MidiDiskstream; class AudioEngine;
class AudioFileSource; class AudioFileSource;
class MidiSource;
class Auditioner;
class Processor;
class Send;
class IOProcessor;
class PortInsert;
class PluginInsert;
class Bundle;
class TempoMap;
class AudioTrack;
class NamedSelection;
class AudioRegion; class AudioRegion;
class AudioSource;
class Region; class AudioTrack;
class Playlist; class Auditioner;
class VSTPlugin; class AutomationList;
class AuxInput;
class BufferSet;
class Bundle;
class ControlProtocolInfo; class ControlProtocolInfo;
class Diskstream;
class MidiTrack;
class MidiRegion;
class SMFSource;
class SessionDirectory;
class SessionMetadata;
class ExportHandler; class ExportHandler;
class ExportStatus; class ExportStatus;
class IO;
struct RouteGroup; class IOProcessor;
class MidiDiskstream;
class MidiRegion;
class MidiSource;
class MidiTrack;
class NamedSelection;
class Playlist;
class PluginInsert;
class Port;
class PortInsert;
class Processor;
class Region;
class Route;
class RouteGroup;
class SMFSource;
class Send;
class SessionDirectory;
class SessionMetadata;
class Slave;
class Source;
class TempoMap;
class VSTPlugin;
using std::vector; using std::vector;
using std::string; using std::string;
@ -136,115 +132,115 @@ class Session : public PBD::StatefulDestructible
}; };
struct Event { struct Event {
enum Type { enum Type {
SetTransportSpeed, SetTransportSpeed,
SetDiskstreamSpeed, SetDiskstreamSpeed,
Locate, Locate,
LocateRoll, LocateRoll,
LocateRollLocate, LocateRollLocate,
SetLoop, SetLoop,
PunchIn, PunchIn,
PunchOut, PunchOut,
RangeStop, RangeStop,
RangeLocate, RangeLocate,
Overwrite, Overwrite,
SetSlaveSource, SetSlaveSource,
Audition, Audition,
InputConfigurationChange, InputConfigurationChange,
SetAudioRange, SetAudioRange,
SetPlayRange, SetPlayRange,
/* only one of each of these events /* only one of each of these events
can be queued at any one time can be queued at any one time
*/ */
StopOnce, StopOnce,
AutoLoop AutoLoop
}; };
enum Action { enum Action {
Add, Add,
Remove, Remove,
Replace, Replace,
Clear Clear
}; };
Type type; Type type;
Action action; Action action;
nframes_t action_frame; nframes_t action_frame;
nframes_t target_frame; nframes_t target_frame;
double speed; double speed;
union { union {
void* ptr; void* ptr;
bool yes_or_no; bool yes_or_no;
nframes_t target2_frame; nframes_t target2_frame;
SlaveSource slave; SlaveSource slave;
Route* route; Route* route;
}; };
boost::shared_ptr<Region> region; boost::shared_ptr<Region> region;
list<AudioRange> audio_range; list<AudioRange> audio_range;
list<MusicRange> music_range; list<MusicRange> music_range;
Event(Type t, Action a, nframes_t when, nframes_t where, double spd, bool yn = false) Event(Type t, Action a, nframes_t when, nframes_t where, double spd, bool yn = false)
: type (t), : type (t),
action (a), action (a),
action_frame (when), action_frame (when),
target_frame (where), target_frame (where),
speed (spd), speed (spd),
yes_or_no (yn) {} yes_or_no (yn) {}
void set_ptr (void* p) { void set_ptr (void* p) {
ptr = p; ptr = p;
} }
bool before (const Event& other) const { bool before (const Event& other) const {
return action_frame < other.action_frame; return action_frame < other.action_frame;
} }
bool after (const Event& other) const { bool after (const Event& other) const {
return action_frame > other.action_frame; return action_frame > other.action_frame;
} }
static bool compare (const Event *e1, const Event *e2) { static bool compare (const Event *e1, const Event *e2) {
return e1->before (*e2); return e1->before (*e2);
} }
void *operator new (size_t ignored) { void *operator new (size_t ignored) {
return pool.alloc (); return pool.alloc ();
} }
void operator delete(void *ptr, size_t size) { void operator delete(void *ptr, size_t size) {
pool.release (ptr); pool.release (ptr);
} }
static const nframes_t Immediate = 0; static const nframes_t Immediate = 0;
private: private:
static MultiAllocSingleReleasePool pool; static MultiAllocSingleReleasePool pool;
}; };
/* creating from an XML file */ /* creating from an XML file */
Session (AudioEngine&, Session (AudioEngine&,
const string& fullpath, const string& fullpath,
const string& snapshot_name, const string& snapshot_name,
string mix_template = ""); string mix_template = "");
/* creating a new Session */ /* creating a new Session */
Session (AudioEngine&, Session (AudioEngine&,
string fullpath, string fullpath,
string snapshot_name, string snapshot_name,
AutoConnectOption input_auto_connect, AutoConnectOption input_auto_connect,
AutoConnectOption output_auto_connect, AutoConnectOption output_auto_connect,
uint32_t control_out_channels, uint32_t control_out_channels,
uint32_t master_out_channels, uint32_t master_out_channels,
uint32_t n_physical_in, uint32_t n_physical_in,
uint32_t n_physical_out, uint32_t n_physical_out,
nframes_t initial_length); nframes_t initial_length);
virtual ~Session (); virtual ~Session ();
@ -573,12 +569,12 @@ class Session : public PBD::StatefulDestructible
static sigc::signal<void> EndTimeChanged; static sigc::signal<void> EndTimeChanged;
static sigc::signal<void> SMPTEOffsetChanged; static sigc::signal<void> SMPTEOffsetChanged;
void request_slave_source (SlaveSource); void request_slave_source (SlaveSource);
bool synced_to_jack() const { return Config->get_slave_source() == JACK; } bool synced_to_jack() const { return Config->get_slave_source() == JACK; }
double transport_speed() const { return _transport_speed; } double transport_speed() const { return _transport_speed; }
bool transport_stopped() const { return _transport_speed == 0.0f; } bool transport_stopped() const { return _transport_speed == 0.0f; }
bool transport_rolling() const { return _transport_speed != 0.0f; } bool transport_rolling() const { return _transport_speed != 0.0f; }
void set_silent (bool yn); void set_silent (bool yn);
bool silent () { return _silent; } bool silent () { return _silent; }
@ -615,17 +611,17 @@ class Session : public PBD::StatefulDestructible
/* source management */ /* source management */
struct import_status : public InterThreadInfo { struct import_status : public InterThreadInfo {
string doing_what; string doing_what;
/* control info */ /* control info */
uint32_t total; uint32_t total;
SrcQuality quality; SrcQuality quality;
volatile bool freeze; volatile bool freeze;
std::vector<Glib::ustring> paths; std::vector<Glib::ustring> paths;
bool replace_existing_source; bool replace_existing_source;
/* result */ /* result */
SourceList sources; SourceList sources;
}; };
void import_audiofiles (import_status&); void import_audiofiles (import_status&);
@ -728,8 +724,8 @@ class Session : public PBD::StatefulDestructible
/* flattening stuff */ /* flattening stuff */
boost::shared_ptr<Region> write_one_track (AudioTrack&, nframes_t start, nframes_t end, bool overwrite, vector<boost::shared_ptr<Source> >&, boost::shared_ptr<Region> write_one_track (AudioTrack&, nframes_t start, nframes_t end,
InterThreadInfo& wot); bool overwrite, vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot);
int freeze (InterThreadInfo&); int freeze (InterThreadInfo&);
/* session-wide solo/mute/rec-enable */ /* session-wide solo/mute/rec-enable */
@ -946,21 +942,14 @@ class Session : public PBD::StatefulDestructible
gain_t* gain_automation_buffer () const { return _gain_automation_buffer; } gain_t* gain_automation_buffer () const { return _gain_automation_buffer; }
pan_t** pan_automation_buffer () const { return _pan_automation_buffer; } pan_t** pan_automation_buffer () const { return _pan_automation_buffer; }
/* buffers for conversion */
enum RunContext {
ButlerContext = 0,
TransportContext,
ExportContext
};
/* VST support */ /* VST support */
static long vst_callback (AEffect* effect, static long vst_callback (AEffect* effect,
long opcode, long opcode,
long index, long index,
long value, long value,
void* ptr, void* ptr,
float opt); float opt);
static sigc::signal<void> SendFeedback; static sigc::signal<void> SendFeedback;
@ -971,8 +960,6 @@ class Session : public PBD::StatefulDestructible
void add_controllable (boost::shared_ptr<PBD::Controllable>); void add_controllable (boost::shared_ptr<PBD::Controllable>);
void remove_controllable (PBD::Controllable*); void remove_controllable (PBD::Controllable*);
/* metadata */
SessionMetadata & metadata () { return *_metadata; } SessionMetadata & metadata () { return *_metadata; }
protected: protected:
@ -1208,12 +1195,12 @@ class Session : public PBD::StatefulDestructible
inline bool transport_work_requested() const { return g_atomic_int_get(&butler_should_do_transport_work); } inline bool transport_work_requested() const { return g_atomic_int_get(&butler_should_do_transport_work); }
struct ButlerRequest { struct ButlerRequest {
enum Type { enum Type {
Wake, Wake,
Run, Run,
Pause, Pause,
Quit Quit
}; };
}; };
enum PostTransportWork { enum PostTransportWork {
@ -1235,14 +1222,15 @@ class Session : public PBD::StatefulDestructible
}; };
static const PostTransportWork ProcessCannotProceedMask = static const PostTransportWork ProcessCannotProceedMask =
PostTransportWork (PostTransportInputChange| PostTransportWork (
PostTransportSpeed| PostTransportInputChange|
PostTransportReverse| PostTransportSpeed|
PostTransportCurveRealloc| PostTransportReverse|
PostTransportScrub| PostTransportCurveRealloc|
PostTransportAudition| PostTransportScrub|
PostTransportLocate| PostTransportAudition|
PostTransportStop); PostTransportLocate|
PostTransportStop);
PostTransportWork post_transport_work; PostTransportWork post_transport_work;
@ -1397,15 +1385,11 @@ class Session : public PBD::StatefulDestructible
bool process_can_proceed() const { return !(post_transport_work & ProcessCannotProceedMask); } bool process_can_proceed() const { return !(post_transport_work & ProcessCannotProceedMask); }
struct MIDIRequest { struct MIDIRequest {
enum Type {
enum Type { PortChange,
PortChange, Quit
Quit };
}; Type type;
Type type;
MIDIRequest () {}
}; };
Glib::Mutex midi_lock; Glib::Mutex midi_lock;
@ -1587,18 +1571,18 @@ class Session : public PBD::StatefulDestructible
/* S/W RAID */ /* S/W RAID */
struct space_and_path { struct space_and_path {
uint32_t blocks; /* 4kB blocks */ uint32_t blocks; /* 4kB blocks */
string path; string path;
space_and_path() { space_and_path() {
blocks = 0; blocks = 0;
} }
}; };
struct space_and_path_ascending_cmp { struct space_and_path_ascending_cmp {
bool operator() (space_and_path a, space_and_path b) { bool operator() (space_and_path a, space_and_path b) {
return a.blocks > b.blocks; return a.blocks > b.blocks;
} }
}; };
void setup_raid_path (string path); void setup_raid_path (string path);
@ -1647,36 +1631,36 @@ class Session : public PBD::StatefulDestructible
/* click track */ /* click track */
struct Click { struct Click {
nframes_t start; nframes_t start;
nframes_t duration; nframes_t duration;
nframes_t offset; nframes_t offset;
const Sample *data; const Sample *data;
Click (nframes_t s, nframes_t d, const Sample *b) Click (nframes_t s, nframes_t d, const Sample *b)
: start (s), duration (d), data (b) { offset = 0; } : start (s), duration (d), data (b) { offset = 0; }
void *operator new(size_t ignored) { void *operator new(size_t ignored) {
return pool.alloc (); return pool.alloc ();
}; };
void operator delete(void *ptr, size_t size) { void operator delete(void *ptr, size_t size) {
pool.release (ptr); pool.release (ptr);
} }
private: private:
static Pool pool; static Pool pool;
}; };
typedef list<Click*> Clicks; typedef list<Click*> Clicks;
Clicks clicks; Clicks clicks;
bool _clicking; bool _clicking;
boost::shared_ptr<IO> _click_io; boost::shared_ptr<IO> _click_io;
Sample* click_data; Sample* click_data;
Sample* click_emphasis_data; Sample* click_emphasis_data;
nframes_t click_length; nframes_t click_length;
nframes_t click_emphasis_length; nframes_t click_emphasis_length;
mutable Glib::RWLock click_lock; mutable Glib::RWLock click_lock;
static const Sample default_click[]; static const Sample default_click[];
static const nframes_t default_click_length; static const nframes_t default_click_length;
@ -1711,11 +1695,11 @@ class Session : public PBD::StatefulDestructible
/* VST support */ /* VST support */
long _vst_callback (VSTPlugin*, long _vst_callback (VSTPlugin*,
long opcode, long opcode,
long index, long index,
long value, long value,
void* ptr, void* ptr,
float opt); float opt);
/* number of hardware ports we're using, /* number of hardware ports we're using,
based on max (requested,available) based on max (requested,available)
@ -1730,7 +1714,6 @@ class Session : public PBD::StatefulDestructible
uint32_t n_physical_midi_outputs; uint32_t n_physical_midi_outputs;
uint32_t n_physical_midi_inputs; uint32_t n_physical_midi_inputs;
int find_all_sources (std::string path, std::set<std::string>& result); int find_all_sources (std::string path, std::set<std::string>& result);
int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot); int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
@ -1754,13 +1737,9 @@ class Session : public PBD::StatefulDestructible
static bool _disable_all_loaded_plugins; static bool _disable_all_loaded_plugins;
/* Metadata */
SessionMetadata * _metadata; SessionMetadata * _metadata;
/* used in ::audible_frame() */ mutable bool have_looped; ///< Used in ::audible_frame(*)
mutable bool have_looped;
}; };
} // namespace ARDOUR } // namespace ARDOUR

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

@ -29,6 +29,7 @@ class Session;
class Diskstream; class Diskstream;
class Playlist; class Playlist;
class RouteGroup; class RouteGroup;
class Region;
class Track : public Route class Track : public Route
{ {

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

@ -378,6 +378,12 @@ namespace ARDOUR {
LV2, LV2,
VST VST
}; };
enum RunContext {
ButlerContext = 0,
TransportContext,
ExportContext
};
enum SlaveSource { enum SlaveSource {
None = 0, None = 0,

6
libs/ardour/audio_diskstream.cc
View file

@ -53,6 +53,8 @@
#include <ardour/audio_port.h> #include <ardour/audio_port.h>
#include <ardour/source_factory.h> #include <ardour/source_factory.h>
#include <ardour/audio_buffer.h> #include <ardour/audio_buffer.h>
#include <ardour/session.h>
#include <ardour/io.h>
#include "i18n.h" #include "i18n.h"
#include <locale.h> #include <locale.h>
@ -1403,7 +1405,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
* written at all unless @a force_flush is true. * written at all unless @a force_flush is true.
*/ */
int int
AudioDiskstream::do_flush (Session::RunContext context, bool force_flush) AudioDiskstream::do_flush (RunContext context, bool force_flush)
{ {
uint32_t to_write; uint32_t to_write;
int32_t ret = 0; int32_t ret = 0;
@ -1555,7 +1557,7 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
*/ */
while (more_work && !err) { while (more_work && !err) {
switch (do_flush (Session::TransportContext, true)) { switch (do_flush (TransportContext, true)) {
case 0: case 0:
more_work = false; more_work = false;
break; break;

3
libs/ardour/diskstream.cc
View file

@ -50,6 +50,9 @@
#include <ardour/cycle_timer.h> #include <ardour/cycle_timer.h>
#include <ardour/region.h> #include <ardour/region.h>
#include <ardour/panner.h> #include <ardour/panner.h>
#include <ardour/session.h>
#include <ardour/io.h>
#include <ardour/route.h>
#include "i18n.h" #include "i18n.h"
#include <locale.h> #include <locale.h>

11
libs/ardour/export_channel.cc
View file

@ -18,12 +18,13 @@
*/ */
#include <ardour/export_channel.h>
#include <ardour/export_failed.h>
#include <ardour/audioengine.h>
#include <ardour/audio_port.h>
#include <ardour/audio_buffer.h> #include <ardour/audio_buffer.h>
#include <ardour/audio_port.h>
#include <ardour/audio_track.h>
#include <ardour/audioengine.h>
#include <ardour/export_channel.h>
#include <ardour/export_failed.h>
#include <ardour/session.h>
using namespace ARDOUR; using namespace ARDOUR;

1
libs/ardour/internal_send.cc
View file

@ -28,6 +28,7 @@
#include <ardour/buffer_set.h> #include <ardour/buffer_set.h>
#include <ardour/meter.h> #include <ardour/meter.h>
#include <ardour/panner.h> #include <ardour/panner.h>
#include <ardour/io.h>
#include "i18n.h" #include "i18n.h"

32
libs/ardour/io_processor.cc
View file

@ -35,6 +35,7 @@
#include <ardour/send.h> #include <ardour/send.h>
#include <ardour/port_insert.h> #include <ardour/port_insert.h>
#include <ardour/plugin_insert.h> #include <ardour/plugin_insert.h>
#include <ardour/io.h>
#include "i18n.h" #include "i18n.h"
@ -121,3 +122,34 @@ IOProcessor::silence (nframes_t nframes, nframes_t offset)
{ {
_io->silence(nframes, offset); _io->silence(nframes, offset);
} }
ChanCount
IOProcessor::output_streams() const
{
return _io->n_outputs();
}
ChanCount
IOProcessor::input_streams () const
{
return _io->n_inputs();
}
ChanCount
IOProcessor::natural_output_streams() const
{
return _io->n_outputs();
}
ChanCount
IOProcessor::natural_input_streams () const
{
return _io->n_inputs();
}
void
IOProcessor::automation_snapshot (nframes_t now, bool force)
{
_io->automation_snapshot(now, force);
}

22
libs/ardour/midi_diskstream.cc
View file

@ -38,17 +38,19 @@
#include <ardour/ardour.h> #include <ardour/ardour.h>
#include <ardour/audioengine.h> #include <ardour/audioengine.h>
#include <ardour/midi_diskstream.h>
#include <ardour/utils.h>
#include <ardour/configuration.h> #include <ardour/configuration.h>
#include <ardour/smf_source.h>
#include <ardour/send.h>
#include <ardour/region_factory.h>
#include <ardour/midi_playlist.h>
#include <ardour/playlist_factory.h>
#include <ardour/cycle_timer.h> #include <ardour/cycle_timer.h>
#include <ardour/midi_region.h> #include <ardour/io.h>
#include <ardour/midi_diskstream.h>
#include <ardour/midi_playlist.h>
#include <ardour/midi_port.h> #include <ardour/midi_port.h>
#include <ardour/midi_region.h>
#include <ardour/playlist_factory.h>
#include <ardour/region_factory.h>
#include <ardour/send.h>
#include <ardour/session.h>
#include <ardour/smf_source.h>
#include <ardour/utils.h>
#include "i18n.h" #include "i18n.h"
#include <locale.h> #include <locale.h>
@ -870,7 +872,7 @@ MidiDiskstream::do_refill ()
* written at all unless @a force_flush is true. * written at all unless @a force_flush is true.
*/ */
int int
MidiDiskstream::do_flush (Session::RunContext context, bool force_flush) MidiDiskstream::do_flush (RunContext context, bool force_flush)
{ {
uint32_t to_write; uint32_t to_write;
int32_t ret = 0; int32_t ret = 0;
@ -941,7 +943,7 @@ MidiDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_cap
*/ */
while (more_work && !err) { while (more_work && !err) {
switch (do_flush (Session::TransportContext, true)) { switch (do_flush (TransportContext, true)) {
case 0: case 0:
more_work = false; more_work = false;
break; break;

1
libs/ardour/route_group.cc
View file

@ -31,6 +31,7 @@
#include <ardour/audio_track.h> #include <ardour/audio_track.h>
#include <ardour/audio_diskstream.h> #include <ardour/audio_diskstream.h>
#include <ardour/configuration.h> #include <ardour/configuration.h>
#include <ardour/session.h>
using namespace ARDOUR; using namespace ARDOUR;
using namespace sigc; using namespace sigc;

1
libs/ardour/send.cc
View file

@ -28,6 +28,7 @@
#include <ardour/buffer_set.h> #include <ardour/buffer_set.h>
#include <ardour/meter.h> #include <ardour/meter.h>
#include <ardour/panner.h> #include <ardour/panner.h>
#include <ardour/io.h>
#include "i18n.h" #include "i18n.h"

61
libs/ardour/session.cc
View file

@ -43,47 +43,48 @@
#include <pbd/stacktrace.h> #include <pbd/stacktrace.h>
#include <pbd/file_utils.h> #include <pbd/file_utils.h>
#include <ardour/audioengine.h> #include <ardour/analyser.h>
#include <ardour/configuration.h> #include <ardour/audio_buffer.h>
#include <ardour/session.h>
#include <ardour/session_directory.h>
#include <ardour/session_metadata.h>
#include <ardour/utils.h>
#include <ardour/audio_diskstream.h> #include <ardour/audio_diskstream.h>
#include <ardour/audio_track.h>
#include <ardour/audioengine.h>
#include <ardour/audiofilesource.h>
#include <ardour/audioplaylist.h> #include <ardour/audioplaylist.h>
#include <ardour/audioregion.h> #include <ardour/audioregion.h>
#include <ardour/audiofilesource.h> #include <ardour/auditioner.h>
#include <ardour/buffer_set.h>
#include <ardour/bundle.h>
#include <ardour/click.h>
#include <ardour/configuration.h>
#include <ardour/crossfade.h>
#include <ardour/cycle_timer.h>
#include <ardour/data_type.h>
#include <ardour/filename_extensions.h>
#include <ardour/internal_send.h>
#include <ardour/io_processor.h>
#include <ardour/midi_diskstream.h> #include <ardour/midi_diskstream.h>
#include <ardour/midi_playlist.h> #include <ardour/midi_playlist.h>
#include <ardour/midi_region.h> #include <ardour/midi_region.h>
#include <ardour/smf_source.h> #include <ardour/midi_track.h>
#include <ardour/auditioner.h> #include <ardour/named_selection.h>
#include <ardour/recent_sessions.h> #include <ardour/playlist.h>
#include <ardour/io_processor.h>
#include <ardour/send.h>
#include <ardour/processor.h>
#include <ardour/plugin_insert.h> #include <ardour/plugin_insert.h>
#include <ardour/port_insert.h> #include <ardour/port_insert.h>
#include <ardour/slave.h> #include <ardour/processor.h>
#include <ardour/tempo.h> #include <ardour/recent_sessions.h>
#include <ardour/audio_track.h>
#include <ardour/midi_track.h>
#include <ardour/cycle_timer.h>
#include <ardour/named_selection.h>
#include <ardour/crossfade.h>
#include <ardour/playlist.h>
#include <ardour/internal_send.h>
#include <ardour/click.h>
#include <ardour/data_type.h>
#include <ardour/buffer_set.h>
#include <ardour/source_factory.h>
#include <ardour/region_factory.h> #include <ardour/region_factory.h>
#include <ardour/filename_extensions.h> #include <ardour/route_group.h>
#include <ardour/send.h>
#include <ardour/session.h>
#include <ardour/session_directory.h> #include <ardour/session_directory.h>
#include <ardour/session_directory.h>
#include <ardour/session_metadata.h>
#include <ardour/slave.h>
#include <ardour/smf_source.h>
#include <ardour/source_factory.h>
#include <ardour/tape_file_matcher.h> #include <ardour/tape_file_matcher.h>
#include <ardour/analyser.h> #include <ardour/tempo.h>
#include <ardour/audio_buffer.h> #include <ardour/utils.h>
#include <ardour/bundle.h>
#include "i18n.h" #include "i18n.h"

11
libs/ardour/session_butler.cc
View file

@ -31,12 +31,13 @@
#include <pbd/pthread_utils.h> #include <pbd/pthread_utils.h>
#include <pbd/stacktrace.h> #include <pbd/stacktrace.h>
#include <ardour/configuration.h>
#include <ardour/audioengine.h>
#include <ardour/session.h>
#include <ardour/audio_diskstream.h> #include <ardour/audio_diskstream.h>
#include <ardour/midi_diskstream.h> #include <ardour/audioengine.h>
#include <ardour/configuration.h>
#include <ardour/crossfade.h> #include <ardour/crossfade.h>
#include <ardour/io.h>
#include <ardour/midi_diskstream.h>
#include <ardour/session.h>
#include <ardour/timestamps.h> #include <ardour/timestamps.h>
#include "i18n.h" #include "i18n.h"
@ -315,7 +316,7 @@ Session::butler_thread_work ()
/* note that we still try to flush diskstreams attached to inactive routes /* note that we still try to flush diskstreams attached to inactive routes
*/ */
switch ((*i)->do_flush (Session::ButlerContext)) { switch ((*i)->do_flush (ButlerContext)) {
case 0: case 0:
bytes += (*i)->write_data_count(); bytes += (*i)->write_data_count();
break; break;

13
libs/ardour/session_export.cc
View file

@ -22,17 +22,18 @@
#include <pbd/error.h> #include <pbd/error.h>
#include <glibmm/thread.h> #include <glibmm/thread.h>
#include <ardour/ardour.h>
#include <ardour/audio_diskstream.h>
#include <ardour/audioengine.h>
#include <ardour/export_failed.h> #include <ardour/export_failed.h>
#include <ardour/export_file_io.h> #include <ardour/export_file_io.h>
#include <ardour/export_utilities.h>
#include <ardour/export_handler.h> #include <ardour/export_handler.h>
#include <ardour/export_status.h> #include <ardour/export_status.h>
#include <ardour/timestamps.h> #include <ardour/export_utilities.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
#include <ardour/audioengine.h>
#include <ardour/audio_diskstream.h>
#include <ardour/panner.h> #include <ardour/panner.h>
#include <ardour/route.h>
#include <ardour/session.h>
#include <ardour/timestamps.h>
#include "i18n.h" #include "i18n.h"

1
libs/ardour/session_state.cc
View file

@ -103,6 +103,7 @@
#include <ardour/directory_names.h> #include <ardour/directory_names.h>
#include <ardour/template_utils.h> #include <ardour/template_utils.h>
#include <ardour/ticker.h> #include <ardour/ticker.h>
#include <ardour/route_group.h>
#include <control_protocol/control_protocol.h> #include <control_protocol/control_protocol.h>

1
libs/ardour/smf_source.cc
View file

@ -33,6 +33,7 @@
#include <glibmm/miscutils.h> #include <glibmm/miscutils.h>
#include <evoral/SMFReader.hpp> #include <evoral/SMFReader.hpp>
#include <evoral/Control.hpp>
#include <ardour/smf_source.h> #include <ardour/smf_source.h>
#include <ardour/session.h> #include <ardour/session.h>

8
libs/surfaces/control_protocol/control_protocol.cc
View file

@ -117,12 +117,12 @@ ControlProtocol::prev_track (uint32_t initial_id)
} }
if (id < 0) { if (id < 0) {
id = limit; uint32_t i = limit;
while (id > initial_id) { while (i > initial_id) {
if ((cr = session->route_by_remote_id (id)) != 0) { if ((cr = session->route_by_remote_id (i)) != 0) {
break; break;
} }
id--; i--;
} }
} }