smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-16 11:46:25 +01:00
Code Issues Projects Releases Wiki Activity

optimize some performance bottlenecks; remove jack_nframes_t that crept back into the code

Browse source 
git-svn-id: svn://localhost/ardour2/branches/midi@1779 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Paul Davis 2007-05-03 23:28:57 +00:00
parent 5a1ca70f07
commit a8da89d745
46 changed files with 291 additions and 306 deletions
Download patch file Download diff file Expand all files Collapse all files

31
libs/ardour/amp.cc
View file

@ -28,27 +28,31 @@ namespace ARDOUR {
/** Apply a declicked gain to the audio buffers of @a bufs */
void
Amp::run (BufferSet& bufs, jack_nframes_t nframes, gain_t initial, gain_t target, bool invert_polarity)
Amp::run (BufferSet& bufs, nframes_t nframes, gain_t initial, gain_t target, bool invert_polarity)
{
if (nframes == 0)
return;
if (bufs.count().get(DataType::AUDIO) == 0)
return;
assert(bufs.buffer_capacity(DataType::AUDIO) >= nframes);
// assert(bufs.buffer_capacity(DataType::AUDIO) >= nframes);
// if we don't need to declick, defer to apply_simple_gain
if (initial == target) {
apply_simple_gain(bufs, nframes, invert_polarity ? -target : target);
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
apply_gain_to_buffer (i->data (), nframes, target);
}
return;
}
const jack_nframes_t declick = std::min ((jack_nframes_t)128, nframes);
const nframes_t declick = std::min ((nframes_t)128, nframes);
gain_t delta;
double fractional_shift = -1.0/declick;
double fractional_pos;
gain_t polscale = invert_polarity ? -1.0f : 1.0f;
if (nframes == 0)
return;
if (target < initial) {
/* fade out: remove more and more of delta from initial */
delta = -(initial - target);
@ -58,11 +62,11 @@ Amp::run (BufferSet& bufs, jack_nframes_t nframes, gain_t initial, gain_t target
}
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
Sample* const buffer = i->data(nframes);
Sample* const buffer = i->data();
fractional_pos = 1.0;
for (jack_nframes_t nx = 0; nx < declick; ++nx) {
for (nframes_t nx = 0; nx < declick; ++nx) {
buffer[nx] *= polscale * (initial + (delta * (0.5 + 0.5 * cos (M_PI * fractional_pos))));
fractional_pos += fractional_shift;
}
@ -78,20 +82,15 @@ Amp::run (BufferSet& bufs, jack_nframes_t nframes, gain_t initial, gain_t target
if (target == 0.0) {
memset (&buffer[declick], 0, sizeof (Sample) * (nframes - declick));
} else if (target != 1.0) {
for (jack_nframes_t nx = declick; nx < nframes; ++nx) {
buffer[nx] *= target;
}
apply_gain_to_buffer (&buffer[declick], nframes - declick, target);
}
}
}
}
void
Amp::apply_simple_gain (BufferSet& bufs, jack_nframes_t nframes, gain_t target)
Amp::apply_simple_gain (BufferSet& bufs, nframes_t nframes, gain_t target)
{
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
i->apply_gain(target, nframes);
}
}

4
libs/ardour/ardour/amp.h
View file

@ -31,9 +31,9 @@ class BufferSet;
*/
class Amp {
public:
static void run (BufferSet& bufs, jack_nframes_t nframes, gain_t initial, gain_t target, bool invert_polarity);
static void run (BufferSet& bufs, nframes_t nframes, gain_t initial, gain_t target, bool invert_polarity);
static void apply_simple_gain(BufferSet& bufs, jack_nframes_t nframes, gain_t target);
static void apply_simple_gain(BufferSet& bufs, nframes_t nframes, gain_t target);
};

17
libs/ardour/ardour/audio_port.h
View file

@ -38,8 +38,11 @@ class AudioPort : public Port {
free (_port);
}
void cycle_start(jack_nframes_t nframes);
void cycle_end();
void cycle_start(nframes_t nframes) {
_buffer.set_data ((Sample*) jack_port_get_buffer (_port, nframes), nframes);
}
void cycle_end() {}
DataType type() const { return DataType(DataType::AUDIO); }
@ -72,8 +75,8 @@ class AudioPort : public Port {
uint32_t short_overs () const { return _short_overs; }
uint32_t long_overs () const { return _long_overs; }
static void set_short_over_length (jack_nframes_t);
static void set_long_over_length (jack_nframes_t);
static void set_short_over_length (nframes_t);
static void set_long_over_length (nframes_t);
protected:
friend class AudioEngine;
@ -85,14 +88,14 @@ class AudioPort : public Port {
AudioBuffer _buffer;
jack_nframes_t _overlen;
nframes_t _overlen;
jack_default_audio_sample_t _peak;
float _peak_db;
uint32_t _short_overs;
uint32_t _long_overs;
static jack_nframes_t _long_over_length;
static jack_nframes_t _short_over_length;
static nframes_t _long_over_length;
static nframes_t _short_over_length;
};
} // namespace ARDOUR

2
libs/ardour/ardour/audioengine.h
View file

@ -68,8 +68,6 @@ class AudioEngine : public sigc::trackable
int start ();
bool running() const { return _running; }
int run_process_cycle (ARDOUR::Session*, jack_nframes_t nframes);
Glib::Mutex& process_lock() { return _process_lock; }
nframes_t frame_rate();

8
libs/ardour/ardour/audioregion.h
View file

@ -176,10 +176,10 @@ class AudioRegion : public Region
protected:
int set_live_state (const XMLNode&, Change&, bool send);
virtual bool verify_start (jack_nframes_t);
virtual bool verify_start_and_length (jack_nframes_t, jack_nframes_t);
virtual bool verify_start_mutable (jack_nframes_t&_start);
virtual bool verify_length (jack_nframes_t);
virtual bool verify_start (nframes_t);
virtual bool verify_start_and_length (nframes_t, nframes_t);
virtual bool verify_start_mutable (nframes_t&_start);
virtual bool verify_length (nframes_t);
/*virtual void recompute_at_start () = 0;
virtual void recompute_at_end () = 0;*/
};

33
libs/ardour/ardour/buffer.h
View file

