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

Work towards removal of Session's Diskstream list. 

Havn't managed to completely remove it because of Session loading from XML - the
Diskstreams are separate from the Tracks (I assume as a throwback to when they
were distinct) so the Diskstreams need to be stored somewhere until the Tracks
are loaded.  Ideally tracks should completely own their Diskstreams - not sure
how to accomplish this without breaking Session loading though...


git-svn-id: svn://localhost/ardour2/branches/midi@687 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
David Robillard 2006-07-19 05:44:23 +00:00
parent 50a3102b9b
commit 0cdb918d4d
25 changed files with 133 additions and 586 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
gtk2_ardour/ardour_ui.cc
View File

@ -53,7 +53,7 @@
#include <ardour/audio_diskstream.h>
#include <ardour/audiofilesource.h>
#include <ardour/recent_sessions.h>
#include <ardour/session_diskstream.h>
#include <ardour/session_route.h>
#include <ardour/port.h>
#include <ardour/audio_track.h>
#include <ardour/midi_track.h>
@ -544,9 +544,10 @@ ARDOUR_UI::update_buffer_load ()
}
void
ARDOUR_UI::count_recenabled_diskstreams (Diskstream& ds)
ARDOUR_UI::count_recenabled_diskstreams (Route* route)
{
if (ds.record_enabled()) {
Track* track = dynamic_cast<Track*>(route);
if (track && track->diskstream().record_enabled()) {
rec_enabled_diskstreams++;
}
}
@ -572,7 +573,7 @@ ARDOUR_UI::update_disk_space()
if (session->actively_recording()){
rec_enabled_diskstreams = 0;
session->foreach_diskstream (this, &ARDOUR_UI::count_recenabled_diskstreams);
session->foreach_route (this, &ARDOUR_UI::count_recenabled_diskstreams);
if (rec_enabled_diskstreams) {
frames /= rec_enabled_diskstreams;
@ -592,7 +593,7 @@ ARDOUR_UI::update_disk_space()
frames -= mins * fr * 60;
secs = frames / fr;
snprintf (buf, sizeof(buf), _("Space: %02dh:%02dm:%02ds"), hrs, mins, secs);
snprintf (buf, sizeof(buf), _("Disk: %02dh:%02dm:%02ds"), hrs, mins, secs);
}
disk_space_label.set_text (buf);
@ -1210,10 +1211,10 @@ ARDOUR_UI::toggle_record_enable (uint32_t dstream)
if ((r = session->route_by_remote_id (dstream)) != 0) {
AudioTrack* at;
Track* t;
if ((at = dynamic_cast<AudioTrack*>(r)) != 0) {
at->disk_stream().set_record_enabled (!at->disk_stream().record_enabled(), this);
if ((t = dynamic_cast<Track*>(r)) != 0) {
t->diskstream().set_record_enabled (!t->diskstream().record_enabled(), this);
}
}
if (session == 0) {

2
gtk2_ardour/ardour_ui.h
View File

@ -628,7 +628,7 @@ class ARDOUR_UI : public Gtkmm2ext::UI
void toggle_record_enable (uint32_t);
uint32_t rec_enabled_diskstreams;
void count_recenabled_diskstreams (ARDOUR::Diskstream&);
void count_recenabled_diskstreams (ARDOUR::Route*);
About* about;
bool shown_flag;

4
gtk2_ardour/audio_time_axis.cc
View File

@ -230,8 +230,8 @@ AudioTimeAxisView::AudioTimeAxisView (PublicEditor& ed, Session& sess, Route& rt
audio_track()->FreezeChange.connect (mem_fun(*this, &AudioTimeAxisView::map_frozen));
audio_track()->diskstream_changed.connect (mem_fun(*this, &AudioTimeAxisView::diskstream_changed));
get_diskstream()->speed_changed.connect (mem_fun(*this, &AudioTimeAxisView::speed_changed));
audio_track()->DiskstreamChanged.connect (mem_fun(*this, &AudioTimeAxisView::diskstream_changed));
get_diskstream()->SpeedChanged.connect (mem_fun(*this, &AudioTimeAxisView::speed_changed));
controls_ebox.set_name ("AudioTrackControlsBaseUnselected");
controls_base_selected_name = "AudioTrackControlsBaseSelected";

4
gtk2_ardour/editor_audio_import.cc
View File

@ -314,7 +314,7 @@ int
case ImportToTrack:
if (track) {
Playlist* playlist = track->disk_stream().playlist();
Playlist* playlist = track->diskstream().playlist();
AudioRegion* copy = new AudioRegion (region);
begin_reversible_command (_("insert sndfile"));
@ -330,7 +330,7 @@ int
case ImportAsTrack:
AudioTrack* at = session->new_audio_track (in_chans, out_chans);
AudioRegion* copy = new AudioRegion (region);
at->disk_stream().playlist()->add_region (*copy, pos);
at->diskstream().playlist()->add_region (*copy, pos);
break;
}

2
gtk2_ardour/editor_timefx.cc
View File

@ -184,7 +184,7 @@ Editor::do_timestretch (TimeStretchDialog& dialog)
continue;
}
if ((playlist = at->disk_stream().playlist()) == 0) {
if ((playlist = at->diskstream().playlist()) == 0) {
i = tmp;
continue;
}

46
gtk2_ardour/mixer_strip.cc
View File

@ -290,8 +290,8 @@ MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, Route& rt, bool in_mixer)
_route.panner().Changed.connect (mem_fun(*this, &MixerStrip::connect_to_pan));
if (is_audio_track()) {
audio_track()->diskstream_changed.connect (mem_fun(*this, &MixerStrip::diskstream_changed));
get_diskstream()->speed_changed.connect (mem_fun(*this, &MixerStrip::speed_changed));
audio_track()->DiskstreamChanged.connect (mem_fun(*this, &MixerStrip::diskstream_changed));
get_diskstream()->SpeedChanged.connect (mem_fun(*this, &MixerStrip::speed_changed));
}
_route.name_changed.connect (mem_fun(*this, &RouteUI::name_changed));
@ -558,11 +558,6 @@ MixerStrip::input_press (GdkEventButton *ev)
case 1:
#if ADVANCED_ROUTE_DISKSTREAM_CONNECTIVITY
if (is_audio_track()) {
citems.push_back (MenuElem (_("Track"), mem_fun(*this, &MixerStrip::select_stream_input)));
}
#endif
citems.push_back (MenuElem (_("Edit"), mem_fun(*this, &MixerStrip::edit_input_configuration)));
citems.push_back (SeparatorElem());
citems.push_back (MenuElem (_("Disconnect"), mem_fun (*(static_cast<RouteUI*>(this)), &RouteUI::disconnect_input)));
@ -659,43 +654,6 @@ MixerStrip::add_connection_to_output_menu (ARDOUR::Connection* c)
}
}
void
MixerStrip::select_stream_input ()
{
using namespace Menu_Helpers;
Menu *stream_menu = manage (new Menu);
MenuList& items = stream_menu->items();
stream_menu->set_name ("ArdourContextMenu");
Session::DiskstreamList streams = _session.disk_streams();
for (Session::DiskstreamList::iterator i = streams.begin(); i != streams.end(); ++i) {
AudioDiskstream* ads = dynamic_cast<AudioDiskstream*>(*i);
if (ads && !(*i)->hidden()) {
items.push_back (CheckMenuElem (ads->name(), bind (mem_fun(*this, &MixerStrip::stream_input_chosen), ads)));
if (get_diskstream() == ads) {
ignore_toggle = true;
static_cast<CheckMenuItem *> (&items.back())->set_active (true);
ignore_toggle = false;
}
}
}
stream_menu->popup (1, 0);
}
void
MixerStrip::stream_input_chosen (AudioDiskstream *stream)
{
if (is_audio_track()) {
audio_track()->set_diskstream (*stream, this);
}
}
void
MixerStrip::update_diskstream_display ()
{

2
gtk2_ardour/mixer_strip.h
View File

@ -171,8 +171,6 @@ class MixerStrip : public RouteUI, public Gtk::EventBox
Gtk::Menu output_menu;
void add_connection_to_output_menu (ARDOUR::Connection *);
void stream_input_chosen (ARDOUR::AudioDiskstream*);
void select_stream_input ();
void connection_input_chosen (ARDOUR::Connection *);
void connection_output_chosen (ARDOUR::Connection *);

2
gtk2_ardour/playlist_selector.cc
View File

@ -243,7 +243,7 @@ PlaylistSelector::selection_changed ()
return;
}
at->disk_stream().use_playlist (apl);
at->diskstream().use_playlist (apl);
hide ();
}

11
gtk2_ardour/route_ui.cc
View File

@ -75,7 +75,7 @@ RouteUI::RouteUI (ARDOUR::Route& rt, ARDOUR::Session& sess, const char* m_name,
if (is_audio_track()) {
AudioTrack* at = dynamic_cast<AudioTrack*>(&_route);
get_diskstream()->record_enable_changed.connect (mem_fun (*this, &RouteUI::route_rec_enable_changed));
get_diskstream()->RecordEnableChanged.connect (mem_fun (*this, &RouteUI::route_rec_enable_changed));
_session.RecordStateChanged.connect (mem_fun (*this, &RouteUI::session_rec_enable_changed));
@ -886,13 +886,10 @@ RouteUI::is_midi_track () const
Diskstream*
RouteUI::get_diskstream () const
{
AudioTrack *at;
MidiTrack *mt;
Track *t;
if ((at = dynamic_cast<AudioTrack*>(&_route)) != 0) {
return &at->disk_stream();
} else if ((mt = dynamic_cast<MidiTrack*>(&_route)) != 0) {
return &mt->disk_stream();
if ((t = dynamic_cast<Track*>(&_route)) != 0) {
return &t->diskstream();
} else {
return 0;
}

8
gtk2_ardour/streamview.cc
View File

@ -71,9 +71,9 @@ StreamView::StreamView (AudioTimeAxisView& tv)
_amplitude_above_axis = 1.0;
if (_trackview.is_audio_track()) {
_trackview.audio_track()->diskstream_changed.connect (mem_fun (*this, &StreamView::diskstream_changed));
_trackview.audio_track()->DiskstreamChanged.connect (mem_fun (*this, &StreamView::diskstream_changed));
_trackview.session().TransportStateChange.connect (mem_fun (*this, &StreamView::transport_changed));
_trackview.get_diskstream()->record_enable_changed.connect (mem_fun (*this, &StreamView::rec_enable_changed));
_trackview.get_diskstream()->RecordEnableChanged.connect (mem_fun (*this, &StreamView::rec_enable_changed));
_trackview.session().RecordStateChanged.connect (mem_fun (*this, &StreamView::sess_rec_enable_changed));
}
@ -501,7 +501,7 @@ StreamView::diskstream_changed (void *src_ignored)
AudioTrack *at;
if ((at = _trackview.audio_track()) != 0) {
AudioDiskstream& ds = at->disk_stream();
AudioDiskstream& ds = at->audio_diskstream();
/* XXX grrr: when will SigC++ allow me to bind references? */
Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun (*this, &StreamView::display_diskstream), &ds));
} else {
@ -672,7 +672,7 @@ StreamView::setup_rec_box ()
AudioTrack* at;
at = _trackview.audio_track(); /* we know what it is already */
AudioDiskstream& ds = at->disk_stream();
AudioDiskstream& ds = at->audio_diskstream();
jack_nframes_t frame_pos = ds.current_capture_start ();
gdouble xstart = _trackview.editor.frame_to_pixel (frame_pos);
gdouble xend;

3
libs/ardour/SConscript
View File

@ -27,6 +27,8 @@ ardour.Append(POTFILE = domain + '.pot')
ardour.Append(CPPPATH = '#libs/surfaces/control_protocol')
ardour_files=Split("""
diskstream.cc
track.cc
audio_diskstream.cc
audio_library.cc
audio_playlist.cc
@ -36,7 +38,6 @@ audiofilesource.cc
audiofilter.cc
audioregion.cc
audiosource.cc
diskstream.cc
midi_source.cc
midi_diskstream.cc
midi_playlist.cc

2
libs/ardour/ardour/audio_diskstream.h
View File

@ -172,6 +172,8 @@ class AudioDiskstream : public Diskstream
const PBD::ID& id() const { return _id; }
XMLNode* deprecated_io_node;
protected:
friend class Session;

106
libs/ardour/ardour/audio_track.h
View File

@ -21,7 +21,7 @@
#ifndef __ardour_audio_track_h__
#define __ardour_audio_track_h__
#include <ardour/route.h>
#include <ardour/track.h>
namespace ARDOUR {
@ -30,7 +30,7 @@ class AudioDiskstream;
class AudioPlaylist;
class RouteGroup;
class AudioTrack : public Route
class AudioTrack : public Track
{
public:
AudioTrack (Session&, string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal);
@ -39,67 +39,39 @@ class AudioTrack : public Route
int set_name (string str, void *src);
int roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
int roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, int declick, bool can_record, bool rec_monitors_input);
int no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input);
int silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, bool can_record, bool rec_monitors_input);
jack_nframes_t offset, int declick, bool can_record, bool rec_monitors_input);
int no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input);
int silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, bool can_record, bool rec_monitors_input);
void toggle_monitor_input ();
bool can_record() const { return true; }
void set_record_enable (bool yn, void *src);
AudioDiskstream& disk_stream() const { return *_diskstream; }
int set_diskstream (AudioDiskstream&, void *);
AudioDiskstream& audio_diskstream() const;
int use_diskstream (string name);
int use_diskstream (const PBD::ID& id);
TrackMode mode() const { return _mode; }
void set_mode (TrackMode m);
sigc::signal<void> ModeChanged;
jack_nframes_t update_total_latency();
void set_latency_delay (jack_nframes_t);
int export_stuff (vector<Sample*>& buffers, char * workbuf, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t end_frame);
sigc::signal<void,void*> diskstream_changed;
enum FreezeState {
NoFreeze,
Frozen,
UnFrozen
};
FreezeState freeze_state() const;
sigc::signal<void> FreezeChange;
void freeze (InterThreadInfo&);
void unfreeze ();
void bounce (InterThreadInfo&);
void bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo&);
XMLNode& get_state();
XMLNode& get_template();
int set_state(const XMLNode& node);
PBD::Controllable& rec_enable_control() {
return _rec_enable_control;
}
bool record_enabled() const;
void set_meter_point (MeterPoint, void* src);
protected:
AudioDiskstream *_diskstream;
MeterPoint _saved_meter_point;
TrackMode _mode;
XMLNode& state (bool full);
void passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame,
@ -107,61 +79,15 @@ class AudioTrack : public Route
bool meter);
uint32_t n_process_buffers ();
private:
struct FreezeRecordInsertInfo {
FreezeRecordInsertInfo(XMLNode& st)
: state (st), insert (0) {}
int set_diskstream (AudioDiskstream&, void *);
XMLNode state;
Insert* insert;
PBD::ID id;
UndoAction memento;
};
struct FreezeRecord {
FreezeRecord() {
playlist = 0;
have_mementos = false;
}
~FreezeRecord();
AudioPlaylist* playlist;
vector<FreezeRecordInsertInfo*> insert_info;
bool have_mementos;
FreezeState state;
};
FreezeRecord _freeze_record;
XMLNode* pending_state;
void diskstream_record_enable_changed (void *src);
void diskstream_input_channel_changed (void *src);
void input_change_handler (void *src);
sigc::connection recenable_connection;
sigc::connection ic_connection;
int deprecated_use_diskstream_connections ();
int deprecated_use_diskstream_connections ();
void set_state_part_two ();
void set_state_part_three ();
struct RecEnableControllable : public PBD::Controllable {
RecEnableControllable (AudioTrack&);
void set_value (float);
float get_value (void) const;
AudioTrack& track;
};
RecEnableControllable _rec_enable_control;
bool _destructive;
};
}; /* namespace ARDOUR*/
} /* namespace ARDOUR*/
#endif /* __ardour_audio_track_h__ */

8
libs/ardour/ardour/diskstream.h
View File

@ -146,9 +146,9 @@ class Diskstream : public Stateful, public sigc::trackable
virtual void handle_input_change (IOChange, void *src);
sigc::signal<void,void*> record_enable_changed;
sigc::signal<void> speed_changed;
sigc::signal<void,void*> reverse_changed;
sigc::signal<void,void*> RecordEnableChanged;
sigc::signal<void> SpeedChanged;
sigc::signal<void,void*> ReverseChanged;
sigc::signal<void> PlaylistChanged;
sigc::signal<void> AlignmentStyleChanged;
@ -156,8 +156,6 @@ class Diskstream : public Stateful, public sigc::trackable
static sigc::signal<void> DiskUnderrun;
static sigc::signal<void,Diskstream*> DiskstreamCreated; // XXX use a ref with sigc2
//static sigc::signal<void,list<Source*>*> DeleteSources;
XMLNode* deprecated_io_node;
protected:
friend class Session;

112
libs/ardour/ardour/midi_track.h
View File

@ -20,7 +20,7 @@
#ifndef __ardour_midi_track_h__
#define __ardour_midi_track_h__
#include <ardour/route.h>
#include <ardour/track.h>
namespace ARDOUR
{
@ -30,79 +30,49 @@ class MidiDiskstream;
class MidiPlaylist;
class RouteGroup;
class MidiTrack : public Route
class MidiTrack : public Track
{
public:
MidiTrack (Session&, string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal);
MidiTrack (Session&, const XMLNode&);
~MidiTrack ();
int set_name (string str, void *src);
int roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, int declick, bool can_record, bool rec_monitors_input);
int no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input);
int silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, bool can_record, bool rec_monitors_input);
void toggle_monitor_input ();
bool can_record() const { return true; }
int roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, int declick, bool can_record, bool rec_monitors_input);
int no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input);
int silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, bool can_record, bool rec_monitors_input);
void set_record_enable (bool yn, void *src);
MidiDiskstream& disk_stream() const { return *_diskstream; }
MidiDiskstream& midi_diskstream() const;
int set_diskstream (MidiDiskstream&, void *);
int use_diskstream (string name);
int use_diskstream (const PBD::ID& id);
TrackMode mode() const { return _mode; }
void set_mode (TrackMode m);
sigc::signal<void> ModeChanged;
jack_nframes_t update_total_latency();
void set_latency_delay (jack_nframes_t);
void set_latency_delay (jack_nframes_t);
int export_stuff (vector<unsigned char*>& buffers, char * workbuf, uint32_t nbufs,
jack_nframes_t nframes, jack_nframes_t end_frame);
sigc::signal<void,void*> diskstream_changed;
enum FreezeState {
NoFreeze,
Frozen,
UnFrozen
};
FreezeState freeze_state() const;
sigc::signal<void> FreezeChange;
void freeze (InterThreadInfo&);
void unfreeze ();
void bounce (InterThreadInfo&);
void bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo&);
XMLNode& get_state();
XMLNode& get_template();
int set_state(const XMLNode& node);
PBD::Controllable& rec_enable_control() { return _rec_enable_control; }
bool record_enabled() const;
void set_meter_point (MeterPoint, void* src);
protected:
MidiDiskstream *_diskstream;
MeterPoint _saved_meter_point;
TrackMode _mode;
XMLNode& state (bool full);
void passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame,
@ -112,64 +82,12 @@ protected:
uint32_t n_process_buffers ();
private:
struct FreezeRecordInsertInfo
{
FreezeRecordInsertInfo(XMLNode& st)
: state (st), insert (0)
{}
int set_diskstream (MidiDiskstream&, void *);
XMLNode state;
Insert* insert;
PBD::ID id;
UndoAction memento;
};
struct FreezeRecord
{
FreezeRecord()
{
playlist = 0;
have_mementos = false;
}
~FreezeRecord();
MidiPlaylist* playlist;
vector<FreezeRecordInsertInfo*> insert_info;
bool have_mementos;
FreezeState state;
};
FreezeRecord _freeze_record;
XMLNode* pending_state;
void diskstream_record_enable_changed (void *src);
void diskstream_input_channel_changed (void *src);
void input_change_handler (void *src);
sigc::connection recenable_connection;
sigc::connection ic_connection;
int deprecated_use_diskstream_connections ();
void set_state_part_two ();
void set_state_part_three ();
struct MIDIRecEnableControllable : public PBD::Controllable {
MIDIRecEnableControllable (MidiTrack&);
void set_value (float);
float get_value (void) const;
MidiTrack& track;
};
MIDIRecEnableControllable _rec_enable_control;
bool _destructive;
};
}
; /* namespace ARDOUR*/
} /* namespace ARDOUR*/
#endif /* __ardour_midi_track_h__ */

7
libs/ardour/ardour/session.h
View File

@ -290,15 +290,8 @@ class Session : public sigc::trackable, public Stateful
uint32_t get_next_diskstream_id() const { return n_diskstreams(); }
uint32_t n_diskstreams() const;
template<class T> void foreach_diskstream (T *obj, void (T::*func)(Diskstream&));
typedef list<Diskstream *> DiskstreamList;
Session::DiskstreamList disk_streams() const {
Glib::RWLock::ReaderLock lm (diskstream_lock);
return diskstreams; /* XXX yes, force a copy */
}
typedef list<Route *> RouteList;
RouteList get_routes() const {

42
libs/ardour/ardour/session_diskstream.h
View File

@ -1,42 +0,0 @@
/*
Copyright (C) 2002 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.
$Id$
*/
#ifndef __ardour_session_diskstream_h__
#define __ardour_session_diskstream_h__
#include <ardour/session.h>
#include <ardour/audio_diskstream.h>
namespace ARDOUR {
template<class T> void
Session::foreach_diskstream (T *obj, void (T::*func)(Diskstream&))
{
Glib::RWLock::ReaderLock lm (diskstream_lock);
for (DiskstreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); i++) {
if (!(*i)->hidden()) {
(obj->*func) (**i);
}
}
}
} /* namespace */
#endif /* __ardour_session_diskstream_h__ */

6
libs/ardour/audio_diskstream.cc
View File

@ -59,6 +59,7 @@ sigc::signal<void,list<AudioFileSource*>*> AudioDiskstream::DeleteSources;
AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
: Diskstream(sess, name, flag)
, deprecated_io_node(NULL)
, _playlist(NULL)
{
/* prevent any write sources from being created */
@ -75,6 +76,7 @@ AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream:
AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
: Diskstream(sess, node)
, deprecated_io_node(NULL)
, _playlist(NULL)
{
in_set_state = true;
@ -1832,7 +1834,7 @@ AudioDiskstream::engage_record_enable (void* src)
}
}
record_enable_changed (src); /* EMIT SIGNAL */
RecordEnableChanged (src); /* EMIT SIGNAL */
}
void
@ -1847,7 +1849,7 @@ AudioDiskstream::disengage_record_enable (void* src)
}
}
capturing_sources.clear ();
record_enable_changed (src); /* EMIT SIGNAL */
RecordEnableChanged (src); /* EMIT SIGNAL */
}

139
libs/ardour/audio_track.cc
View File

@ -41,9 +41,7 @@ using namespace ARDOUR;
using namespace PBD;
AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode mode)
: Route (sess, name, 1, -1, -1, -1, flag),
_diskstream (0),
_rec_enable_control (*this)
: Track (sess, name, flag, mode)
{
AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0);
@ -68,9 +66,7 @@ AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode
}
AudioTrack::AudioTrack (Session& sess, const XMLNode& node)
: Route (sess, "to be renamed", 0, 0, -1, -1),
_diskstream (0),
_rec_enable_control (*this)
: Track (sess, node)
{
_freeze_record.state = NoFreeze;
set_state (node);
@ -88,16 +84,18 @@ AudioTrack::~AudioTrack ()
int
AudioTrack::deprecated_use_diskstream_connections ()
{
if (_diskstream->deprecated_io_node == 0) {
AudioDiskstream& diskstream = audio_diskstream();
if (diskstream.deprecated_io_node == 0) {
return 0;
}
const XMLProperty* prop;
XMLNode& node (*_diskstream->deprecated_io_node);
XMLNode& node (*diskstream.deprecated_io_node);
/* don't do this more than once. */
_diskstream->deprecated_io_node = 0;
diskstream.deprecated_io_node = 0;
set_input_minimum (-1);
set_input_maximum (-1);
@ -148,7 +146,7 @@ AudioTrack::set_diskstream (AudioDiskstream& ds, void *src)
_diskstream->set_io (*this);
_diskstream->set_destructive (_mode == Destructive);
if (_diskstream->deprecated_io_node) {
if (audio_diskstream().deprecated_io_node) {
if (!connecting_legal) {
ConnectingLegal.connect (mem_fun (*this, &AudioTrack::deprecated_use_diskstream_connections));
@ -161,9 +159,9 @@ AudioTrack::set_diskstream (AudioDiskstream& ds, void *src)
_diskstream->monitor_input (false);
ic_connection.disconnect();
ic_connection = input_changed.connect (mem_fun (*_diskstream, &AudioDiskstream::handle_input_change));
ic_connection = input_changed.connect (mem_fun (*_diskstream, &Diskstream::handle_input_change));
diskstream_changed (src); /* EMIT SIGNAL */
DiskstreamChanged (src); /* EMIT SIGNAL */
return 0;
}
@ -229,10 +227,10 @@ AudioTrack::set_record_enable (bool yn, void *src)
_rec_enable_control.Changed ();
}
void
AudioTrack::set_meter_point (MeterPoint p, void *src)
AudioDiskstream&
AudioTrack::audio_diskstream() const
{
Route::set_meter_point (p, src);
return *dynamic_cast<AudioDiskstream*>(_diskstream);
}
int
@ -306,18 +304,6 @@ AudioTrack::set_state (const XMLNode& node)
return 0;
}
XMLNode&
AudioTrack::get_template ()
{
return state (false);
}
XMLNode&
AudioTrack::get_state ()
{
return state (true);
}
XMLNode&
AudioTrack::state(bool full_state)
{
@ -494,7 +480,7 @@ AudioTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nf
return 0;
}
_diskstream->check_record_status (start_frame, nframes, can_record);
audio_diskstream().check_record_status (start_frame, nframes, can_record);
bool send_silence;
@ -561,7 +547,8 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram
Sample* b;
Sample* tmpb;
jack_nframes_t transport_frame;
AudioDiskstream& diskstream = audio_diskstream();
{
Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
if (lm.locked()) {
@ -587,13 +574,13 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram
playback distance to zero, thus causing diskstream::commit
to do nothing.
*/
return _diskstream->process (transport_frame, 0, 0, can_record, rec_monitors_input);
return diskstream.process (transport_frame, 0, 0, can_record, rec_monitors_input);
}
_silent = false;
apply_gain_automation = false;
if ((dret = _diskstream->process (transport_frame, nframes, offset, can_record, rec_monitors_input)) != 0) {
if ((dret = diskstream.process (transport_frame, nframes, offset, can_record, rec_monitors_input)) != 0) {
silence (nframes, offset);
@ -606,7 +593,7 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram
just_meter_input (start_frame, end_frame, nframes, offset);
}
if (_diskstream->record_enabled() && !can_record && !_session.get_auto_input()) {
if (diskstream.record_enabled() && !can_record && !_session.get_auto_input()) {
/* not actually recording, but we want to hear the input material anyway,
at least potentially (depending on monitoring options)
@ -614,7 +601,7 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram
passthru (start_frame, end_frame, nframes, offset, 0, true);
} else if ((b = _diskstream->playback_buffer(0)) != 0) {
} else if ((b = diskstream.playback_buffer(0)) != 0) {
/*
XXX is it true that the earlier test on n_outputs()
@ -636,8 +623,8 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram
for (i = 0, n = 1; i < limit; ++i, ++n) {
memcpy (bufs[i], b, sizeof (Sample) * nframes);
if (n < _diskstream->n_channels()) {
tmpb = _diskstream->playback_buffer(n);
if (n < diskstream.n_channels()) {
tmpb = diskstream.playback_buffer(n);
if (tmpb!=0) {
b = tmpb;
}
@ -646,7 +633,7 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram
/* don't waste time with automation if we're recording or we've just stopped (yes it can happen) */
if (!_diskstream->record_enabled() && _session.transport_rolling()) {
if (!diskstream.record_enabled() && _session.transport_rolling()) {
Glib::Mutex::Lock am (automation_lock, Glib::TRY_LOCK);
if (am.locked() && gain_automation_playback()) {
@ -682,15 +669,7 @@ AudioTrack::silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jac
silence (nframes, offset);
return _diskstream->process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input);
}
void
AudioTrack::toggle_monitor_input ()
{
for (vector<Port*>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
(*i)->request_monitor_input(!(*i)->monitoring_input());
}
return audio_diskstream().process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input);
}
int
@ -703,7 +682,7 @@ AudioTrack::set_name (string str, void *src)
return -1;
}
if (_diskstream->set_name (str, src)) {
if (audio_diskstream().set_name (str, src)) {
return -1;
}
@ -726,11 +705,12 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, char * workbuf, uint32_t nbu
gain_t this_gain = _gain;
vector<Sample*>::iterator bi;
Sample * b;
AudioDiskstream& diskstream = audio_diskstream();
Glib::RWLock::ReaderLock rlock (redirect_lock);
// FIXME
AudioPlaylist* const apl = dynamic_cast<AudioPlaylist*>(_diskstream->playlist());
AudioPlaylist* const apl = dynamic_cast<AudioPlaylist*>(diskstream.playlist());
assert(apl);
if (apl->read (buffers[0], mix_buffer, gain_buffer, workbuf, start, nframes) != nframes) {
@ -742,7 +722,7 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, char * workbuf, uint32_t nbu
b = buffers[0];
++bi;
for (; bi != buffers.end(); ++bi, ++n) {
if (n < _diskstream->n_channels()) {
if (n < diskstream.n_channels()) {
if (apl->read ((*bi), mix_buffer, gain_buffer, workbuf, start, nframes, n) != nframes) {
return -1;
}
@ -819,23 +799,7 @@ void
AudioTrack::set_latency_delay (jack_nframes_t longest_session_latency)
{
Route::set_latency_delay (longest_session_latency);
_diskstream->set_roll_delay (_roll_delay);
}
jack_nframes_t
AudioTrack::update_total_latency ()
{
_own_latency = 0;
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
if ((*i)->active ()) {
_own_latency += (*i)->latency ();
}
}
set_port_latency (_own_latency);
return _own_latency;
audio_diskstream().set_roll_delay (_roll_delay);
}
void
@ -863,8 +827,9 @@ AudioTrack::freeze (InterThreadInfo& itt)
string dir;
AudioRegion* region;
string region_name;
AudioDiskstream& diskstream = audio_diskstream();
if ((_freeze_record.playlist = dynamic_cast<AudioPlaylist*>(_diskstream->playlist())) == 0) {
if ((_freeze_record.playlist = dynamic_cast<AudioPlaylist*>(diskstream.playlist())) == 0) {
return;
}
@ -931,13 +896,13 @@ AudioTrack::freeze (InterThreadInfo& itt)
(AudioRegion::Flag) (AudioRegion::WholeFile|AudioRegion::DefaultFlags),
false);
new_playlist->set_orig_diskstream_id (_diskstream->id());
new_playlist->set_orig_diskstream_id (diskstream.id());
new_playlist->add_region (*region, 0);
new_playlist->set_frozen (true);
region->set_locked (true);
_diskstream->use_playlist (dynamic_cast<AudioPlaylist*>(new_playlist));
_diskstream->set_record_enabled (false, this);
diskstream.use_playlist (dynamic_cast<AudioPlaylist*>(new_playlist));
diskstream.set_record_enabled (false, this);
_freeze_record.state = Frozen;
FreezeChange(); /* EMIT SIGNAL */
@ -947,7 +912,7 @@ void
AudioTrack::unfreeze ()
{
if (_freeze_record.playlist) {
_diskstream->use_playlist (_freeze_record.playlist);
audio_diskstream().use_playlist (_freeze_record.playlist);
if (_freeze_record.have_mementos) {
@ -975,45 +940,13 @@ AudioTrack::unfreeze ()
FreezeChange (); /* EMIT SIGNAL */
}
AudioTrack::FreezeRecord::~FreezeRecord ()
{
for (vector<FreezeRecordInsertInfo*>::iterator i = insert_info.begin(); i != insert_info.end(); ++i) {
delete *i;
}
}
AudioTrack::FreezeState
AudioTrack::freeze_state() const
{
return _freeze_record.state;
}
AudioTrack::RecEnableControllable::RecEnableControllable (AudioTrack& s)
: track (s)
{
}
void
AudioTrack::RecEnableControllable::set_value (float val)
{
bool bval = ((val >= 0.5f) ? true: false);
track.set_record_enable (bval, this);
}
float
AudioTrack::RecEnableControllable::get_value (void) const
{
if (track.record_enabled()) { return 1.0f; }
return 0.0f;
}
void
AudioTrack::set_mode (TrackMode m)
{
if (_diskstream) {
if (_mode != m) {
_mode = m;
_diskstream->set_destructive (m == Destructive);
audio_diskstream().set_destructive (m == Destructive);
ModeChanged();
}
}

6
libs/ardour/auditioner.cc
View File

@ -48,7 +48,7 @@ Auditioner::Auditioner (Session& s)
}
if (right.length()) {
disk_stream().add_channel();
audio_diskstream().add_channel();
add_output_port (right, this, Buffer::AUDIO);
}
@ -116,11 +116,11 @@ Auditioner::audition_region (AudioRegion& region)
_diskstream->playlist()->add_region (*the_region, 0, 1, false);
while (_diskstream->n_channels() < the_region->n_channels()) {
_diskstream->add_channel ();
audio_diskstream().add_channel ();
}
while (_diskstream->n_channels() > the_region->n_channels()) {
_diskstream->remove_channel ();
audio_diskstream().remove_channel ();
}
/* force a panner reset now that we have all channels */

9
libs/ardour/diskstream.cc
View File

@ -63,16 +63,14 @@ sigc::signal<void> Diskstream::DiskOverrun;
sigc::signal<void> Diskstream::DiskUnderrun;
Diskstream::Diskstream (Session &sess, const string &name, Flag flag)
: deprecated_io_node(NULL)
, _name (name)
: _name (name)
, _session (sess)
{
init (flag);
}
Diskstream::Diskstream (Session& sess, const XMLNode& node)
: deprecated_io_node(NULL)
, _session (sess)
: _session (sess)
{
init (Recordable);
@ -114,7 +112,6 @@ Diskstream::init (Flag f)
playback_distance = 0;
_read_data_count = 0;
_write_data_count = 0;
deprecated_io_node = 0;
/* there are no channels at this point, so these
two calls just get speed_buffer_size and wrap_buffer
@ -188,7 +185,7 @@ Diskstream::realtime_set_speed (double sp, bool global)
if (!global) {
_seek_required = true;
}
speed_changed (); /* EMIT SIGNAL */
SpeedChanged (); /* EMIT SIGNAL */
}
return _buffer_reallocation_required || _seek_required;

15
libs/ardour/midi_diskstream.cc
View File

@ -480,9 +480,10 @@ MidiDiskstream::set_state (const XMLNode& node)
in_set_state = true;
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
if ((*niter)->name() == IO::state_node_name) {
/*if ((*niter)->name() == IO::state_node_name) {
deprecated_io_node = new XMLNode (**niter);
}
}*/
assert ((*niter)->name() != IO::state_node_name);
if ((*niter)->name() == X_("CapturingSources")) {
capture_pending_node = *niter;
@ -497,14 +498,8 @@ MidiDiskstream::set_state (const XMLNode& node)
_name = prop->value();
}
if (deprecated_io_node) {
if ((prop = deprecated_io_node->property ("id")) != 0) {
_id = prop->value ();
}
} else {
if ((prop = node.property ("id")) != 0) {
_id = prop->value ();
}
if ((prop = node.property ("id")) != 0) {
_id = prop->value ();
}
if ((prop = node.property ("flags")) != 0) {

5
libs/ardour/midi_region.cc
View File

@ -366,7 +366,8 @@ XMLNode&
MidiRegion::state (bool full)
{
XMLNode& node (Region::state (full));
//XMLNode *child;
#if 0
//XMLNode *child;
char buf[64];
char buf2[64];
LocaleGuard lg (X_("POSIX"));
@ -386,7 +387,7 @@ MidiRegion::state (bool full)
if (full && _extra_xml) {
node.add_child_copy (*_extra_xml);
}
#endif
return node;
}

151
libs/ardour/midi_track.cc
View File

@ -40,9 +40,7 @@ using namespace ARDOUR;
using namespace PBD;
MidiTrack::MidiTrack (Session& sess, string name, Route::Flag flag, TrackMode mode)
: Route (sess, name, 1, -1, -1, -1, flag, Buffer::MIDI),
_diskstream (0),
_rec_enable_control (*this)
: Track (sess, name, flag, mode, Buffer::MIDI)
{
MidiDiskstream::Flag dflags = MidiDiskstream::Flag (0);
@ -67,9 +65,7 @@ MidiTrack::MidiTrack (Session& sess, string name, Route::Flag flag, TrackMode mo
}
MidiTrack::MidiTrack (Session& sess, const XMLNode& node)
: Route (sess, "to be renamed", 0, 0, -1, -1),
_diskstream (0),
_rec_enable_control (*this)
: Track (sess, node)
{
_freeze_record.state = NoFreeze;
set_state (node);
@ -92,57 +88,6 @@ MidiTrack::handle_smpte_offset_change ()
}
#endif
int
MidiTrack::deprecated_use_diskstream_connections ()
{
if (_diskstream->deprecated_io_node == 0) {
return 0;
}
const XMLProperty* prop;
XMLNode& node (*_diskstream->deprecated_io_node);
/* don't do this more than once. */
_diskstream->deprecated_io_node = 0;
set_input_minimum (-1);
set_input_maximum (-1);
set_output_minimum (-1);
set_output_maximum (-1);
if ((prop = node.property ("gain")) != 0) {
set_gain (atof (prop->value().c_str()), this);
_gain = _desired_gain;
}
if ((prop = node.property ("input-connection")) != 0) {
Connection* c = _session.connection_by_name (prop->value());
if (c == 0) {
PBD::error << string_compose(_("Unknown connection \"%1\" listed for input of %2"), prop->value(), _name) << endmsg;
if ((c = _session.connection_by_name (_("in 1"))) == 0) {
PBD::error << _("No input connections available as a replacement")
<< endmsg;
return -1;
} else {
PBD::info << string_compose (_("Connection %1 was not available - \"in 1\" used instead"), prop->value())
<< endmsg;
}
}
use_input_connection (*c, this);
} else if ((prop = node.property ("inputs")) != 0) {
if (set_inputs (prop->value())) {
PBD::error << string_compose(_("improper input channel list in XML node (%1)"), prop->value()) << endmsg;
return -1;
}
}
return 0;
}
int
MidiTrack::set_diskstream (MidiDiskstream& ds, void *src)
@ -155,22 +100,13 @@ MidiTrack::set_diskstream (MidiDiskstream& ds, void *src)
_diskstream->set_io (*this);
_diskstream->set_destructive (_mode == Destructive);
if (_diskstream->deprecated_io_node) {
if (!connecting_legal) {
ConnectingLegal.connect (mem_fun (*this, &MidiTrack::deprecated_use_diskstream_connections));
} else {
deprecated_use_diskstream_connections ();
}
}
_diskstream->set_record_enabled (false, this);
//_diskstream->monitor_input (false);
ic_connection.disconnect();
ic_connection = input_changed.connect (mem_fun (*_diskstream, &MidiDiskstream::handle_input_change));
diskstream_changed (src); /* EMIT SIGNAL */
DiskstreamChanged (src); /* EMIT SIGNAL */
return 0;
}
@ -239,10 +175,10 @@ MidiTrack::set_record_enable (bool yn, void *src)
#endif
}
void
MidiTrack::set_meter_point (MeterPoint p, void *src)
MidiDiskstream&
MidiTrack::midi_diskstream() const
{
Route::set_meter_point (p, src);
return *dynamic_cast<MidiDiskstream*>(_diskstream);
}
int
@ -316,18 +252,6 @@ MidiTrack::set_state (const XMLNode& node)
return 0;
}
XMLNode&
MidiTrack::get_template ()
{
return state (false);
}
XMLNode&
MidiTrack::get_state ()
{
return state (true);
}
XMLNode&
MidiTrack::state(bool full_state)
{
@ -504,7 +428,7 @@ MidiTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfr
return 0;
}
_diskstream->check_record_status (start_frame, nframes, can_record);
midi_diskstream().check_record_status (start_frame, nframes, can_record);
bool send_silence;
@ -693,15 +617,7 @@ MidiTrack::silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack
silence (nframes, offset);
return _diskstream->process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input);
}
void
MidiTrack::toggle_monitor_input ()
{
for (vector<Port*>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
(*i)->request_monitor_input(!(*i)->monitoring_input());
}
return midi_diskstream().process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input);
}
int
@ -830,22 +746,6 @@ MidiTrack::set_latency_delay (jack_nframes_t longest_session_latency)
_diskstream->set_roll_delay (_roll_delay);
}
jack_nframes_t
MidiTrack::update_total_latency ()
{
_own_latency = 0;
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
if ((*i)->active ()) {
_own_latency += (*i)->latency ();
}
}
set_port_latency (_own_latency);
return _own_latency;
}
void
MidiTrack::bounce (InterThreadInfo& itt)
{
@ -950,11 +850,13 @@ MidiTrack::freeze (InterThreadInfo& itt)
_freeze_record.state = Frozen;
FreezeChange(); /* EMIT SIGNAL */
#endif
}
void
MidiTrack::unfreeze ()
{
#if 0
if (_freeze_record.playlist) {
diskstream->use_playlist (_freeze_record.playlist);
@ -984,39 +886,6 @@ MidiTrack::unfreeze ()
FreezeChange (); /* EMIT SIGNAL */
}
MidiTrack::FreezeRecord::~FreezeRecord ()
{
for (vector<FreezeRecordInsertInfo*>::iterator i = insert_info.begin(); i != insert_info.end(); ++i) {
delete *i;
}
}
MidiTrack::FreezeState
MidiTrack::freeze_state() const
{
return _freeze_record.state;
}
MidiTrack::MIDIRecEnableControllable::MIDIRecEnableControllable (MidiTrack& s)
: track(s)
{
}
void
MidiTrack::MIDIRecEnableControllable::set_value (float val)
{
bool bval = ((val >= 0.5f) ? true: false);
track.set_record_enable (bval, this);
}
float
MidiTrack::MIDIRecEnableControllable::get_value (void) const
{
if (track.record_enabled()) { return 1.0f; }
return 0.0f;
}
void
MidiTrack::set_mode (TrackMode m)
{

10
libs/ardour/session.cc
View File

@ -1772,7 +1772,7 @@ Session::new_midi_track (TrackMode mode)
track->set_control_outs (cports);
}
#endif
track->diskstream_changed.connect (mem_fun (this, &Session::resort_routes));
track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
add_route (track);
@ -1983,7 +1983,7 @@ Session::new_audio_track (int input_channels, int output_channels, TrackMode mod
track->set_control_outs (cports);
}
track->diskstream_changed.connect (mem_fun (this, &Session::resort_routes));
track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
add_route (track);
@ -2182,7 +2182,7 @@ Session::remove_route (Route& route)
AudioDiskstream* ds = 0;
if ((at = dynamic_cast<AudioTrack*>(&route)) != 0) {
ds = &at->disk_stream();
ds = &at->audio_diskstream();
}
if (ds) {
@ -3812,7 +3812,7 @@ Session::write_one_audio_track (AudioTrack& track, jack_nframes_t start, jack_nf
/* call tree *MUST* hold route_lock */
if ((playlist = track.disk_stream().playlist()) == 0) {
if ((playlist = track.diskstream().playlist()) == 0) {
goto out;
}
@ -3822,7 +3822,7 @@ Session::write_one_audio_track (AudioTrack& track, jack_nframes_t start, jack_nf
goto out;
}
nchans = track.disk_stream().n_channels();
nchans = track.audio_diskstream().n_channels();
dir = discover_best_sound_dir ();