Match request in function names to the eventual call to jack_port_request_monitor.

[ardour.git] / libs / ardour / audio_diskstream.cc

diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc
index 2f72dbee5e2c7b112657c483d7c479ea932ac7f7..f096a463efe421d2538c4b90124523319777f857 100644 (file)
--- a/libs/ardour/audio_diskstream.cc
+++ b/libs/ardour/audio_diskstream.cc
@@ -31,7 +31,6 @@
 #include <sys/mman.h>
 
 #include "pbd/error.h"
 #include <sys/mman.h>
 
 #include "pbd/error.h"

-#include <glibmm/thread.h>

 #include "pbd/xml++.h"
 #include "pbd/memento_command.h"
 #include "pbd/enumwriter.h"
 #include "pbd/xml++.h"
 #include "pbd/memento_command.h"
 #include "pbd/enumwriter.h"


@@ -57,6 +56,7 @@
 #include "ardour/send.h"
 #include "ardour/session.h"
 #include "ardour/source_factory.h"
 #include "ardour/send.h"
 #include "ardour/session.h"
 #include "ardour/source_factory.h"

+#include "ardour/track.h"

 #include "ardour/utils.h"
 #include "ardour/session_playlists.h"
 #include "ardour/route.h"
 #include "ardour/utils.h"
 #include "ardour/session_playlists.h"
 #include "ardour/route.h"


@@ -162,7 +162,7 @@ AudioDiskstream::non_realtime_input_change ()
                        return;
                }
 
                        return;
                }
 

-                if (input_change_pending.type == IOChange::ConfigurationChanged) {
+               if (input_change_pending.type == IOChange::ConfigurationChanged) {

                        RCUWriter<ChannelList> writer (channels);
                        boost::shared_ptr<ChannelList> c = writer.get_copy();
 
                        RCUWriter<ChannelList> writer (channels);
                        boost::shared_ptr<ChannelList> c = writer.get_copy();
 


@@ -175,11 +175,11 @@ AudioDiskstream::non_realtime_input_change ()
                        }
                }
 
                        }
                }
 

-                if (input_change_pending.type & IOChange::ConnectionsChanged) {
-                        get_input_sources ();
-                        set_capture_offset ();
-                        set_align_style_from_io ();
-                }
+               if (input_change_pending.type & IOChange::ConnectionsChanged) {
+                       get_input_sources ();
+                       set_capture_offset ();
+                       set_align_style_from_io ();
+               }

 
                input_change_pending = IOChange::NoChange;
 
 
                input_change_pending = IOChange::NoChange;
 


@@ -281,7 +281,6 @@ AudioDiskstream::use_new_playlist ()
 
        if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
 
 
        if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
 

-               playlist->set_orig_diskstream_id (id());

                return use_playlist (playlist);
 
        } else {
                return use_playlist (playlist);
 
        } else {


@@ -309,7 +308,6 @@ AudioDiskstream::use_copy_playlist ()
        newname = Playlist::bump_name (_playlist->name(), _session);
 
        if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
        newname = Playlist::bump_name (_playlist->name(), _session);
 
        if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {

-               playlist->set_orig_diskstream_id (id());

                return use_playlist (playlist);
        } else {
                return -1;
                return use_playlist (playlist);
        } else {
                return -1;


@@ -363,7 +361,7 @@ AudioDiskstream::use_destructive_playlist ()
 
        /* be sure to stretch the region out to the maximum length */
 
 
        /* be sure to stretch the region out to the maximum length */
 

-       region->set_length (max_framepos - region->position(), this);
+       region->set_length (max_framepos - region->position());

 
        uint32_t n;
        ChannelList::iterator chan;
 
        uint32_t n;
        ChannelList::iterator chan;


@@ -405,16 +403,25 @@ AudioDiskstream::prepare_record_status(framepos_t capture_start_frame)
        }
 }
 
        }
 }
 