@ -60,12 +60,12 @@ public:
bool silent() const { return _silent; }
/** Clear (eg zero, or empty) buffer starting at TIME @a offset */
virtual void silence(jack_nframes_t len, jack_nframes_t offset=0) = 0;
virtual void silence(nframes_t len, nframes_t offset=0) = 0;
/** Clear the entire buffer */
virtual void clear() { silence(_capacity, 0); }
virtual void read_from(const Buffer& src, jack_nframes_t offset, jack_nframes_t len) = 0;
virtual void read_from(const Buffer& src, nframes_t offset, nframes_t len) = 0;
protected:
Buffer(DataType type, size_t capacity)
@ -95,7 +95,7 @@ public:
~AudioBuffer();
void silence(jack_nframes_t len, jack_nframes_t offset=0)
void silence(nframes_t len, nframes_t offset=0)
{
if (!_silent) {
assert(_capacity > 0);
@ -108,25 +108,25 @@ public:
}
/** Read @a len frames FROM THE START OF @a src into self at @a offset */
void read_from(const Buffer& src, jack_nframes_t len, jack_nframes_t offset)
void read_from(const Buffer& src, nframes_t len, nframes_t offset)
{
assert(_capacity > 0);
assert(src.type() == _type == DataType::AUDIO);
assert(offset + len <= _capacity);
memcpy(_data + offset, ((AudioBuffer&)src).data(len), sizeof(Sample) * len);
memcpy(_data + offset, ((AudioBuffer&)src).data(), sizeof(Sample) * len);
_silent = src.silent();
}
/** Accumulate (add)@a len frames FROM THE START OF @a src into self at @a offset */
void accumulate_from(const AudioBuffer& src, jack_nframes_t len, jack_nframes_t offset)
void accumulate_from(const AudioBuffer& src, nframes_t len, nframes_t offset)
{
assert(_capacity > 0);
assert(offset + len <= _capacity);
Sample* const dst_raw = _data + offset;
const Sample* const src_raw = src.data(len);
const Sample* const src_raw = src.data();
for (jack_nframes_t n = 0; n < len; ++n) {
for (nframes_t n = 0; n < len; ++n) {
dst_raw[n] += src_raw[n];
}
@ -135,20 +135,20 @@ public:
/** Accumulate (add) @a len frames FROM THE START OF @a src into self at @a offset
* scaling by @a gain_coeff */
void accumulate_with_gain_from(const AudioBuffer& src, jack_nframes_t len, jack_nframes_t offset, gain_t gain_coeff)
void accumulate_with_gain_from(const AudioBuffer& src, nframes_t len, nframes_t offset, gain_t gain_coeff)
{
assert(_capacity > 0);
assert(offset + len <= _capacity);
Sample* const dst_raw = _data + offset;
const Sample* const src_raw = src.data(len);
const Sample* const src_raw = src.data();
mix_buffers_with_gain (dst_raw, src_raw, len, gain_coeff);
_silent = ( (src.silent() && _silent) || (_silent && gain_coeff == 0) );
}
void apply_gain(gain_t gain, jack_nframes_t len, jack_nframes_t offset=0) {
void apply_gain(gain_t gain, nframes_t len, nframes_t offset=0) {
apply_gain_to_buffer (_data + offset, len, gain);
}
@ -165,10 +165,13 @@ public:
_silent = false;
}
const Sample* data(jack_nframes_t nframes, jack_nframes_t offset=0) const
const Sample* data () const { return _data; }
Sample* data () { return _data; }
const Sample* data(nframes_t nframes, nframes_t offset) const
{ assert(offset + nframes <= _capacity); return _data + offset; }
Sample* data(jack_nframes_t nframes, jack_nframes_t offset=0)
Sample* data (nframes_t nframes, nframes_t offset)
{ assert(offset + nframes <= _capacity); return _data + offset; }
private:
@ -190,9 +193,9 @@ public:
~MidiBuffer();
void silence(jack_nframes_t dur, jack_nframes_t offset=0);
void silence(nframes_t dur, nframes_t offset=0);
void read_from(const Buffer& src, jack_nframes_t nframes, jack_nframes_t offset);
void read_from(const Buffer& src, nframes_t nframes, nframes_t offset);
bool push_back(const MidiEvent& event);

1
libs/ardour/ardour/data_type.h
View file

@ -19,7 +19,6 @@
#ifndef __ardour_data_type_h__
#define __ardour_data_type_h__
#include <cassert>
#include <string>
#include <ardour/data_type.h>
#include <jack/jack.h>

14
libs/ardour/ardour/io.h
View file

@ -96,11 +96,11 @@ class IO : public PBD::StatefulDestructible
virtual void silence (nframes_t, nframes_t offset);
void collect_input (BufferSet& bufs, jack_nframes_t nframes, jack_nframes_t offset);
void deliver_output (BufferSet& bufs, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t nframes, jack_nframes_t offset);
void just_meter_input (jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t nframes, jack_nframes_t offset);
void collect_input (BufferSet& bufs, nframes_t nframes, nframes_t offset);
void deliver_output (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame,
nframes_t nframes, nframes_t offset);
void just_meter_input (nframes_t start_frame, nframes_t end_frame,
nframes_t nframes, nframes_t offset);
virtual void set_gain (gain_t g, void *src);
void inc_gain (gain_t delta, void *src);
@ -216,11 +216,11 @@ class IO : public PBD::StatefulDestructible
/* automation */
static void set_automation_interval (jack_nframes_t frames) {
static void set_automation_interval (nframes_t frames) {
_automation_interval = frames;
}
static jack_nframes_t automation_interval() {
static nframes_t automation_interval() {
return _automation_interval;
}

2
libs/ardour/ardour/meter.h
View file

@ -41,7 +41,7 @@ public:
void reset_max ();
/** Compute peaks */
void run (BufferSet& bufs, jack_nframes_t nframes, jack_nframes_t offset=0);
void run (BufferSet& bufs, nframes_t nframes, nframes_t offset=0);
float peak_power (uint32_t n) {
if (n < _visible_peak_power.size()) {

20
libs/ardour/ardour/midi_diskstream.h
View file

@ -68,7 +68,7 @@ class MidiDiskstream : public Diskstream
float playback_buffer_load() const;
float capture_buffer_load() const;
void get_playback(MidiBuffer& dst, jack_nframes_t start, jack_nframes_t end);
void get_playback(MidiBuffer& dst, nframes_t start, nframes_t end);
void set_record_enabled (bool yn);
@ -99,21 +99,21 @@ class MidiDiskstream : public Diskstream
void set_pending_overwrite(bool);
int overwrite_existing_buffers ();
void set_block_size (jack_nframes_t);
int internal_playback_seek (jack_nframes_t distance);
int can_internal_playback_seek (jack_nframes_t distance);
void set_block_size (nframes_t);
int internal_playback_seek (nframes_t distance);
int can_internal_playback_seek (nframes_t distance);
int rename_write_sources ();
void reset_write_sources (bool, bool force = false);
void non_realtime_input_change ();
protected:
int seek (jack_nframes_t which_sample, bool complete_refill = false);
int seek (nframes_t which_sample, bool complete_refill = false);
protected:
friend class MidiTrack;
int process (jack_nframes_t transport_frame, jack_nframes_t nframes, jack_nframes_t offset, bool can_record, bool rec_monitors_input);
bool commit (jack_nframes_t nframes);
int process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input);
bool commit (nframes_t nframes);
private:
@ -123,7 +123,7 @@ class MidiDiskstream : public Diskstream
int do_refill_with_alloc();
int read (jack_nframes_t& start, jack_nframes_t cnt, bool reversed);
int read (nframes_t& start, nframes_t cnt, bool reversed);
void finish_capture (bool rec_monitors_input);
void transport_stopped (struct tm&, time_t, bool abort);
@ -139,7 +139,7 @@ class MidiDiskstream : public Diskstream
int use_pending_capture_data (XMLNode& node);
void get_input_sources ();
void check_record_status (jack_nframes_t transport_frame, jack_nframes_t nframes, bool can_record);
void check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record);
void set_align_style_from_io();
void engage_record_enable ();
@ -157,7 +157,7 @@ class MidiDiskstream : public Diskstream
RingBufferNPT<CaptureTransition>* _capture_transition_buf;
//RingBufferNPT<RawMidi>::rw_vector _playback_vector;
//RingBufferNPT<RawMidi>::rw_vector _capture_vector;
jack_nframes_t _last_flush_frame;
nframes_t _last_flush_frame;
};
}; /* namespace ARDOUR */

4
libs/ardour/ardour/midi_playlist.h
View file

@ -41,13 +41,13 @@ public:
MidiPlaylist (Session&, const XMLNode&, bool hidden = false);
MidiPlaylist (Session&, string name, bool hidden = false);
MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, string name, bool hidden = false);
MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, jack_nframes_t start, jack_nframes_t cnt,
MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, nframes_t start, nframes_t cnt,
string name, bool hidden = false);
~MidiPlaylist ();
nframes_t read (MidiRingBuffer& buf,
jack_nframes_t start, jack_nframes_t cnt, uint32_t chan_n=0);
nframes_t start, nframes_t cnt, uint32_t chan_n=0);
int set_state (const XMLNode&);
UndoAction get_memento() const;

4
libs/ardour/ardour/midi_port.h
View file

@ -47,7 +47,7 @@ class MidiPort : public Port {
return _buffer;
}
void cycle_start(jack_nframes_t nframes);
void cycle_start(nframes_t nframes);
void cycle_end();
size_t capacity() { return _buffer.capacity(); }
@ -61,7 +61,7 @@ class MidiPort : public Port {
/* engine isn't supposed to access below here */
MidiBuffer _buffer;
jack_nframes_t _nframes_this_cycle;
nframes_t _nframes_this_cycle;
};
} // namespace ARDOUR

34
libs/ardour/ardour/midi_region.h
View file

