X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_diskstream.cc;h=b2bf7b2b4a8fedffd56ea70d6bb67e1c68fb37e1;hb=1dfcf07ba9448a0a73f85519f04d9c03b08f5e3e;hp=00e1f9298f29065493c6b1b2f2b27e8acf3dc874;hpb=90220998af4f9683d696b511a09b34034e799093;p=ardour.git diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc index 00e1f9298f..b2bf7b2b4a 100644 --- a/libs/ardour/audio_diskstream.cc +++ b/libs/ardour/audio_diskstream.cc @@ -16,7 +16,6 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#include #include #include #include @@ -28,6 +27,7 @@ #include #include +#include "pbd/gstdio_compat.h" #include "pbd/error.h" #include "pbd/xml++.h" #include "pbd/memento_command.h" @@ -46,22 +46,23 @@ #include "ardour/debug.h" #include "ardour/io.h" #include "ardour/playlist_factory.h" +#include "ardour/profile.h" #include "ardour/region_factory.h" #include "ardour/session.h" #include "ardour/session_playlists.h" +#include "ardour/sndfile_helpers.h" #include "ardour/source_factory.h" #include "ardour/track.h" #include "ardour/types.h" #include "ardour/utils.h" -#include "i18n.h" +#include "pbd/i18n.h" #include using namespace std; using namespace ARDOUR; using namespace PBD; -size_t AudioDiskstream::_working_buffers_size = 0; Sample* AudioDiskstream::_mixdown_buffer = 0; gain_t* AudioDiskstream::_gain_buffer = 0; @@ -132,9 +133,13 @@ AudioDiskstream::~AudioDiskstream () void AudioDiskstream::allocate_working_buffers() { - _working_buffers_size = max (disk_write_chunk_frames, disk_read_chunk_frames); - _mixdown_buffer = new Sample[_working_buffers_size]; - _gain_buffer = new gain_t[_working_buffers_size]; + /* with varifill buffer refilling, we compute the read size in bytes (to optimize + for disk i/o bandwidth) and then convert back into samples. These buffers + need to reflect the maximum size we could use, which is 4MB reads, or 2M samples + using 16 bit samples. + */ + _mixdown_buffer = new Sample[2*1048576]; + _gain_buffer = new gain_t[2*1048576]; } void @@ -142,7 +147,6 @@ AudioDiskstream::free_working_buffers() { delete [] _mixdown_buffer; delete [] _gain_buffer; - _working_buffers_size = 0; _mixdown_buffer = 0; _gain_buffer = 0; } @@ -164,7 +168,7 @@ AudioDiskstream::non_realtime_input_change () need_write_sources = true; } - if (input_change_pending.type == IOChange::ConfigurationChanged) { + if (input_change_pending.type & IOChange::ConfigurationChanged) { RCUWriter writer (channels); boost::shared_ptr c = writer.get_copy(); @@ -209,9 +213,9 @@ AudioDiskstream::non_realtime_locate (framepos_t location) /* now refill channel buffers */ if (speed() != 1.0f || speed() != -1.0f) { - seek ((framepos_t) (location * (double) speed())); + seek ((framepos_t) (location * (double) speed()), true); } else { - seek (location); + seek (location, true); } } @@ -312,6 +316,7 @@ AudioDiskstream::use_copy_playlist () newname = Playlist::bump_name (_playlist->name(), _session); if ((playlist = boost::dynamic_pointer_cast(PlaylistFactory::create (audio_playlist(), newname))) != 0) { + playlist->reset_shares(); return use_playlist (playlist); } else { return -1; @@ -355,8 +360,9 @@ AudioDiskstream::use_destructive_playlist () boost::shared_ptr rp; { - const RegionList& rl (_playlist->region_list().rlist()); + const RegionList& rl (_playlist->region_list_property().rlist()); if (rl.size() > 0) { + /* this can happen when dragging a region onto a tape track */ assert((rl.size() == 1)); rp = rl.front(); } @@ -373,9 +379,9 @@ AudioDiskstream::use_destructive_playlist () throw failed_constructor(); } - /* be sure to stretch the region out to the maximum length */ + /* be sure to stretch the region out to the maximum length (non-musical)*/ - region->set_length (max_framepos - region->position()); + region->set_length (max_framepos - region->position(), 0); uint32_t n; ChannelList::iterator chan; @@ -388,7 +394,12 @@ AudioDiskstream::use_destructive_playlist () /* this might be false if we switched modes, so force it */ +#ifdef XXX_OLD_DESTRUCTIVE_API_XXX (*chan)->write_source->set_destructive (true); +#else + // should be set when creating the source or loading the state + assert ((*chan)->write_source->destructive()); +#endif } /* the source list will never be reset for a destructive track */ @@ -519,7 +530,7 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t 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]; @@ -595,14 +606,14 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t } if ((_track->monitoring_state () & MonitoringDisk) || collect_playback) { - + /* we're doing playback */ framecnt_t necessary_samples; /* no varispeed playback if we're recording, because the output .... TBD */ - if (rec_nframes == 0 && _actual_speed != 1.0f) { + if (rec_nframes == 0 && _actual_speed != 1.0) { necessary_samples = (framecnt_t) ceil ((nframes * fabs (_actual_speed))) + 2; } else { necessary_samples = nframes; @@ -651,7 +662,7 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0], 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], @@ -670,13 +681,13 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t 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; } @@ -687,20 +698,20 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t 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; } 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); @@ -720,7 +731,7 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t 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 */ } @@ -783,6 +794,7 @@ AudioDiskstream::commit (framecnt_t playback_distance) if (adjust_capture_position != 0) { capture_captured += adjust_capture_position; + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 now captured %2 (by %3)\n", name(), capture_captured, adjust_capture_position)); adjust_capture_position = 0; } @@ -923,9 +935,15 @@ AudioDiskstream::seek (framepos_t frame, bool complete_refill) file_frame = frame; if (complete_refill) { - while ((ret = do_refill_with_alloc ()) > 0) ; + /* call _do_refill() to refill the entire buffer, using + the largest reads possible. + */ + while ((ret = do_refill_with_alloc (false)) > 0) ; } else { - ret = do_refill_with_alloc (); + /* call _do_refill() to refill just one chunk, and then + return. + */ + ret = do_refill_with_alloc (true); } return ret; @@ -952,7 +970,7 @@ AudioDiskstream::internal_playback_seek (framecnt_t distance) boost::shared_ptr c = channels.reader(); for (chan = c->begin(); chan != c->end(); ++chan) { - (*chan)->playback_buf->increment_read_ptr (llabs(distance)); + (*chan)->playback_buf->increment_read_ptr (::llabs(distance)); } if (first_recordable_frame < max_framepos) { @@ -1067,12 +1085,18 @@ AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, } int -AudioDiskstream::do_refill_with_alloc () +AudioDiskstream::_do_refill_with_alloc (bool partial_fill) { - Sample* mix_buf = new Sample[disk_read_chunk_frames]; - float* gain_buf = new float[disk_read_chunk_frames]; + /* We limit disk reads to at most 4MB chunks, which with floating point + samples would be 1M samples. But we might use 16 or 14 bit samples, + in which case 4MB is more samples than that. Therefore size this for + the smallest sample value .. 4MB = 2M samples (16 bit). + */ - int ret = _do_refill(mix_buf, gain_buf); + Sample* mix_buf = new Sample[2*1048576]; + float* gain_buf = new float[2*1048576]; + + int ret = _do_refill (mix_buf, gain_buf, (partial_fill ? disk_read_chunk_frames : 0)); delete [] mix_buf; delete [] gain_buf; @@ -1082,9 +1106,15 @@ AudioDiskstream::do_refill_with_alloc () /** Get some more data from disk and put it in our channels' playback_bufs, * if there is suitable space in them. + * + * If fill_level is non-zero, then we will refill the buffer so that there is + * still at least fill_level samples of space left to be filled. This is used + * after locates so that we do not need to wait to fill the entire buffer. + * */ + int -AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) +AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_level) { int32_t ret = 0; framecnt_t to_read; @@ -1097,6 +1127,14 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) boost::shared_ptr c = channels.reader(); framecnt_t ts; + /* do not read from disk while session is marked as Loading, to avoid + useless redundant I/O. + */ + + if (_session.state_of_the_state() & Session::Loading) { + return 0; + } + if (c->empty()) { return 0; } @@ -1116,13 +1154,13 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) return 0; } - /* 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 (total_space >= (_slaved ? 3 : 2) * disk_read_chunk_frames) { - ret = 1; + if (fill_level) { + if (fill_level < total_space) { + total_space -= fill_level; + } else { + /* we can't do anything with it */ + fill_level = 0; + } } /* if we're running close to normal speed and there isn't enough @@ -1149,10 +1187,6 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) return 0; } - /* never do more than disk_read_chunk_frames worth of disk input per call (limit doesn't apply for memset) */ - - total_space = min (disk_read_chunk_frames, total_space); - if (reversed) { if (file_frame == 0) { @@ -1219,6 +1253,30 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) framepos_t file_frame_tmp = 0; + /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */ + + const size_t bits_per_sample = format_data_width (_session.config.get_native_file_data_format()); + size_t total_bytes = total_space * bits_per_sample / 8; + + /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer + */ + size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes)); + + /* find nearest (lower) multiple of 16384 */ + + byte_size_for_read = (byte_size_for_read / 16384) * 16384; + + /* now back to samples */ + + framecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8); + + //cerr << name() << " will read " << byte_size_for_read << " out of total bytes " << total_bytes << " in buffer of " + // << c->front()->playback_buf->bufsize() * bits_per_sample / 8 << " bps = " << bits_per_sample << endl; + // cerr << name () << " read samples = " << samples_to_read << " out of total space " << total_space << " in buffer of " << c->front()->playback_buf->bufsize() << " samples\n"; + + // uint64_t before = g_get_monotonic_time (); + // uint64_t elapsed; + for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) { ChannelInfo* chan (*i); @@ -1228,7 +1286,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) chan->playback_buf->get_write_vector (&vector); - if ((framecnt_t) vector.len[0] > disk_read_chunk_frames) { + if ((framecnt_t) vector.len[0] > samples_to_read) { /* 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: @@ -1260,7 +1318,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) len2 = vector.len[1]; to_read = min (ts, len1); - to_read = min (to_read, disk_read_chunk_frames); + to_read = min (to_read, (framecnt_t) samples_to_read); assert (to_read >= 0); @@ -1279,8 +1337,9 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) if (to_read) { - /* we read all of vector.len[0], but it wasn't an entire disk_read_chunk_frames of data, - so read some or all of vector.len[1] as well. + /* we read all of vector.len[0], but it wasn't the + entire samples_to_read of data, so read some or + all of vector.len[1] as well. */ if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) { @@ -1297,11 +1356,17 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) } + // elapsed = g_get_monotonic_time () - before; + // cerr << "\tbandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n"; + file_frame = file_frame_tmp; assert (file_frame >= 0); - out: + ret = ((total_space - samples_to_read) > disk_read_chunk_frames); + + c->front()->playback_buf->get_write_vector (&vector); + out: return ret; } @@ -1411,7 +1476,7 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush) 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; @@ -1522,6 +1587,8 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo if (Config->get_auto_analyse_audio()) { Analyser::queue_source_for_analysis (s, true); } + + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("newly captured source %1 length %2\n", s->path(), s->length (0))); } } @@ -1569,19 +1636,20 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo } _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end()); - + _playlist->clear_changes (); _playlist->set_capture_insertion_in_progress (true); _playlist->freeze (); + const framepos_t preroll_off = _session.preroll_record_trim_len (); for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) { string region_name; 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)); + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture bufpos %5 start @ %2 length %3 add new region %4\n", + _name, (*ci)->start, (*ci)->frames, region_name, buffer_position)); try { @@ -1593,6 +1661,9 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo boost::shared_ptr rx (RegionFactory::create (srcs, plist)); region = boost::dynamic_pointer_cast (rx); + if (preroll_off > 0) { + region->trim_front (buffer_position + preroll_off); + } } catch (failed_constructor& err) { @@ -1602,7 +1673,7 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo i_am_the_modifier++; - _playlist->add_region (region, (*ci)->start, 1, non_layered()); + _playlist->add_region (region, (*ci)->start + preroll_off, 1, non_layered()); _playlist->set_layer (region, DBL_MAX); i_am_the_modifier--; @@ -1636,18 +1707,6 @@ AudioDiskstream::transport_looped (framepos_t transport_frame) // all we need to do is finish this capture, with modified capture length boost::shared_ptr c = channels.reader(); - // adjust the capture length knowing that the data will be recorded to disk - // only necessary after the first loop where we're recording - if (capture_info.size() == 0) { - capture_captured += _capture_offset; - - if (_alignment_style == ExistingMaterial) { - capture_captured += _session.worst_output_latency(); - } else { - capture_captured += _roll_delay; - } - } - finish_capture (c); // the next region will start recording via the normal mechanism @@ -1725,7 +1784,7 @@ AudioDiskstream::finish_capture (boost::shared_ptr c) */ DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("Finish capture, add new CI, %1 + %2\n", ci->start, ci->frames)); - + capture_info.push_back (ci); capture_captured = 0; @@ -1767,25 +1826,25 @@ AudioDiskstream::set_record_safe (bool yn) if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) { return; } - - /* can't rec-safe in destructive mode if transport is before start ???? + + /* can't rec-safe in destructive mode if transport is before start ???? REQUIRES REVIEW */ - + if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) { return; } - + /* yes, i know that this not proof against race conditions, but its good enough. i think. */ - + if (record_safe () != yn) { if (yn) { engage_record_safe (); } else { disengage_record_safe (); } - + RecordSafeChanged (); /* EMIT SIGNAL */ } } @@ -1846,12 +1905,10 @@ XMLNode& AudioDiskstream::get_state () { XMLNode& node (Diskstream::get_state()); - char buf[64] = ""; - LocaleGuard lg (X_("C")); + LocaleGuard lg; boost::shared_ptr c = channels.reader(); - snprintf (buf, sizeof(buf), "%u", (unsigned int) c->size()); - node.add_property ("channels", buf); + node.set_property ("channels", (uint32_t)c->size()); if (!capturing_sources.empty() && _session.get_record_enabled()) { @@ -1860,7 +1917,7 @@ AudioDiskstream::get_state () for (vector >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) { cs_grandchild = new XMLNode (X_("file")); - cs_grandchild->add_property (X_("path"), (*i)->path()); + cs_grandchild->set_property (X_("path"), (*i)->path()); cs_child->add_child_nocopy (*cs_grandchild); } @@ -1868,13 +1925,14 @@ AudioDiskstream::get_state () Location* pi; - if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) { - snprintf (buf, sizeof (buf), "%" PRId64, pi->start()); + if (_session.preroll_record_punch_enabled ()) { + cs_child->set_property (X_("at"), _session.preroll_record_punch_pos()); + } else if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) { + cs_child->set_property (X_("at"), pi->start()); } else { - snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame()); + cs_child->set_property (X_("at"), _session.transport_frame()); } - cs_child->add_property (X_("at"), buf); node.add_child_nocopy (*cs_child); } @@ -1884,12 +1942,10 @@ AudioDiskstream::get_state () int AudioDiskstream::set_state (const XMLNode& node, int version) { - const XMLProperty* prop; XMLNodeList nlist = node.children(); XMLNodeIterator niter; - uint32_t nchans = 1; XMLNode* capture_pending_node = 0; - LocaleGuard lg (X_("C")); + LocaleGuard lg; /* prevent write sources from being created */ @@ -1909,9 +1965,8 @@ AudioDiskstream::set_state (const XMLNode& node, int version) return -1; } - if ((prop = node.property ("channels")) != 0) { - nchans = atoi (prop->value().c_str()); - } + uint32_t nchans = 1; + node.get_property ("channels", nchans); // create necessary extra channels // we are always constructed with one and we always need one @@ -1928,8 +1983,6 @@ AudioDiskstream::set_state (const XMLNode& node, int version) remove_channel (_n_channels.n_audio() - nchans); } - - 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 @@ -2070,7 +2123,7 @@ AudioDiskstream::allocate_temporary_buffers () when slaving to MTC, Timecode etc. */ - double const sp = max (fabsf (_actual_speed), 1.2f); + double const sp = max (fabs (_actual_speed), 1.2); framecnt_t required_wrap_size = (framecnt_t) ceil (_session.get_block_size() * sp) + 2; if (required_wrap_size > wrap_buffer_size) { @@ -2126,6 +2179,22 @@ AudioDiskstream::set_align_style_from_io () } } +#ifdef MIXBUS + // compensate for latency when bouncing from master or mixbus. + // we need to use "ExistingMaterial" to pick up the master bus' latency + // see also Route::direct_feeds_according_to_reality + IOVector ios; + ios.push_back (_io); + if (_session.master_out() && ios.fed_by (_session.master_out()->output())) { + have_physical = true; + } + for (uint32_t n = 0; n < NUM_MIXBUSES && !have_physical; ++n) { + if (_session.get_mixbus (n) && ios.fed_by (_session.get_mixbus(n)->output())) { + have_physical = true; + } + } +#endif + if (have_physical) { set_align_style (ExistingMaterial); } else { @@ -2189,11 +2258,11 @@ AudioDiskstream::playback_buffer_load () const boost::shared_ptr c = channels.reader(); if (c->empty ()) { - return 0; + return 1.0; } return (float) ((double) c->front()->playback_buf->read_space()/ - (double) c->front()->playback_buf->bufsize()); + (double) c->front()->playback_buf->bufsize()); } float @@ -2202,7 +2271,7 @@ AudioDiskstream::capture_buffer_load () const boost::shared_ptr c = channels.reader(); if (c->empty ()) { - return 0; + return 1.0; } return (float) ((double) c->front()->capture_buf->write_space()/ @@ -2212,7 +2281,7 @@ AudioDiskstream::capture_buffer_load () const int AudioDiskstream::use_pending_capture_data (XMLNode& node) { - const XMLProperty* prop; + XMLProperty const * prop; XMLNodeList nlist = node.children(); XMLNodeIterator niter; boost::shared_ptr fs; @@ -2236,8 +2305,8 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) } // This protects sessions from errant CapturingSources in stored sessions - struct stat sbuf; - if (stat (prop->value().c_str(), &sbuf)) { + GStatBuf sbuf; + if (g_stat (prop->value().c_str(), &sbuf)) { continue; } @@ -2285,11 +2354,11 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) boost::shared_ptr wf_region; boost::shared_ptr region; - + /* First create the whole file region */ PropertyList plist; - + 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)); @@ -2304,7 +2373,7 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) * the playlist */ region = boost::dynamic_pointer_cast (RegionFactory::create (pending_sources, plist)); - + _playlist->add_region (region, position); } @@ -2320,6 +2389,7 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) return 0; } +#ifdef XXX_OLD_DESTRUCTIVE_API_XXX int AudioDiskstream::set_non_layered (bool yn) { @@ -2362,6 +2432,10 @@ AudioDiskstream::set_destructive (bool yn) bool AudioDiskstream::can_become_destructive (bool& requires_bounce) const { + if (Profile->get_trx()) { + return false; + } + if (!_playlist) { requires_bounce = false; return false; @@ -2383,7 +2457,7 @@ AudioDiskstream::can_become_destructive (bool& requires_bounce) const boost::shared_ptr first; { - const RegionList& rl (_playlist->region_list().rlist()); + const RegionList& rl (_playlist->region_list_property().rlist()); assert((rl.size() == 1)); first = rl.front(); @@ -2429,6 +2503,7 @@ AudioDiskstream::can_become_destructive (bool& requires_bounce) const requires_bounce = false; return true; } +#endif void AudioDiskstream::adjust_playback_buffering () @@ -2522,7 +2597,7 @@ AudioDiskstream::ChannelInfo::~ChannelInfo () continue to exist. If we do not do this, then the Session retains a reference to it, it is not deleted, and later attempts to create a new source - file will use wierd naming because it already + file will use wierd naming because it already exists. XXX longer term TO-DO: do not add to session source