uint32_t master_out_channels,
uint32_t requested_physical_in,
uint32_t requested_physical_out,
- jack_nframes_t initial_length)
+ nframes_t initial_length)
: _engine (eng),
_mmc_port (default_mmc_port),
output_ac = AutoConnectOption (output_ac & ~AutoConnectMaster);
}
- input_auto_connect = input_ac;
- output_auto_connect = output_ac;
+ Config->set_input_auto_connect (input_ac);
+ Config->set_output_auto_connect (output_ac);
if (second_stage_init (new_session)) {
throw failed_constructor ();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (Config->get_use_hardware_monitoring() && !Config->get_auto_input());
+ (*i)->monitor_input (Config->get_monitoring_model() == HardwareMonitoring && !Config->get_auto_input());
}
}
} else {
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching to input = " << !Config->get_auto_input() << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (Config->get_use_hardware_monitoring());
+ (*i)->monitor_input (Config->get_monitoring_model() == HardwareMonitoring);
}
}
}
void
Session::auto_punch_end_changed (Location* location)
{
- jack_nframes_t when_to_stop = location->end();
+ nframes_t when_to_stop = location->end();
// when_to_stop += _worst_output_latency + _worst_input_latency;
replace_event (Event::PunchOut, when_to_stop);
}
void
Session::auto_punch_changed (Location* location)
{
- jack_nframes_t when_to_stop = location->end();
+ nframes_t when_to_stop = location->end();
replace_event (Event::PunchIn, location->start());
//when_to_stop += _worst_output_latency + _worst_input_latency;
_last_record_location = _transport_frame;
send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordStrobe);
- if (Config->get_use_hardware_monitoring() && Config->get_auto_input()) {
+ if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordExit);
- if (Config->get_use_hardware_monitoring() && Config->get_auto_input()) {
+ if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
{
g_atomic_int_set (&_record_status, Enabled);
- if (Config->get_use_hardware_monitoring()) {
+ if (Config->get_monitoring_model() == HardwareMonitoring) {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
set_dirty();
}
-jack_nframes_t
+nframes_t
Session::audible_frame () const
{
- jack_nframes_t ret;
- jack_nframes_t offset;
- jack_nframes_t tf;
+ nframes_t ret;
+ nframes_t offset;
+ nframes_t tf;
/* the first of these two possible settings for "offset"
mean that the audible frame is stationary until
}
void
-Session::set_frame_rate (jack_nframes_t frames_per_second)
+Session::set_frame_rate (nframes_t frames_per_second)
{
- /** \fn void Session::set_frame_size(jack_nframes_t)
+ /** \fn void Session::set_frame_size(nframes_t)
the AudioEngine object that calls this guarantees
that it will not be called while we are also in
::process(). Its fine to do things that block
sync_time_vars();
- Route::set_automation_interval ((jack_nframes_t) ceil ((double) frames_per_second * 0.25));
+ Route::set_automation_interval ((nframes_t) ceil ((double) frames_per_second * 0.25));
// XXX we need some equivalent to this, somehow
// DestructiveFileSource::setup_standard_crossfades (frames_per_second);
}
void
-Session::set_block_size (jack_nframes_t nframes)
+Session::set_block_size (nframes_t nframes)
{
/* the AudioEngine guarantees
that it will not be called while we are also in
Session::set_default_fade (float steepness, float fade_msecs)
{
#if 0
- jack_nframes_t fade_frames;
+ nframes_t fade_frames;
/* Don't allow fade of less 1 frame */
} else {
- fade_frames = (jack_nframes_t) floor (fade_msecs * _current_frame_rate * 0.001);
+ fade_frames = (nframes_t) floor (fade_msecs * _current_frame_rate * 0.001);
}
} while (track_id < (UINT_MAX-1));
- if (input_auto_connect & AutoConnectPhysical) {
+ if (Config->get_input_auto_connect() & AutoConnectPhysical) {
nphysical_in = min (n_physical_inputs, (uint32_t) physinputs.size());
} else {
nphysical_in = 0;
}
- if (output_auto_connect & AutoConnectPhysical) {
+ if (Config->get_output_auto_connect() & AutoConnectPhysical) {
nphysical_out = min (n_physical_outputs, (uint32_t) physinputs.size());
} else {
nphysical_out = 0;
port = "";
- if (input_auto_connect & AutoConnectPhysical) {
+ if (Config->get_input_auto_connect() & AutoConnectPhysical) {
port = physinputs[(channels_used+x)%nphysical_in];
}
port = "";
- if (nphysical_out && (output_auto_connect & AutoConnectPhysical)) {
+ if (nphysical_out && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
port = physoutputs[(channels_used+x)%nphysical_out];
- } else if (output_auto_connect & AutoConnectMaster) {
+ } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
if (_master_out) {
port = _master_out->input (x%_master_out->n_inputs())->name();
}
port = "";
- if (input_auto_connect & AutoConnectPhysical) {
+ if (Config->get_input_auto_connect() & AutoConnectPhysical) {
port = physinputs[((n+x)%n_physical_inputs)];
}
port = "";
- if (output_auto_connect & AutoConnectPhysical) {
+ if (Config->get_output_auto_connect() & AutoConnectPhysical) {
port = physoutputs[((n+x)%n_physical_outputs)];
- } else if (output_auto_connect & AutoConnectMaster) {
+ } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
if (_master_out) {
port = _master_out->input (x%_master_out->n_inputs())->name();
}
}
for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
- (*x)->solo_changed.connect (sigc::bind (mem_fun (*this, &Session::route_solo_changed), (*x)));
+
+ boost::weak_ptr<Route> wpr (*x);
+
+ (*x)->solo_changed.connect (sigc::bind (mem_fun (*this, &Session::route_solo_changed), wpr));
(*x)->mute_changed.connect (mem_fun (*this, &Session::route_mute_changed));
(*x)->output_changed.connect (mem_fun (*this, &Session::set_worst_io_latencies_x));
(*x)->redirects_changed.connect (mem_fun (*this, &Session::update_latency_compensation_proxy));
*/
if (route == _master_out) {
- _master_out = shared_ptr<Route> ((Route*) 0);
+ _master_out = shared_ptr<Route> ();
}
if (route == _control_out) {
- _control_out = shared_ptr<Route> ((Route*) 0);
+ _control_out = shared_ptr<Route> ();
/* cancel control outs for all routes */
update_latency_compensation (false, false);
set_dirty();
- /* XXX should we disconnect from the Route's signals ? */
+ /* get rid of it from the dead wood collection in the route list manager */
+
+ /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
- save_state (_current_snapshot_name);
+ routes.flush ();
/* try to cause everyone to drop their references */
route->drop_references ();
+
+ /* save the new state of the world */
+
+ if (save_state (_current_snapshot_name)) {
+ save_history (_current_snapshot_name);
+ }
}
void
}
void
-Session::route_solo_changed (void* src, shared_ptr<Route> route)
+Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
{
if (solo_update_disabled) {
// We know already
}
bool is_track;
-
- is_track = (dynamic_cast<AudioTrack*>(route.get()) != 0);
+ boost::shared_ptr<Route> route = wpr.lock ();
+
+ if (!route) {
+ /* should not happen */
+ error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
+ return;
+ }
+
+ is_track = (boost::dynamic_pointer_cast<AudioTrack>(route) != 0);
shared_ptr<RouteList> r = routes.reader ();
then leave it as it is.
*/
- if (_solo_latched) {
+ if (Config->get_solo_latched()) {
continue;
}
}
return;
}
- jack_nframes_t max = get_maximum_extent ();
+ nframes_t max = get_maximum_extent ();
if (max > end_location->end()) {
end_location->set_end (max);
}
}
-jack_nframes_t
+nframes_t
Session::get_maximum_extent () const
{
- jack_nframes_t max = 0;
- jack_nframes_t me;
+ nframes_t max = 0;
+ nframes_t me;
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
set_dirty();
}
-jack_nframes_t
+nframes_t
Session::available_capture_duration ()
{
const double scale = 4096.0 / sizeof (Sample);
return max_frames;
}
- return (jack_nframes_t) floor (_total_free_4k_blocks * scale);
+ return (nframes_t) floor (_total_free_4k_blocks * scale);
}
void
}
void
-Session::allocate_pan_automation_buffers (jack_nframes_t nframes, uint32_t howmany, bool force)
+Session::allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force)
{
if (!force && howmany <= _npan_buffers) {
return;
}
int
-Session::write_one_audio_track (AudioTrack& track, jack_nframes_t start, jack_nframes_t len,
+Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t len,
bool overwrite, vector<boost::shared_ptr<AudioSource> >& srcs, InterThreadInfo& itt)
{
int ret = -1;
char buf[PATH_MAX+1];
string dir;
uint32_t nchans;
- jack_nframes_t position;
- jack_nframes_t this_chunk;
- jack_nframes_t to_do;
+ nframes_t position;
+ nframes_t this_chunk;
+ nframes_t to_do;
vector<Sample*> buffers;
// any bigger than this seems to cause stack overflows in called functions
- const jack_nframes_t chunk_size = (128 * 1024)/4;
+ const nframes_t chunk_size = (128 * 1024)/4;
g_atomic_int_set (&processing_prohibited, 1);