#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>
}
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++;
}
}
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;
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);
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) {
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;
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";
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"));
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;
}
continue;
}
- if ((playlist = at->disk_stream().playlist()) == 0) {
+ if ((playlist = at->diskstream().playlist()) == 0) {
i = tmp;
continue;
}
_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));
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)));
}
}
-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 ()
{
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 *);
return;
}
- at->disk_stream().use_playlist (apl);
+ at->diskstream().use_playlist (apl);
hide ();
}
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));
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;
}
_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));
}
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 {
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;
ardour.Append(CPPPATH = '#libs/surfaces/control_protocol')
ardour_files=Split("""
+diskstream.cc
+track.cc
audio_diskstream.cc
audio_library.cc
audio_playlist.cc
audiofilter.cc
audioregion.cc
audiosource.cc
-diskstream.cc
midi_source.cc
midi_diskstream.cc
midi_playlist.cc
const PBD::ID& id() const { return _id; }
+ XMLNode* deprecated_io_node;
+
protected:
friend class Session;
#ifndef __ardour_audio_track_h__
#define __ardour_audio_track_h__
-#include <ardour/route.h>
+#include <ardour/track.h>
namespace ARDOUR {
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);
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 ();
+ 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);
- 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,
bool meter);
uint32_t n_process_buffers ();
-
+
private:
- struct FreezeRecordInsertInfo {
- FreezeRecordInsertInfo(XMLNode& st)
- : state (st), insert (0) {}
-
- 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 set_diskstream (AudioDiskstream&, void *);
- 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__ */
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;
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;
#ifndef __ardour_midi_track_h__
#define __ardour_midi_track_h__
-#include <ardour/route.h>
+#include <ardour/track.h>
namespace ARDOUR
{
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,
uint32_t n_process_buffers ();
private:
- struct FreezeRecordInsertInfo
- {
- FreezeRecordInsertInfo(XMLNode& st)
- : state (st), insert (0)
- {}
-
- 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 ();
+ int set_diskstream (MidiDiskstream&, void *);
+
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__ */
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 {
+++ /dev/null
-/*
- 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__ */
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 */
AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
: Diskstream(sess, node)
+ , deprecated_io_node(NULL)
, _playlist(NULL)
{
in_set_state = true;
}
}
- record_enable_changed (src); /* EMIT SIGNAL */
+ RecordEnableChanged (src); /* EMIT SIGNAL */
}
void
}
}
capturing_sources.clear ();
- record_enable_changed (src); /* EMIT SIGNAL */
+ RecordEnableChanged (src); /* EMIT SIGNAL */
}
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);
}
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);
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);
_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));
_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;
}
_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
return 0;
}
-XMLNode&
-AudioTrack::get_template ()
-{
- return state (false);
-}
-
-XMLNode&
-AudioTrack::get_state ()
-{
- return state (true);
-}
-
XMLNode&
AudioTrack::state(bool full_state)
{
return 0;
}
- _diskstream->check_record_status (start_frame, nframes, can_record);
+ audio_diskstream().check_record_status (start_frame, nframes, can_record);
bool send_silence;
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()) {
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);
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)
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()
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;
}
/* 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()) {
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
return -1;
}
- if (_diskstream->set_name (str, src)) {
+ if (audio_diskstream().set_name (str, src)) {
return -1;
}
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) {
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;
}
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
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;
}
(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 */
AudioTrack::unfreeze ()
{
if (_freeze_record.playlist) {
- _diskstream->use_playlist (_freeze_record.playlist);
+ audio_diskstream().use_playlist (_freeze_record.playlist);
if (_freeze_record.have_mementos) {
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();
}
}
}
if (right.length()) {
- disk_stream().add_channel();
+ audio_diskstream().add_channel();
add_output_port (right, this, Buffer::AUDIO);
}
_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 */
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);
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
if (!global) {
_seek_required = true;
}
- speed_changed (); /* EMIT SIGNAL */
+ SpeedChanged (); /* EMIT SIGNAL */
}
return _buffer_reallocation_required || _seek_required;
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;
_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) {
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"));
if (full && _extra_xml) {
node.add_child_copy (*_extra_xml);
}
-
+#endif
return node;
}
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);
}
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);
}
#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)
_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;
}
#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
return 0;
}
-XMLNode&
-MidiTrack::get_template ()
-{
- return state (false);
-}
-
-XMLNode&
-MidiTrack::get_state ()
-{
- return state (true);
-}
-
XMLNode&
MidiTrack::state(bool full_state)
{
return 0;
}
- _diskstream->check_record_status (start_frame, nframes, can_record);
+ midi_diskstream().check_record_status (start_frame, nframes, can_record);
bool send_silence;
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
_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)
{
_freeze_record.state = Frozen;
FreezeChange(); /* EMIT SIGNAL */
+#endif
}
void
MidiTrack::unfreeze ()
{
+#if 0
if (_freeze_record.playlist) {
diskstream->use_playlist (_freeze_record.playlist);
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)
{
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);
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);
AudioDiskstream* ds = 0;
if ((at = dynamic_cast<AudioTrack*>(&route)) != 0) {
- ds = &at->disk_stream();
+ ds = &at->audio_diskstream();
}
if (ds) {
/* call tree *MUST* hold route_lock */
- if ((playlist = track.disk_stream().playlist()) == 0) {
+ if ((playlist = track.diskstream().playlist()) == 0) {
goto out;
}
goto out;
}
- nchans = track.disk_stream().n_channels();
+ nchans = track.audio_diskstream().n_channels();
dir = discover_best_sound_dir ();
projects / ardour.git / commitdiff