Sample *buf = (Sample *) malloc(sizeof(Sample) * fft_graph.windowSize());
Sample *mixbuf = (Sample *) malloc(sizeof(Sample) * fft_graph.windowSize());
float *gain = (float *) malloc(sizeof(float) * fft_graph.windowSize());
- char *work = (char *) malloc(sizeof(char) * fft_graph.windowSize());
Selection s = PublicEditor::instance().get_selection();
TimeSelection ts = s.time;
n = (*j).length() - i;
}
- n = pl->read(buf, mixbuf, gain, work, (*j).start + i, n);
+ n = pl->read(buf, mixbuf, gain, (*j).start + i, n);
if ( n < fft_graph.windowSize()) {
for (int j = n; j < fft_graph.windowSize(); j++) {
n = arv->region().length() - i;
}
- n = arv->audio_region().read_at(buf, mixbuf, gain, work, arv->region().position() + i, n);
+ n = arv->audio_region().read_at(buf, mixbuf, gain, arv->region().position() + i, n);
if ( n < fft_graph.windowSize()) {
for (int j = n; j < fft_graph.windowSize(); j++) {
free(buf);
free(mixbuf);
- free(work);
track_list_ready = true;
} /* end lock */
jack_nframes_t to_read;
Sample buf[chunk_size];
gain_t gain_buffer[chunk_size];
- char workbuf[chunk_size *4];
jack_nframes_t pos;
char s[PATH_MAX+1];
uint32_t cnt;
fs = (*src);
- if (region.read_at (buf, buf, gain_buffer, workbuf, pos, this_time) != this_time) {
+ if (region.read_at (buf, buf, gain_buffer, pos, this_time) != this_time) {
break;
}
- if (fs->write (buf, this_time, workbuf) != this_time) {
+ if (fs->write (buf, this_time) != this_time) {
error << "" << endmsg;
goto error_out;
}
jack_nframes_t nframes;
Sample buf[chunk_size];
gain_t gain_buffer[chunk_size];
- char workbuf[chunk_size*4];
jack_nframes_t pos;
char s[PATH_MAX+1];
uint32_t cnt;
fs = sources[n];
- if (playlist.read (buf, buf, gain_buffer, workbuf, pos, this_time, n) != this_time) {
+ if (playlist.read (buf, buf, gain_buffer, pos, this_time, n) != this_time) {
break;
}
- if (fs->write (buf, this_time, workbuf) != this_time) {
+ if (fs->write (buf, this_time) != this_time) {
goto error_out;
}
}
for (uint32_t n=0; n < channels; ++n) {
fs = sources[n];
- if (fs->write (buf, this_time, workbuf) != this_time) {
+ if (fs->write (buf, this_time) != this_time) {
goto error_out;
}
}
/* The two central butler operations */
int do_flush (Session::RunContext context, bool force = false);
- int do_refill () { return _do_refill(_mixdown_buffer, _gain_buffer, _conversion_buffer); }
+ int do_refill () { return _do_refill(_mixdown_buffer, _gain_buffer); }
int do_refill_with_alloc();
- int read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, char * workbuf,
+ int read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
jack_nframes_t& start, jack_nframes_t cnt,
ChannelInfo& channel_info, int channel, bool reversed);
static size_t _working_buffers_size;
static Sample* _mixdown_buffer;
static gain_t* _gain_buffer;
- static char* _conversion_buffer;
- // Uh, /really/ private? (death to friend classes)
- int _do_refill (Sample *mixdown_buffer, float *gain_buffer, char *workbuf);
+ // Uh, /really/ private? (there should probably be less friends of Diskstream)
+ int _do_refill (Sample *mixdown_buffer, float *gain_buffer);
std::vector<AudioFileSource*> capturing_sources;
int use_diskstream (string name);
int use_diskstream (const PBD::ID& id);
- int export_stuff (vector<Sample*>& buffers, char * workbuf, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t end_frame);
+ int export_stuff (vector<Sample*>& buffers, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t end_frame);
void freeze (InterThreadInfo&);
void unfreeze ();
void clear (bool with_delete = false, bool with_save = true);
- jack_nframes_t read (Sample *dst, Sample *mixdown, float *gain_buffer, char * workbuf, jack_nframes_t start, jack_nframes_t cnt, uint32_t chan_n=0);
+ jack_nframes_t read (Sample *dst, Sample *mixdown, float *gain_buffer, jack_nframes_t start, jack_nframes_t cnt, uint32_t chan_n=0);
int set_state (const XMLNode&);
UndoAction get_memento() const;
uint32_t chan_n=0, double samples_per_unit= 1.0) const;
virtual jack_nframes_t read_at (Sample *buf, Sample *mixdown_buf,
- float *gain_buf, char * workbuf, jack_nframes_t position, jack_nframes_t cnt,
+ float *gain_buf, jack_nframes_t position, jack_nframes_t cnt,
uint32_t chan_n = 0,
jack_nframes_t read_frames = 0,
jack_nframes_t skip_frames = 0) const;
jack_nframes_t master_read_at (Sample *buf, Sample *mixdown_buf,
- float *gain_buf, char * workbuf,
+ float *gain_buf,
jack_nframes_t position, jack_nframes_t cnt, uint32_t chan_n=0) const;
XMLNode& state (bool);
void recompute_gain_at_start ();
jack_nframes_t _read_at (const SourceList&, Sample *buf, Sample *mixdown_buffer,
- float *gain_buffer, char * workbuf, jack_nframes_t position, jack_nframes_t cnt,
+ float *gain_buffer, jack_nframes_t position, jack_nframes_t cnt,
uint32_t chan_n = 0,
jack_nframes_t read_frames = 0,
jack_nframes_t skip_frames = 0) const;
virtual jack_nframes_t available_peaks (double zoom) const;
- virtual jack_nframes_t read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const;
- virtual jack_nframes_t write (Sample *src, jack_nframes_t cnt, char * workbuf);
+ virtual jack_nframes_t read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const;
+ virtual jack_nframes_t write (Sample *src, jack_nframes_t cnt);
virtual float sample_rate () const = 0;
int do_build_peak (jack_nframes_t, jack_nframes_t);
- virtual jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const = 0;
- virtual jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt, char * workbuf) = 0;
+ virtual jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const = 0;
+ virtual jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt) = 0;
virtual string peak_path(string audio_path) = 0;
virtual string old_peak_path(string audio_path) = 0;
void set_header_timeline_position () {};
protected:
- jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const;
+ jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const;
- jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt, char * workbuf)
+ jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt)
{ return 0; }
ARDOUR::AudioRegion& out() const { return *_out; }
jack_nframes_t read_at (Sample *buf, Sample *mixdown_buffer,
- float *gain_buffer, char * workbuf, jack_nframes_t position, jack_nframes_t cnt,
+ float *gain_buffer, jack_nframes_t position, jack_nframes_t cnt,
uint32_t chan_n,
jack_nframes_t read_frames = 0,
jack_nframes_t skip_frames = 0);
static void setup_standard_crossfades (jack_nframes_t sample_rate);
protected:
- jack_nframes_t write_unlocked (Sample *src, jack_nframes_t cnt, char * workbuf);
+ jack_nframes_t write_unlocked (Sample *src, jack_nframes_t cnt);
virtual void handle_header_position_change ();
Sample* xfade_buf;
void init ();
- jack_nframes_t crossfade (Sample* data, jack_nframes_t cnt, int dir, char * workbuf);
+ jack_nframes_t crossfade (Sample* data, jack_nframes_t cnt, int dir);
void set_timeline_position (jack_nframes_t);
};
uint32_t n_channels() { return _n_channels; }
- static jack_nframes_t disk_io_frames() { return disk_io_chunk_frames; }
- static void set_disk_io_chunk_frames (uint32_t n) { disk_io_chunk_frames = n; }
+ static jack_nframes_t disk_io_frames() { return disk_io_chunk_frames; }
+ static void set_disk_io_chunk_frames (uint32_t n) { disk_io_chunk_frames = n; }
/* Stateful */
virtual XMLNode& get_state(void) = 0;
ExportContext
};
- char * conversion_buffer(RunContext context) { return _conversion_buffers[context]; }
-
/* VST support */
static long vst_callback (AEffect* effect,
vector<Sample *> _passthru_buffers;
vector<Sample *> _silent_buffers;
vector<Sample *> _send_buffers;
- map<RunContext,char*> _conversion_buffers;
jack_nframes_t current_block_size;
jack_nframes_t _worst_output_latency;
jack_nframes_t _worst_input_latency;
protected:
void set_header_timeline_position ();
- jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const;
- jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt, char * workbuf);
+ jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const;
+ jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt);
jack_nframes_t write_float (Sample* data, jack_nframes_t pos, jack_nframes_t cnt);
size_t AudioDiskstream::_working_buffers_size = 0;
Sample* AudioDiskstream::_mixdown_buffer = 0;
gain_t* AudioDiskstream::_gain_buffer = 0;
-char* AudioDiskstream::_conversion_buffer = 0;
AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
: Diskstream(sess, name, flag)
_working_buffers_size = disk_io_frames();
_mixdown_buffer = new Sample[_working_buffers_size];
_gain_buffer = new gain_t[_working_buffers_size];
- _conversion_buffer = new char[_working_buffers_size * 4];
}
void
{
delete _mixdown_buffer;
delete _gain_buffer;
- delete _conversion_buffer;
_working_buffers_size = 0;
_mixdown_buffer = 0;
_gain_buffer = 0;
- _conversion_buffer = 0;
}
void
{
Sample* mixdown_buffer;
float* gain_buffer;
- char * workbuf;
int ret = -1;
bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
mixdown_buffer = new Sample[size];
gain_buffer = new float[size];
- workbuf = new char[size*4];
/* reduce size so that we can fill the buffer correctly. */
size--;
jack_nframes_t to_read = size - overwrite_offset;
- if (read ((*chan).playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, workbuf,
- start, to_read, *chan, n, reversed)) {
+ if (read ((*chan).playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
_id, size, playback_sample) << endmsg;
goto out;
cnt -= to_read;
- if (read ((*chan).playback_buf->buffer(), mixdown_buffer, gain_buffer, workbuf,
+ if (read ((*chan).playback_buf->buffer(), mixdown_buffer, gain_buffer,
start, cnt, *chan, n, reversed)) {
error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
_id, size, playback_sample) << endmsg;
pending_overwrite = false;
delete [] gain_buffer;
delete [] mixdown_buffer;
- delete [] workbuf;
return ret;
}
}
int
-AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, char * workbuf, jack_nframes_t& start, jack_nframes_t cnt,
+AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, jack_nframes_t& start, jack_nframes_t cnt,
ChannelInfo& channel_info, int channel, bool reversed)
{
jack_nframes_t this_read = 0;
this_read = min(cnt,this_read);
- if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, workbuf, start, this_read, channel) != 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,
start) << endmsg;
return -1;
{
Sample* mix_buf = new Sample[disk_io_chunk_frames];
float* gain_buf = new float[disk_io_chunk_frames];
- char* work_buf = new char[disk_io_chunk_frames * 4];
- int ret = _do_refill(mix_buf, gain_buf, work_buf);
+ int ret = _do_refill(mix_buf, gain_buf);
delete [] mix_buf;
delete [] gain_buf;
- delete [] work_buf;
return ret;
}
int
-AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer, char * workbuf)
+AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
{
int32_t ret = 0;
jack_nframes_t to_read;
assert(mixdown_buffer);
assert(gain_buffer);
- assert(workbuf);
channels.front().playback_buf->get_write_vector (&vector);
if (to_read) {
- if (read (buf1, mixdown_buffer, gain_buffer, workbuf, file_frame_tmp, to_read, chan, chan_n, reversed)) {
+ if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
ret = -1;
goto out;
}
so read some or all of vector.len[1] as well.
*/
- if (read (buf2, mixdown_buffer, gain_buffer, workbuf, file_frame_tmp, to_read, chan, chan_n, reversed)) {
+ if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
ret = -1;
goto out;
}
int
AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
{
- char* workbuf = _session.conversion_buffer(context);
-
uint32_t to_write;
int32_t ret = 0;
RingBufferNPT<Sample>::rw_vector vector;
}
}
- if ((!(*chan).write_source) || (*chan).write_source->write (vector.buf[0], to_write, workbuf) != 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;
return -1;
}
to_write = min ((jack_nframes_t)(disk_io_chunk_frames - to_write), (jack_nframes_t) vector.len[1]);
- if ((*chan).write_source->write (vector.buf[1], to_write, workbuf) != to_write) {
+ if ((*chan).write_source->write (vector.buf[1], to_write) != to_write) {
error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
return -1;
}
};
jack_nframes_t
-AudioPlaylist::read (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, char * workbuf, jack_nframes_t start,
+AudioPlaylist::read (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, jack_nframes_t start,
jack_nframes_t cnt, unsigned chan_n)
{
jack_nframes_t ret = cnt;
for (vector<Region*>::iterator i = r.begin(); i != r.end(); ++i) {
AudioRegion* const ar = dynamic_cast<AudioRegion*>(*i);
assert(ar);
- ar->read_at (buf, mixdown_buffer, gain_buffer, workbuf, start, cnt, chan_n, read_frames, skip_frames);
+ ar->read_at (buf, mixdown_buffer, gain_buffer, start, cnt, chan_n, read_frames, skip_frames);
_read_data_count += ar->read_data_count();
}
for (vector<Crossfade*>::iterator i = x.begin(); i != x.end(); ++i) {
- (*i)->read_at (buf, mixdown_buffer, gain_buffer, workbuf, start, cnt, chan_n);
+ (*i)->read_at (buf, mixdown_buffer, gain_buffer, start, cnt, chan_n);
/* don't JACK up _read_data_count, since its the same data as we just
read from the regions, and the OS should handle that for us.
}
int
-AudioTrack::export_stuff (vector<Sample*>& buffers, char * workbuf, uint32_t nbufs, jack_nframes_t start, jack_nframes_t nframes)
+AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, jack_nframes_t start, jack_nframes_t nframes)
{
gain_t gain_automation[nframes];
gain_t gain_buffer[nframes];
AudioPlaylist* const apl = dynamic_cast<AudioPlaylist*>(diskstream.playlist());
assert(apl);
- if (apl->read (buffers[0], mix_buffer, gain_buffer, workbuf, start, nframes) != nframes) {
+ if (apl->read (buffers[0], mix_buffer, gain_buffer, start, nframes) != nframes) {
return -1;
}
++bi;
for (; bi != buffers.end(); ++bi, ++n) {
if (n < diskstream.n_channels()) {
- if (apl->read ((*bi), mix_buffer, gain_buffer, workbuf, start, nframes, n) != nframes) {
+ if (apl->read ((*bi), mix_buffer, gain_buffer, start, nframes, n) != nframes) {
return -1;
}
b = (*bi);
}
jack_nframes_t
-AudioRegion::read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, char * workbuf, jack_nframes_t position,
+AudioRegion::read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, jack_nframes_t position,
jack_nframes_t cnt,
uint32_t chan_n, jack_nframes_t read_frames, jack_nframes_t skip_frames) const
{
- return _read_at (sources, buf, mixdown_buffer, gain_buffer, workbuf, position, cnt, chan_n, read_frames, skip_frames);
+ return _read_at (sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, read_frames, skip_frames);
}
jack_nframes_t
-AudioRegion::master_read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, char * workbuf, jack_nframes_t position,
+AudioRegion::master_read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, jack_nframes_t position,
jack_nframes_t cnt, uint32_t chan_n) const
{
- return _read_at (master_sources, buf, mixdown_buffer, gain_buffer, workbuf, position, cnt, chan_n, 0, 0);
+ return _read_at (master_sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, 0, 0);
}
jack_nframes_t
-AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buffer, float *gain_buffer, char * workbuf,
+AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buffer, float *gain_buffer,
jack_nframes_t position, jack_nframes_t cnt,
uint32_t chan_n, jack_nframes_t read_frames, jack_nframes_t skip_frames) const
{
_read_data_count = 0;
- if (srcs[chan_n]->read (mixdown_buffer, _start + internal_offset, to_read, workbuf) != to_read) {
+ if (srcs[chan_n]->read (mixdown_buffer, _start + internal_offset, to_read) != to_read) {
return 0; /* "read nothing" */
}
if (spec.channels == 1) {
- if (sources.front()->read (spec.dataF, _start + spec.pos, to_read, 0) != to_read) {
+ if (sources.front()->read (spec.dataF, _start + spec.pos, to_read) != to_read) {
goto out;
}
for (uint32_t chan = 0; chan < spec.channels; ++chan) {
- if (sources[chan]->read (buf, _start + spec.pos, to_read, 0) != to_read) {
+ if (sources[chan]->read (buf, _start + spec.pos, to_read) != to_read) {
goto out;
}
{
const jack_nframes_t blocksize = 64 * 1024;
Sample buf[blocksize];
- char workbuf[blocksize * 4];
jack_nframes_t fpos;
jack_nframes_t fend;
jack_nframes_t to_read;
/* read it in */
- if (source (n).read (buf, fpos, to_read, workbuf) != to_read) {
+ if (source (n).read (buf, fpos, to_read) != to_read) {
return;
}
}
jack_nframes_t
-AudioSource::read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const
+AudioSource::read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
{
Glib::Mutex::Lock lm (_lock);
- return read_unlocked (dst, start, cnt, workbuf);
+ return read_unlocked (dst, start, cnt);
}
jack_nframes_t
-AudioSource::write (Sample *dst, jack_nframes_t cnt, char * workbuf)
+AudioSource::write (Sample *dst, jack_nframes_t cnt)
{
Glib::Mutex::Lock lm (_lock);
- return write_unlocked (dst, cnt, workbuf);
+ return write_unlocked (dst, cnt);
}
int
int ret = -1;
PeakData* staging = 0;
Sample* raw_staging = 0;
- char * workbuf = 0;
int peakfile = -1;
expected_peaks = (cnt / (double) frames_per_peak);
*/
Sample* raw_staging = new Sample[cnt];
- workbuf = new char[cnt*4];
- if (read_unlocked (raw_staging, start, cnt, workbuf) != cnt) {
+ if (read_unlocked (raw_staging, start, cnt) != cnt) {
error << _("cannot read sample data for unscaled peak computation") << endmsg;
return -1;
}
}
delete [] raw_staging;
- delete [] workbuf;
return 0;
}
jack_nframes_t nvisual_peaks = 0;
jack_nframes_t chunksize = (jack_nframes_t) min (cnt, (jack_nframes_t) 4096);
raw_staging = new Sample[chunksize];
- workbuf = new char[chunksize *4];
jack_nframes_t frame_pos = start;
double pixel_pos = floor (frame_pos / samples_per_visual_peak);
to_read = min (chunksize, (_length - current_frame));
- if ((frames_read = read_unlocked (raw_staging, current_frame, to_read, workbuf)) == 0) {
+ if ((frames_read = read_unlocked (raw_staging, current_frame, to_read)) == 0) {
error << string_compose(_("AudioSource[%1]: peak read - cannot read %2 samples at offset %3")
, _name, to_read, current_frame)
<< endmsg;
delete [] raw_staging;
}
- if (workbuf) {
- delete [] workbuf;
- }
-
return ret;
}
Sample xmin, xmax;
uint32_t peaki;
PeakData* peakbuf;
- char * workbuf = 0;
jack_nframes_t frames_read;
jack_nframes_t frames_to_read;
off_t first_peak_byte;
peakbuf = new PeakData[(cnt/frames_per_peak)+1];
peaki = 0;
- workbuf = new char[max(frames_per_peak, cnt) * 4];
-
if ((peakfile = ::open (peakpath.c_str(), O_RDWR|O_CREAT, 0664)) < 0) {
error << string_compose(_("AudioSource: cannot open peakpath \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
return -1;
/* lock for every read */
- if ((frames_read = read (buf, current_frame, frames_to_read, workbuf)) != frames_to_read) {
+ if ((frames_read = read (buf, current_frame, frames_to_read)) != frames_to_read) {
error << string_compose(_("%1: could not write read raw data for peak computation (%2)"), _name, strerror (errno)) << endmsg;
goto out;
}
if (peakfile >= 0) {
close (peakfile);
}
- if (workbuf)
- delete [] workbuf;
return ret;
}
}
}
- AudioDiskstream::set_disk_io_chunk_frames (minimum_disk_io_bytes.get() / sizeof (Sample));
+ Diskstream::set_disk_io_chunk_frames (minimum_disk_io_bytes.get() / sizeof (Sample));
return 0;
}
}
jack_nframes_t
-CoreAudioSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const
+CoreAudioSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
{
OSStatus err = noErr;
jack_nframes_t
Crossfade::read_at (Sample *buf, Sample *mixdown_buffer,
- float *gain_buffer, char * workbuf, jack_nframes_t start, jack_nframes_t cnt, uint32_t chan_n,
+ float *gain_buffer, jack_nframes_t start, jack_nframes_t cnt, uint32_t chan_n,
jack_nframes_t read_frames, jack_nframes_t skip_frames)
{
jack_nframes_t offset;
offset = start - _position;
- _out->read_at (crossfade_buffer_out, mixdown_buffer, gain_buffer, workbuf, start, to_write, chan_n, read_frames, skip_frames);
- _in->read_at (crossfade_buffer_in, mixdown_buffer, gain_buffer, workbuf, start, to_write, chan_n, read_frames, skip_frames);
+ _out->read_at (crossfade_buffer_out, mixdown_buffer, gain_buffer, start, to_write, chan_n, read_frames, skip_frames);
+ _in->read_at (crossfade_buffer_in, mixdown_buffer, gain_buffer, start, to_write, chan_n, read_frames, skip_frames);
float* fiv = new float[to_write];
float* fov = new float[to_write];
}
jack_nframes_t
-DestructiveFileSource::crossfade (Sample* data, jack_nframes_t cnt, int fade_in, char * workbuf)
+DestructiveFileSource::crossfade (Sample* data, jack_nframes_t cnt, int fade_in)
{
jack_nframes_t xfade = min (xfade_frames, cnt);
jack_nframes_t nofade = cnt - xfade;
}
jack_nframes_t
-DestructiveFileSource::write_unlocked (Sample* data, jack_nframes_t cnt, char * workbuf)
+DestructiveFileSource::write_unlocked (Sample* data, jack_nframes_t cnt)
{
jack_nframes_t old_file_pos;
jack_nframes_t ofilepos = file_pos;
// fade in
- if (crossfade (data, subcnt, 1, workbuf) != subcnt) {
+ if (crossfade (data, subcnt, 1) != subcnt) {
return 0;
}
// fade out
subcnt = cnt - subcnt;
- if (crossfade (tmpdata, subcnt, 0, workbuf) != subcnt) {
+ if (crossfade (tmpdata, subcnt, 0) != subcnt) {
return 0;
}
/* move to the correct location place */
file_pos = capture_start_frame;
- if (crossfade (data, cnt, 1, workbuf) != cnt) {
+ if (crossfade (data, cnt, 1) != cnt) {
return 0;
}
_capture_start = false;
_capture_end = false;
- if (crossfade (data, cnt, 0, workbuf) != cnt) {
+ if (crossfade (data, cnt, 0) != cnt) {
return 0;
}
using namespace ARDOUR;
using namespace PBD;
-jack_nframes_t Diskstream::disk_io_chunk_frames = 0;
+/* XXX This goes uninitialized when there is no ~/.ardour2 directory.
+ * I can't figure out why, so this will do for now (just stole the
+ * default from configuration_vars.h). 0 is not a good value for
+ * allocating buffer sizes..
+ */
+jack_nframes_t Diskstream::disk_io_chunk_frames = 1024 * 256;
sigc::signal<void,Diskstream*> Diskstream::DiskstreamCreated;
sigc::signal<void,list<Source*>*> Diskstream::DeleteSources;
SF_INFO info;
float *data = 0;
Sample **channel_data = 0;
- char * workbuf = 0;
long nfiles = 0;
long n;
string basepath;
data = new float[BLOCKSIZE * info.channels];
channel_data = new Sample * [ info.channels ];
- workbuf = new char[BLOCKSIZE * 4];
for (n = 0; n < info.channels; ++n) {
channel_data[n] = new Sample[BLOCKSIZE];
/* flush to disk */
for (chn = 0; chn < info.channels; ++chn) {
- newfiles[chn]->write (channel_data[chn], nread, workbuf);
+ newfiles[chn]->write (channel_data[chn], nread);
}
so_far += nread;
if (data) {
delete [] data;
}
- if (workbuf) {
- delete [] workbuf;
- }
if (channel_data) {
for (n = 0; n < info.channels; ++n) {
AudioRegion::SourceList::iterator si;
const jack_nframes_t blocksize = 256 * 1048;
Sample buf[blocksize];
- char * workbuf = 0;;
jack_nframes_t fpos;
jack_nframes_t fend;
jack_nframes_t fstart;
goto out;
}
- workbuf = new char[blocksize * 4];
-
fend = region.start() + region.length();
fstart = region.start();
/* read it in */
- if (region.source (n).read (buf, fpos, to_read, workbuf) != to_read) {
+ if (region.source (n).read (buf, fpos, to_read) != to_read) {
goto out;
}
/* write it out */
- if ((*si)->write (buf, to_read, workbuf) != to_read) {
+ if ((*si)->write (buf, to_read) != to_read) {
goto out;
}
}
delete *si;
}
}
- if (workbuf) {
- delete [] workbuf;
- }
return ret;
}
free(*i);
}
- for (map<RunContext,char*>::iterator i = _conversion_buffers.begin(); i != _conversion_buffers.end(); ++i) {
- delete [] (i->second);
- }
-
AudioDiskstream::free_working_buffers();
#undef TRACK_DESTRUCTION
jack_nframes_t this_chunk;
jack_nframes_t to_do;
vector<Sample*> buffers;
- char * workbuf = 0;
// any bigger than this seems to cause stack overflows in called functions
const jack_nframes_t chunk_size = (128 * 1024)/4;
buffers.push_back (b);
}
- workbuf = new char[chunk_size * 4];
-
while (to_do && !itt.cancel) {
this_chunk = min (to_do, chunk_size);
- if (track.export_stuff (buffers, workbuf, nchans, start, this_chunk)) {
+ if (track.export_stuff (buffers, nchans, start, this_chunk)) {
goto out;
}
AudioFileSource* afs = dynamic_cast<AudioFileSource*>(*src);
if (afs) {
- if (afs->write (buffers[n], this_chunk, workbuf) != this_chunk) {
+ if (afs->write (buffers[n], this_chunk) != this_chunk) {
goto out;
}
}
free(*i);
}
- if (workbuf) {
- delete [] workbuf;
- }
-
g_atomic_int_set (&processing_prohibited, 0);
itt.done = true;
xfade_model = ShortCrossfade;
destructive_index = 0;
- /* allocate conversion buffers */
- _conversion_buffers[ButlerContext] = new char[AudioDiskstream::disk_io_frames() * 4];
- _conversion_buffers[TransportContext] = new char[AudioDiskstream::disk_io_frames() * 4];
AudioDiskstream::allocate_working_buffers();
/* default short fade = 15ms */
for (uint32_t i = 0; i < sources.size(); ++i) {
gain_t gain_buffer[bufsize];
Sample buffer[bufsize];
- char workbuf[bufsize*4];
jack_nframes_t pos = 0;
jack_nframes_t this_read = 0;
not the ones currently in use, in case it's already been
subject to timefx. */
- if ((this_read = tsr.region->master_read_at (buffer, buffer, gain_buffer, workbuf, pos + tsr.region->position(), this_time)) != this_time) {
+ if ((this_read = tsr.region->master_read_at (buffer, buffer, gain_buffer, pos + tsr.region->position(), this_time)) != this_time) {
error << string_compose (_("tempoize: error reading data from %1"), sources[i]->name()) << endmsg;
goto out;
}
st.putSamples (buffer, this_read);
while ((this_read = st.receiveSamples (buffer, bufsize)) > 0 && tsr.running) {
- if (sources[i]->write (buffer, this_read, workbuf) != this_read) {
+ if (sources[i]->write (buffer, this_read) != this_read) {
error << string_compose (_("error writing tempo-adjusted data to %1"), sources[i]->name()) << endmsg;
goto out;
}
}
while (tsr.running && (this_read = st.receiveSamples (buffer, bufsize)) > 0) {
- if (sources[i]->write (buffer, this_read, workbuf) != this_read) {
+ if (sources[i]->write (buffer, this_read) != this_read) {
error << string_compose (_("error writing tempo-adjusted data to %1"), sources[i]->name()) << endmsg;
goto out;
}
}
jack_nframes_t
-SndFileSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const
+SndFileSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
{
int32_t nread;
float *ptr;
}
jack_nframes_t
-SndFileSource::write_unlocked (Sample *data, jack_nframes_t cnt, char * workbuf)
+SndFileSource::write_unlocked (Sample *data, jack_nframes_t cnt)
{
if (!writable()) {
return 0;
projects / ardour.git / commitdiff