+
+/** 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
 int

-AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
+AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance)

 {
        uint32_t n;
        boost::shared_ptr<ChannelList> c = channels.reader();
        ChannelList::iterator chan;
 {
        uint32_t n;
        boost::shared_ptr<ChannelList> c = channels.reader();
        ChannelList::iterator chan;

-       int ret = -1;

        framecnt_t rec_offset = 0;
        framecnt_t rec_nframes = 0;
        bool collect_playback = false;
        framecnt_t rec_offset = 0;
        framecnt_t rec_nframes = 0;
        bool collect_playback = false;

+       bool can_record = _session.actively_recording ();

 
        playback_distance = 0;
 
 
        playback_distance = 0;
 


@@ -441,23 +448,23 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool ca
                (*chan)->current_playback_buffer = 0;
        }
 
                (*chan)->current_playback_buffer = 0;
        }
 

-       // Safeguard against situations where process() goes haywire when autopunching 
+       // 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_framepos;
        }
 
        // and last_recordable_frame < first_recordable_frame
 
        if (last_recordable_frame < first_recordable_frame) {
                last_recordable_frame = max_framepos;
        }
 

-        if (record_enabled()) {
+       if (record_enabled()) {
+
+               OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
+               calculate_record_range (ot, transport_frame, nframes, rec_nframes, rec_offset);

 
 

-                OverlapType ot = 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;
-                        was_recording = true;
-                }
-        }
+               if (rec_nframes && !was_recording) {
+                       capture_captured = 0;
+                       was_recording = true;
+               }
+       }

 
        if (can_record && !_last_capture_sources.empty()) {
                _last_capture_sources.clear ();
 
        if (can_record && !_last_capture_sources.empty()) {
                _last_capture_sources.clear ();


@@ -488,11 +495,12 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool ca
                                   for recording, and use rec_offset
                                */
 
                                   for recording, and use rec_offset
                                */
 

-                               AudioPort* const ap = _io->audio (n);
+                               boost::shared_ptr<AudioPort> const ap = _io->audio (n);

                                assert(ap);
                                assert(rec_nframes <= (framecnt_t) ap->get_audio_buffer(nframes).capacity());
                                assert(ap);
                                assert(rec_nframes <= (framecnt_t) ap->get_audio_buffer(nframes).capacity());

-                               memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer (nframes).data(rec_offset), sizeof (Sample) * rec_nframes);

 
 

+                               Sample *buf = ap->get_audio_buffer (nframes).data (rec_offset);
+                               memcpy (chaninfo->current_capture_buffer, buf, sizeof (Sample) * rec_nframes);

 
                        } else {
 
 
                        } else {
 


@@ -500,13 +508,13 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool ca
 
                                if (rec_nframes > total) {
                                        DiskOverrun ();
 
                                if (rec_nframes > total) {
                                        DiskOverrun ();

-                                       goto out;
+                                       return -1;

                                }
 
                                }
 

-                               AudioPort* const ap = _io->audio (n);
+                               boost::shared_ptr<AudioPort> const ap = _io->audio (n);

                                assert(ap);
 
                                assert(ap);
 

-                               Sample* buf = ap->get_audio_buffer(nframes).data();
+                               Sample* buf = ap->get_audio_buffer(nframes).data (rec_offset);

                                framecnt_t first = chaninfo->capture_vector.len[0];
 
                                memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
                                framecnt_t first = chaninfo->capture_vector.len[0];
 
                                memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);


@@ -521,7 +529,7 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool ca
        } else {
 
                if (was_recording) {
        } else {
 
                if (was_recording) {

-                       finish_capture (rec_monitors_input, c);
+                       finish_capture (c);

                }
 
        }
                }
 
        }


@@ -566,8 +574,8 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool ca
                collect_playback = true;
        }
 
                collect_playback = true;
        }
 

