#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 <locale.h>
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;
if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
- playlist->set_orig_diskstream_id (id());
return use_playlist (playlist);
} else {
newname = Playlist::bump_name (_playlist->name(), _session);
if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
- playlist->set_orig_diskstream_id (id());
return use_playlist (playlist);
} else {
return -1;
* 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 (framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance)
{
uint32_t n;
boost::shared_ptr<ChannelList> c = channels.reader();
ChannelList::iterator chan;
- int ret = -1;
framecnt_t rec_offset = 0;
framecnt_t rec_nframes = 0;
bool collect_playback = false;
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;
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) {
if (rec_nframes > total) {
DiskOverrun ();
- goto out;
+ return -1;
}
boost::shared_ptr<AudioPort> const ap = _io->audio (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;
}
cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
cerr << "underrun for " << _name << endl;
DiskUnderrun ();
- goto out;
+ return -1;
} else {
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],
}
if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
- process_varispeed_playback(nframes, c);
+
+ interpolation.set_speed (_target_speed);
+
+ int channel = 0;
+ for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++channel) {
+ ChannelInfo* chaninfo (*chan);
+
+ playback_distance = interpolation.interpolate (
+ channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
+
+ chaninfo->current_playback_buffer = chaninfo->speed_buffer;
+ }
+
} else {
playback_distance = nframes;
}
_speed = _target_speed;
}
- ret = 0;
-
- if (commit (nframes)) {
- need_butler = true;
- }
-
- out:
- return ret;
-}
-
-void
-AudioDiskstream::process_varispeed_playback (pframes_t nframes, boost::shared_ptr<ChannelList> c)
-{
- ChannelList::iterator chan;
-
- interpolation.set_speed (_target_speed);
-
- int channel = 0;
- for (chan = c->begin(); chan != c->end(); ++chan, ++channel) {
- ChannelInfo* chaninfo (*chan);
-
- playback_distance = interpolation.interpolate (
- channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
-
- chaninfo->current_playback_buffer = chaninfo->speed_buffer;
- }
+ 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 /* nframes */)
+AudioDiskstream::commit (framecnt_t playback_distance)
{
bool need_butler = false;
ChannelList::iterator chan;
boost::shared_ptr<ChannelList> 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 ();
}
/* 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;
// 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) {
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));
}
} 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<ChannelList> 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 ();
}
}
}
- 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<ChannelList> 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&
*/
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) {
}
void
-AudioDiskstream::monitor_input (bool yn)
+AudioDiskstream::request_jack_monitors_input (bool yn)
{
boost::shared_ptr<ChannelList> 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);
}
}
}
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)
projects / ardour.git / blobdiff