X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_diskstream.cc;h=c302e06681ca05f394b14c7451eafafb6e27501b;hb=5e1cfcc7ed557fc28ca8b362deceefa1967ab22b;hp=77c0ac94324cac3318d6462f410cf6873987f1e2;hpb=9afd18358b2a6dff8315e7c592a091e514a7661f;p=ardour.git diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc index 77c0ac9432..c302e06681 100644 --- a/libs/ardour/audio_diskstream.cc +++ b/libs/ardour/audio_diskstream.cc @@ -37,29 +37,24 @@ #include "pbd/stateful_diff_command.h" #include "ardour/analyser.h" -#include "ardour/ardour.h" #include "ardour/audio_buffer.h" #include "ardour/audio_diskstream.h" #include "ardour/audio_port.h" #include "ardour/audioengine.h" #include "ardour/audiofilesource.h" - #include "ardour/audioplaylist.h" #include "ardour/audioregion.h" #include "ardour/butler.h" -#include "ardour/configuration.h" -#include "ardour/cycle_timer.h" #include "ardour/debug.h" #include "ardour/io.h" #include "ardour/playlist_factory.h" #include "ardour/region_factory.h" -#include "ardour/send.h" #include "ardour/session.h" +#include "ardour/session_playlists.h" #include "ardour/source_factory.h" #include "ardour/track.h" +#include "ardour/types.h" #include "ardour/utils.h" -#include "ardour/session_playlists.h" -#include "ardour/route.h" #include "i18n.h" #include @@ -156,7 +151,7 @@ void AudioDiskstream::non_realtime_input_change () { { - Glib::Mutex::Lock lm (state_lock); + Glib::Threads::Mutex::Lock lm (state_lock); if (input_change_pending.type == IOChange::NoChange) { return; @@ -281,7 +276,6 @@ AudioDiskstream::use_new_playlist () if ((playlist = boost::dynamic_pointer_cast (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) { - playlist->set_orig_diskstream_id (id()); return use_playlist (playlist); } else { @@ -309,7 +303,6 @@ AudioDiskstream::use_copy_playlist () newname = Playlist::bump_name (_playlist->name(), _session); if ((playlist = boost::dynamic_pointer_cast(PlaylistFactory::create (audio_playlist(), newname))) != 0) { - playlist->set_orig_diskstream_id (id()); return use_playlist (playlist); } else { return -1; @@ -415,18 +408,17 @@ AudioDiskstream::prepare_record_status(framepos_t capture_start_frame) * that someone can read playback_distance worth of data from. */ int -AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool& need_butler) +AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance, bool need_disk_signal) { uint32_t n; boost::shared_ptr c = channels.reader(); ChannelList::iterator chan; - int ret = -1; framecnt_t rec_offset = 0; framecnt_t rec_nframes = 0; bool collect_playback = false; bool can_record = _session.actively_recording (); - framecnt_t playback_distance = 0; + playback_distance = 0; if (!_io || !_io->active()) { return 0; @@ -438,7 +430,7 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool& n return 0; } - Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK); + Glib::Threads::Mutex::Lock sm (state_lock, Glib::Threads::TRY_LOCK); if (!sm.locked()) { return 1; @@ -460,7 +452,7 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool& n if (record_enabled()) { - OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes); + Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes); calculate_record_range (ot, transport_frame, nframes, rec_nframes, rec_offset); if (rec_nframes && !was_recording) { @@ -502,22 +494,22 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool& n assert(ap); assert(rec_nframes <= (framecnt_t) ap->get_audio_buffer(nframes).capacity()); - Sample *buf = ap->get_audio_buffer (nframes).data (rec_offset); + Sample *buf = bufs.get_audio (n).data(rec_offset); memcpy (chaninfo->current_capture_buffer, buf, sizeof (Sample) * rec_nframes); - + } else { framecnt_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1]; if (rec_nframes > total) { DiskOverrun (); - goto out; + return -1; } boost::shared_ptr const ap = _io->audio (n); assert(ap); - Sample* buf = ap->get_audio_buffer(nframes).data (rec_offset); + Sample *buf = bufs.get_audio (n).data(rec_offset); framecnt_t first = chaninfo->capture_vector.len[0]; memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first); @@ -586,7 +578,7 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool& n /* no varispeed playback if we're recording, because the output .... TBD */ if (rec_nframes == 0 && _actual_speed != 1.0f) { - necessary_samples = (framecnt_t) floor ((nframes * fabs (_actual_speed))) + 1; + necessary_samples = (framecnt_t) ceil ((nframes * fabs (_actual_speed))) + 2; } else { necessary_samples = nframes; } @@ -617,7 +609,7 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool& n cerr << _name << " Need " << necessary_samples << " total = " << total << endl; cerr << "underrun for " << _name << endl; DiskUnderrun (); - goto out; + return -1; } else { @@ -626,6 +618,8 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool& n as our current_playback_buffer. */ + assert(wrap_buffer_size >= necessary_samples); + /* Copy buf[0] from playback_buf */ memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0], @@ -663,16 +657,53 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool& n _speed = _target_speed; } - ret = 0; + if (need_disk_signal) { + + /* copy data over to buffer set */ + + size_t n_buffers = bufs.count().n_audio(); + size_t n_chans = c->size(); + gain_t scaling = 1.0f; + + if (n_chans > n_buffers) { + scaling = ((float) n_buffers)/n_chans; + } - if (commit (playback_distance)) { - need_butler = true; + for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) { + + AudioBuffer& buf (bufs.get_audio (n%n_buffers)); + ChannelInfo* chaninfo (*chan); + + if (n < n_chans) { + if (scaling != 1.0f) { + buf.read_from_with_gain (chaninfo->current_playback_buffer, nframes, scaling); + } else { + buf.read_from (chaninfo->current_playback_buffer, nframes); + } + } else { + if (scaling != 1.0f) { + buf.accumulate_with_gain_from (chaninfo->current_playback_buffer, nframes, scaling); + } else { + buf.accumulate_from (chaninfo->current_playback_buffer, nframes); + } + } + } + + /* leave the MIDI count alone */ + ChanCount cnt (DataType::AUDIO, n_chans); + cnt.set (DataType::MIDI, bufs.count().n_midi()); + bufs.set_count (cnt); + + /* extra buffers will already be silent, so leave them alone */ } - out: - return ret; + return 0; } +/** Update various things including playback_sample, read pointer on each channel's playback_buf + * and write pointer on each channel's capture_buf. Also wout whether the butler is needed. + * @return true if the butler is required. + */ bool AudioDiskstream::commit (framecnt_t playback_distance) { @@ -823,7 +854,7 @@ AudioDiskstream::seek (framepos_t frame, bool complete_refill) ChannelList::iterator chan; boost::shared_ptr c = channels.reader(); - Glib::Mutex::Lock lm (state_lock); + Glib::Threads::Mutex::Lock lm (state_lock); for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) { (*chan)->playback_buf->reset (); @@ -1390,7 +1421,7 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo } /* XXX is there anything we can do if err != 0 ? */ - Glib::Mutex::Lock lm (capture_info_lock); + Glib::Threads::Mutex::Lock lm (capture_info_lock); if (capture_info.empty()) { return; @@ -1487,6 +1518,7 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n"; _playlist->clear_changes (); + _playlist->set_capture_insertion_in_progress (true); _playlist->freeze (); for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) { @@ -1517,21 +1549,15 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo i_am_the_modifier++; - if (_playlist->explicit_relayering()) { - /* We are in `explicit relayering' mode, so we must specify which layer this new region - should end up on. Put it at the top. - */ - region->set_layer (_playlist->top_layer() + 1); - region->set_pending_explicit_relayer (true); - } - _playlist->add_region (region, (*ci)->start, 1, non_layered()); + _playlist->set_layer (region, DBL_MAX); i_am_the_modifier--; buffer_position += (*ci)->frames; } _playlist->thaw (); + _playlist->set_capture_insertion_in_progress (false); _session.add_command (new StatefulDiffCommand (_playlist)); } @@ -1677,22 +1703,33 @@ AudioDiskstream::set_record_enabled (bool yn) } else { disengage_record_enable (); } + + RecordEnableChanged (); /* EMIT SIGNAL */ } } -void -AudioDiskstream::engage_record_enable () +bool +AudioDiskstream::prep_record_enable () { + if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) { + return false; + } + + /* can't rec-enable in destructive mode if transport is before start */ + + if (destructive() && _session.transport_frame() < _session.current_start_frame()) { + return false; + } + bool rolling = _session.transport_speed() != 0.0f; boost::shared_ptr c = channels.reader(); - g_atomic_int_set (&_record_enabled, 1); capturing_sources.clear (); if (Config->get_monitoring_model() == HardwareMonitoring) { for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - (*chan)->source.ensure_monitor_input (!(_session.config.get_auto_input() && rolling)); + (*chan)->source.request_jack_monitors_input (!(_session.config.get_auto_input() && rolling)); capturing_sources.push_back ((*chan)->write_source); (*chan)->write_source->mark_streaming_write_started (); } @@ -1704,21 +1741,21 @@ AudioDiskstream::engage_record_enable () } } - RecordEnableChanged (); /* EMIT SIGNAL */ + return true; } -void -AudioDiskstream::disengage_record_enable () +bool +AudioDiskstream::prep_record_disable () { - g_atomic_int_set (&_record_enabled, 0); boost::shared_ptr c = channels.reader(); if (Config->get_monitoring_model() == HardwareMonitoring) { for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - (*chan)->source.ensure_monitor_input (false); + (*chan)->source.request_jack_monitors_input (false); } } capturing_sources.clear (); - RecordEnableChanged (); /* EMIT SIGNAL */ + + return true; } XMLNode& @@ -1957,7 +1994,7 @@ AudioDiskstream::allocate_temporary_buffers () */ double const sp = max (fabsf (_actual_speed), 1.2f); - framecnt_t required_wrap_size = (framecnt_t) floor (_session.get_block_size() * sp) + 1; + framecnt_t required_wrap_size = (framecnt_t) ceil (_session.get_block_size() * sp) + 2; if (required_wrap_size > wrap_buffer_size) { @@ -1979,12 +2016,12 @@ AudioDiskstream::allocate_temporary_buffers () } void -AudioDiskstream::monitor_input (bool yn) +AudioDiskstream::request_jack_monitors_input (bool yn) { boost::shared_ptr c = channels.reader(); for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - (*chan)->source.ensure_monitor_input (yn); + (*chan)->source.request_jack_monitors_input (yn); } } @@ -2131,7 +2168,7 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) fs = boost::dynamic_pointer_cast ( SourceFactory::createWritable ( DataType::AUDIO, _session, - prop->value(), string(), false, _session.frame_rate())); + prop->value(), false, _session.frame_rate())); } catch (failed_constructor& err) { @@ -2307,13 +2344,13 @@ AudioDiskstream::ChannelSource::is_physical () const } void -AudioDiskstream::ChannelSource::ensure_monitor_input (bool yn) const +AudioDiskstream::ChannelSource::request_jack_monitors_input (bool yn) const { if (name.empty()) { return; } - return AudioEngine::instance()->ensure_monitor_input (name, yn); + return AudioEngine::instance()->request_jack_monitors_input (name, yn); } AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)