-       if (collect_playback) {
-
+       if ((_track->monitoring_state () & MonitoringDisk) || collect_playback) {
+               

                /* we're doing playback */
 
                framecnt_t necessary_samples;
                /* we're doing playback */
 
                framecnt_t necessary_samples;


@@ -586,12 +594,17 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool ca
 
                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 <= (framecnt_t) chaninfo->playback_vector.len[0]) {
                for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
 
                        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 {
                                chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
 
                        } else {


@@ -601,13 +614,21 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool ca
                                        cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
                                        cerr << "underrun for " << _name << endl;
                                        DiskUnderrun ();
                                        cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
                                        cerr << "underrun for " << _name << endl;
                                        DiskUnderrun ();

-                                       goto out;
+                                       return -1;

 
                                } else {
 
 
                                } 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.
+                                       */
+
+                                       /* 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));

+                                       
+                                       /* 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])
                                        memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
                                                        chaninfo->playback_vector.buf[1],
                                                        (necessary_samples - chaninfo->playback_vector.len[0])


@@ -619,45 +640,35 @@ AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool ca
                }
 
                if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
                }
 
                if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {

-                       process_varispeed_playback(nframes, c);
+
+                       interpolation.set_speed (_target_speed);
+
+                       int channel = 0;
+                       for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++channel) {
+                               ChannelInfo* chaninfo (*chan);
+                               
+                               playback_distance = interpolation.interpolate (
+                                       channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
+                               
+                               chaninfo->current_playback_buffer = chaninfo->speed_buffer;
+                       }
+                       

                } else {
                        playback_distance = nframes;
                }
 
                _speed = _target_speed;
                } else {
                        playback_distance = nframes;
                }
 
                _speed = _target_speed;

-
-       } 
-
-       ret = 0;
-
-       if (commit (nframes)) {
-               need_butler = true;

        }
 
        }
 

-  out:
-       return ret;
-}
-
-void
-AudioDiskstream::process_varispeed_playback (pframes_t nframes, boost::shared_ptr<ChannelList> c)
-{
-       ChannelList::iterator chan;
-
-       interpolation.set_speed (_target_speed);
-
-       int channel = 0;
-       for (chan = c->begin(); chan != c->end(); ++chan, ++channel) {
-               ChannelInfo* chaninfo (*chan);
-
-               playback_distance = interpolation.interpolate (
-                               channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
-
-               chaninfo->current_playback_buffer = chaninfo->speed_buffer;
-       }
+       return 0;

 }
 
 }
 

+/** Update various things including playback_sample, read pointer on each channel's playback_buf
+ *  and write pointer on each channel's capture_buf.  Also wout whether the butler is needed.
+ *  @return true if the butler is required.
+ */

 bool
 bool

-AudioDiskstream::commit (framecnt_t /* nframes */)
+AudioDiskstream::commit (framecnt_t playback_distance)

 {
        bool need_butler = false;
 
 {
        bool need_butler = false;
 


@@ -685,11 +696,11 @@ AudioDiskstream::commit (framecnt_t /* nframes */)
                capture_captured += adjust_capture_position;
                adjust_capture_position = 0;
        }
                capture_captured += adjust_capture_position;
                adjust_capture_position = 0;
        }

-       
+

        if (c->empty()) {
                return false;
        }
        if (c->empty()) {
                return false;
        }

-       
+

        if (_slaved) {
                if (_io && _io->active()) {
                        need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
        if (_slaved) {
                if (_io && _io->active()) {
                        need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;


@@ -731,7 +742,7 @@ AudioDiskstream::overwrite_existing_buffers ()
                _pending_overwrite = false;
                return 0;
        }
                _pending_overwrite = false;
                return 0;
        }

-       
+

        Sample* mixdown_buffer;
        float* gain_buffer;
        int ret = -1;
        Sample* mixdown_buffer;
        float* gain_buffer;
        int ret = -1;


@@ -746,8 +757,8 @@ AudioDiskstream::overwrite_existing_buffers ()
        gain_buffer = new float[size];
 
        /* reduce size so that we can fill the buffer correctly (ringbuffers
        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)
-         */
+          can only handle size-1, otherwise they appear to be empty)
+       */

        size--;
 
        uint32_t n=0;
        size--;
 
        uint32_t n=0;


@@ -771,9 +782,9 @@ AudioDiskstream::overwrite_existing_buffers ()
 
                framecnt_t to_read = size - overwrite_offset;
 
 
                framecnt_t to_read = size - overwrite_offset;
 

-               if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
+               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"),
                        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;
                }
 
                        goto out;
                }
 


@@ -781,10 +792,9 @@ AudioDiskstream::overwrite_existing_buffers ()
 
                        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"),
                                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;
                        }
                }
                                goto out;
                        }
                }


@@ -864,10 +874,17 @@ AudioDiskstream::internal_playback_seek (framecnt_t distance)
        return 0;
 }
 
        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
 int

-AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, 
+AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,

                        framepos_t& start, framecnt_t cnt,
                        framepos_t& start, framecnt_t cnt,

