X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_diskstream.cc;h=c302e06681ca05f394b14c7451eafafb6e27501b;hb=5e1cfcc7ed557fc28ca8b362deceefa1967ab22b;hp=ceee6467abb52cb22f9126929ae5fd409f792b0c;hpb=722ea289a7e3aa0e4c346d81c2ed99aa981ba77d;p=ardour.git diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc index ceee6467ab..c302e06681 100644 --- a/libs/ardour/audio_diskstream.cc +++ b/libs/ardour/audio_diskstream.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2000-2006 Paul Davis + Copyright (C) 2000-2006 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 @@ -30,28 +30,31 @@ #include #include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "pbd/error.h" +#include "pbd/xml++.h" +#include "pbd/memento_command.h" +#include "pbd/enumwriter.h" +#include "pbd/stateful_diff_command.h" + +#include "ardour/analyser.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/debug.h" +#include "ardour/io.h" +#include "ardour/playlist_factory.h" +#include "ardour/region_factory.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 "i18n.h" #include @@ -66,28 +69,23 @@ gain_t* AudioDiskstream::_gain_buffer = 0; AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag) : Diskstream(sess, name, flag) - , deprecated_io_node(NULL) , channels (new ChannelList) { /* prevent any write sources from being created */ in_set_state = true; - - init(flag); use_new_playlist (); - in_set_state = false; } - + AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node) : Diskstream(sess, node) - , deprecated_io_node(NULL) , channels (new ChannelList) { in_set_state = true; - init (Recordable); + init (); - if (set_state (node)) { + if (set_state (node, Stateful::loading_state_version)) { in_set_state = false; throw failed_constructor(); } @@ -100,10 +98,8 @@ AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node) } void -AudioDiskstream::init (Diskstream::Flag f) +AudioDiskstream::init () { - Diskstream::init(f); - /* there are no channels at this point, so these two calls just get speed_buffer_size and wrap_buffer size setup without duplicating their code. @@ -111,19 +107,16 @@ AudioDiskstream::init (Diskstream::Flag f) set_block_size (_session.get_block_size()); allocate_temporary_buffers (); - - add_channel (1); - assert(_n_channels == ChanCount(DataType::AUDIO, 1)); } AudioDiskstream::~AudioDiskstream () { - notify_callbacks (); + DEBUG_TRACE (DEBUG::Destruction, string_compose ("Audio Diskstream %1 destructor\n", _name)); { RCUWriter writer (channels); boost::shared_ptr c = writer.get_copy(); - + for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { delete *chan; } @@ -158,40 +151,36 @@ void AudioDiskstream::non_realtime_input_change () { { - Glib::Mutex::Lock lm (state_lock); + Glib::Threads::Mutex::Lock lm (state_lock); - if (input_change_pending == NoChange) { + if (input_change_pending.type == IOChange::NoChange) { return; } - { + if (input_change_pending.type == IOChange::ConfigurationChanged) { RCUWriter writer (channels); boost::shared_ptr c = writer.get_copy(); - + _n_channels.set(DataType::AUDIO, c->size()); - - if (_io->n_inputs().n_audio() > _n_channels.n_audio()) { - add_channel_to (c, _io->n_inputs().n_audio() - _n_channels.n_audio()); - } else if (_io->n_inputs().n_audio() < _n_channels.n_audio()) { - remove_channel_from (c, _n_channels.n_audio() - _io->n_inputs().n_audio()); + + if (_io->n_ports().n_audio() > _n_channels.n_audio()) { + add_channel_to (c, _io->n_ports().n_audio() - _n_channels.n_audio()); + } else if (_io->n_ports().n_audio() < _n_channels.n_audio()) { + remove_channel_from (c, _n_channels.n_audio() - _io->n_ports().n_audio()); } } - - get_input_sources (); - set_capture_offset (); - - if (first_input_change) { - set_align_style (_persistent_alignment_style); - first_input_change = false; - } else { + + if (input_change_pending.type & IOChange::ConnectionsChanged) { + get_input_sources (); + set_capture_offset (); set_align_style_from_io (); } - - input_change_pending = NoChange; + + input_change_pending = IOChange::NoChange; /* implicit unlock */ } - + /* reset capture files */ reset_write_sources (false); @@ -199,12 +188,24 @@ AudioDiskstream::non_realtime_input_change () /* now refill channel buffers */ if (speed() != 1.0f || speed() != -1.0f) { - seek ((nframes_t) (_session.transport_frame() * (double) speed())); + seek ((framepos_t) (_session.transport_frame() * (double) speed())); } else { seek (_session.transport_frame()); } } +void +AudioDiskstream::non_realtime_locate (framepos_t location) +{ + /* now refill channel buffers */ + + if (speed() != 1.0f || speed() != -1.0f) { + seek ((framepos_t) (location * (double) speed())); + } else { + seek (location); + } +} + void AudioDiskstream::get_input_sources () { @@ -212,37 +213,30 @@ AudioDiskstream::get_input_sources () uint32_t n; ChannelList::iterator chan; - uint32_t ni = _io->n_inputs().n_audio(); + uint32_t ni = _io->n_ports().n_audio(); + vector connections; for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) { - - const char **connections = _io->input(n)->get_connections (); - - if (connections == 0 || connections[0] == 0) { - - if ((*chan)->source) { + + connections.clear (); + + if (_io->nth (n)->get_connections (connections) == 0) { + if (!(*chan)->source.name.empty()) { // _source->disable_metering (); } - - (*chan)->source = 0; - + (*chan)->source.name = string(); } else { - (*chan)->source = dynamic_cast( - _session.engine().get_port_by_name (connections[0]) ); - } - - if (connections) { - free (connections); + (*chan)->source.name = connections[0]; } } -} +} int AudioDiskstream::find_and_use_playlist (const string& name) { boost::shared_ptr playlist; - - if ((playlist = boost::dynamic_pointer_cast (_session.playlist_by_name (name))) == 0) { + + if ((playlist = boost::dynamic_pointer_cast (_session.playlists->by_name (name))) == 0) { playlist = boost::dynamic_pointer_cast (PlaylistFactory::create (DataType::AUDIO, _session, name)); } @@ -281,11 +275,10 @@ 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 { + } else { return -1; } } @@ -308,11 +301,10 @@ AudioDiskstream::use_copy_playlist () boost::shared_ptr 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()); + + if ((playlist = boost::dynamic_pointer_cast(PlaylistFactory::create (audio_playlist(), newname))) != 0) { return use_playlist (playlist); - } else { + } else { return -1; } } @@ -322,15 +314,22 @@ AudioDiskstream::setup_destructive_playlist () { SourceList srcs; boost::shared_ptr c = channels.reader(); - + for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { srcs.push_back ((*chan)->write_source); } /* a single full-sized region */ - boost::shared_ptr region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name)); - _playlist->add_region (region, srcs.front()->natural_position()); + assert (!srcs.empty ()); + + PropertyList plist; + plist.add (Properties::name, _name.val()); + plist.add (Properties::start, 0); + plist.add (Properties::length, max_framepos - (max_framepos - srcs.front()->natural_position())); + + boost::shared_ptr region (RegionFactory::create (srcs, plist)); + _playlist->add_region (region, srcs.front()->natural_position()); } void @@ -338,7 +337,7 @@ AudioDiskstream::use_destructive_playlist () { /* this is called from the XML-based constructor or ::set_destructive. when called, we already have a playlist and a region, but we need to - set up our sources for write. we use the sources associated + set up our sources for write. we use the sources associated with the (presumed single, full-extent) region. */ @@ -357,7 +356,7 @@ AudioDiskstream::use_destructive_playlist () /* be sure to stretch the region out to the maximum length */ - region->set_length (max_frames - region->position(), this); + region->set_length (max_framepos - region->position()); uint32_t n; ChannelList::iterator chan; @@ -377,176 +376,66 @@ AudioDiskstream::use_destructive_playlist () } void -AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record) +AudioDiskstream::prepare_record_status(framepos_t capture_start_frame) { - int possibly_recording; - int rolling; - int change; - const int transport_rolling = 0x4; - const int track_rec_enabled = 0x2; - const int global_rec_enabled = 0x1; - - /* merge together the 3 factors that affect record status, and compute - what has changed. - */ - - rolling = _session.transport_speed() != 0.0f; - possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record; - change = possibly_recording ^ last_possibly_recording; - - if (possibly_recording == last_possibly_recording) { - return; - } - - /* change state */ - - /* if per-track or global rec-enable turned on while the other was already on, we've started recording */ - - if ((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record) || - ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) { - - /* starting to record: compute first+last frames */ - - first_recordable_frame = transport_frame + _capture_offset; - last_recordable_frame = max_frames; - capture_start_frame = transport_frame; - - if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) { - - /* was stopped, now rolling (and recording) */ - - if (_alignment_style == ExistingMaterial) { - first_recordable_frame += _session.worst_output_latency(); - } else { - first_recordable_frame += _roll_delay; - } - - } else { - - /* was rolling, but record state changed */ - - if (_alignment_style == ExistingMaterial) { - - if (!Config->get_punch_in()) { - - /* manual punch in happens at the correct transport frame - because the user hit a button. but to get alignment correct - we have to back up the position of the new region to the - appropriate spot given the roll delay. - */ - - capture_start_frame -= _roll_delay; - - /* XXX paul notes (august 2005): i don't know why - this is needed. - */ - - first_recordable_frame += _capture_offset; - - } else { - - /* autopunch toggles recording at the precise - transport frame, and then the DS waits - to start recording for a time that depends - on the output latency. - */ + if (recordable() && destructive()) { + boost::shared_ptr c = channels.reader(); + for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - first_recordable_frame += _session.worst_output_latency(); - } + RingBufferNPT::rw_vector transitions; + (*chan)->capture_transition_buf->get_write_vector (&transitions); + if (transitions.len[0] > 0) { + transitions.buf[0]->type = CaptureStart; + transitions.buf[0]->capture_val = capture_start_frame; + (*chan)->capture_transition_buf->increment_write_ptr(1); } else { - - if (Config->get_punch_in()) { - first_recordable_frame += _roll_delay; - } else { - capture_start_frame -= _roll_delay; - } + // bad! + fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!") + << endmsg; } - - } - - if (recordable() && destructive()) { - boost::shared_ptr c = channels.reader(); - for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - - RingBufferNPT::rw_vector transvec; - (*chan)->capture_transition_buf->get_write_vector(&transvec); - - if (transvec.len[0] > 0) { - transvec.buf[0]->type = CaptureStart; - transvec.buf[0]->capture_val = capture_start_frame; - (*chan)->capture_transition_buf->increment_write_ptr(1); - } - else { - // bad! - fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!") - << endmsg; - } - } - } - - } else if (!record_enabled() || !can_record) { - - /* stop recording */ - - last_recordable_frame = transport_frame + _capture_offset; - - if (_alignment_style == ExistingMaterial) { - last_recordable_frame += _session.worst_output_latency(); - } else { - last_recordable_frame += _roll_delay; } } - - last_possibly_recording = possibly_recording; } + +/** Do some record stuff [not described in this comment!] + * + * Also: + * - Setup playback_distance with the nframes, or nframes adjusted + * for current varispeed, if appropriate. + * - Setup current_playback_buffer in each ChannelInfo to point to data + * that someone can read playback_distance worth of data from. + */ int -AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input) +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; - nframes_t rec_offset = 0; - nframes_t rec_nframes = 0; - bool nominally_recording; - bool re = record_enabled (); + framecnt_t rec_offset = 0; + framecnt_t rec_nframes = 0; bool collect_playback = false; + bool can_record = _session.actively_recording (); - /* if we've already processed the frames corresponding to this call, - just return. this allows multiple routes that are taking input - from this diskstream to call our ::process() method, but have - this stuff only happen once. more commonly, it allows both - the AudioTrack that is using this AudioDiskstream *and* the Session - to call process() without problems. - */ + playback_distance = 0; - if (_processed) { + if (!_io || !_io->active()) { return 0; } - commit_should_unlock = false; - - check_record_status (transport_frame, nframes, can_record); - - nominally_recording = (can_record && re); + check_record_status (transport_frame, can_record); if (nframes == 0) { - _processed = true; return 0; } - /* This lock is held until the end of AudioDiskstream::commit, so these two functions - must always be called as a pair. The only exception is if this function - returns a non-zero value, in which case, ::commit should not be called. - */ + Glib::Threads::Mutex::Lock sm (state_lock, Glib::Threads::TRY_LOCK); - // If we can't take the state lock return. - if (!state_lock.trylock()) { + if (!sm.locked()) { return 1; - } - commit_should_unlock = true; + } + adjust_capture_position = 0; for (chan = c->begin(); chan != c->end(); ++chan) { @@ -554,55 +443,17 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_ (*chan)->current_playback_buffer = 0; } - if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) { - OverlapType ot; - - // Safeguard against situations where process() goes haywire when autopunching and last_recordable_frame < first_recordable_frame - if (last_recordable_frame < first_recordable_frame) { - last_recordable_frame = max_frames; - } + // Safeguard against situations where process() goes haywire when autopunching + // and last_recordable_frame < first_recordable_frame - ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes); + if (last_recordable_frame < first_recordable_frame) { + last_recordable_frame = max_framepos; + } - switch (ot) { - case OverlapNone: - rec_nframes = 0; - break; - - case OverlapInternal: - /* ---------- recrange - |---| transrange - */ - rec_nframes = nframes; - rec_offset = 0; - break; - - case OverlapStart: - /* |--------| recrange - -----| transrange - */ - rec_nframes = transport_frame + nframes - first_recordable_frame; - if (rec_nframes) { - rec_offset = first_recordable_frame - transport_frame; - } - break; - - case OverlapEnd: - /* |--------| recrange - |-------- transrange - */ - rec_nframes = last_recordable_frame - transport_frame; - rec_offset = 0; - break; - - case OverlapExternal: - /* |--------| recrange - -------------- transrange - */ - rec_nframes = last_recordable_frame - first_recordable_frame; - rec_offset = first_recordable_frame - transport_frame; - break; - } + if (record_enabled()) { + + 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) { capture_captured = 0; @@ -610,14 +461,13 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_ } } - - if (can_record && !_last_capture_regions.empty()) { - _last_capture_regions.clear (); + if (can_record && !_last_capture_sources.empty()) { + _last_capture_sources.clear (); } - if (nominally_recording || rec_nframes) { + if (rec_nframes) { - uint32_t limit = _io->n_inputs ().n_audio(); + uint32_t limit = _io->n_ports ().n_audio(); /* one or more ports could already have been removed from _io, but our channel setup hasn't yet been updated. prevent us from trying to @@ -627,44 +477,46 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_ */ for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) { - + ChannelInfo* chaninfo (*chan); chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector); - if (rec_nframes <= chaninfo->capture_vector.len[0]) { - + if (rec_nframes <= (framecnt_t) chaninfo->capture_vector.len[0]) { + chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0]; - /* note: grab the entire port buffer, but only copy what we were supposed to for recording, and use - rec_offset + /* note: grab the entire port buffer, but only copy what we were supposed to + for recording, and use rec_offset */ - AudioPort* const ap = _io->audio_input(n); + boost::shared_ptr const ap = _io->audio (n); assert(ap); - assert(rec_nframes <= ap->get_audio_buffer().capacity()); - memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer().data(rec_nframes, offset + rec_offset), sizeof (Sample) * rec_nframes); + assert(rec_nframes <= (framecnt_t) ap->get_audio_buffer(nframes).capacity()); + Sample *buf = bufs.get_audio (n).data(rec_offset); + memcpy (chaninfo->current_capture_buffer, buf, sizeof (Sample) * rec_nframes); + } else { - nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1]; + framecnt_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1]; if (rec_nframes > total) { DiskOverrun (); - goto out; + return -1; } - AudioPort* const ap = _io->audio_input(n); + boost::shared_ptr const ap = _io->audio (n); assert(ap); - Sample* buf = ap->get_audio_buffer().data(nframes, offset); - nframes_t first = chaninfo->capture_vector.len[0]; + 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); memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first); memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first)); memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first)); - + chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer; } } @@ -672,13 +524,13 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_ } else { if (was_recording) { - finish_capture (rec_monitors_input, c); + finish_capture (c); } } - + if (rec_nframes) { - + /* data will be written to disk */ if (rec_nframes == nframes && rec_offset == 0) { @@ -702,7 +554,7 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_ adjust_capture_position = rec_nframes; - } else if (nominally_recording) { + } else if (can_record && record_enabled()) { /* can't do actual capture yet - waiting for latency effects to finish before we start*/ @@ -717,113 +569,150 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_ collect_playback = true; } - if (collect_playback) { - + if ((_track->monitoring_state () & MonitoringDisk) || collect_playback) { + /* we're doing playback */ - nframes_t necessary_samples; + framecnt_t necessary_samples; /* no varispeed playback if we're recording, because the output .... TBD */ if (rec_nframes == 0 && _actual_speed != 1.0f) { - necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1; + necessary_samples = (framecnt_t) ceil ((nframes * fabs (_actual_speed))) + 2; } else { necessary_samples = nframes; } - + for (chan = c->begin(); chan != c->end(); ++chan) { (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector); } - n = 0; + n = 0; + + /* Setup current_playback_buffer in each ChannelInfo to point to data that someone + can read necessary_samples (== nframes at a transport speed of 1) worth of data + from right now. + */ for (chan = c->begin(); chan != c->end(); ++chan, ++n) { - - ChannelInfo* chaninfo (*chan); - if (necessary_samples <= chaninfo->playback_vector.len[0]) { + ChannelInfo* chaninfo (*chan); + if (necessary_samples <= (framecnt_t) chaninfo->playback_vector.len[0]) { + /* There are enough samples in the first part of the ringbuffer */ chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0]; } else { - nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1]; - + framecnt_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1]; + if (necessary_samples > total) { + cerr << _name << " Need " << necessary_samples << " total = " << total << endl; + cerr << "underrun for " << _name << endl; DiskUnderrun (); - goto out; - + return -1; + } else { + + /* We have enough samples, but not in one lump. Coalesce the two parts + into one in playback_wrap_buffer in our ChannelInfo, and specify that + 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], + chaninfo->playback_vector.len[0] * sizeof (Sample)); - memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0], - chaninfo->playback_vector.len[0] * sizeof (Sample)); - memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], chaninfo->playback_vector.buf[1], - (necessary_samples - chaninfo->playback_vector.len[0]) * sizeof (Sample)); - + /* Copy buf[1] from playback_buf */ + memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], + chaninfo->playback_vector.buf[1], + (necessary_samples - chaninfo->playback_vector.len[0]) + * sizeof (Sample)); + chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer; } } - } + } if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) { - - uint64_t phase = last_phase; - nframes_t i = 0; - // Linearly interpolate into the alt buffer - // using 40.24 fixp maths (swh) + interpolation.set_speed (_target_speed); - for (chan = c->begin(); chan != c->end(); ++chan) { - - float fr; + int channel = 0; + for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++channel) { ChannelInfo* chaninfo (*chan); - - i = 0; - phase = last_phase; - - for (nframes_t outsample = 0; outsample < nframes; ++outsample) { - i = phase >> 24; - fr = (phase & 0xFFFFFF) / 16777216.0f; - chaninfo->speed_buffer[outsample] = - chaninfo->current_playback_buffer[i] * (1.0f - fr) + - chaninfo->current_playback_buffer[i+1] * fr; - phase += phi; - } + + playback_distance = interpolation.interpolate ( + channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer); chaninfo->current_playback_buffer = chaninfo->speed_buffer; } - - playback_distance = i + 1; - last_phase = (phase & 0xFFFFFF); - + } else { playback_distance = nframes; } + _speed = _target_speed; } - ret = 0; + if (need_disk_signal) { - out: - _processed = true; + /* 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 (ret) { + 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); + } + } + } - /* we're exiting with failure, so ::commit will not - be called. unlock the state lock. - */ - - commit_should_unlock = false; - state_lock.unlock(); - } + /* 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 */ + } - 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 (nframes_t nframes) +AudioDiskstream::commit (framecnt_t playback_distance) { bool need_butler = false; + if (!_io || !_io->active()) { + return false; + } + if (_actual_speed < 0.0) { playback_sample -= playback_distance; } else { @@ -834,29 +723,35 @@ AudioDiskstream::commit (nframes_t nframes) for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { (*chan)->playback_buf->increment_read_ptr (playback_distance); - + if (adjust_capture_position) { (*chan)->capture_buf->increment_write_ptr (adjust_capture_position); } } - + if (adjust_capture_position != 0) { capture_captured += adjust_capture_position; adjust_capture_position = 0; } - - if (_slaved) { - need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2; - } else { - need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames - || c->front()->capture_buf->read_space() >= disk_io_chunk_frames; - } - if (commit_should_unlock) { - state_lock.unlock(); + if (c->empty()) { + return false; } - _processed = false; + if (_slaved) { + if (_io && _io->active()) { + need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2; + } else { + need_butler = false; + } + } else { + if (_io && _io->active()) { + need_butler = ((framecnt_t) c->front()->playback_buf->write_space() >= disk_io_chunk_frames) + || ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames); + } else { + need_butler = ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames); + } + } return need_butler; } @@ -865,41 +760,52 @@ void AudioDiskstream::set_pending_overwrite (bool yn) { /* called from audio thread, so we can use the read ptr and playback sample as we wish */ - - pending_overwrite = yn; + + _pending_overwrite = yn; overwrite_frame = playback_sample; - overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr(); + + boost::shared_ptr c = channels.reader (); + if (!c->empty ()) { + overwrite_offset = c->front()->playback_buf->get_read_ptr(); + } } int AudioDiskstream::overwrite_existing_buffers () { boost::shared_ptr c = channels.reader(); - Sample* mixdown_buffer; - float* gain_buffer; - int ret = -1; + if (c->empty ()) { + _pending_overwrite = false; + return 0; + } + + Sample* mixdown_buffer; + float* gain_buffer; + int ret = -1; bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f; overwrite_queued = false; /* assume all are the same size */ - nframes_t size = c->front()->playback_buf->bufsize(); - - mixdown_buffer = new Sample[size]; - gain_buffer = new float[size]; - - /* reduce size so that we can fill the buffer correctly. */ + framecnt_t size = c->front()->playback_buf->bufsize(); + + mixdown_buffer = new Sample[size]; + gain_buffer = new float[size]; + + /* reduce size so that we can fill the buffer correctly (ringbuffers + can only handle size-1, otherwise they appear to be empty) + */ size--; - + uint32_t n=0; - nframes_t start; + framepos_t start; for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) { start = overwrite_frame; - nframes_t cnt = size; - + framecnt_t cnt = size; + /* to fill the buffer without resetting the playback sample, we need to do it one or two chunks (normally two). @@ -908,63 +814,62 @@ AudioDiskstream::overwrite_existing_buffers () ^ overwrite_offset |<- second chunk->||<----------------- first chunk ------------------>| - + */ - - nframes_t to_read = size - overwrite_offset; - if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) { + framecnt_t to_read = size - overwrite_offset; + + if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, n, reversed)) { error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"), - _id, size, playback_sample) << endmsg; + id(), size, playback_sample) << endmsg; goto out; } - + if (cnt > to_read) { cnt -= to_read; - - if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer, - start, cnt, *chan, n, reversed)) { + + if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer, start, cnt, n, reversed)) { error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"), - _id, size, playback_sample) << endmsg; + id(), size, playback_sample) << endmsg; goto out; } } } ret = 0; - + out: - pending_overwrite = false; - delete [] gain_buffer; - delete [] mixdown_buffer; - return ret; + _pending_overwrite = false; + delete [] gain_buffer; + delete [] mixdown_buffer; + return ret; } int -AudioDiskstream::seek (nframes_t frame, bool complete_refill) +AudioDiskstream::seek (framepos_t frame, bool complete_refill) { uint32_t n; int ret = -1; 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 (); (*chan)->capture_buf->reset (); } - + /* can't rec-enable in destructive mode if transport is before start */ - + if (destructive() && record_enabled() && frame < _session.current_start_frame()) { disengage_record_enable (); } - + playback_sample = frame; file_frame = frame; - + if (complete_refill) { while ((ret = do_refill_with_alloc ()) > 0) ; } else { @@ -975,21 +880,21 @@ AudioDiskstream::seek (nframes_t frame, bool complete_refill) } int -AudioDiskstream::can_internal_playback_seek (nframes_t distance) +AudioDiskstream::can_internal_playback_seek (framecnt_t distance) { ChannelList::iterator chan; boost::shared_ptr c = channels.reader(); for (chan = c->begin(); chan != c->end(); ++chan) { - if ((*chan)->playback_buf->read_space() < distance) { + if ((*chan)->playback_buf->read_space() < (size_t) distance) { return false; - } + } } return true; } int -AudioDiskstream::internal_playback_seek (nframes_t distance) +AudioDiskstream::internal_playback_seek (framecnt_t distance) { ChannelList::iterator chan; boost::shared_ptr c = channels.reader(); @@ -998,66 +903,76 @@ AudioDiskstream::internal_playback_seek (nframes_t distance) (*chan)->playback_buf->increment_read_ptr (distance); } - first_recordable_frame += distance; + if (first_recordable_frame < max_framepos) { + first_recordable_frame += distance; + } playback_sample += distance; - + return 0; } +/** Read some data for 1 channel from our playlist into a buffer. + * @param buf Buffer to write to. + * @param start Session frame to start reading from; updated to where we end up + * after the read. + * @param cnt Count of samples to read. + * @param reversed true if we are running backwards, otherwise false. + */ int -AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt, - ChannelInfo* channel_info, int channel, bool reversed) +AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, + framepos_t& start, framecnt_t cnt, + int channel, bool reversed) { - nframes_t this_read = 0; + framecnt_t this_read = 0; bool reloop = false; - nframes_t loop_end = 0; - nframes_t loop_start = 0; - nframes_t loop_length = 0; - nframes_t offset = 0; + framepos_t loop_end = 0; + framepos_t loop_start = 0; + framecnt_t offset = 0; Location *loc = 0; /* XXX we don't currently play loops in reverse. not sure why */ if (!reversed) { + framecnt_t loop_length = 0; + /* Make the use of a Location atomic for this read operation. - + Note: Locations don't get deleted, so all we care about when I say "atomic" is that we are always pointing to the same one and using a start/length values obtained just once. */ - + if ((loc = loop_location) != 0) { loop_start = loc->start(); loop_end = loc->end(); loop_length = loop_end - loop_start; } - + /* if we are looping, ensure that the first frame we read is at the correct position within the loop. */ - + if (loc && start >= loop_end) { - //cerr << "start adjusted from " << start; start = loop_start + ((start - loop_start) % loop_length); - //cerr << "to " << start << endl; } + } - //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl; + if (reversed) { + start -= cnt; } + /* We need this while loop in case we hit a loop boundary, in which case our read from + the playlist must be split into more than one section. + */ + while (cnt) { - if (reversed) { - start -= cnt; - } - /* take any loop into account. we can't read past the end of the loop. */ if (loc && (loop_end - start < cnt)) { this_read = loop_end - start; - //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl; reloop = true; } else { reloop = false; @@ -1071,27 +986,25 @@ AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, this_read = min(cnt,this_read); if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) { - error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read, + error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), id(), this_read, start) << endmsg; return -1; } - _read_data_count = _playlist->read_data_count(); - if (reversed) { swap_by_ptr (buf, buf + this_read - 1); - + } else { - + /* if we read to the end of the loop, go back to the beginning */ - + if (reloop) { start = loop_start; } else { start += this_read; } - } + } cnt -= this_read; offset += this_read; @@ -1107,26 +1020,29 @@ AudioDiskstream::do_refill_with_alloc () float* gain_buf = new float[disk_io_chunk_frames]; int ret = _do_refill(mix_buf, gain_buf); - + delete [] mix_buf; delete [] gain_buf; return ret; } +/** Get some more data from disk and put it in our channels' playback_bufs, + * if there is suitable space in them. + */ int AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) { int32_t ret = 0; - nframes_t to_read; + framecnt_t to_read; RingBufferNPT::rw_vector vector; - bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f; - nframes_t total_space; - nframes_t zero_fill; + bool const reversed = (_visible_speed * _session.transport_speed()) < 0.0f; + framecnt_t total_space; + framecnt_t zero_fill; uint32_t chan_n; ChannelList::iterator i; boost::shared_ptr c = channels.reader(); - nframes_t ts; + framecnt_t ts; if (c->empty()) { return 0; @@ -1141,8 +1057,9 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) vector.len[1] = 0; c->front()->playback_buf->get_write_vector (&vector); - + if ((total_space = vector.len[0] + vector.len[1]) == 0) { + /* nowhere to write to */ return 0; } @@ -1150,28 +1067,32 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) this track, let the caller know so that it can arrange for us to be called again, ASAP. */ - - if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) { + + if (total_space >= (_slaved ? 3 : 2) * disk_io_chunk_frames) { ret = 1; } - - /* if we're running close to normal speed and there isn't enough - space to do disk_io_chunk_frames of I/O, then don't bother. - + + /* if we're running close to normal speed and there isn't enough + space to do disk_io_chunk_frames of I/O, then don't bother. + at higher speeds, just do it because the sync between butler and audio thread may not be good enough. + + Note: it is a design assumption that disk_io_chunk_frames is smaller + than the playback buffer size, so this check should never trip when + the playback buffer is empty. */ - + if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) { return 0; } - + /* when slaved, don't try to get too close to the read pointer. this leaves space for the buffer reversal to have something useful to work with. */ - - if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) { + + if (_slaved && total_space < (framecnt_t) (c->front()->playback_buf->bufsize() / 2)) { return 0; } @@ -1186,7 +1107,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) /* at start: nothing to do but fill with silence */ for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) { - + ChannelInfo* chan (*i); chan->playback_buf->get_write_vector (&vector); memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]); @@ -1200,27 +1121,26 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) if (file_frame < total_space) { - /* too close to the start: read what we can, - and then zero fill the rest + /* too close to the start: read what we can, + and then zero fill the rest */ zero_fill = total_space - file_frame; total_space = file_frame; - file_frame = 0; } else { - + zero_fill = 0; } } else { - if (file_frame == max_frames) { + if (file_frame == max_framepos) { /* at end: nothing to do but fill with silence */ - + for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) { - + ChannelInfo* chan (*i); chan->playback_buf->get_write_vector (&vector); memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]); @@ -1231,52 +1151,52 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) } return 0; } - - if (file_frame > max_frames - total_space) { + + if (file_frame > max_framepos - total_space) { /* to close to the end: read what we can, and zero fill the rest */ - zero_fill = total_space - (max_frames - file_frame); - total_space = max_frames - file_frame; + zero_fill = total_space - (max_framepos - file_frame); + total_space = max_framepos - file_frame; } else { zero_fill = 0; } } - - nframes_t file_frame_tmp = 0; + + framepos_t file_frame_tmp = 0; for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) { ChannelInfo* chan (*i); Sample* buf1; Sample* buf2; - nframes_t len1, len2; + framecnt_t len1, len2; chan->playback_buf->get_write_vector (&vector); - if (vector.len[0] > disk_io_chunk_frames) { - + if ((framecnt_t) vector.len[0] > disk_io_chunk_frames) { + /* we're not going to fill the first chunk, so certainly do not bother with the other part. it won't be connected with the part we do fill, as in: - + .... => writable space ++++ => readable space ^^^^ => 1 x disk_io_chunk_frames that would be filled - + |......|+++++++++++++|...............................| buf1 buf0 ^^^^^^^^^^^^^^^ - - - So, just pretend that the buf1 part isn't there. - + + + So, just pretend that the buf1 part isn't there. + */ - + vector.buf[1] = 0; vector.len[1] = 0; - - } + + } ts = total_space; file_frame_tmp = file_frame; @@ -1289,9 +1209,11 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) to_read = min (ts, len1); to_read = min (to_read, disk_io_chunk_frames); + assert (to_read >= 0); + if (to_read) { - if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) { + if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) { ret = -1; goto out; } @@ -1308,26 +1230,27 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) so read some or all of vector.len[1] as well. */ - if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) { + if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) { ret = -1; goto out; } - + chan->playback_buf->increment_write_ptr (to_read); } if (zero_fill) { - /* do something */ + /* XXX: do something */ } } - + file_frame = file_frame_tmp; + assert (file_frame >= 0); out: return ret; -} +} /** Flush pending data to disk. * @@ -1335,20 +1258,18 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) * of data to disk. it will never write more than that. If it writes that * much and there is more than that waiting to be written, it will return 1, * otherwise 0 on success or -1 on failure. - * + * * If there is less than disk_io_chunk_frames to be written, no data will be * written at all unless @a force_flush is true. */ int -AudioDiskstream::do_flush (Session::RunContext context, bool force_flush) +AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush) { uint32_t to_write; int32_t ret = 0; RingBufferNPT::rw_vector vector; RingBufferNPT::rw_vector transvec; - nframes_t total; - - _write_data_count = 0; + framecnt_t total; transvec.buf[0] = 0; transvec.buf[1] = 0; @@ -1357,7 +1278,7 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush) boost::shared_ptr c = channels.reader(); for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - + (*chan)->capture_buf->get_read_vector (&vector); total = vector.len[0] + vector.len[1]; @@ -1369,7 +1290,7 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush) /* if there are 2+ chunks of disk i/o possible for this track, let the caller know so that it can arrange for us to be called again, ASAP. - + if we are forcing a flush, then if there is* any* extra work, let the caller know. @@ -1379,38 +1300,35 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush) if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) { ret = 1; - } + } + + to_write = min (disk_io_chunk_frames, (framecnt_t) vector.len[0]); - to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]); - // check the transition buffer when recording destructive // important that we get this after the capture buf if (destructive()) { (*chan)->capture_transition_buf->get_read_vector(&transvec); size_t transcount = transvec.len[0] + transvec.len[1]; - bool have_start = false; size_t ti; for (ti=0; ti < transcount; ++ti) { CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]]; - + if (captrans.type == CaptureStart) { // by definition, the first data we got above represents the given capture pos (*chan)->write_source->mark_capture_start (captrans.capture_val); (*chan)->curr_capture_cnt = 0; - have_start = true; - } - else if (captrans.type == CaptureEnd) { + } else if (captrans.type == CaptureEnd) { // capture end, the capture_val represents total frames in capture if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) { // shorten to make the write a perfect fit - uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt); + uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt); if (nto_write < to_write) { ret = 1; // should we? @@ -1418,7 +1336,7 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush) to_write = nto_write; (*chan)->write_source->mark_capture_end (); - + // increment past this transition, but go no further ++ti; break; @@ -1437,29 +1355,27 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush) } if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) { - error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg; + error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg; return -1; } (*chan)->capture_buf->increment_read_ptr (to_write); (*chan)->curr_capture_cnt += to_write; - + if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) { - + /* we wrote all of vector.len[0] but it wasn't an entire - disk_io_chunk_frames of data, so arrange for some part + disk_io_chunk_frames of data, so arrange for some part of vector.len[1] to be flushed to disk as well. */ - - to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]); + + to_write = min ((framecnt_t)(disk_io_chunk_frames - to_write), (framecnt_t) vector.len[1]); if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) { - error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg; + error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg; return -1; } - _write_data_count += (*chan)->write_source->write_data_count(); - (*chan)->capture_buf->increment_read_ptr (to_write); (*chan)->curr_capture_cnt += to_write; } @@ -1470,29 +1386,29 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush) } void -AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture) +AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture) { uint32_t buffer_position; bool more_work = true; int err = 0; boost::shared_ptr region; - nframes_t total_capture; + framecnt_t total_capture; SourceList srcs; SourceList::iterator src; ChannelList::iterator chan; vector::iterator ci; boost::shared_ptr c = channels.reader(); - uint32_t n = 0; + uint32_t n = 0; bool mark_write_completed = false; - finish_capture (true, c); + finish_capture (c); - /* butler is already stopped, but there may be work to do + /* butler is already stopped, but there may be work to do to flush remaining data to disk. */ while (more_work && !err) { - switch (do_flush (Session::TransportContext, true)) { + switch (do_flush (TransportContext, true)) { case 0: more_work = false; break; @@ -1505,14 +1421,14 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca } /* 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; } if (abort_capture) { - + if (destructive()) { goto outout; } @@ -1520,17 +1436,17 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { if ((*chan)->write_source) { - + (*chan)->write_source->mark_for_remove (); (*chan)->write_source->drop_references (); (*chan)->write_source.reset (); } - + /* new source set up in "out" below */ } goto out; - } + } for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) { total_capture += (*ci)->frames; @@ -1541,12 +1457,16 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) { boost::shared_ptr s = (*chan)->write_source; - + if (s) { srcs.push_back (s); s->update_header (capture_info.front()->start, when, twhen); - s->set_captured_for (_name); + s->set_captured_for (_name.val()); s->mark_immutable (); + + if (Config->get_auto_analyse_audio()) { + Analyser::queue_source_for_analysis (s, true); + } } } @@ -1554,13 +1474,13 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca if (destructive()) { - /* send a signal that any UI can pick up to do the right thing. there is + /* send a signal that any UI can pick up to do the right thing. there is a small problem here in that a UI may need the peak data to be ready for the data that was recorded and this isn't interlocked with that process. this problem is deferred to the UI. */ - - _playlist->Modified(); + + _playlist->LayeringChanged(); // XXX this may not get the UI to do the right thing } else { @@ -1572,61 +1492,73 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca so that any sub-regions will obviously be children of this one (later!) */ - + try { - boost::shared_ptr rx (RegionFactory::create (srcs, c->front()->write_source->last_capture_start_frame(), total_capture, - whole_file_region_name, - 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile))); + PropertyList plist; + + plist.add (Properties::start, c->front()->write_source->last_capture_start_frame()); + plist.add (Properties::length, total_capture); + plist.add (Properties::name, whole_file_region_name); + boost::shared_ptr rx (RegionFactory::create (srcs, plist)); + rx->set_automatic (true); + rx->set_whole_file (true); region = boost::dynamic_pointer_cast (rx); region->special_set_position (capture_info.front()->start); } - - + + catch (failed_constructor& err) { error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg; /* XXX what now? */ } - - _last_capture_regions.push_back (region); + + _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end()); // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n"; - - XMLNode &before = _playlist->get_state(); + + _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) { - + string region_name; - _session.region_name (region_name, whole_file_region_name, false); - - // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl; - + RegionFactory::region_name (region_name, whole_file_region_name, false); + + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n", + _name, (*ci)->start, (*ci)->frames, region_name)); + try { - boost::shared_ptr rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name)); + + PropertyList plist; + + plist.add (Properties::start, buffer_position); + plist.add (Properties::length, (*ci)->frames); + plist.add (Properties::name, region_name); + + boost::shared_ptr rx (RegionFactory::create (srcs, plist)); region = boost::dynamic_pointer_cast (rx); } - + catch (failed_constructor& err) { error << _("AudioDiskstream: could not create region for captured audio!") << endmsg; continue; /* XXX is this OK? */ } - - region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr(region))); - - _last_capture_regions.push_back (region); - + i_am_the_modifier++; - _playlist->add_region (region, (*ci)->start); + + _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 (); - XMLNode &after = _playlist->get_state(); - _session.add_command (new MementoCommand(*_playlist, &before, &after)); + _playlist->set_capture_insertion_in_progress (false); + _session.add_command (new StatefulDiffCommand (_playlist)); } mark_write_completed = true; @@ -1645,7 +1577,7 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca } void -AudioDiskstream::transport_looped (nframes_t transport_frame) +AudioDiskstream::transport_looped (framepos_t transport_frame) { if (was_recording) { // all we need to do is finish this capture, with modified capture length @@ -1663,22 +1595,22 @@ AudioDiskstream::transport_looped (nframes_t transport_frame) } } - finish_capture (true, c); + finish_capture (c); // the next region will start recording via the normal mechanism // we'll set the start position to the current transport pos // no latency adjustment or capture offset needs to be made, as that already happened the first time capture_start_frame = transport_frame; first_recordable_frame = transport_frame; // mild lie - last_recordable_frame = max_frames; + last_recordable_frame = max_framepos; was_recording = true; if (recordable() && destructive()) { for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - + RingBufferNPT::rw_vector transvec; (*chan)->capture_transition_buf->get_write_vector(&transvec); - + if (transvec.len[0] > 0) { transvec.buf[0]->type = CaptureStart; transvec.buf[0]->capture_val = capture_start_frame; @@ -1686,30 +1618,32 @@ AudioDiskstream::transport_looped (nframes_t transport_frame) } else { // bad! - fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!") + fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!") << endmsg; } - } + } } } } void -AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr c) +AudioDiskstream::finish_capture (boost::shared_ptr c) { was_recording = false; - + first_recordable_frame = max_framepos; + last_recordable_frame = max_framepos; + if (capture_captured == 0) { return; } if (recordable() && destructive()) { for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - + RingBufferNPT::rw_vector transvec; (*chan)->capture_transition_buf->get_write_vector(&transvec); - + if (transvec.len[0] > 0) { transvec.buf[0]->type = CaptureEnd; transvec.buf[0]->capture_val = capture_captured; @@ -1721,15 +1655,15 @@ AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptrstart = capture_start_frame; ci->frames = capture_captured; - - /* XXX theoretical race condition here. Need atomic exchange ? - However, the circumstances when this is called right + + /* XXX theoretical race condition here. Need atomic exchange ? + However, the circumstances when this is called right now (either on record-disable or transport_stopped) mean that no actual race exists. I think ... We now have a capture_info_lock, but it is only to be used @@ -1741,12 +1675,15 @@ AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptrn_inputs().n_audio() == 0) { + if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) { return; } @@ -1756,15 +1693,6 @@ AudioDiskstream::set_record_enabled (bool yn) return; } - if (yn && channels.reader()->front()->source == 0) { - - /* pick up connections not initiated *from* the IO object - we're associated with. - */ - - get_input_sources (); - } - /* yes, i know that this not proof against race conditions, but its good enough. i think. */ @@ -1775,73 +1703,71 @@ 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) { - if ((*chan)->source) { - (*chan)->source->ensure_monitor_input (!(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 (); } - + } else { for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { 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 c = channels.reader(); - for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - if (Config->get_monitoring_model() == HardwareMonitoring) { - if ((*chan)->source) { - (*chan)->source->ensure_monitor_input (false); - } + if (Config->get_monitoring_model() == HardwareMonitoring) { + for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { + (*chan)->source.request_jack_monitors_input (false); } } capturing_sources.clear (); - RecordEnableChanged (); /* EMIT SIGNAL */ + + return true; } XMLNode& AudioDiskstream::get_state () { - XMLNode* node = new XMLNode ("AudioDiskstream"); + XMLNode& node (Diskstream::get_state()); char buf[64] = ""; LocaleGuard lg (X_("POSIX")); - boost::shared_ptr c = channels.reader(); - - node->add_property ("flags", enum_2_string (_flags)); + boost::shared_ptr c = channels.reader(); snprintf (buf, sizeof(buf), "%zd", c->size()); - node->add_property ("channels", buf); - - node->add_property ("playlist", _playlist->name()); - - snprintf (buf, sizeof(buf), "%.12g", _visible_speed); - node->add_property ("speed", buf); - - node->add_property("name", _name); - id().print (buf, sizeof (buf)); - node->add_property("id", buf); + node.add_property ("channels", buf); if (!capturing_sources.empty() && _session.get_record_enabled()) { @@ -1858,25 +1784,21 @@ AudioDiskstream::get_state () Location* pi; - if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) { - snprintf (buf, sizeof (buf), "%" PRIu32, pi->start()); + if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) { + snprintf (buf, sizeof (buf), "%" PRId64, pi->start()); } else { - snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame()); + snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame()); } cs_child->add_property (X_("at"), buf); - node->add_child_nocopy (*cs_child); - } - - if (_extra_xml) { - node->add_child_copy (*_extra_xml); + node.add_child_nocopy (*cs_child); } - return* node; + return node; } int -AudioDiskstream::set_state (const XMLNode& node) +AudioDiskstream::set_state (const XMLNode& node, int version) { const XMLProperty* prop; XMLNodeList nlist = node.children(); @@ -1885,89 +1807,51 @@ AudioDiskstream::set_state (const XMLNode& node) XMLNode* capture_pending_node = 0; LocaleGuard lg (X_("POSIX")); + /* prevent write sources from being created */ + in_set_state = true; - for (niter = nlist.begin(); niter != nlist.end(); ++niter) { - if ((*niter)->name() == IO::state_node_name) { + for (niter = nlist.begin(); niter != nlist.end(); ++niter) { + if ((*niter)->name() == IO::state_node_name) { deprecated_io_node = new XMLNode (**niter); - } + } if ((*niter)->name() == X_("CapturingSources")) { capture_pending_node = *niter; } - } - - /* prevent write sources from being created */ - - in_set_state = true; - - if ((prop = node.property ("name")) != 0) { - _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 ("flags")) != 0) { - _flags = Flag (string_2_enum (prop->value(), _flags)); + if (Diskstream::set_state (node, version)) { + return -1; } if ((prop = node.property ("channels")) != 0) { nchans = atoi (prop->value().c_str()); } - + // create necessary extra channels // we are always constructed with one and we always need one _n_channels.set(DataType::AUDIO, channels.reader()->size()); - + if (nchans > _n_channels.n_audio()) { add_channel (nchans - _n_channels.n_audio()); + IO::PortCountChanged(_n_channels); } else if (nchans < _n_channels.n_audio()) { remove_channel (_n_channels.n_audio() - nchans); } - if ((prop = node.property ("playlist")) == 0) { - return -1; - } - - { - bool had_playlist = (_playlist != 0); - - if (find_and_use_playlist (prop->value())) { - return -1; - } - - if (!had_playlist) { - _playlist->set_orig_diskstream_id (_id); - } - - if (!destructive() && capture_pending_node) { - /* destructive streams have one and only one source per channel, - and so they never end up in pending capture in any useful - sense. - */ - use_pending_capture_data (*capture_pending_node); - } - - } - if ((prop = node.property ("speed")) != 0) { - double sp = atof (prop->value().c_str()); - if (realtime_set_speed (sp, false)) { - non_realtime_set_speed (); - } + if (!destructive() && capture_pending_node) { + /* destructive streams have one and only one source per channel, + and so they never end up in pending capture in any useful + sense. + */ + use_pending_capture_data (*capture_pending_node); } in_set_state = false; @@ -1976,11 +1860,9 @@ AudioDiskstream::set_state (const XMLNode& node) capturing_sources.clear (); - /* write sources are handled when we handle the input set + /* write sources are handled when we handle the input set up of the IO that owns this DS (::non_realtime_input_change()) */ - - in_set_state = false; return 0; } @@ -2000,18 +1882,13 @@ AudioDiskstream::use_new_write_source (uint32_t n) } ChannelInfo* chan = (*c)[n]; - - if (chan->write_source) { - chan->write_source->done_with_peakfile_writes (); - chan->write_source->set_allow_remove_if_empty (true); - chan->write_source.reset (); - } try { - if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) { + if ((chan->write_source = _session.create_audio_source_for_session ( + n_channels().n_audio(), name(), n, destructive())) == 0) { throw failed_constructor(); } - } + } catch (failed_constructor &err) { error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg; @@ -2026,25 +1903,46 @@ AudioDiskstream::use_new_write_source (uint32_t n) return 0; } +list > +AudioDiskstream::steal_write_sources() +{ + /* not possible to steal audio write sources */ + list > ret; + return ret; +} + void -AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force) +AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/) { ChannelList::iterator chan; boost::shared_ptr c = channels.reader(); uint32_t n; - if (!recordable()) { + if (!_session.writable() || !recordable()) { return; } - + capturing_sources.clear (); for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) { + if (!destructive()) { - if ((*chan)->write_source && mark_write_complete) { - (*chan)->write_source->mark_streaming_write_completed (); + if ((*chan)->write_source) { + + if (mark_write_complete) { + (*chan)->write_source->mark_streaming_write_completed (); + (*chan)->write_source->done_with_peakfile_writes (); + } + + if ((*chan)->write_source->removable()) { + (*chan)->write_source->mark_for_remove (); + (*chan)->write_source->drop_references (); + } + + (*chan)->write_source.reset (); } + use_new_write_source (n); if (record_enabled()) { @@ -2052,13 +1950,14 @@ AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force) } } else { + if ((*chan)->write_source == 0) { use_new_write_source (n); } } } - if (destructive()) { + if (destructive() && !c->empty ()) { /* we now have all our write sources set up, so create the playlist's single region. @@ -2070,32 +1969,16 @@ AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force) } } -int -AudioDiskstream::rename_write_sources () -{ - ChannelList::iterator chan; - boost::shared_ptr c = channels.reader(); - uint32_t n; - - for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) { - if ((*chan)->write_source != 0) { - (*chan)->write_source->set_source_name (_name, destructive()); - /* XXX what to do if one of them fails ? */ - } - } - - return 0; -} - void -AudioDiskstream::set_block_size (nframes_t nframes) +AudioDiskstream::set_block_size (pframes_t /*nframes*/) { if (_session.get_block_size() > speed_buffer_size) { speed_buffer_size = _session.get_block_size(); boost::shared_ptr c = channels.reader(); for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - if ((*chan)->speed_buffer) delete [] (*chan)->speed_buffer; + if ((*chan)->speed_buffer) + delete [] (*chan)->speed_buffer; (*chan)->speed_buffer = new Sample[speed_buffer_size]; } } @@ -2107,21 +1990,25 @@ AudioDiskstream::allocate_temporary_buffers () { /* make sure the wrap buffer is at least large enough to deal with the speeds up to 1.2, to allow for micro-variation - when slaving to MTC, SMPTE etc. + when slaving to MTC, Timecode etc. */ - double sp = max (fabsf (_actual_speed), 1.2f); - nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1; + double const sp = max (fabsf (_actual_speed), 1.2f); + framecnt_t required_wrap_size = (framecnt_t) ceil (_session.get_block_size() * sp) + 2; if (required_wrap_size > wrap_buffer_size) { boost::shared_ptr c = channels.reader(); for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - if ((*chan)->playback_wrap_buffer) delete [] (*chan)->playback_wrap_buffer; - (*chan)->playback_wrap_buffer = new Sample[required_wrap_size]; - if ((*chan)->capture_wrap_buffer) delete [] (*chan)->capture_wrap_buffer; - (*chan)->capture_wrap_buffer = new Sample[required_wrap_size]; + if ((*chan)->playback_wrap_buffer) { + delete [] (*chan)->playback_wrap_buffer; + } + (*chan)->playback_wrap_buffer = new Sample[required_wrap_size]; + if ((*chan)->capture_wrap_buffer) { + delete [] (*chan)->capture_wrap_buffer; + } + (*chan)->capture_wrap_buffer = new Sample[required_wrap_size]; } wrap_buffer_size = required_wrap_size; @@ -2129,15 +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) { - - if ((*chan)->source) { - (*chan)->source->ensure_monitor_input (yn); - } + (*chan)->source.request_jack_monitors_input (yn); } } @@ -2146,16 +2030,20 @@ AudioDiskstream::set_align_style_from_io () { bool have_physical = false; + if (_alignment_choice != Automatic) { + return; + } + if (_io == 0) { return; } get_input_sources (); - + boost::shared_ptr c = channels.reader(); for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { - if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) { + if ((*chan)->source.is_physical ()) { have_physical = true; break; } @@ -2172,7 +2060,13 @@ int AudioDiskstream::add_channel_to (boost::shared_ptr c, uint32_t how_many) { while (how_many--) { - c->push_back (new ChannelInfo(_session.diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size)); + c->push_back (new ChannelInfo( + _session.butler()->audio_diskstream_playback_buffer_size(), + _session.butler()->audio_diskstream_capture_buffer_size(), + speed_buffer_size, wrap_buffer_size)); + interpolation.add_channel_to ( + _session.butler()->audio_diskstream_playback_buffer_size(), + speed_buffer_size); } _n_channels.set(DataType::AUDIO, c->size()); @@ -2192,9 +2086,10 @@ AudioDiskstream::add_channel (uint32_t how_many) int AudioDiskstream::remove_channel_from (boost::shared_ptr c, uint32_t how_many) { - while (--how_many && !c->empty()) { + while (how_many-- && !c->empty()) { delete c->back(); c->pop_back(); + interpolation.remove_channel_from (); } _n_channels.set(DataType::AUDIO, c->size()); @@ -2207,7 +2102,7 @@ AudioDiskstream::remove_channel (uint32_t how_many) { RCUWriter writer (channels); boost::shared_ptr c = writer.get_copy(); - + return remove_channel_from (c, how_many); } @@ -2216,6 +2111,10 @@ AudioDiskstream::playback_buffer_load () const { boost::shared_ptr c = channels.reader(); + if (c->empty ()) { + return 0; + } + return (float) ((double) c->front()->playback_buf->read_space()/ (double) c->front()->playback_buf->bufsize()); } @@ -2225,6 +2124,10 @@ AudioDiskstream::capture_buffer_load () const { boost::shared_ptr c = channels.reader(); + if (c->empty ()) { + return 0; + } + return (float) ((double) c->front()->capture_buf->write_space()/ (double) c->front()->capture_buf->bufsize()); } @@ -2238,13 +2141,13 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) boost::shared_ptr fs; boost::shared_ptr first_fs; SourceList pending_sources; - nframes_t position; + framepos_t position; if ((prop = node.property (X_("at"))) == 0) { return -1; } - if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) { + if (sscanf (prop->value().c_str(), "%" PRIu64, &position) != 1) { return -1; } @@ -2255,9 +2158,17 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) continue; } + // This protects sessions from errant CapturingSources in stored sessions + struct stat sbuf; + if (stat (prop->value().c_str(), &sbuf)) { + continue; + } + try { fs = boost::dynamic_pointer_cast ( - SourceFactory::createWritable (DataType::AUDIO, _session, prop->value(), false, _session.frame_rate())); + SourceFactory::createWritable ( + DataType::AUDIO, _session, + prop->value(), false, _session.frame_rate())); } catch (failed_constructor& err) { @@ -2268,12 +2179,12 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) } pending_sources.push_back (fs); - + if (first_fs == 0) { first_fs = fs; } - fs->set_captured_for (_name); + fs->set_captured_for (_name.val()); } } @@ -2289,31 +2200,27 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) } boost::shared_ptr region; - + try { - region = boost::dynamic_pointer_cast (RegionFactory::create (pending_sources, 0, first_fs->length(), - region_name_from_path (first_fs->name(), true), - 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile))); - region->special_set_position (0); - } - catch (failed_constructor& err) { - error << string_compose (_("%1: cannot create whole-file region from pending capture sources"), - _name) - << endmsg; - - return -1; - } + PropertyList plist; - try { - region = boost::dynamic_pointer_cast (RegionFactory::create (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name(), true))); + plist.add (Properties::start, 0); + plist.add (Properties::length, first_fs->length (first_fs->timeline_position())); + plist.add (Properties::name, region_name_from_path (first_fs->name(), true)); + + region = boost::dynamic_pointer_cast (RegionFactory::create (pending_sources, plist)); + + region->set_automatic (true); + region->set_whole_file (true); + region->special_set_position (0); } catch (failed_constructor& err) { - error << string_compose (_("%1: cannot create region from pending capture sources"), - _name) - << endmsg; - + error << string_compose ( + _("%1: cannot create whole-file region from pending capture sources"), + _name) << endmsg; + return -1; } @@ -2323,15 +2230,29 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) } int -AudioDiskstream::set_destructive (bool yn) +AudioDiskstream::set_non_layered (bool yn) { - bool bounce_ignored; + if (yn != non_layered()) { + + if (yn) { + _flags = Flag (_flags | NonLayered); + } else { + _flags = Flag (_flags & ~NonLayered); + } + } + + return 0; +} +int +AudioDiskstream::set_destructive (bool yn) +{ if (yn != destructive()) { - + if (yn) { + bool bounce_ignored; /* requestor should already have checked this and - bounced if necessary and desired + bounced if necessary and desired */ if (!can_become_destructive (bounce_ignored)) { return -1; @@ -2363,10 +2284,13 @@ AudioDiskstream::can_become_destructive (bool& requires_bounce) const } boost::shared_ptr first = _playlist->find_next_region (_session.current_start_frame(), Start, 1); - assert (first); + if (!first) { + requires_bounce = false; + return true; + } /* do the source(s) for the region cover the session start position ? */ - + if (first->position() != _session.current_start_frame()) { if (first->start() > _session.current_start_frame()) { requires_bounce = true; @@ -2380,8 +2304,8 @@ AudioDiskstream::can_become_destructive (bool& requires_bounce) const assert (afirst); - if (afirst->source()->used() > 1) { - requires_bounce = true; + if (_session.playlists->source_use_count (afirst->source()) > 1) { + requires_bounce = true; return false; } @@ -2389,10 +2313,48 @@ AudioDiskstream::can_become_destructive (bool& requires_bounce) const return true; } -AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size) +void +AudioDiskstream::adjust_playback_buffering () +{ + boost::shared_ptr c = channels.reader(); + + for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { + (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size()); + } +} + +void +AudioDiskstream::adjust_capture_buffering () +{ + boost::shared_ptr c = channels.reader(); + + for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) { + (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size()); + } +} + +bool +AudioDiskstream::ChannelSource::is_physical () const +{ + if (name.empty()) { + return false; + } + + return AudioEngine::instance()->port_is_physical (name); +} + +void +AudioDiskstream::ChannelSource::request_jack_monitors_input (bool yn) const +{ + if (name.empty()) { + return; + } + + 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) { - peak_power = 0.0f; - source = 0; current_capture_buffer = 0; current_playback_buffer = 0; curr_capture_cnt = 0; @@ -2401,14 +2363,14 @@ AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_si playback_wrap_buffer = new Sample[wrap_size]; capture_wrap_buffer = new Sample[wrap_size]; - playback_buf = new RingBufferNPT (bufsize); - capture_buf = new RingBufferNPT (bufsize); + playback_buf = new RingBufferNPT (playback_bufsize); + capture_buf = new RingBufferNPT (capture_bufsize); capture_transition_buf = new RingBufferNPT (256); - + /* touch the ringbuffer buffers, which will cause them to be mapped into locked physical RAM if we're running with mlockall(). this doesn't do - much if we're not. + much if we're not. */ memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize()); @@ -2416,39 +2378,61 @@ AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_si memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize()); } +void +AudioDiskstream::ChannelInfo::resize_playback (framecnt_t playback_bufsize) +{ + delete playback_buf; + playback_buf = new RingBufferNPT (playback_bufsize); + memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize()); +} + +void +AudioDiskstream::ChannelInfo::resize_capture (framecnt_t capture_bufsize) +{ + delete capture_buf; + + capture_buf = new RingBufferNPT (capture_bufsize); + memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize()); +} + AudioDiskstream::ChannelInfo::~ChannelInfo () { - if (write_source) { - write_source.reset (); - } - - if (speed_buffer) { - delete [] speed_buffer; - speed_buffer = 0; - } + write_source.reset (); - if (playback_wrap_buffer) { - delete [] playback_wrap_buffer; - playback_wrap_buffer = 0; - } + delete [] speed_buffer; + speed_buffer = 0; - if (capture_wrap_buffer) { - delete [] capture_wrap_buffer; - capture_wrap_buffer = 0; - } - - if (playback_buf) { - delete playback_buf; - playback_buf = 0; - } + delete [] playback_wrap_buffer; + playback_wrap_buffer = 0; - if (capture_buf) { - delete capture_buf; - capture_buf = 0; - } + delete [] capture_wrap_buffer; + capture_wrap_buffer = 0; + + delete playback_buf; + playback_buf = 0; + + delete capture_buf; + capture_buf = 0; + + delete capture_transition_buf; + capture_transition_buf = 0; +} + + +bool +AudioDiskstream::set_name (string const & name) +{ + Diskstream::set_name (name); + + /* get a new write source so that its name reflects the new diskstream name */ + + boost::shared_ptr c = channels.reader(); + ChannelList::iterator i; + int n = 0; - if (capture_transition_buf) { - delete capture_transition_buf; - capture_transition_buf = 0; + for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) { + use_new_write_source (n); } + + return true; }