void
ARDOUR_UI::blink ()
{
- // Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
+ Blink (blink_on = !blink_on); /* EMIT_SIGNAL */
}
void
auto_loop_button.set_visual_state (0);
}
-bool
-messagefoo (GdkEventButton* ev)
-{
- cerr << " roll button pressed\n";
- return false;
-}
-
-bool
-messagefoo2 (GdkEventButton* ev)
-{
- cerr << " roll button release\n";
- return false;
-}
-
void
ARDOUR_UI::setup_transport ()
{
RefPtr<Action> act;
- roll_button.signal_button_press_event().connect (sigc::ptr_fun (messagefoo));
- roll_button.signal_button_release_event().connect (sigc::ptr_fun (messagefoo2));
-
act = ActionManager::get_action (X_("Transport"), X_("Stop"));
act->connect_proxy (stop_button);
act = ActionManager::get_action (X_("Transport"), X_("Roll"));
nframes_t offset = 0;
Location *loc = 0;
+ /* XXX we don't currently play loops in reverse. not sure why */
+
if (!reversed) {
+
/* Make the use of a Location atomic for this read operation.
Note: Locations don't get deleted, so all we care about
start = loop_start + ((start - loop_start) % loop_length);
//cerr << "to " << start << endl;
}
+
//cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
}
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)) {
if (reversed) {
- /* don't adjust start, since caller has already done that
- */
-
swap_by_ptr (buf, buf + this_read - 1);
} else {
if ((total_space = vector.len[0] + vector.len[1]) == 0) {
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.
return 0;
}
+ /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
+
total_space = min (disk_io_chunk_frames, total_space);
if (reversed) {
} else {
- /* move read position backwards because we are going
- to reverse the data.
- */
-
- file_frame -= total_space;
zero_fill = 0;
}
chan.playback_buf->get_write_vector (&vector);
+ if (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.
+
+ */
+
+ vector.buf[1] = 0;
+ vector.len[1] = 0;
+
+ }
+
ts = total_space;
file_frame_tmp = file_frame;
- if (reversed) {
- buf1 = vector.buf[1];
- len1 = vector.len[1];
- buf2 = vector.buf[0];
- len2 = vector.len[0];
- } else {
- buf1 = vector.buf[0];
- len1 = vector.len[0];
- buf2 = vector.buf[1];
- len2 = vector.len[1];
- }
-
+ buf1 = vector.buf[0];
+ len1 = vector.len[0];
+ buf2 = vector.buf[1];
+ len2 = vector.len[1];
to_read = min (ts, len1);
to_read = min (to_read, disk_io_chunk_frames);
ret = -1;
goto out;
}
-
+
chan.playback_buf->increment_write_ptr (to_read);
ts -= to_read;
}
if (to_read) {
-
/* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
so read some or all of vector.len[1] as well.
*/
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*si);
if (afs) {
afs->update_header (region->position(), *now, xnow);
+ afs->mark_immutable ();
}
}
{
SourceList nsrcs;
SourceList::iterator si;
- const nframes_t blocksize = 256 * 1048;
- Sample buf[blocksize];
+ nframes_t blocksize = 256 * 1024;
+ Sample* buf;
nframes_t fpos;
- nframes_t fend;
nframes_t fstart;
nframes_t to_read;
int ret = -1;
goto out;
}
- fend = region->start() + region->length();
fstart = region->start();
- if (blocksize < fend) {
- fpos =max(fstart, fend - blocksize);
- } else {
- fpos = fstart;
+ if (blocksize > region->length()) {
+ blocksize = region->length();
}
- to_read = min (region->length(), blocksize);
+ fpos = max (fstart, (fstart + region->length() - blocksize));
+ buf = new Sample[blocksize];
+ to_read = blocksize;
+
+ cerr << "Reverse " << region->name() << " len = " << region->length() << " blocksize = " << blocksize << " start at " << fstart << endl;
/* now read it backwards */
- while (1) {
+ while (to_read) {
uint32_t n;
for (n = 0, si = nsrcs.begin(); n < region->n_channels(); ++n, ++si) {
/* read it in */
+
+ cerr << "read at " << fpos << " for " << to_read << endl;
if (region->source (n)->read (buf, fpos, to_read) != to_read) {
goto out;
}
-
+
/* swap memory order */
for (nframes_t i = 0; i < to_read/2; ++i) {
}
}
- if (fpos == fstart) {
- break;
- } else if (fpos > fstart + to_read) {
+ if (fpos > fstart + blocksize) {
fpos -= to_read;
- to_read = min (fstart - fpos, blocksize);
+ to_read = blocksize;
} else {
- to_read = fpos-fstart;
+ to_read = fpos - fstart;
+ cerr << "Last read detected, only " << fpos - fstart << " left; move to start and read " << to_read << endl;
fpos = fstart;
}
};
out:
+ delete [] buf;
+
if (ret) {
for (si = nsrcs.begin(); si != nsrcs.end(); ++si) {
(*si)->mark_for_remove ();
nframes_t oldlen;
int32_t frame_pos = _length;
+
+ cerr << _name << " write " << cnt << " floats to " << frame_pos << endl;
if (write_float (data, frame_pos, cnt) != cnt) {
return 0;
oldlen = _length;
update_length (oldlen, cnt);
+ cerr << "\t length is now " << _length << endl;
+
if (_build_peakfiles) {
PeakBuildRecord *pbr = 0;
projects / ardour.git / commitdiff