-                      ChannelInfo* /*channel_info*/, int channel, bool reversed)
+                       int channel, bool reversed)

 {
        framecnt_t this_read = 0;
        bool reloop = false;
 {
        framecnt_t this_read = 0;
        bool reloop = false;


@@ -901,25 +918,24 @@ AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
                */
 
                if (loc && start >= loop_end) {
                */
 
                if (loc && start >= loop_end) {

-                       //cerr << "start adjusted from " << start;

                        start = loop_start + ((start - loop_start) % loop_length);
                        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;
        }
        }
 
        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) {
 
                /* 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;
        while (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;
                        reloop = true;
                } else {
                        reloop = false;


@@ -933,13 +949,11 @@ 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) {
                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;
                }
 
                                         start) << endmsg;
                        return -1;
                }
 

-               _read_data_count = _playlist->read_data_count();
-

                if (reversed) {
 
                        swap_by_ptr (buf, buf + this_read - 1);
                if (reversed) {
 
                        swap_by_ptr (buf, buf + this_read - 1);


@@ -976,13 +990,16 @@ AudioDiskstream::do_refill_with_alloc ()
        return ret;
 }
 
        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;
        framecnt_t to_read;
        RingBufferNPT<Sample>::rw_vector vector;
 int
 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 {
        int32_t ret = 0;
        framecnt_t to_read;
        RingBufferNPT<Sample>::rw_vector vector;

-       bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
+       bool const reversed = (_visible_speed * _session.transport_speed()) < 0.0f;

        framecnt_t total_space;
        framecnt_t zero_fill;
        uint32_t chan_n;
        framecnt_t total_space;
        framecnt_t zero_fill;
        uint32_t chan_n;


@@ -1005,6 +1022,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
        c->front()->playback_buf->get_write_vector (&vector);
 
        if ((total_space = vector.len[0] + 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;
        }
 
                return 0;
        }
 


@@ -1013,7 +1031,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
           for us to be called again, ASAP.
        */
 
           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;
        }
 
                ret = 1;
        }
 


@@ -1022,6 +1040,10 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 
           at higher speeds, just do it because the sync between butler
           and audio thread may not be good enough.
 
           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) {
        */
 
        if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {


@@ -1154,7 +1176,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 
                if (to_read) {
 
 
                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;
                        }
                                ret = -1;
                                goto out;
                        }


@@ -1171,7 +1193,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
                           so read some or all of vector.len[1] as well.
                        */
 
                           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;
                        }
                                ret = -1;
                                goto out;
                        }


@@ -1180,14 +1202,14 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
                }
 
                if (zero_fill) {
                }
 
                if (zero_fill) {

-                       /* do something */
+                       /* XXX: do something */

                }
 
        }
 
        file_frame = file_frame_tmp;
        assert (file_frame >= 0);
                }
 
        }
 
        file_frame = file_frame_tmp;
        assert (file_frame >= 0);

-       
+

   out:
 
        return ret;
   out:
 
        return ret;


@@ -1212,8 +1234,6 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
        RingBufferNPT<CaptureTransition>::rw_vector transvec;
        framecnt_t total;
 
        RingBufferNPT<CaptureTransition>::rw_vector transvec;
        framecnt_t total;
 

-       _write_data_count = 0;
-

        transvec.buf[0] = 0;
        transvec.buf[1] = 0;
        vector.buf[0] = 0;
        transvec.buf[0] = 0;
        transvec.buf[1] = 0;
        vector.buf[0] = 0;


@@ -1253,7 +1273,6 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
                if (destructive()) {
                        (*chan)->capture_transition_buf->get_read_vector(&transvec);
                        size_t transcount = transvec.len[0] + transvec.len[1];
                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) {
                        size_t ti;
 
                        for (ti=0; ti < transcount; ++ti) {


@@ -1265,9 +1284,7 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
                                        (*chan)->write_source->mark_capture_start (captrans.capture_val);
                                        (*chan)->curr_capture_cnt = 0;
 
                                        (*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
 
 
                                        // capture end, the capture_val represents total frames in capture
 


@@ -1301,7 +1318,7 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
                }
 
                if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
                }
 
                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;
                }
 
                        return -1;
                }
 


@@ -1318,12 +1335,10 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
                        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) {
                        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;
                        }
 
                                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;
                }
                        (*chan)->capture_buf->increment_read_ptr (to_write);
                        (*chan)->curr_capture_cnt += to_write;
                }