@ -50,16 +50,16 @@ class MidiRegion : public Region
boost::shared_ptr<MidiSource> midi_source (uint32_t n=0) const;
jack_nframes_t read_at (MidiRingBuffer& dst,
jack_nframes_t position,
jack_nframes_t dur,
nframes_t read_at (MidiRingBuffer& dst,
nframes_t position,
nframes_t dur,
uint32_t chan_n = 0,
jack_nframes_t read_frames = 0,
jack_nframes_t skip_frames = 0) const;
nframes_t read_frames = 0,
nframes_t skip_frames = 0) const;
jack_nframes_t master_read_at (MidiRingBuffer& dst,
jack_nframes_t position,
jack_nframes_t dur,
nframes_t master_read_at (MidiRingBuffer& dst,
nframes_t position,
nframes_t dur,
uint32_t chan_n=0) const;
XMLNode& state (bool);
@ -72,10 +72,10 @@ class MidiRegion : public Region
private:
friend class RegionFactory;
MidiRegion (boost::shared_ptr<MidiSource>, jack_nframes_t start, jack_nframes_t length);
MidiRegion (boost::shared_ptr<MidiSource>, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
MidiRegion (SourceList &, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
MidiRegion (boost::shared_ptr<const MidiRegion>, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
MidiRegion (boost::shared_ptr<MidiSource>, nframes_t start, nframes_t length);
MidiRegion (boost::shared_ptr<MidiSource>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
MidiRegion (SourceList &, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
MidiRegion (boost::shared_ptr<const MidiRegion>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
MidiRegion (boost::shared_ptr<const MidiRegion>);
MidiRegion (boost::shared_ptr<MidiSource>, const XMLNode&);
MidiRegion (SourceList &, const XMLNode&);
@ -84,12 +84,12 @@ class MidiRegion : public Region
friend class Playlist;
private:
jack_nframes_t _read_at (const SourceList&, MidiRingBuffer& dst,
jack_nframes_t position,
jack_nframes_t dur,
nframes_t _read_at (const SourceList&, MidiRingBuffer& dst,
nframes_t position,
nframes_t dur,
uint32_t chan_n = 0,
jack_nframes_t read_frames = 0,
jack_nframes_t skip_frames = 0) const;
nframes_t read_frames = 0,
nframes_t skip_frames = 0) const;
void recompute_at_start ();
void recompute_at_end ();

12
libs/ardour/ardour/midi_ring_buffer.h
View file

@ -94,10 +94,10 @@ public:
/** Read events all events up to time @a end into @a out, leaving stamps intact.
* Any events before @a start will be dropped. */
size_t read(MidiBuffer& out, jack_nframes_t start, jack_nframes_t end);
size_t read(MidiBuffer& out, nframes_t start, nframes_t end);
/** Write all events from @a in, applying @a offset to all time stamps */
size_t write(const MidiBuffer& in, jack_nframes_t offset = 0);
size_t write(const MidiBuffer& in, nframes_t offset = 0);
inline void clear_event(size_t index);
@ -128,7 +128,7 @@ MidiRingBuffer::clear_event(size_t index)
inline size_t
MidiRingBuffer::write (const MidiEvent& ev)
{
//static jack_nframes_t last_write_time = 0;
//static nframes_t last_write_time = 0;
assert(ev.size > 0);
@ -162,13 +162,13 @@ MidiRingBuffer::write (const MidiEvent& ev)
}
inline size_t
MidiRingBuffer::read(MidiBuffer& dst, jack_nframes_t start, jack_nframes_t end)
MidiRingBuffer::read(MidiBuffer& dst, nframes_t start, nframes_t end)
{
if (read_space() == 0)
return 0;
size_t priv_read_ptr = g_atomic_int_get(&_read_ptr);
jack_nframes_t time = _ev_buf[priv_read_ptr].time;
nframes_t time = _ev_buf[priv_read_ptr].time;
size_t count = 0;
size_t limit = read_space();
@ -205,7 +205,7 @@ MidiRingBuffer::read(MidiBuffer& dst, jack_nframes_t start, jack_nframes_t end)
}
inline size_t
MidiRingBuffer::write(const MidiBuffer& in, jack_nframes_t offset)
MidiRingBuffer::write(const MidiBuffer& in, nframes_t offset)
{
size_t num_events = in.size();
size_t to_write = std::min(write_space(), num_events);

10
libs/ardour/ardour/midi_source.h
View file

@ -47,8 +47,8 @@ class MidiSource : public Source
MidiSource (Session& session, const XMLNode&);
virtual ~MidiSource ();
virtual jack_nframes_t read (MidiRingBuffer& dst, jack_nframes_t start, jack_nframes_t cnt, jack_nframes_t stamp_offset) const;
virtual jack_nframes_t write (MidiRingBuffer& src, jack_nframes_t cnt);
virtual nframes_t read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const;
virtual nframes_t write (MidiRingBuffer& src, nframes_t cnt);
virtual void mark_for_remove() = 0;
virtual void mark_streaming_write_completed () {}
@ -64,14 +64,14 @@ class MidiSource : public Source
// The MIDI equivalent to "peaks"
static int start_view_data_thread ();
static void stop_view_data_thread ();
mutable sigc::signal<void,jack_nframes_t,jack_nframes_t> ViewDataRangeReady;
mutable sigc::signal<void,nframes_t,nframes_t> ViewDataRangeReady;
XMLNode& get_state ();
int set_state (const XMLNode&);
protected:
virtual jack_nframes_t read_unlocked (MidiRingBuffer& dst, jack_nframes_t start, jack_nframes_t cnt, jack_nframes_t stamp_offset) const = 0;
virtual jack_nframes_t write_unlocked (MidiRingBuffer& dst, jack_nframes_t cnt) = 0;
virtual nframes_t read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const = 0;
virtual nframes_t write_unlocked (MidiRingBuffer& dst, nframes_t cnt) = 0;
mutable Glib::Mutex _lock;
string _captured_for;

22
libs/ardour/ardour/midi_track.h
View file

@ -39,18 +39,18 @@ public:
int set_name (string str, void *src);
int roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, int declick, bool can_record, bool rec_monitors_input);
int roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
nframes_t offset, int declick, bool can_record, bool rec_monitors_input);
int no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input);
int no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input);
int silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t offset, bool can_record, bool rec_monitors_input);
int silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
nframes_t offset, bool can_record, bool rec_monitors_input);
void process_output_buffers (BufferSet& bufs,
jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t nframes, jack_nframes_t offset, bool with_redirects, int declick,
nframes_t start_frame, nframes_t end_frame,
nframes_t nframes, nframes_t offset, bool with_redirects, int declick,
bool meter);
boost::shared_ptr<MidiDiskstream> midi_diskstream() const;
@ -60,16 +60,16 @@ public:
int set_mode (TrackMode m);
void set_latency_delay (jack_nframes_t);
void set_latency_delay (nframes_t);
int export_stuff (BufferSet& bufs,
jack_nframes_t nframes, jack_nframes_t end_frame);
nframes_t nframes, nframes_t end_frame);
void freeze (InterThreadInfo&);
void unfreeze ();
void bounce (InterThreadInfo&);
void bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo&);
void bounce_range (nframes_t start, nframes_t end, InterThreadInfo&);
int set_state(const XMLNode& node);

2
libs/ardour/ardour/port.h
View file

