void
AudioDiskstream::allocate_working_buffers()
{
- assert(disk_io_frames() > 0);
-
- _working_buffers_size = disk_io_frames();
+ _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];
}
}
} 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);
+ need_butler = ((framecnt_t) c->front()->playback_buf->write_space() >= disk_read_chunk_frames)
+ || ((framecnt_t) c->front()->capture_buf->read_space() >= disk_write_chunk_frames);
} else {
- need_butler = ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
+ need_butler = ((framecnt_t) c->front()->capture_buf->read_space() >= disk_write_chunk_frames);
}
}
int
AudioDiskstream::do_refill_with_alloc ()
{
- Sample* mix_buf = new Sample[disk_io_chunk_frames];
- float* gain_buf = new float[disk_io_chunk_frames];
+ Sample* mix_buf = new Sample[disk_read_chunk_frames];
+ float* gain_buf = new float[disk_read_chunk_frames];
int ret = _do_refill(mix_buf, gain_buf);
for us to be called again, ASAP.
*/
- if (total_space >= (_slaved ? 3 : 2) * disk_io_chunk_frames) {
+ if (total_space >= (_slaved ? 3 : 2) * disk_read_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.
+ space to do disk_read_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
+ Note: it is a design assumption that disk_read_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_read_chunk_frames) && fabs (_actual_speed) < 2.0f) {
return 0;
}
return 0;
}
- /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
+ /* never do more than disk_read_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
- total_space = min (disk_io_chunk_frames, total_space);
+ total_space = min (disk_read_chunk_frames, total_space);
if (reversed) {
chan->playback_buf->get_write_vector (&vector);
- if ((framecnt_t) vector.len[0] > disk_io_chunk_frames) {
+ if ((framecnt_t) vector.len[0] > disk_read_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
+ ^^^^ => 1 x disk_read_chunk_frames that would be filled
|......|+++++++++++++|...............................|
buf1 buf0
len2 = vector.len[1];
to_read = min (ts, len1);
- to_read = min (to_read, disk_io_chunk_frames);
+ to_read = min (to_read, disk_read_chunk_frames);
assert (to_read >= 0);
if (to_read) {
- /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
+ /* 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.
*/
/** Flush pending data to disk.
*
- * Important note: this function will write *AT MOST* disk_io_chunk_frames
+ * Important note: this function will write *AT MOST* disk_write_chunk_frames
* 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
+ * If there is less than disk_write_chunk_frames to be written, no data will be
* written at all unless @a force_flush is true.
*/
int
total = vector.len[0] + vector.len[1];
- if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
+ if (total == 0 || (total < disk_write_chunk_frames && !force_flush && was_recording)) {
goto out;
}
let the caller know too.
*/
- if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
+ if (total >= 2 * disk_write_chunk_frames || ((force_flush || !was_recording) && total > disk_write_chunk_frames)) {
ret = 1;
}
- to_write = min (disk_io_chunk_frames, (framecnt_t) vector.len[0]);
+ to_write = min (disk_write_chunk_frames, (framecnt_t) vector.len[0]);
// check the transition buffer when recording destructive
// important that we get this after the capture buf
(*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()) {
+ if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_write_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_write_chunk_frames of data, so arrange for some part
of vector.len[1] to be flushed to disk as well.
*/
- to_write = min ((framecnt_t)(disk_io_chunk_frames - to_write), (framecnt_t) vector.len[1]);
+ to_write = min ((framecnt_t)(disk_write_chunk_frames - to_write), (framecnt_t) vector.len[1]);
DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 additional write of %2\n", name(), to_write));
having the old data or knowing what change caused the overwrite. */
midi_playlist()->resolve_note_trackers (*_playback_buf, overwrite_frame);
- read (overwrite_frame, disk_io_chunk_frames, false);
+ read (overwrite_frame, disk_read_chunk_frames, false);
file_frame = overwrite_frame; // it was adjusted by ::read()
overwrite_queued = false;
_pending_overwrite = false;
/** Flush pending data to disk.
*
- * Important note: this function will write *AT MOST* disk_io_chunk_frames
+ * Important note: this function will write *AT MOST* disk_write_chunk_frames
* 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
+ * If there is less than disk_write_chunk_frames to be written, no data will be
* written at all unless @a force_flush is true.
*/
int
if (total == 0 ||
_capture_buf->read_space() == 0 ||
- (!force_flush && (total < disk_io_chunk_frames) && was_recording)) {
+ (!force_flush && (total < disk_write_chunk_frames) && was_recording)) {
goto out;
}
let the caller know too.
*/
- if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
+ if (total >= 2 * disk_write_chunk_frames || ((force_flush || !was_recording) && total > disk_write_chunk_frames)) {
ret = 1;
}
/* push out everything we have, right now */
to_write = max_framecnt;
} else {
- to_write = disk_io_chunk_frames;
+ to_write = disk_write_chunk_frames;
}
- if (record_enabled() && ((total > disk_io_chunk_frames) || force_flush)) {
+ if (record_enabled() && ((total > disk_write_chunk_frames) || force_flush)) {
Source::Lock lm(_write_source->mutex());
if (_write_source->midi_write (lm, *_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;