@@ -1349,7 +1364,7 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo
        uint32_t n = 0;
        bool mark_write_completed = false;
 
        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
           to flush remaining data to disk.
 
        /* butler is already stopped, but there may be work to do
           to flush remaining data to disk.


@@ -1473,18 +1488,18 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo
                        string region_name;
 
                        RegionFactory::region_name (region_name, whole_file_region_name, false);
                        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 start @ %2 length %3 add new region %4\n",
+                                                                             _name, (*ci)->start, (*ci)->frames, region_name));

 
                        try {
 
                                PropertyList plist;
 
                        try {
 
                                PropertyList plist;

-                               
+

                                plist.add (Properties::start, buffer_position);
                                plist.add (Properties::length, (*ci)->frames);
                                plist.add (Properties::name, region_name);
                                plist.add (Properties::start, buffer_position);
                                plist.add (Properties::length, (*ci)->frames);
                                plist.add (Properties::name, region_name);

-                               
+

                                boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
                                region = boost::dynamic_pointer_cast<AudioRegion> (rx);
                        }
                                boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
                                region = boost::dynamic_pointer_cast<AudioRegion> (rx);
                        }


@@ -1503,7 +1518,7 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo
                                region->set_layer (_playlist->top_layer() + 1);
                                region->set_pending_explicit_relayer (true);
                        }
                                region->set_layer (_playlist->top_layer() + 1);
                                region->set_pending_explicit_relayer (true);
                        }

-                       
+

                        _playlist->add_region (region, (*ci)->start, 1, non_layered());
                        i_am_the_modifier--;
 
                        _playlist->add_region (region, (*ci)->start, 1, non_layered());
                        i_am_the_modifier--;
 


@@ -1548,7 +1563,7 @@ AudioDiskstream::transport_looped (framepos_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
 
                // the next region will start recording via the normal mechanism
                // we'll set the start position to the current transport pos


@@ -1581,7 +1596,7 @@ AudioDiskstream::transport_looped (framepos_t transport_frame)
 }
 
 void
 }
 
 void

-AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
+AudioDiskstream::finish_capture (boost::shared_ptr<ChannelList> c)

 {
        was_recording = false;
        first_recordable_frame = max_framepos;
 {
        was_recording = false;
        first_recordable_frame = max_framepos;


@@ -1671,7 +1686,7 @@ AudioDiskstream::engage_record_enable ()
        if (Config->get_monitoring_model() == HardwareMonitoring) {
 
                for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
        if (Config->get_monitoring_model() == HardwareMonitoring) {
 
                for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {

-                        (*chan)->source.ensure_monitor_input (!(_session.config.get_auto_input() && rolling));
+                       (*chan)->source.request_jack_monitors_input (!(_session.config.get_auto_input() && rolling));

                        capturing_sources.push_back ((*chan)->write_source);
                        (*chan)->write_source->mark_streaming_write_started ();
                }
                        capturing_sources.push_back ((*chan)->write_source);
                        (*chan)->write_source->mark_streaming_write_started ();
                }


@@ -1693,7 +1708,7 @@ AudioDiskstream::disengage_record_enable ()
        boost::shared_ptr<ChannelList> c = channels.reader();
        if (Config->get_monitoring_model() == HardwareMonitoring) {
                for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
        boost::shared_ptr<ChannelList> c = channels.reader();
        if (Config->get_monitoring_model() == HardwareMonitoring) {
                for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {

-                        (*chan)->source.ensure_monitor_input (false);
+                       (*chan)->source.request_jack_monitors_input (false);

                }
        }
        capturing_sources.clear ();
                }
        }
        capturing_sources.clear ();


@@ -1841,11 +1856,11 @@ AudioDiskstream::use_new_write_source (uint32_t n)
        /* do not remove destructive files even if they are empty */
 
        chan->write_source->set_allow_remove_if_empty (!destructive());
        /* do not remove destructive files even if they are empty */
 
        chan->write_source->set_allow_remove_if_empty (!destructive());

-       
+

        return 0;
 }
 
        return 0;
 }
 

-list<boost::shared_ptr<Source> > 
+list<boost::shared_ptr<Source> >

 AudioDiskstream::steal_write_sources()
 {
        /* not possible to steal audio write sources */
 AudioDiskstream::steal_write_sources()
 {
        /* not possible to steal audio write sources */


@@ -1881,7 +1896,7 @@ AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
                                        (*chan)->write_source->mark_for_remove ();
                                        (*chan)->write_source->drop_references ();
                                }
                                        (*chan)->write_source->mark_for_remove ();
                                        (*chan)->write_source->drop_references ();
                                }

-                               
+

                                (*chan)->write_source.reset ();
                        }
 
                                (*chan)->write_source.reset ();
                        }
 