@ -41,7 +41,7 @@ class Port : public sigc::trackable {
virtual DataType type() const = 0;
virtual void cycle_start(jack_nframes_t nframes) {}
virtual void cycle_start(nframes_t nframes) {}
virtual void cycle_end() {}
virtual Buffer& get_buffer() = 0;

8
libs/ardour/ardour/region.h
View file

@ -213,10 +213,10 @@ class Region : public PBD::StatefulDestructible, public boost::enable_shared_fro
void maybe_uncopy ();
void first_edit ();
virtual bool verify_start (jack_nframes_t);
virtual bool verify_start_and_length (jack_nframes_t, jack_nframes_t);
virtual bool verify_start_mutable (jack_nframes_t&_start);
virtual bool verify_length (jack_nframes_t);
virtual bool verify_start (nframes_t);
virtual bool verify_start_and_length (nframes_t, nframes_t);
virtual bool verify_start_mutable (nframes_t&_start);
virtual bool verify_length (nframes_t);
virtual void recompute_at_start () = 0;
virtual void recompute_at_end () = 0;

6
libs/ardour/ardour/session.h
View file

@ -1319,13 +1319,13 @@ class Session : public PBD::StatefulDestructible
/* cache the most-recently requested time conversions. This helps when we
* have multiple clocks showing the same time (e.g. the transport frame) */
bool last_smpte_valid;
jack_nframes_t last_smpte_when;
nframes_t last_smpte_when;
SMPTE::Time last_smpte;
bool _send_smpte_update; ///< Flag to send a full frame (SMPTE) MTC message this cycle
int send_full_time_code(jack_nframes_t nframes);
int send_midi_time_code_for_cycle(jack_nframes_t nframes);
int send_full_time_code(nframes_t nframes);
int send_midi_time_code_for_cycle(nframes_t nframes);
nframes_t adjust_apparent_position (nframes_t frames);

14
libs/ardour/ardour/smf_source.h
View file

@ -56,8 +56,8 @@ class SMFSource : public MidiSource {
*/
// FIXME and thus are useless for MIDI.. but make MidiDiskstream compile easier! :)
virtual jack_nframes_t last_capture_start_frame() const { return 0; }
virtual void mark_capture_start (jack_nframes_t) {}
virtual nframes_t last_capture_start_frame() const { return 0; }
virtual void mark_capture_start (nframes_t) {}
virtual void mark_capture_end () {}
virtual void clear_capture_marks() {}
@ -68,7 +68,7 @@ class SMFSource : public MidiSource {
void set_allow_remove_if_empty (bool yn);
void mark_for_remove();
int update_header (jack_nframes_t when, struct tm&, time_t);
int update_header (nframes_t when, struct tm&, time_t);
int flush_header ();
int flush_footer ();
@ -81,7 +81,7 @@ class SMFSource : public MidiSource {
string take_id() const { return _take_id; }
static void set_search_path (string);
static void set_header_position_offset (jack_nframes_t offset, bool negative);
static void set_header_position_offset (nframes_t offset, bool negative);
XMLNode& get_state ();
int set_state (const XMLNode&);
@ -90,8 +90,8 @@ class SMFSource : public MidiSource {
int init (string idstr, bool must_exist);
jack_nframes_t read_unlocked (MidiRingBuffer& dst, jack_nframes_t start, jack_nframes_t cn, jack_nframes_t stamp_offset) const;
jack_nframes_t write_unlocked (MidiRingBuffer& dst, jack_nframes_t cnt);
nframes_t read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cn, nframes_t stamp_offset) const;
nframes_t write_unlocked (MidiRingBuffer& dst, nframes_t cnt);
bool find (std::string path, bool must_exist, bool& is_new);
bool removable() const;
@ -112,7 +112,7 @@ class SMFSource : public MidiSource {
bool _allow_remove_if_empty;
uint64_t _timeline_position;
FILE* _fd;
jack_nframes_t _last_ev_time; // last frame time written, relative to source start
nframes_t _last_ev_time; // last frame time written, relative to source start
uint32_t _track_size;
uint32_t _header_size; // size of SMF header, including MTrk chunk header

8
libs/ardour/ardour/source.h
View file

@ -52,9 +52,9 @@ class Source : public PBD::StatefulDestructible
void stamp (time_t when) { _timestamp = when; }
/** @return the number of items in this source */
jack_nframes_t length() const { return _length; }
nframes_t length() const { return _length; }
virtual jack_nframes_t natural_position() const { return 0; }
virtual nframes_t natural_position() const { return 0; }
virtual void mark_for_remove() = 0;
virtual void mark_streaming_write_completed () = 0;
@ -74,13 +74,13 @@ class Source : public PBD::StatefulDestructible
static sigc::signal<void,Source*> SourceCreated;
protected:
void update_length (jack_nframes_t pos, jack_nframes_t cnt);
void update_length (nframes_t pos, nframes_t cnt);
Session& _session;
string _name;
DataType _type;
time_t _timestamp;
jack_nframes_t _length;
nframes_t _length;
Glib::Mutex playlist_lock;
typedef std::map<boost::shared_ptr<ARDOUR::Playlist>, uint32_t > PlaylistMap;

23
libs/ardour/audio_port.cc
View file

@ -23,8 +23,8 @@
using namespace ARDOUR;
using namespace std;
jack_nframes_t AudioPort::_short_over_length = 2;
jack_nframes_t AudioPort::_long_over_length = 10;
nframes_t AudioPort::_short_over_length = 2;
nframes_t AudioPort::_long_over_length = 10;
AudioPort::AudioPort(jack_port_t* p)
: Port(p)
@ -51,23 +51,4 @@ AudioPort::reset()
reset_meters ();
}
void
AudioPort::cycle_start (jack_nframes_t nframes)
{
if (_flags & JackPortIsOutput) {
const bool silent = _buffer.silent();
// FIXME: do nothing, we can cache the value (but capacity needs to be set for MIDI)
_buffer.set_data((Sample*)jack_port_get_buffer (_port, nframes), nframes);
if (silent) {
_buffer.silence(nframes);
}
} else {
_buffer.set_data((Sample*)jack_port_get_buffer (_port, nframes), nframes);
}
}
void
AudioPort::cycle_end()
{
// whatever...
}

16
libs/ardour/audio_track.cc
View file

@ -586,7 +586,7 @@ AudioTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
uint32_t i;
for (i = 0, n = 1; i < limit; ++i, ++n) {
memcpy (bufs.get_audio(i).data(nframes), b, sizeof (Sample) * nframes);
memcpy (bufs.get_audio(i).data(), b, sizeof (Sample) * nframes);
if (n < diskstream->n_channels().get(DataType::AUDIO)) {
tmpb = diskstream->playback_buffer(n);
if (tmpb!=0) {
@ -652,26 +652,26 @@ AudioTrack::export_stuff (BufferSet& buffers, nframes_t start, nframes_t nframes
boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist());
assert(apl);
if (apl->read (buffers.get_audio(nframes).data(nframes),
if (apl->read (buffers.get_audio(nframes).data(),
mix_buffer, gain_buffer, start, nframes) != nframes) {
return -1;
}
assert(buffers.count().get(DataType::AUDIO) >= 1);
uint32_t n=1;
Sample* b = buffers.get_audio(0).data(nframes);
Sample* b = buffers.get_audio(0).data();
BufferSet::audio_iterator bi = buffers.audio_begin();
++bi;
for ( ; bi != buffers.audio_end(); ++bi, ++n) {
if (n < diskstream->n_channels().get(DataType::AUDIO)) {
if (apl->read (bi->data(nframes), mix_buffer, gain_buffer, start, nframes, n) != nframes) {
if (apl->read (bi->data(), mix_buffer, gain_buffer, start, nframes, n) != nframes) {
return -1;
}
b = bi->data(nframes);
b = bi->data();
}
else {
/* duplicate last across remaining buffers */
memcpy (bi->data(nframes), b, sizeof (Sample) * nframes);
memcpy (bi->data(), b, sizeof (Sample) * nframes);
}
}
@ -700,7 +700,7 @@ AudioTrack::export_stuff (BufferSet& buffers, nframes_t start, nframes_t nframes
_gain_automation_curve.get_vector (start, start + nframes, gain_automation, nframes);
for (BufferSet::audio_iterator bi = buffers.audio_begin(); bi != buffers.audio_end(); ++bi) {
Sample *b = bi->data(nframes);
Sample *b = bi->data();
for (nframes_t n = 0; n < nframes; ++n) {
b[n] *= gain_automation[n];
}
@ -709,7 +709,7 @@ AudioTrack::export_stuff (BufferSet& buffers, nframes_t start, nframes_t nframes
} else {
for (BufferSet::audio_iterator bi = buffers.audio_begin(); bi != buffers.audio_end(); ++bi) {
Sample *b = bi->data(nframes);
Sample *b = bi->data();
for (nframes_t n = 0; n < nframes; ++n) {
b[n] *= this_gain;
}

68
libs/ardour/audioengine.cc
View file

@ -304,14 +304,27 @@ AudioEngine::process_callback (nframes_t nframes)
return 0;
}
if (run_process_cycle (session, nframes)) {
/* we were zombified, maybe because a ladspa plugin took
too long, or jackd exited, or something like that.
*/
boost::shared_ptr<Ports> p = ports.reader();
// Prepare ports (ie read data if necessary)
for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
(*i)->cycle_start (nframes);
}
if (session) {
session->process (nframes);
}
if (!_running) {
_processed_frames = next_processed_frames;
return 0;
}
// Finalize ports (ie write data if necessary)
for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
(*i)->cycle_end ();
}
if (last_monitor_check + monitor_check_interval < next_processed_frames) {
boost::shared_ptr<Ports> p = ports.reader();
@ -336,28 +349,6 @@ AudioEngine::process_callback (nframes_t nframes)
return 0;
}
int
AudioEngine::run_process_cycle (Session* s, jack_nframes_t nframes)
{
boost::shared_ptr<Ports> p = ports.reader();
// Prepare ports (ie read data if necessary)
for (Ports::iterator i = p->begin(); i != p->end(); ++i)
(*i)->cycle_start (nframes);
s->process (nframes);
if (!_running) {
return -1;
}
// Finalize ports (ie write data if necessary)
for (Ports::iterator i = p->begin(); i != p->end(); ++i)
(*i)->cycle_end ();
return 0;
}
int
AudioEngine::_sample_rate_callback (nframes_t nframes, void *arg)
{
@ -456,14 +447,23 @@ AudioEngine::set_session (Session *s)
can before we really start running.
*/
run_process_cycle (session, blocksize);
run_process_cycle (session, blocksize);
run_process_cycle (session, blocksize);
run_process_cycle (session, blocksize);
run_process_cycle (session, blocksize);
run_process_cycle (session, blocksize);
run_process_cycle (session, blocksize);
run_process_cycle (session, blocksize);
boost::shared_ptr<Ports> p = ports.reader();
for (Ports::iterator i = p->begin(); i != p->end(); ++i)
(*i)->cycle_start (blocksize);
s->process (blocksize);
s->process (blocksize);
s->process (blocksize);
s->process (blocksize);
s->process (blocksize);
s->process (blocksize);
s->process (blocksize);
s->process (blocksize);
for (Ports::iterator i = p->begin(); i != p->end(); ++i)
(*i)->cycle_end ();
}
}

2
libs/ardour/automation_event.cc
View file

@ -1335,7 +1335,7 @@ AutomationList::set_state (const XMLNode& node)
const XMLNodeList& elist = node.children();
XMLNodeConstIterator i;
XMLProperty* prop;
jack_nframes_t x;
nframes_t x;
double y;
freeze ();

4
libs/ardour/buffer.cc
View file

@ -103,7 +103,7 @@ MidiBuffer::~MidiBuffer()
* Note that offset and nframes refer to sample time, NOT buffer offsets or event counts.
*/
void
MidiBuffer::read_from(const Buffer& src, jack_nframes_t nframes, jack_nframes_t offset)
MidiBuffer::read_from(const Buffer& src, nframes_t nframes, nframes_t offset)
{
assert(src.type() == DataType::MIDI);
const MidiBuffer& msrc = (MidiBuffer&)src;
@ -154,7 +154,7 @@ MidiBuffer::push_back(const MidiEvent& ev)
void
MidiBuffer::silence(jack_nframes_t dur, jack_nframes_t offset)
MidiBuffer::silence(nframes_t dur, nframes_t offset)
{
// FIXME use parameters
assert(offset == 0);

2
libs/ardour/buffer_set.cc
View file

@ -151,7 +151,7 @@ BufferSet::buffer_capacity(DataType type) const
// FIXME: make 'in' const
void
BufferSet::read_from(BufferSet& in, jack_nframes_t nframes, jack_nframes_t offset)
BufferSet::read_from(BufferSet& in, nframes_t nframes, nframes_t offset)
{
assert(available() >= in.count());

2
libs/ardour/control_protocol_manager.cc
View file

@ -96,11 +96,13 @@ ControlProtocolManager::drop_session ()
for (list<ControlProtocolInfo*>::iterator p = control_protocol_info.begin(); p != control_protocol_info.end(); ++p) {
// otherwise the ControlProtocol instances are not recreated in set_session
if ((*p)->protocol) {
(*p)->requested = true;
(*p)->protocol = 0;
}
}
}
}
ControlProtocol*
ControlProtocolManager::instantiate (ControlProtocolInfo& cpi)

2
libs/ardour/io.cc
View file

@ -1444,7 +1444,7 @@ IO::load_automation (string path)
while (in.getline (line, sizeof(line), '\n')) {
char type;
jack_nframes_t when;
nframes_t when;
double value;
if (++linecnt == 1) {

2
libs/ardour/meter.cc
View file

@ -33,7 +33,7 @@ namespace ARDOUR {
* be set to 0.
*/
void
PeakMeter::run (BufferSet& bufs, jack_nframes_t nframes, jack_nframes_t offset)
PeakMeter::run (BufferSet& bufs, nframes_t nframes, nframes_t offset)
{
size_t meterable = std::min(bufs.count().get(DataType::AUDIO), _peak_power.size());

46
libs/ardour/midi_diskstream.cc
View file

@ -172,7 +172,7 @@ MidiDiskstream::non_realtime_input_change ()
/* now refill channel buffers */
if (speed() != 1.0f || speed() != -1.0f) {
seek ((jack_nframes_t) (_session.transport_frame() * (double) speed()));
seek ((nframes_t) (_session.transport_frame() * (double) speed()));
}
else {
seek (_session.transport_frame());
@ -308,7 +308,7 @@ MidiDiskstream::set_destructive (bool yn)
}
void
MidiDiskstream::check_record_status (jack_nframes_t transport_frame, jack_nframes_t nframes, bool can_record)
MidiDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
{
// FIXME: waaay too much code to duplicate (AudioDiskstream)
@ -431,12 +431,12 @@ MidiDiskstream::check_record_status (jack_nframes_t transport_frame, jack_nframe
}
int
MidiDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes, jack_nframes_t offset, bool can_record, bool rec_monitors_input)
MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input)
{
// FIXME: waay too much code to duplicate (AudioDiskstream::process)
int ret = -1;
jack_nframes_t rec_offset = 0;
jack_nframes_t rec_nframes = 0;
nframes_t rec_offset = 0;
nframes_t rec_nframes = 0;
bool nominally_recording;
bool re = record_enabled ();
bool collect_playback = false;
@ -582,12 +582,12 @@ MidiDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes,
/* we're doing playback */
jack_nframes_t necessary_samples;
nframes_t necessary_samples;
/* no varispeed playback if we're recording, because the output .... TBD */
if (rec_nframes == 0 && _actual_speed != 1.0f) {
necessary_samples = (jack_nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
} else {
necessary_samples = nframes;
}
@ -618,7 +618,7 @@ MidiDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes,
}
bool
MidiDiskstream::commit (jack_nframes_t nframes)
MidiDiskstream::commit (nframes_t nframes)
{
bool need_butler = false;
@ -674,7 +674,7 @@ MidiDiskstream::overwrite_existing_buffers ()
}
int
MidiDiskstream::seek (jack_nframes_t frame, bool complete_refill)
MidiDiskstream::seek (nframes_t frame, bool complete_refill)
{
Glib::Mutex::Lock lm (state_lock);
int ret = -1;
@ -696,7 +696,7 @@ MidiDiskstream::seek (jack_nframes_t frame, bool complete_refill)
}
int
MidiDiskstream::can_internal_playback_seek (jack_nframes_t distance)
MidiDiskstream::can_internal_playback_seek (nframes_t distance)
{
if (_playback_buf->read_space() < distance) {
return false;
@ -706,7 +706,7 @@ MidiDiskstream::can_internal_playback_seek (jack_nframes_t distance)
}
int
MidiDiskstream::internal_playback_seek (jack_nframes_t distance)
MidiDiskstream::internal_playback_seek (nframes_t distance)
{
first_recordable_frame += distance;
playback_sample += distance;
@ -716,13 +716,13 @@ MidiDiskstream::internal_playback_seek (jack_nframes_t distance)
/** @a start is set to the new frame position (TIME) read up to */
int
MidiDiskstream::read (jack_nframes_t& start, jack_nframes_t dur, bool reversed)
MidiDiskstream::read (nframes_t& start, nframes_t dur, bool reversed)
{
jack_nframes_t this_read = 0;
nframes_t this_read = 0;
bool reloop = false;
jack_nframes_t loop_end = 0;
jack_nframes_t loop_start = 0;
jack_nframes_t loop_length = 0;
nframes_t loop_end = 0;
nframes_t loop_start = 0;
nframes_t loop_length = 0;
Location *loc = 0;
if (!reversed) {
@ -884,8 +884,8 @@ MidiDiskstream::do_refill ()
// So (read it, then) write it:
jack_nframes_t file_frame_tmp = file_frame;
jack_nframes_t to_read = min(disk_io_chunk_frames, (max_frames - file_frame));
nframes_t file_frame_tmp = file_frame;
nframes_t to_read = min(disk_io_chunk_frames, (max_frames - file_frame));
// FIXME: read count?
if (read (file_frame_tmp, to_read, reversed)) {
@ -917,7 +917,7 @@ MidiDiskstream::do_flush (Session::RunContext context, bool force_flush)
int32_t ret = 0;
// FIXME: I'd be lying if I said I knew what this thing was
//RingBufferNPT<CaptureTransition>::rw_vector transvec;
jack_nframes_t total;
nframes_t total;
_write_data_count = 0;
@ -949,7 +949,7 @@ MidiDiskstream::do_flush (Session::RunContext context, bool force_flush)
ret = 1;
}
//to_write = min (disk_io_chunk_frames, (jack_nframes_t) vector.len[0]);
//to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
to_write = disk_io_chunk_frames;
assert(!destructive());
@ -977,7 +977,7 @@ MidiDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_cap
bool more_work = true;
int err = 0;
boost::shared_ptr<MidiRegion> region;
jack_nframes_t total_capture;
nframes_t total_capture;
MidiRegion::SourceList srcs;
MidiRegion::SourceList::iterator src;
vector<CaptureInfo*>::iterator ci;
@ -1411,7 +1411,7 @@ MidiDiskstream::rename_write_sources ()
}
void
MidiDiskstream::set_block_size (jack_nframes_t nframes)
MidiDiskstream::set_block_size (nframes_t nframes)
{
}
@ -1477,7 +1477,7 @@ MidiDiskstream::use_pending_capture_data (XMLNode& node)
* so that an event at start has time = 0
*/
void
MidiDiskstream::get_playback(MidiBuffer& dst, jack_nframes_t start, jack_nframes_t end)
MidiDiskstream::get_playback(MidiBuffer& dst, nframes_t start, nframes_t end)
{
dst.clear();
assert(dst.size() == 0);

16
libs/ardour/midi_playlist.cc
View file

@ -100,7 +100,7 @@ MidiPlaylist::MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, string
*/
}
MidiPlaylist::MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, jack_nframes_t start, jack_nframes_t dur, string name, bool hidden)
MidiPlaylist::MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, nframes_t start, nframes_t dur, string name, bool hidden)
: Playlist (other, start, dur, name, hidden)
{
/* this constructor does NOT notify others (session) */
@ -118,9 +118,9 @@ struct RegionSortByLayer {
};
/** Returns the number of frames in time duration read (eg could be large when 0 events are read) */
jack_nframes_t
MidiPlaylist::read (MidiRingBuffer& dst, jack_nframes_t start,
jack_nframes_t dur, unsigned chan_n)
nframes_t
MidiPlaylist::read (MidiRingBuffer& dst, nframes_t start,
nframes_t dur, unsigned chan_n)
{
/* this function is never called from a realtime thread, so
its OK to block (for short intervals).
@ -128,10 +128,10 @@ MidiPlaylist::read (MidiRingBuffer& dst, jack_nframes_t start,
Glib::Mutex::Lock rm (region_lock);
jack_nframes_t ret = 0;
jack_nframes_t end = start + dur - 1;
//jack_nframes_t read_frames = 0;
//jack_nframes_t skip_frames = 0;
nframes_t ret = 0;
nframes_t end = start + dur - 1;
//nframes_t read_frames = 0;
//nframes_t skip_frames = 0;
//_read_data_count = 0;

10
libs/ardour/midi_port.cc
View file

@ -45,7 +45,7 @@ MidiPort::~MidiPort()
}
void
MidiPort::cycle_start (jack_nframes_t nframes)
MidiPort::cycle_start (nframes_t nframes)
{
_buffer.clear();
assert(_buffer.size() == 0);
@ -62,7 +62,7 @@ MidiPort::cycle_start (jack_nframes_t nframes)
void* jack_buffer = jack_port_get_buffer(_port, nframes);
const jack_nframes_t event_count
const nframes_t event_count
= jack_midi_get_event_count(jack_buffer);
assert(event_count < _buffer.capacity());
@ -70,7 +70,7 @@ MidiPort::cycle_start (jack_nframes_t nframes)
MidiEvent ev;
// FIXME: too slow, event struct is copied twice (here and MidiBuffer::push_back)
for (jack_nframes_t i=0; i < event_count; ++i) {
for (nframes_t i=0; i < event_count; ++i) {
// This will fail to compile if we change MidiEvent to our own class
jack_midi_event_get(static_cast<jack_midi_event_t*>(&ev), jack_buffer, i);
@ -100,13 +100,13 @@ MidiPort::cycle_end()
void* jack_buffer = jack_port_get_buffer(_port, _nframes_this_cycle);
const jack_nframes_t event_count = _buffer.size();
const nframes_t event_count = _buffer.size();
//if (event_count > 0)
// cerr << "MIDIPort writing " << event_count << " events." << endl;
jack_midi_clear_buffer(jack_buffer);
for (jack_nframes_t i=0; i < event_count; ++i) {
for (nframes_t i=0; i < event_count; ++i) {
const jack_midi_event_t& ev = _buffer[i];
assert(ev.time < _nframes_this_cycle);
jack_midi_event_write(jack_buffer, ev.time, ev.buffer, ev.size);

34
libs/ardour/midi_region.cc
View file

@ -48,21 +48,21 @@ using namespace std;
using namespace ARDOUR;
/** Basic MidiRegion constructor (one channel) */
MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src, jack_nframes_t start, jack_nframes_t length)
MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src, nframes_t start, nframes_t length)
: Region (src, start, length, PBD::basename_nosuffix(src->name()), DataType::MIDI, 0, Region::Flag(Region::DefaultFlags|Region::External))
{
assert(_name.find("/") == string::npos);
}
/* Basic MidiRegion constructor (one channel) */
MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Flag flags)
MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src, nframes_t start, nframes_t length, const string& name, layer_t layer, Flag flags)
: Region (src, start, length, name, DataType::MIDI, layer, flags)
{
assert(_name.find("/") == string::npos);
}
/* Basic MidiRegion constructor (many channels) */
MidiRegion::MidiRegion (SourceList& srcs, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Flag flags)
MidiRegion::MidiRegion (SourceList& srcs, nframes_t start, nframes_t length, const string& name, layer_t layer, Flag flags)
: Region (srcs, start, length, name, DataType::MIDI, layer, flags)
{
assert(_name.find("/") == string::npos);
@ -70,7 +70,7 @@ MidiRegion::MidiRegion (SourceList& srcs, jack_nframes_t start, jack_nframes_t l
/** Create a new MidiRegion, that is part of an existing one */
MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other, jack_nframes_t offset, jack_nframes_t length, const string& name, layer_t layer, Flag flags)
MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags)
: Region (other, offset, length, name, layer, flags)
{
assert(_name.find("/") == string::npos);
@ -108,31 +108,31 @@ MidiRegion::~MidiRegion ()
{
}
jack_nframes_t
MidiRegion::read_at (MidiRingBuffer& out, jack_nframes_t position,
jack_nframes_t dur,
uint32_t chan_n, jack_nframes_t read_frames, jack_nframes_t skip_frames) const
nframes_t
MidiRegion::read_at (MidiRingBuffer& out, nframes_t position,
nframes_t dur,
uint32_t chan_n, nframes_t read_frames, nframes_t skip_frames) const
{
return _read_at (_sources, out, position, dur, chan_n, read_frames, skip_frames);
}
jack_nframes_t
MidiRegion::master_read_at (MidiRingBuffer& out, jack_nframes_t position,
jack_nframes_t dur, uint32_t chan_n) const
nframes_t
MidiRegion::master_read_at (MidiRingBuffer& out, nframes_t position,
nframes_t dur, uint32_t chan_n) const
{
return _read_at (_master_sources, out, position, dur, chan_n, 0, 0);
}
jack_nframes_t
nframes_t
MidiRegion::_read_at (const SourceList& srcs, MidiRingBuffer& dst,
jack_nframes_t position, jack_nframes_t dur,
uint32_t chan_n, jack_nframes_t read_frames, jack_nframes_t skip_frames) const
nframes_t position, nframes_t dur,
uint32_t chan_n, nframes_t read_frames, nframes_t skip_frames) const
{
// cerr << _name << "._read_at(" << position << ") - " << _position << endl;
jack_nframes_t internal_offset = 0;
jack_nframes_t src_offset = 0;
jack_nframes_t to_read = 0;
nframes_t internal_offset = 0;
nframes_t src_offset = 0;
nframes_t to_read = 0;
/* precondition: caller has verified that we cover the desired section */

8
libs/ardour/midi_source.cc
View file

@ -90,15 +90,15 @@ MidiSource::set_state (const XMLNode& node)
return 0;
}
jack_nframes_t
MidiSource::read (MidiRingBuffer& dst, jack_nframes_t start, jack_nframes_t cnt, jack_nframes_t stamp_offset) const
nframes_t
MidiSource::read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const
{
Glib::Mutex::Lock lm (_lock);
return read_unlocked (dst, start, cnt, stamp_offset);
}
jack_nframes_t
MidiSource::write (MidiRingBuffer& dst, jack_nframes_t cnt)
nframes_t
MidiSource::write (MidiRingBuffer& dst, nframes_t cnt)
{
Glib::Mutex::Lock lm (_lock);
return write_unlocked (dst, cnt);

18
libs/ardour/midi_track.cc
View file

@ -352,7 +352,7 @@ MidiTrack::set_state_part_two ()
}
int
MidiTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset,
MidiTrack::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
bool session_state_changing, bool can_record, bool rec_monitors_input)
{
if (n_outputs().get(DataType::MIDI) == 0) {
@ -433,7 +433,7 @@ MidiTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfr
}
int
MidiTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset, int declick,
MidiTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick,
bool can_record, bool rec_monitors_input)
{
int dret;
@ -448,7 +448,7 @@ MidiTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframe
return 0;
}
jack_nframes_t transport_frame = _session.transport_frame();
nframes_t transport_frame = _session.transport_frame();
if ((nframes = check_initial_delay (nframes, offset, transport_frame)) == 0) {
/* need to do this so that the diskstream sets its
@ -507,7 +507,7 @@ MidiTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframe
}
int
MidiTrack::silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset,
MidiTrack::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
bool can_record, bool rec_monitors_input)
{
if (n_outputs().get(DataType::MIDI) == 0 && _redirects.empty()) {
@ -529,8 +529,8 @@ MidiTrack::silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack
void
MidiTrack::process_output_buffers (BufferSet& bufs,
jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t nframes, jack_nframes_t offset, bool with_redirects, int declick,
nframes_t start_frame, nframes_t end_frame,
nframes_t nframes, nframes_t offset, bool with_redirects, int declick,
bool meter)
{
/* There's no such thing as a MIDI bus for the time being, to avoid diverging from trunk
@ -578,13 +578,13 @@ MidiTrack::set_name (string str, void *src)
}
int
MidiTrack::export_stuff (BufferSet& bufs, jack_nframes_t nframes, jack_nframes_t end_frame)
MidiTrack::export_stuff (BufferSet& bufs, nframes_t nframes, nframes_t end_frame)
{
return -1;
}
void
MidiTrack::set_latency_delay (jack_nframes_t longest_session_latency)
MidiTrack::set_latency_delay (nframes_t longest_session_latency)
{
Route::set_latency_delay (longest_session_latency);
_diskstream->set_roll_delay (_roll_delay);
@ -600,7 +600,7 @@ MidiTrack::bounce (InterThreadInfo& itt)
void
MidiTrack::bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo& itt)
MidiTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt)
{
throw;
//vector<MidiSource*> srcs;

18
libs/ardour/panner.cc
View file

@ -244,7 +244,7 @@ BaseStereoPanner::load (istream& in, string path, uint32_t& linecnt)
_automation.clear ();
while (in.getline (line, sizeof (line), '\n')) {
jack_nframes_t when;
nframes_t when;
double value;
++linecnt;
@ -281,11 +281,11 @@ BaseStereoPanner::distribute (AudioBuffer& srcbuf, BufferSet& obufs, gain_t gain
return;
}
Sample* const src = srcbuf.data(nframes);
Sample* const src = srcbuf.data();
/* LEFT */
dst = obufs.get_audio(0).data(nframes);
dst = obufs.get_audio(0).data();
if (fabsf ((delta = (left - desired_left))) > 0.002) { // about 1 degree of arc
@ -335,7 +335,7 @@ BaseStereoPanner::distribute (AudioBuffer& srcbuf, BufferSet& obufs, gain_t gain
/* RIGHT */
dst = obufs.get_audio(1).data(nframes);
dst = obufs.get_audio(1).data();
if (fabsf ((delta = (right - desired_right))) > 0.002) { // about 1 degree of arc
@ -434,7 +434,7 @@ EqualPowerStereoPanner::distribute_automated (AudioBuffer& srcbuf, BufferSet& ob
Sample* dst;
pan_t* pbuf;
Sample* const src = srcbuf.data(nframes);
Sample* const src = srcbuf.data();
/* fetch positional data */
@ -473,7 +473,7 @@ EqualPowerStereoPanner::distribute_automated (AudioBuffer& srcbuf, BufferSet& ob
/* LEFT */
dst = obufs.get_audio(0).data(nframes);
dst = obufs.get_audio(0).data();
pbuf = buffers[0];
for (nframes_t n = 0; n < nframes; ++n) {
@ -484,7 +484,7 @@ EqualPowerStereoPanner::distribute_automated (AudioBuffer& srcbuf, BufferSet& ob
/* RIGHT */
dst = obufs.get_audio(1).data(nframes);
dst = obufs.get_audio(1).data();
pbuf = buffers[1];
for (nframes_t n = 0; n < nframes; ++n) {
@ -642,12 +642,12 @@ Multi2dPanner::distribute (AudioBuffer& srcbuf, BufferSet& obufs, gain_t gain_co
return;
}
Sample* const src = srcbuf.data(nframes);
Sample* const src = srcbuf.data();
for (n = 0, o = parent.outputs.begin(); o != parent.outputs.end(); ++o, ++n) {
dst = obufs.get_audio(n).data(nframes);
dst = obufs.get_audio(n).data();
#ifdef CAN_INTERP
if (fabsf ((delta = (left_interp - desired_left))) > 0.002) { // about 1 degree of arc

12
libs/ardour/region.cc
View file

@ -50,7 +50,7 @@ Change Region::LayerChanged = ARDOUR::new_change ();
Change Region::HiddenChanged = ARDOUR::new_change ();
/** Basic Region constructor (single source) */
Region::Region (boost::shared_ptr<Source> src, jack_nframes_t start, jack_nframes_t length, const string& name, DataType type, layer_t layer, Region::Flag flags)
Region::Region (boost::shared_ptr<Source> src, nframes_t start, nframes_t length, const string& name, DataType type, layer_t layer, Region::Flag flags)
: _name(name)
, _type(type)
, _flags(flags)
@ -73,7 +73,7 @@ Region::Region (boost::shared_ptr<Source> src, jack_nframes_t start, jack_nframe
}
/** Basic Region constructor (many sources) */
Region::Region (SourceList& srcs, jack_nframes_t start, jack_nframes_t length, const string& name, DataType type, layer_t layer, Region::Flag flags)
Region::Region (SourceList& srcs, nframes_t start, nframes_t length, const string& name, DataType type, layer_t layer, Region::Flag flags)
: _name(name)
, _type(type)
, _flags(flags)
@ -1191,7 +1191,7 @@ Region::source_equivalent (boost::shared_ptr<const Region> other) const
}
bool
Region::verify_length (jack_nframes_t len)
Region::verify_length (nframes_t len)
{
for (uint32_t n=0; n < _sources.size(); ++n) {
if (_start > _sources[n]->length() - len) {
@ -1202,7 +1202,7 @@ Region::verify_length (jack_nframes_t len)
}
bool
Region::verify_start_and_length (jack_nframes_t new_start, jack_nframes_t new_length)
Region::verify_start_and_length (nframes_t new_start, nframes_t new_length)
{
for (uint32_t n=0; n < _sources.size(); ++n) {
if (new_length > _sources[n]->length() - new_start) {
@ -1212,7 +1212,7 @@ Region::verify_start_and_length (jack_nframes_t new_start, jack_nframes_t new_le
return true;
}
bool
Region::verify_start (jack_nframes_t pos)
Region::verify_start (nframes_t pos)
{
for (uint32_t n=0; n < _sources.size(); ++n) {
if (pos > _sources[n]->length() - _length) {
@ -1223,7 +1223,7 @@ Region::verify_start (jack_nframes_t pos)
}
bool
Region::verify_start_mutable (jack_nframes_t& new_start)
Region::verify_start_mutable (nframes_t& new_start)
{
for (uint32_t n=0; n < _sources.size(); ++n) {
if (new_start > _sources[n]->length() - _length) {

8
libs/ardour/route.cc
View file

@ -459,7 +459,7 @@ Route::process_output_buffers (BufferSet& bufs,
if (_phase_invert) {
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
Sample* const sp = i->data(nframes);
Sample* const sp = i->data();
for (nframes_t nx = 0; nx < nframes; ++nx) {
sp[nx] *= -gab[nx];
@ -467,7 +467,7 @@ Route::process_output_buffers (BufferSet& bufs,
}
} else {
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
Sample* const sp = i->data(nframes);
Sample* const sp = i->data();
for (nframes_t nx = 0; nx < nframes; ++nx) {
sp[nx] *= gab[nx];
@ -505,7 +505,7 @@ Route::process_output_buffers (BufferSet& bufs,
}
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
Sample* const sp = i->data(nframes);
Sample* const sp = i->data();
apply_gain_to_buffer(sp,nframes,this_gain);
}
@ -699,7 +699,7 @@ Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes,
}
void
Route::passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter)
Route::passthru_silence (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter)
{
process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, offset, true, declick, meter);
}

4
libs/ardour/session.cc
View file

@ -1380,7 +1380,7 @@ Session::set_frame_rate (nframes_t frames_per_second)
sync_time_vars();
Route::set_automation_interval ((jack_nframes_t) ceil ((double) frames_per_second * 0.25));
Route::set_automation_interval ((nframes_t) ceil ((double) frames_per_second * 0.25));
// XXX we need some equivalent to this, somehow
// SndFileSource::setup_standard_crossfades (frames_per_second);
@ -4097,7 +4097,7 @@ Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t le
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
if (afs) {
if (afs->write (buffers.get_audio(n).data(this_chunk), this_chunk) != this_chunk) {
if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
goto out;
}
}

4
libs/ardour/session_click.cc
View file

@ -53,10 +53,10 @@ Session::click (nframes_t start, nframes_t nframes, nframes_t offset)
return;
}
const jack_nframes_t end = start + (jack_nframes_t)floor(nframes * _transport_speed);
const nframes_t end = start + (nframes_t)floor(nframes * _transport_speed);
BufferSet& bufs = get_scratch_buffers(ChanCount(DataType::AUDIO, 1));
buf = bufs.get_audio(0).data(nframes);
buf = bufs.get_audio(0).data();
points = _tempo_map->get_points (start, end);
if (points == 0) {

2
libs/ardour/session_export.cc
View file

@ -589,7 +589,7 @@ Session::process_export (nframes_t nframes, AudioExportSpecification* spec)
cerr << "FIXME: Non-audio export" << endl;
continue;
}
Sample* port_buffer = port->get_audio_buffer().data(nframes);
Sample* port_buffer = port->get_audio_buffer().data();
/* now interleave the data from the channel into the float buffer */

12
libs/ardour/session_midi.cc
View file

@ -763,7 +763,7 @@ Session::change_midi_ports ()
* have been called with the appropriate nframes parameter this cycle.
*/
int
Session::send_full_time_code(jack_nframes_t nframes)
Session::send_full_time_code(nframes_t nframes)
{
/* This function could easily send at a given frame offset, but would
* that be useful? Does ardour do sub-block accurate locating? [DR] */
@ -787,7 +787,7 @@ Session::send_full_time_code(jack_nframes_t nframes)
if (((mtc_smpte_bits >> 5) != MIDI::MTC_25_FPS) && (transmitting_smpte_time.frames % 2)) {
// start MTC quarter frame transmission on an even frame
SMPTE::increment( transmitting_smpte_time );
outbound_mtc_smpte_frame += (jack_nframes_t) _frames_per_smpte_frame;
outbound_mtc_smpte_frame += (nframes_t) _frames_per_smpte_frame;
}
// Compensate for audio latency
@ -828,7 +828,7 @@ Session::send_full_time_code(jack_nframes_t nframes)
* earlier already this cycle by send_full_time_code)
*/
int
Session::send_midi_time_code_for_cycle(jack_nframes_t nframes)
Session::send_midi_time_code_for_cycle(nframes_t nframes)
{
assert (next_quarter_frame_to_send >= 0);
assert (next_quarter_frame_to_send <= 7);
@ -845,7 +845,7 @@ Session::send_midi_time_code_for_cycle(jack_nframes_t nframes)
}
/* Duration of one quarter frame */
jack_nframes_t quarter_frame_duration = ((long) _frames_per_smpte_frame) >> 2;
nframes_t quarter_frame_duration = ((long) _frames_per_smpte_frame) >> 2;
//cerr << "(MTC) TR: " << _transport_frame << " - SF: " << outbound_mtc_smpte_frame
//<< " - NQ: " << next_quarter_frame_to_send << " - FD" << quarter_frame_duration << endl;
@ -888,14 +888,14 @@ Session::send_midi_time_code_for_cycle(jack_nframes_t nframes)
break;
}
const jack_nframes_t msg_time = (outbound_mtc_smpte_frame
const nframes_t msg_time = (outbound_mtc_smpte_frame
+ (quarter_frame_duration * next_quarter_frame_to_send));
// This message must fall within this block or something is broken
assert(msg_time >= _transport_frame);
assert(msg_time < _transport_frame + nframes);
jack_nframes_t out_stamp = msg_time - _transport_frame;
nframes_t out_stamp = msg_time - _transport_frame;
assert(out_stamp < nframes);
if (!_mtc_port->midimsg (mtc_msg, 2, out_stamp)) {

8
libs/ardour/session_process.cc
View file

@ -130,8 +130,8 @@ Session::process_routes (nframes_t nframes, nframes_t offset)
record_active = actively_recording(); // || (get_record_enabled() && get_punch_in());
const jack_nframes_t start_frame = _transport_frame;
const jack_nframes_t end_frame = _transport_frame + (jack_nframes_t)floor(nframes * _transport_speed);
const nframes_t start_frame = _transport_frame;
const nframes_t end_frame = _transport_frame + (nframes_t)floor(nframes * _transport_speed);
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
@ -176,8 +176,8 @@ Session::silent_process_routes (nframes_t nframes, nframes_t offset)
declick = -1;
}
const jack_nframes_t start_frame = _transport_frame;
const jack_nframes_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
const nframes_t start_frame = _transport_frame;
const nframes_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {

14
libs/ardour/smf_source.cc
View file

@ -163,7 +163,7 @@ SMFSource::open()
}
int
SMFSource::update_header (jack_nframes_t when, struct tm&, time_t)
SMFSource::update_header (nframes_t when, struct tm&, time_t)
{
_timeline_position = when;
return flush_header();
@ -220,7 +220,7 @@ SMFSource::flush_footer()
*/
/*
long
SMFSource::find_first_event_after(jack_nframes_t start)
SMFSource::find_first_event_after(nframes_t start)
{
// FIXME: obviously this is slooow
@ -287,12 +287,12 @@ SMFSource::read_event(MidiEvent& ev) const
return ev.size;
}
jack_nframes_t
SMFSource::read_unlocked (MidiRingBuffer& dst, jack_nframes_t start, jack_nframes_t cnt, jack_nframes_t stamp_offset) const
nframes_t
SMFSource::read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const
{
//cerr << "SMF - read " << start << ", count=" << cnt << ", offset=" << stamp_offset << endl;
jack_nframes_t time = 0;
nframes_t time = 0;
// FIXME: ugh
unsigned char ev_buf[MidiBuffer::max_event_size()];
@ -334,8 +334,8 @@ SMFSource::read_unlocked (MidiRingBuffer& dst, jack_nframes_t start, jack_nframe
return cnt;
}
jack_nframes_t
SMFSource::write_unlocked (MidiRingBuffer& src, jack_nframes_t cnt)
nframes_t
SMFSource::write_unlocked (MidiRingBuffer& src, nframes_t cnt)
{
//cerr << "SMF WRITE -- " << _length << "--" << cnt << endl;

2
libs/ardour/source.cc
View file

@ -122,7 +122,7 @@ Source::set_state (const XMLNode& node)
}
void
Source::update_length (jack_nframes_t pos, jack_nframes_t cnt)
Source::update_length (nframes_t pos, nframes_t cnt)
{
if (pos + cnt > _length) {
_length = pos+cnt;