@@ -1943,11 +1958,13 @@ AudioDiskstream::allocate_temporary_buffers ()
                boost::shared_ptr<ChannelList> c = channels.reader();
 
                for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
                boost::shared_ptr<ChannelList> c = channels.reader();
 
                for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {

-                       if ((*chan)->playback_wrap_buffer)
+                       if ((*chan)->playback_wrap_buffer) {

                                delete [] (*chan)->playback_wrap_buffer;
                                delete [] (*chan)->playback_wrap_buffer;

+                       }

                        (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
                        (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];

-                       if ((*chan)->capture_wrap_buffer)
+                       if ((*chan)->capture_wrap_buffer) {

                                delete [] (*chan)->capture_wrap_buffer;
                                delete [] (*chan)->capture_wrap_buffer;

+                       }

                        (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
                }
 
                        (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
                }
 


@@ -1961,7 +1978,7 @@ AudioDiskstream::monitor_input (bool yn)
        boost::shared_ptr<ChannelList> c = channels.reader();
 
        for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
        boost::shared_ptr<ChannelList> c = channels.reader();
 
        for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {

-                (*chan)->source.ensure_monitor_input (yn);
+               (*chan)->source.request_jack_monitors_input (yn);

        }
 }
 
        }
 }
 


@@ -2001,7 +2018,7 @@ AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_
 {
        while (how_many--) {
                c->push_back (new ChannelInfo(
 {
        while (how_many--) {
                c->push_back (new ChannelInfo(

-                                     _session.butler()->audio_diskstream_playback_buffer_size(), 
+                                     _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_capture_buffer_size(),
                                      speed_buffer_size, wrap_buffer_size));
                interpolation.add_channel_to (


@@ -2067,7 +2084,7 @@ AudioDiskstream::capture_buffer_load () const
        if (c->empty ()) {
                return 0;
        }
        if (c->empty ()) {
                return 0;
        }

-       
+

        return (float) ((double) c->front()->capture_buf->write_space()/
                        (double) c->front()->capture_buf->bufsize());
 }
        return (float) ((double) c->front()->capture_buf->write_space()/
                        (double) c->front()->capture_buf->bufsize());
 }


@@ -2142,9 +2159,9 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node)
        boost::shared_ptr<AudioRegion> region;
 
        try {
        boost::shared_ptr<AudioRegion> region;
 
        try {

-               
+

                PropertyList plist;
                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));
                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));


@@ -2253,7 +2270,7 @@ AudioDiskstream::can_become_destructive (bool& requires_bounce) const
        return true;
 }
 
        return true;
 }
 

-void 
+void

 AudioDiskstream::adjust_playback_buffering ()
 {
        boost::shared_ptr<ChannelList> c = channels.reader();
 AudioDiskstream::adjust_playback_buffering ()
 {
        boost::shared_ptr<ChannelList> c = channels.reader();


@@ -2263,7 +2280,7 @@ AudioDiskstream::adjust_playback_buffering ()
        }
 }
 
        }
 }
 

-void 
+void

 AudioDiskstream::adjust_capture_buffering ()
 {
        boost::shared_ptr<ChannelList> c = channels.reader();
 AudioDiskstream::adjust_capture_buffering ()
 {
        boost::shared_ptr<ChannelList> c = channels.reader();


@@ -2276,26 +2293,25 @@ AudioDiskstream::adjust_capture_buffering ()
 bool
 AudioDiskstream::ChannelSource::is_physical () const
 {
 bool
 AudioDiskstream::ChannelSource::is_physical () const
 {

-        if (name.empty()) {
-                return false;
-        }
+       if (name.empty()) {
+               return false;
+       }

 
 

-        return AudioEngine::instance()->port_is_physical (name);
+       return AudioEngine::instance()->port_is_physical (name);

 }
 
 void
 }
 
 void

-AudioDiskstream::ChannelSource::ensure_monitor_input (bool yn) const
+AudioDiskstream::ChannelSource::request_jack_monitors_input (bool yn) const

 {
 {

-        if (name.empty()) {
-                return;
-        }
+       if (name.empty()) {
+               return;
+       }

 
 

-        return AudioEngine::instance()->ensure_monitor_input (name, yn);
+       return AudioEngine::instance()->request_jack_monitors_input (name, yn);

 }
 
 AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
 {
 }
 
 AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
 {

-       peak_power = 0.0f;

        current_capture_buffer = 0;
        current_playback_buffer = 0;
        curr_capture_cnt = 0;
        current_capture_buffer = 0;
        current_playback_buffer = 0;
        curr_capture_cnt = 0;


@@ -2359,3 +2375,21 @@ AudioDiskstream::ChannelInfo::~ChannelInfo ()
        capture_transition_buf = 0;
 }
 
        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<ChannelList> c = channels.reader();
+       ChannelList::iterator i;
+       int n = 0;
+
+       for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) {
+               use_new_write_source (n);
+       }
+
+       return true;
+}