for (std::list<ARDOUR::AudioRange>::iterator j = ts.begin(); j != ts.end(); ++j) {
- jack_nframes_t i = 0;
+ nframes_t i = 0;
int n;
while ( i < (*j).length() ) {
continue;
// cerr << " - " << (*j)->region().name() << ": " << (*j)->region().length() << " samples starting at " << (*j)->region().position() << endl;
- jack_nframes_t i = 0;
+ nframes_t i = 0;
int n;
while ( i < arv->region()->length() ) {
sigc::signal<void,bool> ARDOUR_UI::Blink;
sigc::signal<void> ARDOUR_UI::RapidScreenUpdate;
sigc::signal<void> ARDOUR_UI::SuperRapidScreenUpdate;
-sigc::signal<void,jack_nframes_t> ARDOUR_UI::Clock;
+sigc::signal<void,nframes_t> ARDOUR_UI::Clock;
ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[], string rcfile)
}
void
-ARDOUR_UI::update_sample_rate (jack_nframes_t ignored)
+ARDOUR_UI::update_sample_rate (nframes_t ignored)
{
char buf[32];
} else {
- jack_nframes_t rate = engine->frame_rate();
+ nframes_t rate = engine->frame_rate();
if (fmod (rate, 1000.0) != 0.0) {
snprintf (buf, sizeof (buf), _("%.1f kHz / %4.1f msecs"),
return;
}
- jack_nframes_t frames = session->available_capture_duration();
+ nframes_t frames = session->available_capture_duration();
char buf[64];
if (frames == max_frames) {
int hrs;
int mins;
int secs;
- jack_nframes_t fr = session->frame_rate();
+ nframes_t fr = session->frame_rate();
if (session->actively_recording()){
}
void
-ARDOUR_UI::do_transport_locate (jack_nframes_t new_position)
+ARDOUR_UI::do_transport_locate (nframes_t new_position)
{
- jack_nframes_t _preroll = 0;
+ nframes_t _preroll = 0;
if (session) {
// XXX CONFIG_CHANGE FIX - requires AnyTime handling
ARDOUR_UI::transport_goto_end ()
{
if (session) {
- jack_nframes_t frame = session->current_end_frame();
+ nframes_t frame = session->current_end_frame();
session->request_locate (frame);
/* force displayed area in editor to start no matter
AutoConnectOption output_connect,
uint32_t nphysin,
uint32_t nphysout,
- jack_nframes_t initial_length)
+ nframes_t initial_length)
{
Session *new_session;
int x;
}
void
-ARDOUR_UI::set_jack_buffer_size (jack_nframes_t nframes)
+ARDOUR_UI::set_jack_buffer_size (nframes_t nframes)
{
engine->request_buffer_size (nframes);
update_sample_rate (0);
ARDOUR::AutoConnectOption output_connect,
uint32_t nphysin,
uint32_t nphysout,
- jack_nframes_t initial_length);
+ nframes_t initial_length);
bool session_is_new() const { return _session_is_new; }
ARDOUR::Session* the_session() { return session; }
static sigc::signal<void,bool> Blink;
static sigc::signal<void> RapidScreenUpdate;
static sigc::signal<void> SuperRapidScreenUpdate;
- static sigc::signal<void,jack_nframes_t> Clock;
+ static sigc::signal<void,nframes_t> Clock;
/* this is a helper function to centralize the (complex) logic for
blinking rec-enable buttons.
void save_ardour_state ();
gboolean configure_handler (GdkEventConfigure* conf);
- void do_transport_locate (jack_nframes_t position);
+ void do_transport_locate (nframes_t position);
void halt_on_xrun_message ();
AudioClock primary_clock;
Gtk::Label sample_rate_label;
Gtk::EventBox sample_rate_box;
- void update_sample_rate (jack_nframes_t);
+ void update_sample_rate (nframes_t);
gint every_second ();
gint every_point_one_seconds ();
void disconnect_from_jack ();
void reconnect_to_jack ();
- void set_jack_buffer_size (jack_nframes_t);
+ void set_jack_buffer_size (nframes_t);
Gtk::MenuItem* jack_disconnect_item;
Gtk::MenuItem* jack_reconnect_item;
RadioAction::Group jack_latency_group;
- act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency32"), X_("32"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 32));
+ act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency32"), X_("32"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 32));
ActionManager::jack_sensitive_actions.push_back (act);
- act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency64"), X_("64"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 64));
+ act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency64"), X_("64"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 64));
ActionManager::jack_sensitive_actions.push_back (act);
- act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency128"), X_("128"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 128));
+ act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency128"), X_("128"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 128));
ActionManager::jack_sensitive_actions.push_back (act);
- act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency256"), X_("256"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 256));
+ act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency256"), X_("256"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 256));
ActionManager::jack_sensitive_actions.push_back (act);
- act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency512"), X_("512"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 512));
+ act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency512"), X_("512"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 512));
ActionManager::jack_sensitive_actions.push_back (act);
- act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency1024"), X_("1024"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 1024));
+ act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency1024"), X_("1024"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 1024));
ActionManager::jack_sensitive_actions.push_back (act);
- act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency2048"), X_("2048"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 2048));
+ act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency2048"), X_("2048"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 2048));
ActionManager::jack_sensitive_actions.push_back (act);
- act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency4096"), X_("4096"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 4096));
+ act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency4096"), X_("4096"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 4096));
ActionManager::jack_sensitive_actions.push_back (act);
- act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency8192"), X_("8192"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (jack_nframes_t) 8192));
+ act = ActionManager::register_radio_action (jack_actions, jack_latency_group, X_("JACKLatency8192"), X_("8192"), bind (mem_fun(*this, &ARDOUR_UI::set_jack_buffer_size), (nframes_t) 8192));
ActionManager::jack_sensitive_actions.push_back (act);
/* these actions are intended to be shared across all windows */
}
void
-AudioClock::set (jack_nframes_t when, bool force)
+AudioClock::set (nframes_t when, bool force)
{
if ((!force && !is_visible()) || session == 0) {
void
AudioClock::smpte_offset_changed ()
{
- jack_nframes_t current;
+ nframes_t current;
switch (_mode) {
case SMPTE:
}
void
-AudioClock::set_frames (jack_nframes_t when, bool force)
+AudioClock::set_frames (nframes_t when, bool force)
{
char buf[32];
snprintf (buf, sizeof (buf), "%u", when);
}
void
-AudioClock::set_minsec (jack_nframes_t when, bool force)
+AudioClock::set_minsec (nframes_t when, bool force)
{
char buf[32];
- jack_nframes_t left;
+ nframes_t left;
int hrs;
int mins;
float secs;
left = when;
hrs = (int) floor (left / (session->frame_rate() * 60.0f * 60.0f));
- left -= (jack_nframes_t) floor (hrs * session->frame_rate() * 60.0f * 60.0f);
+ left -= (nframes_t) floor (hrs * session->frame_rate() * 60.0f * 60.0f);
mins = (int) floor (left / (session->frame_rate() * 60.0f));
- left -= (jack_nframes_t) floor (mins * session->frame_rate() * 60.0f);
+ left -= (nframes_t) floor (mins * session->frame_rate() * 60.0f);
secs = left / (float) session->frame_rate();
if (force || hrs != ms_last_hrs) {
}
void
-AudioClock::set_smpte (jack_nframes_t when, bool force)
+AudioClock::set_smpte (nframes_t when, bool force)
{
char buf[32];
SMPTE::Time smpte;
}
void
-AudioClock::set_bbt (jack_nframes_t when, bool force)
+AudioClock::set_bbt (nframes_t when, bool force)
{
char buf[16];
BBT_Time bbt;
{
if (session == 0) return FALSE;
- jack_nframes_t frames = 0;
+ nframes_t frames = 0;
switch (ev->button) {
case 1:
{
if (session == 0) return FALSE;
- jack_nframes_t frames = 0;
+ nframes_t frames = 0;
switch (ev->direction) {
if (trunc(drag_accum) != 0) {
- jack_nframes_t frames;
- jack_nframes_t pos ;
+ nframes_t frames;
+ nframes_t pos ;
int dir;
dir = (drag_accum < 0 ? 1:-1);
pos = current_time();
if (frames != 0 && frames * drag_accum < current_time()) {
- set ((jack_nframes_t) floor (pos - drag_accum * frames), false); // minus because up is negative in computer-land
+ set ((nframes_t) floor (pos - drag_accum * frames), false); // minus because up is negative in computer-land
} else {
set (0 , false);
return TRUE;
}
-jack_nframes_t
-AudioClock::get_frames (Field field,jack_nframes_t pos,int dir)
+nframes_t
+AudioClock::get_frames (Field field,nframes_t pos,int dir)
{
- jack_nframes_t frames = 0;
+ nframes_t frames = 0;
BBT_Time bbt;
switch (field) {
case SMPTE_Hours:
- frames = (jack_nframes_t) floor (3600.0 * session->frame_rate());
+ frames = (nframes_t) floor (3600.0 * session->frame_rate());
break;
case SMPTE_Minutes:
- frames = (jack_nframes_t) floor (60.0 * session->frame_rate());
+ frames = (nframes_t) floor (60.0 * session->frame_rate());
break;
case SMPTE_Seconds:
frames = session->frame_rate();
break;
case SMPTE_Frames:
- frames = (jack_nframes_t) floor (session->frame_rate() / Config->get_smpte_frames_per_second());
+ frames = (nframes_t) floor (session->frame_rate() / Config->get_smpte_frames_per_second());
break;
case AudioFrames:
break;
case MS_Hours:
- frames = (jack_nframes_t) floor (3600.0 * session->frame_rate());
+ frames = (nframes_t) floor (3600.0 * session->frame_rate());
break;
case MS_Minutes:
- frames = (jack_nframes_t) floor (60.0 * session->frame_rate());
+ frames = (nframes_t) floor (60.0 * session->frame_rate());
break;
case MS_Seconds:
frames = session->frame_rate();
return frames;
}
-jack_nframes_t
-AudioClock::current_time (jack_nframes_t pos) const
+nframes_t
+AudioClock::current_time (nframes_t pos) const
{
- jack_nframes_t ret = 0;
+ nframes_t ret = 0;
switch (_mode) {
case SMPTE:
return ret;
}
-jack_nframes_t
-AudioClock::current_duration (jack_nframes_t pos) const
+nframes_t
+AudioClock::current_duration (nframes_t pos) const
{
- jack_nframes_t ret = 0;
+ nframes_t ret = 0;
switch (_mode) {
case SMPTE:
}
}
-jack_nframes_t
+nframes_t
AudioClock::smpte_frame_from_display () const
{
if (session == 0) {
}
SMPTE::Time smpte;
- jack_nframes_t sample;
+ nframes_t sample;
smpte.hours = atoi (hours_label.get_text());
smpte.minutes = atoi (minutes_label.get_text());
// Testcode for smpte<->sample conversions (P.S.)
SMPTE::Time smpte1;
- jack_nframes_t sample1;
- jack_nframes_t oldsample = 0;
+ nframes_t sample1;
+ nframes_t oldsample = 0;
SMPTE::Time smpte2;
- jack_nframes_t sample_increment;
+ nframes_t sample_increment;
sample_increment = (long)rint(session->frame_rate() / session->smpte_frames_per_second);
return sample;
}
-jack_nframes_t
+nframes_t
AudioClock::minsec_frame_from_display () const
{
if (session == 0) {
int mins = atoi (ms_minutes_label.get_text());
float secs = atof (ms_seconds_label.get_text());
- jack_nframes_t sr = session->frame_rate();
+ nframes_t sr = session->frame_rate();
- return (jack_nframes_t) floor ((hrs * 60.0f * 60.0f * sr) + (mins * 60.0f * sr) + (secs * sr));
+ return (nframes_t) floor ((hrs * 60.0f * 60.0f * sr) + (mins * 60.0f * sr) + (secs * sr));
}
-jack_nframes_t
-AudioClock::bbt_frame_from_display (jack_nframes_t pos) const
+nframes_t
+AudioClock::bbt_frame_from_display (nframes_t pos) const
{
if (session == 0) {
error << "AudioClock::current_time() called with BBT mode but without session!" << endmsg;
any.bbt.beats = atoi (beats_label.get_text());
any.bbt.ticks = atoi (ticks_label.get_text());
- jack_nframes_t ret = session->convert_to_frames_at (pos, any);
+ nframes_t ret = session->convert_to_frames_at (pos, any);
return ret;
}
-jack_nframes_t
-AudioClock::bbt_frame_duration_from_display (jack_nframes_t pos) const
+nframes_t
+AudioClock::bbt_frame_duration_from_display (nframes_t pos) const
{
if (session == 0) {
error << "AudioClock::current_time() called with BBT mode but without session!" << endmsg;
return session->tempo_map().bbt_duration_at(pos,bbt,1);
}
-jack_nframes_t
+nframes_t
AudioClock::audio_frame_from_display () const
{
- return (jack_nframes_t) atoi (audio_frames_label.get_text());
+ return (nframes_t) atoi (audio_frames_label.get_text());
}
void
Mode mode() const { return _mode; }
- void set (jack_nframes_t, bool force = false);
+ void set (nframes_t, bool force = false);
void set_mode (Mode);
- jack_nframes_t current_time (jack_nframes_t position = 0) const;
- jack_nframes_t current_duration (jack_nframes_t position = 0) const;
+ nframes_t current_time (nframes_t position = 0) const;
+ nframes_t current_duration (nframes_t position = 0) const;
void set_session (ARDOUR::Session *s);
sigc::signal<void> ValueChanged;
Gtk::EventBox clock_base;
Gtk::Frame clock_frame;
- jack_nframes_t last_when;
+ nframes_t last_when;
uint32_t last_hrs;
uint32_t last_mins;
bool field_focus_in_event (GdkEventFocus *, Field);
bool field_focus_out_event (GdkEventFocus *, Field);
- void set_smpte (jack_nframes_t, bool);
- void set_bbt (jack_nframes_t, bool);
- void set_minsec (jack_nframes_t, bool);
- void set_frames (jack_nframes_t, bool);
+ void set_smpte (nframes_t, bool);
+ void set_bbt (nframes_t, bool);
+ void set_minsec (nframes_t, bool);
+ void set_frames (nframes_t, bool);
- jack_nframes_t get_frames (Field,jack_nframes_t pos = 0,int dir=1);
+ nframes_t get_frames (Field,nframes_t pos = 0,int dir=1);
void smpte_sanitize_display();
- jack_nframes_t smpte_frame_from_display () const;
- jack_nframes_t bbt_frame_from_display (jack_nframes_t) const;
- jack_nframes_t bbt_frame_duration_from_display (jack_nframes_t) const;
- jack_nframes_t minsec_frame_from_display () const;
- jack_nframes_t audio_frame_from_display () const;
+ nframes_t smpte_frame_from_display () const;
+ nframes_t bbt_frame_from_display (nframes_t) const;
+ nframes_t bbt_frame_duration_from_display (nframes_t) const;
+ nframes_t minsec_frame_from_display () const;
+ nframes_t audio_frame_from_display () const;
void build_ops_menu ();
void setup_events ();
void
AudioRegionEditor::length_clock_changed ()
{
- jack_nframes_t frames = length_clock.current_time();
+ nframes_t frames = length_clock.current_time();
_region->trim_end (_region->position() + frames, this);
length_clock.set (_region->length());
AudioRegionEditor::fade_in_changed ()
{
float msecs = fade_in_length_adjustment.get_value();
- jack_nframes_t sr = _session.frame_rate();
- jack_nframes_t adj_frames = (jack_nframes_t) floor (msecs * (sr/1000.0f));
- jack_nframes_t frames;
+ nframes_t sr = _session.frame_rate();
+ nframes_t adj_frames = (nframes_t) floor (msecs * (sr/1000.0f));
+ nframes_t frames;
bool x;
- if (adj_frames != (frames = (jack_nframes_t) _region->fade_in().back()->when)) {
+ if (adj_frames != (frames = (nframes_t) _region->fade_in().back()->when)) {
fade_in_length_adjustment.set_value ((frames * 1000.0f) / sr);
}
AudioRegionEditor::fade_out_changed ()
{
float msecs = fade_out_length_adjustment.get_value();
- jack_nframes_t sr = _session.frame_rate();
- jack_nframes_t adj_frames = (jack_nframes_t) floor (msecs * (sr/1000.0f));
- jack_nframes_t frames;
+ nframes_t sr = _session.frame_rate();
+ nframes_t adj_frames = (nframes_t) floor (msecs * (sr/1000.0f));
+ nframes_t frames;
bool x;
- if (adj_frames != (frames = (jack_nframes_t) _region->fade_out().back()->when)) {
+ if (adj_frames != (frames = (nframes_t) _region->fade_out().back()->when)) {
fade_out_length_adjustment.set_value ((frames * 1000.0f) / sr);
}
void
AudioRegionEditor::fade_in_length_adjustment_changed ()
{
- jack_nframes_t fade_length = (jack_nframes_t) floor (fade_in_length_adjustment.get_value() * _session.frame_rate() * 0.001);
- fade_length = max (fade_length, (jack_nframes_t) 64);
+ nframes_t fade_length = (nframes_t) floor (fade_in_length_adjustment.get_value() * _session.frame_rate() * 0.001);
+ fade_length = max (fade_length, (nframes_t) 64);
fade_length = min (fade_length, _region->length());
_region->set_fade_in_length (fade_length);
void
AudioRegionEditor::fade_out_length_adjustment_changed ()
{
- jack_nframes_t fade_length = (jack_nframes_t) floor (fade_out_length_adjustment.get_value() * _session.frame_rate() * 0.001);
- fade_length = max (fade_length, (jack_nframes_t) 64);
+ nframes_t fade_length = (nframes_t) floor (fade_out_length_adjustment.get_value() * _session.frame_rate() * 0.001);
+ fade_length = max (fade_length, (nframes_t) 64);
fade_length = min (fade_length, _region->length());
_region->set_fade_out_length (fade_length);
void
AudioRegionView::reset_fade_in_shape ()
{
- reset_fade_in_shape_width ((jack_nframes_t) audio_region()->fade_in().back()->when);
+ reset_fade_in_shape_width ((nframes_t) audio_region()->fade_in().back()->when);
}
void
-AudioRegionView::reset_fade_in_shape_width (jack_nframes_t width)
+AudioRegionView::reset_fade_in_shape_width (nframes_t width)
{
if (fade_in_handle == 0) {
return;
/* smallest size for a fade is 64 frames */
- width = std::max ((jack_nframes_t) 64, width);
+ width = std::max ((nframes_t) 64, width);
Points* points;
double pwidth = width / samples_per_unit;
void
AudioRegionView::reset_fade_out_shape ()
{
- reset_fade_out_shape_width ((jack_nframes_t) audio_region()->fade_out().back()->when);
+ reset_fade_out_shape_width ((nframes_t) audio_region()->fade_out().back()->when);
}
void
-AudioRegionView::reset_fade_out_shape_width (jack_nframes_t width)
+AudioRegionView::reset_fade_out_shape_width (nframes_t width)
{
if (fade_out_handle == 0) {
return;
/* smallest size for a fade is 64 frames */
- width = std::max ((jack_nframes_t) 64, width);
+ width = std::max ((nframes_t) 64, width);
Points* points;
double pwidth = width / samples_per_unit;
item->w2i (x, y);
- jack_nframes_t fx = trackview.editor.pixel_to_frame (x);
+ nframes_t fx = trackview.editor.pixel_to_frame (x);
if (fx > _region->length()) {
return;
GhostRegion* add_ghost (AutomationTimeAxisView&);
- void reset_fade_in_shape_width (jack_nframes_t);
- void reset_fade_out_shape_width (jack_nframes_t);
+ void reset_fade_in_shape_width (nframes_t);
+ void reset_fade_out_shape_width (nframes_t);
void set_fade_in_active (bool);
void set_fade_out_active (bool);
}
bool
-AudioRegionView::set_position (jack_nframes_t pos, void* src, double* ignored)
+AudioRegionView::set_position (nframes_t pos, void* src, double* ignored)
{
double delta;
bool ret;
void
AudioRegionView::reset_fade_in_shape ()
{
- reset_fade_in_shape_width ((jack_nframes_t) region.fade_in().back()->when);
+ reset_fade_in_shape_width ((nframes_t) region.fade_in().back()->when);
}
void
-AudioRegionView::reset_fade_in_shape_width (jack_nframes_t width)
+AudioRegionView::reset_fade_in_shape_width (nframes_t width)
{
if (fade_in_handle == 0) {
return;
/* smallest size for a fade is 64 frames */
- width = std::max ((jack_nframes_t) 64, width);
+ width = std::max ((nframes_t) 64, width);
Points* points;
double pwidth = width / samples_per_unit;
void
AudioRegionView::reset_fade_out_shape ()
{
- reset_fade_out_shape_width ((jack_nframes_t) region.fade_out().back()->when);
+ reset_fade_out_shape_width ((nframes_t) region.fade_out().back()->when);
}
void
-AudioRegionView::reset_fade_out_shape_width (jack_nframes_t width)
+AudioRegionView::reset_fade_out_shape_width (nframes_t width)
{
if (fade_out_handle == 0) {
return;
/* smallest size for a fade is 64 frames */
- width = std::max ((jack_nframes_t) 64, width);
+ width = std::max ((nframes_t) 64, width);
Points* points;
double pwidth = width / samples_per_unit;
}
bool
-AudioRegionView::set_duration (jack_nframes_t frames, void *src)
+AudioRegionView::set_duration (nframes_t frames, void *src)
{
if (!TimeAxisViewItem::set_duration (frames, src)) {
return false;
}
int sync_dir;
- jack_nframes_t sync_offset;
+ nframes_t sync_offset;
sync_offset = region.sync_offset (sync_dir);
item->w2i (x, y);
- jack_nframes_t fx = trackview.editor.pixel_to_frame (x);
+ nframes_t fx = trackview.editor.pixel_to_frame (x);
if (fx > region.length()) {
return;
// handle multi
- jack_nframes_t start = 0;
+ nframes_t start = 0;
if (rec_regions.size() > 0) {
start = rec_regions.back()->start() + _trackview.get_diskstream()->get_captured_frames(rec_regions.size()-1);
}
at = _trackview.audio_track(); /* we know what it is already */
boost::shared_ptr<AudioDiskstream> ds = at->audio_diskstream();
- jack_nframes_t frame_pos = ds->current_capture_start ();
+ nframes_t frame_pos = ds->current_capture_start ();
gdouble xstart = _trackview.editor.frame_to_pixel (frame_pos);
gdouble xend;
uint32_t fill_color;
}
void
-AudioStreamView::rec_peak_range_ready (jack_nframes_t start, jack_nframes_t cnt, boost::shared_ptr<Source> src)
+AudioStreamView::rec_peak_range_ready (nframes_t start, nframes_t cnt, boost::shared_ptr<Source> src)
{
// this is called from the peak building thread
continue;
}
- jack_nframes_t origlen = region->length();
+ nframes_t origlen = region->length();
if (region == rec_regions.back() && rec_active) {
if (last_rec_peak_frame > region->start()) {
- jack_nframes_t nlen = last_rec_peak_frame - region->start();
+ nframes_t nlen = last_rec_peak_frame - region->start();
if (nlen != region->length()) {
} else {
- jack_nframes_t nlen = _trackview.get_diskstream()->get_captured_frames(n);
+ nframes_t nlen = _trackview.get_diskstream()->get_captured_frames(n);
if (nlen != region->length()) {
private:
void setup_rec_box ();
- void rec_peak_range_ready (
jack_nframes_t start, jack_nframes_t cnt, boost::shared_ptr<ARDOUR::Source> src);
+ void rec_peak_range_ready (
nframes_t start, nframes_t cnt, boost::shared_ptr<ARDOUR::Source> src);
void update_rec_regions ();
void add_region_view_internal (boost::shared_ptr<ARDOUR::Region>, bool wait_for_waves);
bool crossfades_visible;
list<sigc::connection> peak_ready_connections;
- jack_nframes_t last_rec_peak_frame;
+ nframes_t last_rec_peak_frame;
map<boost::shared_ptr<ARDOUR::Source>, bool> rec_peak_ready_map;
};
line to convert them to something relevant.
*/
- mr.xval = (jack_nframes_t) floor (cp.get_x());
+ mr.xval = (nframes_t) floor (cp.get_x());
mr.yval = 1.0 - (cp.get_y() / _height);
/* if xval has not changed, set it directly from the model to avoid rounding errors */
if (mr.xval == trackview.editor.frame_to_unit((*cp.model)->when)) {
- mr.xval = (jack_nframes_t) (*cp.model)->when;
+ mr.xval = (nframes_t) (*cp.model)->when;
} else {
mr.xval = trackview.editor.unit_to_frame (mr.xval);
}
/* part 2: find out where the model point is now
*/
- mr.xpos = (jack_nframes_t) (*cp.model)->when;
+ mr.xpos = (nframes_t) (*cp.model)->when;
mr.ypos = (*cp.model)->value;
/* part 3: get the position of the visual control
after = nth (cp.view_index + 1);
if (before) {
- mr.xmin = (jack_nframes_t) (*before->model)->when;
+ mr.xmin = (nframes_t) (*before->model)->when;
mr.ymin = (*before->model)->value;
mr.start = before->model;
++mr.start;
}
void
-AutomationLine::point_drag (ControlPoint& cp, jack_nframes_t x, float fraction, bool with_push)
+AutomationLine::point_drag (ControlPoint& cp, nframes_t x, float fraction, bool with_push)
{
modify_view (cp, x, fraction, with_push);
drags++;
}
void
-AutomationLine::get_selectables (jack_nframes_t& start, jack_nframes_t& end,
+AutomationLine::get_selectables (nframes_t& start, nframes_t& end,
double botfrac, double topfrac, list<Selectable*>& results)
{
double top;
double bot;
- jack_nframes_t nstart;
- jack_nframes_t nend;
+ nframes_t nstart;
+ nframes_t nend;
bool collecting = false;
/* Curse X11 and its inverted coordinate system! */
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
- jack_nframes_t when = (jack_nframes_t) (*(*i)->model)->when;
+ nframes_t when = (nframes_t) (*(*i)->model)->when;
if (when >= start && when <= end) {
void
AutomationLine::change_model (AutomationList::iterator i, double x, double y)
{
- alist.modify (i, (jack_nframes_t) x, y);
+ alist.modify (i, (nframes_t) x, y);
}
void
void clear();
void set_selected_points (PointSelection&);
- void get_selectables (jack_nframes_t& start, jack_nframes_t& end,
+ void get_selectables (nframes_t& start, nframes_t& end,
double botfrac, double topfrac,
list<Selectable*>& results);
void get_inverted_selectables (Selection&, list<Selectable*>& results);
/* dragging API */
virtual void start_drag (ControlPoint*, float fraction);
- virtual void point_drag(ControlPoint&, jack_nframes_t x, float, bool with_push);
+ virtual void point_drag(ControlPoint&, nframes_t x, float, bool with_push);
virtual void end_drag (ControlPoint*);
virtual void line_drag(uint32_t i1, uint32_t i2, float, bool with_push);
struct ModelRepresentation {
ARDOUR::AutomationList::iterator start;
ARDOUR::AutomationList::iterator end;
- jack_nframes_t xpos;
+ nframes_t xpos;
double ypos;
- jack_nframes_t xmin;
+ nframes_t xmin;
double ymin;
- jack_nframes_t xmax;
+ nframes_t xmax;
double ymax;
- jack_nframes_t xval;
+ nframes_t xval;
double yval;
};
struct AutomationSelectable : public Selectable
{
- jack_nframes_t start;
- jack_nframes_t end;
+ nframes_t start;
+ nframes_t end;
double low_fract;
double high_fract;
TimeAxisView& track;
- AutomationSelectable (jack_nframes_t s, jack_nframes_t e, double l, double h, TimeAxisView& atv)
+ AutomationSelectable (nframes_t s, nframes_t e, double l, double h, TimeAxisView& atv)
: start (s), end (e), low_fract (l), high_fract (h), track (atv) {}
};
}
bool
-AutomationTimeAxisView::paste (jack_nframes_t pos, float times, Selection& selection, size_t nth)
+AutomationTimeAxisView::paste (nframes_t pos, float times, Selection& selection, size_t nth)
{
bool ret = true;
}
bool
-AutomationTimeAxisView::paste_one (AutomationLine& line, jack_nframes_t pos, float times, Selection& selection, size_t nth)
+AutomationTimeAxisView::paste_one (AutomationLine& line, nframes_t pos, float times, Selection& selection, size_t nth)
{
AutomationSelection::iterator p;
AutomationList& alist (line.the_list());
}
void
-AutomationTimeAxisView::get_selectables (jack_nframes_t start, jack_nframes_t end, double top, double bot, list<Selectable*>& results)
+AutomationTimeAxisView::get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& results)
{
if (!lines.empty() && touched (top, bot)) {
double topfrac;
void set_samples_per_unit (double);
std::string name() const { return _name; }
- virtual void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, jack_nframes_t, double) = 0;
+ virtual void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, nframes_t, double) = 0;
virtual void clear_lines ();
virtual void add_line (AutomationLine&);
vector<AutomationLine*> lines;
void set_selected_points (PointSelection&);
- void get_selectables (jack_nframes_t start, jack_nframes_t end, double top, double bot, list<Selectable *>&);
+ void get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable *>&);
void get_inverted_selectables (Selection&, list<Selectable*>& results);
- void show_timestretch (jack_nframes_t start, jack_nframes_t end) {}
+ void show_timestretch (nframes_t start, nframes_t end) {}
void hide_timestretch () {}
/* editing operations */
bool cut_copy_clear (Selection&, Editing::CutCopyOp);
bool cut_copy_clear_objects (PointSelection&, Editing::CutCopyOp);
- bool paste (jack_nframes_t, float times, Selection&, size_t nth);
+ bool paste (nframes_t, float times, Selection&, size_t nth);
void reset_objects (PointSelection&);
void add_ghost (GhostRegion*);
bool cut_copy_clear_one (AutomationLine&, Selection&, Editing::CutCopyOp);
bool cut_copy_clear_objects_one (AutomationLine&, PointSelection&, Editing::CutCopyOp);
- bool paste_one (AutomationLine&, jack_nframes_t, float times, Selection&, size_t nth);
+ bool paste_one (AutomationLine&, nframes_t, float times, Selection&, size_t nth);
void reset_objects_one (AutomationLine&, PointSelection&);
virtual void set_automation_state (ARDOUR::AutoState) = 0;
return;
}
- jack_nframes_t len = xfade.length ();
+ nframes_t len = xfade.length ();
fade[current].normative_curve.clear ();
fade[current].gain_curve.clear ();
CrossfadeEditor::audition_both ()
{
AudioPlaylist& pl (session.the_auditioner()->prepare_playlist());
- jack_nframes_t preroll;
- jack_nframes_t postroll;
- jack_nframes_t length;
- jack_nframes_t left_start_offset;
- jack_nframes_t right_length;
- jack_nframes_t left_length;
+ nframes_t preroll;
+ nframes_t postroll;
+ nframes_t length;
+ nframes_t left_start_offset;
+ nframes_t right_length;
+ nframes_t left_length;
if (preroll_button.get_active()) {
preroll = ARDOUR_UI::instance()->preroll_clock.current_duration ();
ArdourCanvas::Item* item;
ItemType item_type;
void* data;
- jack_nframes_t last_frame_position;
+ nframes_t last_frame_position;
int32_t pointer_frame_offset;
- jack_nframes_t grab_frame;
- jack_nframes_t last_pointer_frame;
- jack_nframes_t current_pointer_frame;
+ nframes_t grab_frame;
+ nframes_t last_pointer_frame;
+ nframes_t current_pointer_frame;
double grab_x, grab_y;
double cumulative_x_drag;
double cumulative_y_drag;
void
Editor::set_frames_per_unit (double fpu)
{
- jack_nframes_t frames;
+ nframes_t frames;
if (fpu == frames_per_unit) {
return;
// convert fpu to frame count
- frames = (jack_nframes_t) floor (fpu * canvas_width);
+ frames = (nframes_t) floor (fpu * canvas_width);
/* don't allow zooms that fit more than the maximum number
of frames into an 800 pixel wide space.
}
void
-Editor::reposition_x_origin (jack_nframes_t frame)
+Editor::reposition_x_origin (nframes_t frame)
{
if (frame != leftmost_frame) {
leftmost_frame = frame;
- jack_nframes_t rightmost_frame = leftmost_frame + current_page_frames ();
+ nframes_t rightmost_frame = leftmost_frame + current_page_frames ();
if (rightmost_frame > last_canvas_frame) {
last_canvas_frame = rightmost_frame;
if (fpu < 1.0) {
fpu = 1.0;
- zoom_range_clock.set ((jack_nframes_t) floor (fpu * canvas_width));
+ zoom_range_clock.set ((nframes_t) floor (fpu * canvas_width));
} else if (fpu > session->current_end_frame() / canvas_width) {
fpu = session->current_end_frame() / canvas_width;
- zoom_range_clock.set ((jack_nframes_t) floor (fpu * canvas_width));
+ zoom_range_clock.set ((nframes_t) floor (fpu * canvas_width));
}
temporal_zoom (fpu);
}
double step = fraction * current_page_frames();
- jack_nframes_t target;
+ nframes_t target;
- if ((fraction < 0.0f) && (session->transport_frame() < (jack_nframes_t) fabs(step))) {
+ if ((fraction < 0.0f) && (session->transport_frame() < (nframes_t) fabs(step))) {
target = 0;
} else if ((fraction > 0.0f) && (max_frames - session->transport_frame() < step)) {
target = (max_frames - (current_page_frames()*2)); // allow room for slop in where the PH is on the screen
} else {
- target = (session->transport_frame() + (jack_nframes_t) floor ((fraction * current_page_frames())));
+ target = (session->transport_frame() + (nframes_t) floor ((fraction * current_page_frames())));
}
/* move visuals, we'll catch up with it later */
}
bool
-Editor::deferred_control_scroll (jack_nframes_t target)
+Editor::deferred_control_scroll (nframes_t target)
{
session->request_locate (target);
return false;
Editor::canvas_horizontally_scrolled ()
{
- leftmost_frame = (jack_nframes_t) floor (horizontal_adjustment.get_value() * frames_per_unit);
+ leftmost_frame = (nframes_t) floor (horizontal_adjustment.get_value() * frames_per_unit);
update_fixed_rulers ();
tempo_map_changed (Change (0));
}
void
-Editor::reposition_and_zoom (jack_nframes_t frame, double nfpu)
+Editor::reposition_and_zoom (nframes_t frame, double nfpu)
{
if (!repos_zoom_queued) {
repos_zoom_queued = true;
}
gint
-Editor::deferred_reposition_and_zoom (jack_nframes_t frame, double nfpu)
+Editor::deferred_reposition_and_zoom (nframes_t frame, double nfpu)
{
set_frames_per_unit (nfpu);
}
void
-Editor::map_position_change (jack_nframes_t frame)
+Editor::map_position_change (nframes_t frame)
{
ENSURE_GUI_THREAD (bind (mem_fun(*this, &Editor::map_position_change), frame));
}
void
-Editor::center_screen (jack_nframes_t frame)
+Editor::center_screen (nframes_t frame)
{
double page = canvas_width * frames_per_unit;
}
void
-Editor::center_screen_internal (jack_nframes_t frame, float page)
+Editor::center_screen_internal (nframes_t frame, float page)
{
page /= 2;
if (frame > page) {
- frame -= (jack_nframes_t) page;
+ frame -= (nframes_t) page;
} else {
frame = 0;
}
{
ENSURE_GUI_THREAD (mem_fun (*this, &Editor::handle_new_duration));
- jack_nframes_t new_end = session->get_maximum_extent() + (jack_nframes_t) floorf (current_page_frames() * 0.10f);
+ nframes_t new_end = session->get_maximum_extent() + (nframes_t) floorf (current_page_frames() * 0.10f);
if (new_end > last_canvas_frame) {
last_canvas_frame = new_end;
}
void
-Editor::popup_track_context_menu (int button, int32_t time, ItemType item_type, bool with_selection, jack_nframes_t frame)
+Editor::popup_track_context_menu (int button, int32_t time, ItemType item_type, bool with_selection, nframes_t frame)
{
using namespace Menu_Helpers;
- Menu* (Editor::*build_menu_function)(jack_nframes_t);
+ Menu* (Editor::*build_menu_function)(nframes_t);
Menu *menu;
switch (item_type) {
}
Menu*
-Editor::build_track_context_menu (jack_nframes_t ignored)
+Editor::build_track_context_menu (nframes_t ignored)
{
using namespace Menu_Helpers;
}
Menu*
-Editor::build_track_bus_context_menu (jack_nframes_t ignored)
+Editor::build_track_bus_context_menu (nframes_t ignored)
{
using namespace Menu_Helpers;
}
Menu*
-Editor::build_track_region_context_menu (jack_nframes_t frame)
+Editor::build_track_region_context_menu (nframes_t frame)
{
using namespace Menu_Helpers;
MenuList& edit_items = track_region_context_menu.items();
Playlist* pl;
if ((ds = atv->get_diskstream()) && ((pl = ds->playlist()))) {
- Playlist::RegionList* regions = pl->regions_at ((jack_nframes_t) floor ( (double)frame * ds->speed()));
+ Playlist::RegionList* regions = pl->regions_at ((nframes_t) floor ( (double)frame * ds->speed()));
for (Playlist::RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
add_region_context_items (atv->audio_view(), (*i), edit_items);
}
}
Menu*
-Editor::build_track_crossfade_context_menu (jack_nframes_t frame)
+Editor::build_track_crossfade_context_menu (nframes_t frame)
{
using namespace Menu_Helpers;
MenuList& edit_items = track_crossfade_context_menu.items();
Menu*
-Editor::build_track_selection_context_menu (jack_nframes_t ignored)
+Editor::build_track_selection_context_menu (nframes_t ignored)
{
using namespace Menu_Helpers;
MenuList& edit_items = track_selection_context_menu.items();
}
void
-Editor::snap_to (jack_nframes_t& start, int32_t direction, bool for_mark)
+Editor::snap_to (nframes_t& start, int32_t direction, bool for_mark)
{
Location* before = 0;
Location* after = 0;
return;
}
- const jack_nframes_t one_second = session->frame_rate();
- const jack_nframes_t one_minute = session->frame_rate() * 60;
+ const nframes_t one_second = session->frame_rate();
+ const nframes_t one_minute = session->frame_rate() * 60;
- jack_nframes_t presnap = start;
+ nframes_t presnap = start;
switch (snap_type) {
case SnapToFrame:
case SnapToCDFrame:
if (direction) {
- start = (jack_nframes_t) ceil ((double) start / (one_second / 75)) * (one_second / 75);
+ start = (nframes_t) ceil ((double) start / (one_second / 75)) * (one_second / 75);
} else {
- start = (jack_nframes_t) floor ((double) start / (one_second / 75)) * (one_second / 75);
+ start = (nframes_t) floor ((double) start / (one_second / 75)) * (one_second / 75);
}
break;
case SnapToSMPTEFrame:
if (direction) {
- start = (jack_nframes_t) (ceil ((double) start / session->frames_per_smpte_frame()) * session->frames_per_smpte_frame());
+ start = (nframes_t) (ceil ((double) start / session->frames_per_smpte_frame()) * session->frames_per_smpte_frame());
} else {
- start = (jack_nframes_t) (floor ((double) start / session->frames_per_smpte_frame()) * session->frames_per_smpte_frame());
+ start = (nframes_t) (floor ((double) start / session->frames_per_smpte_frame()) * session->frames_per_smpte_frame());
}
break;
start -= session->smpte_offset ();
}
if (direction > 0) {
- start = (jack_nframes_t) ceil ((double) start / one_second) * one_second;
+ start = (nframes_t) ceil ((double) start / one_second) * one_second;
} else {
- start = (jack_nframes_t) floor ((double) start / one_second) * one_second;
+ start = (nframes_t) floor ((double) start / one_second) * one_second;
}
if (session->smpte_offset_negative())
start -= session->smpte_offset ();
}
if (direction) {
- start = (jack_nframes_t) ceil ((double) start / one_minute) * one_minute;
+ start = (nframes_t) ceil ((double) start / one_minute) * one_minute;
} else {
- start = (jack_nframes_t) floor ((double) start / one_minute) * one_minute;
+ start = (nframes_t) floor ((double) start / one_minute) * one_minute;
}
if (session->smpte_offset_negative())
{
case SnapToSeconds:
if (direction) {
- start = (jack_nframes_t) ceil ((double) start / one_second) * one_second;
+ start = (nframes_t) ceil ((double) start / one_second) * one_second;
} else {
- start = (jack_nframes_t) floor ((double) start / one_second) * one_second;
+ start = (nframes_t) floor ((double) start / one_second) * one_second;
}
break;
case SnapToMinutes:
if (direction) {
- start = (jack_nframes_t) ceil ((double) start / one_minute) * one_minute;
+ start = (nframes_t) ceil ((double) start / one_minute) * one_minute;
} else {
- start = (jack_nframes_t) floor ((double) start / one_minute) * one_minute;
+ start = (nframes_t) floor ((double) start / one_minute) * one_minute;
}
break;
case SnapToRegionSync:
case SnapToRegionBoundary:
if (!region_boundary_cache.empty()) {
- vector<jack_nframes_t>::iterator i;
+ vector<nframes_t>::iterator i;
if (direction > 0) {
i = std::upper_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start);
/* select this point and any others that it represents */
double y1, y2;
- jack_nframes_t x1, x2;
+ nframes_t x1, x2;
x1 = pixel_to_frame (clicked_control_point->get_x() - 10);
x2 = pixel_to_frame (clicked_control_point->get_x() + 10);
} else if (op == Selection::Extend) {
list<Selectable*> results;
- jack_nframes_t last_frame;
- jack_nframes_t first_frame;
+ nframes_t last_frame;
+ nframes_t first_frame;
/* 1. find the last selected regionview in the track that was clicked in */
return *_playlist_selector;
}
-jack_nframes_t
-Editor::get_nudge_distance (jack_nframes_t pos, jack_nframes_t& next)
+nframes_t
+Editor::get_nudge_distance (nframes_t pos, nframes_t& next)
{
- jack_nframes_t ret;
+ nframes_t ret;
ret = nudge_clock.current_duration (pos);
next = ret + 1; /* XXXX fix me */
}
bool
-Editor::audio_region_selection_covers (jack_nframes_t where)
+Editor::audio_region_selection_covers (nframes_t where)
{
for (RegionSelection::iterator a = selection->regions.begin(); a != selection->regions.end(); ++a) {
if ((*a)->region()->covers (where)) {
void connect_to_session (ARDOUR::Session *);
ARDOUR::Session* current_session() const { return session; }
- jack_nframes_t leftmost_position() const { return leftmost_frame; }
- jack_nframes_t current_page_frames() const {
- return (jack_nframes_t) floor (canvas_width * frames_per_unit);
+ nframes_t leftmost_position() const { return leftmost_frame; }
+ nframes_t current_page_frames() const {
+ return (nframes_t) floor (canvas_width * frames_per_unit);
}
void set_snap_to (Editing::SnapType);
void set_edit_menu (Gtk::Menu&);
- jack_nframes_t unit_to_frame (double unit) {
- return (jack_nframes_t) rint (unit * frames_per_unit);
+ nframes_t unit_to_frame (double unit) {
+ return (nframes_t) rint (unit * frames_per_unit);
}
- double frame_to_unit (jack_nframes_t frame) {
+ double frame_to_unit (nframes_t frame) {
return rint ((double) frame / (double) frames_per_unit);
}
xscroll_adjustment.
*/
- jack_nframes_t pixel_to_frame (double pixel) {
+ nframes_t pixel_to_frame (double pixel) {
/* pixel can be less than zero when motion events
are processed. since we've already run the world->canvas
*/
if (pixel >= 0) {
- return (jack_nframes_t) rint (pixel * frames_per_unit * GNOME_CANVAS(track_canvas.gobj())->pixels_per_unit);
+ return (nframes_t) rint (pixel * frames_per_unit * GNOME_CANVAS(track_canvas.gobj())->pixels_per_unit);
} else {
return 0;
}
}
- gulong frame_to_pixel (jack_nframes_t frame) {
+ gulong frame_to_pixel (nframes_t frame) {
return (gulong) rint ((frame / (frames_per_unit * GNOME_CANVAS(track_canvas.gobj())->pixels_per_unit)));
}
PlaylistSelector& playlist_selector() const;
void route_name_changed (TimeAxisView *);
gdouble frames_per_unit;
- jack_nframes_t leftmost_frame;
+ nframes_t leftmost_frame;
void clear_playlist (ARDOUR::Playlist&);
void new_playlists ();
bool new_regionviews_display_gain () { return _new_regionviews_show_envelope; }
void prepare_for_cleanup ();
- void reposition_x_origin (jack_nframes_t sample);
+ void reposition_x_origin (nframes_t sample);
void maximise_editing_space();
void restore_editing_space();
protected:
void map_transport_state ();
- void map_position_change (jack_nframes_t);
+ void map_position_change (nframes_t);
void on_realize();
void hide();
void show ();
void set_name (const string&);
- void set_position (jack_nframes_t start, jack_nframes_t end = 0);
+ void set_position (nframes_t start, nframes_t end = 0);
void set_color_rgba (uint32_t);
};
void hide_marker (ArdourCanvas::Item*, GdkEvent*);
void clear_marker_display ();
- void mouse_add_new_marker (jack_nframes_t where);
+ void mouse_add_new_marker (nframes_t where);
TimeAxisView* clicked_trackview;
AudioTimeAxisView* clicked_audio_trackview;
Gtk::Menu * track_edit_playlist_submenu;
Gtk::Menu * track_selection_edit_playlist_submenu;
- void popup_track_context_menu (int, int, ItemType, bool, jack_nframes_t);
- Gtk::Menu* build_track_context_menu (jack_nframes_t);
- Gtk::Menu* build_track_bus_context_menu (jack_nframes_t);
- Gtk::Menu* build_track_region_context_menu (jack_nframes_t frame);
- Gtk::Menu* build_track_crossfade_context_menu (jack_nframes_t);
- Gtk::Menu* build_track_selection_context_menu (jack_nframes_t);
+ void popup_track_context_menu (int, int, ItemType, bool, nframes_t);
+ Gtk::Menu* build_track_context_menu (nframes_t);
+ Gtk::Menu* build_track_bus_context_menu (nframes_t);
+ Gtk::Menu* build_track_region_context_menu (nframes_t frame);
+ Gtk::Menu* build_track_crossfade_context_menu (nframes_t);
+ Gtk::Menu* build_track_selection_context_menu (nframes_t);
void add_dstream_context_items (Gtk::Menu_Helpers::MenuList&);
void add_bus_context_items (Gtk::Menu_Helpers::MenuList&);
void add_region_context_items (AudioStreamView*, boost::shared_ptr<ARDOUR::Region>, Gtk::Menu_Helpers::MenuList&);
void update_just_smpte ();
void update_fixed_rulers ();
void update_tempo_based_rulers ();
- void popup_ruler_menu (jack_nframes_t where = 0, ItemType type = RegionItem);
+ void popup_ruler_menu (nframes_t where = 0, ItemType type = RegionItem);
void update_ruler_visibility ();
void ruler_toggled (int);
gint ruler_label_button_release (GdkEventButton*);
Editor& editor;
ArdourCanvas::Points points;
ArdourCanvas::Line canvas_item;
- jack_nframes_t current_frame;
+ nframes_t current_frame;
double length;
Cursor (Editor&, const string& color, bool (Editor::*)(GdkEvent*,ArdourCanvas::Item*));
~Cursor ();
- void set_position (jack_nframes_t);
+ void set_position (nframes_t);
void set_length (double units);
void set_y_axis (double position);
};
void select_all_selectables_using_cursor (Cursor *, bool);
void select_all_selectables_between_cursors (Cursor *, Cursor *);
- boost::shared_ptr<ARDOUR::Region> find_next_region (jack_nframes_t, ARDOUR::RegionPoint, int32_t dir, TrackViewList&, TimeAxisView ** = 0);
+ boost::shared_ptr<ARDOUR::Region> find_next_region (nframes_t, ARDOUR::RegionPoint, int32_t dir, TrackViewList&, TimeAxisView ** = 0);
- vector<jack_nframes_t> region_boundary_cache;
+ vector<nframes_t> region_boundary_cache;
void build_region_boundary_cache ();
Gtk::VBox trackview_vpacker;
double canvas_width;
double canvas_height;
- jack_nframes_t last_canvas_frame;
+ nframes_t last_canvas_frame;
bool track_canvas_map_handler (GdkEventAny*);
bool time_canvas_map_handler (GdkEventAny*);
Gtk::HBox edit_controls_hbox;
void control_scroll (float);
- bool deferred_control_scroll (jack_nframes_t);
+ bool deferred_control_scroll (nframes_t);
sigc::connection control_scroll_connection;
void tie_vertical_scrolling ();
void canvas_horizontally_scrolled ();
- void reposition_and_zoom (jack_nframes_t sample, double fpu);
- gint deferred_reposition_and_zoom (jack_nframes_t sample, double fpu);
+ void reposition_and_zoom (nframes_t sample, double fpu);
+ gint deferred_reposition_and_zoom (nframes_t sample, double fpu);
void end_location_changed (ARDOUR::Location*);
bool repos_zoom_queued;
static void build_cursors ();
sigc::connection scroll_connection;
- jack_nframes_t last_update_frame;
- void center_screen (jack_nframes_t);
- void center_screen_internal (jack_nframes_t, float);
+ nframes_t last_update_frame;
+ void center_screen (nframes_t);
+ void center_screen_internal (nframes_t, float);
void update_current_screen ();
void session_going_away ();
- jack_nframes_t cut_buffer_start;
- jack_nframes_t cut_buffer_length;
+ nframes_t cut_buffer_start;
+ nframes_t cut_buffer_length;
bool typed_event (ArdourCanvas::Item*, GdkEvent*, ItemType);
bool button_press_handler (ArdourCanvas::Item*, GdkEvent*, ItemType);
void register_actions ();
- int ensure_cursor (jack_nframes_t* pos);
+ int ensure_cursor (nframes_t* pos);
void handle_new_audio_region (boost::shared_ptr<ARDOUR::AudioRegion>);
void handle_audio_region_removed (boost::shared_ptr<ARDOUR::AudioRegion>);
void cut_copy_ranges (Editing::CutCopyOp);
void mouse_paste ();
- void paste_internal (jack_nframes_t position, float times);
+ void paste_internal (nframes_t position, float times);
/* EDITING OPERATIONS */
void lower_region ();
void lower_region_to_bottom ();
void split_region ();
- void split_region_at (jack_nframes_t);
- void split_regions_at (jack_nframes_t, RegionSelection&);
+ void split_region_at (nframes_t);
+ void split_regions_at (nframes_t, RegionSelection&);
void crop_region_to_selection ();
- void set_a_regions_sync_position (boost::shared_ptr<ARDOUR::Region>, jack_nframes_t);
+ void set_a_regions_sync_position (boost::shared_ptr<ARDOUR::Region>, nframes_t);
void set_region_sync_from_edit_cursor ();
void remove_region_sync();
- void align_selection (ARDOUR::RegionPoint, jack_nframes_t position);
- void align_selection_relative (ARDOUR::RegionPoint point, jack_nframes_t position);
- void align_region (boost::shared_ptr<ARDOUR::Region>, ARDOUR::RegionPoint point, jack_nframes_t position);
- void align_region_internal (boost::shared_ptr<ARDOUR::Region>, ARDOUR::RegionPoint point, jack_nframes_t position);
+ void align_selection (ARDOUR::RegionPoint, nframes_t position);
+ void align_selection_relative (ARDOUR::RegionPoint point, nframes_t position);
+ void align_region (boost::shared_ptr<ARDOUR::Region>, ARDOUR::RegionPoint point, nframes_t position);
+ void align_region_internal (boost::shared_ptr<ARDOUR::Region>, ARDOUR::RegionPoint point, nframes_t position);
void remove_some_regions ();
void remove_clicked_region ();
void destroy_clicked_region ();
void temporal_zoom_selection ();
void temporal_zoom_session ();
void temporal_zoom (gdouble scale);
- void temporal_zoom_by_frame (jack_nframes_t start, jack_nframes_t end, const string & op);
- void temporal_zoom_to_frame (bool coarser, jack_nframes_t frame);
+ void temporal_zoom_by_frame (nframes_t start, nframes_t end, const string & op);
+ void temporal_zoom_to_frame (bool coarser, nframes_t frame);
void amplitude_zoom (gdouble scale);
void amplitude_zoom_step (bool in);
void add_external_audio_action (Editing::ImportMode);
- void bring_in_external_audio (Editing::ImportMode mode, ARDOUR::AudioTrack*, jack_nframes_t& pos, bool prompt);
- void do_import (vector<Glib::ustring> paths, bool split, Editing::ImportMode mode, ARDOUR::AudioTrack*, jack_nframes_t&, bool);
- void do_embed (vector<Glib::ustring> paths, bool split, Editing::ImportMode mode, ARDOUR::AudioTrack*, jack_nframes_t&, bool);
- int import_sndfile (Glib::ustring path, Editing::ImportMode mode, ARDOUR::AudioTrack* track, jack_nframes_t& pos);
+ void bring_in_external_audio (Editing::ImportMode mode, ARDOUR::AudioTrack*, nframes_t& pos, bool prompt);
+ void do_import (vector<Glib::ustring> paths, bool split, Editing::ImportMode mode, ARDOUR::AudioTrack*, nframes_t&, bool);
+ void do_embed (vector<Glib::ustring> paths, bool split, Editing::ImportMode mode, ARDOUR::AudioTrack*, nframes_t&, bool);
+ int import_sndfile (Glib::ustring path, Editing::ImportMode mode, ARDOUR::AudioTrack* track, nframes_t& pos);
int embed_sndfile (Glib::ustring path, bool split, bool multiple_files, bool& check_sample_rate, Editing::ImportMode mode,
- ARDOUR::AudioTrack* track, jack_nframes_t& pos, bool prompt);
- int finish_bringing_in_audio (boost::shared_ptr<ARDOUR::AudioRegion> region, uint32_t, uint32_t, ARDOUR::AudioTrack* track, jack_nframes_t& pos, Editing::ImportMode mode);
+ ARDOUR::AudioTrack* track, nframes_t& pos, bool prompt);
+ int finish_bringing_in_audio (boost::shared_ptr<ARDOUR::AudioRegion> region, uint32_t, uint32_t, ARDOUR::AudioTrack* track, nframes_t& pos, Editing::ImportMode mode);
/* generic interthread progress window */
void keyboard_selection_begin ();
void keyboard_selection_finish (bool add);
bool have_pending_keyboard_selection;
- jack_nframes_t pending_keyboard_selection_start;
+ nframes_t pending_keyboard_selection_start;
boost::shared_ptr<ARDOUR::Region> select_region_for_operation (int dir, TimeAxisView **tv);
void extend_selection_to_end_of_region (bool next);
void remove_gain_control_point (ArdourCanvas::Item*, GdkEvent*);
void remove_control_point (ArdourCanvas::Item*, GdkEvent*);
- void mouse_brush_insert_region (RegionView*, jack_nframes_t pos);
- void brush (jack_nframes_t);
+ void mouse_brush_insert_region (RegionView*, nframes_t pos);
+ void brush (nframes_t);
- void show_verbose_time_cursor (jack_nframes_t frame, double offset = 0, double xpos=-1, double ypos=-1);
- void show_verbose_duration_cursor (jack_nframes_t start, jack_nframes_t end, double offset = 0, double xpos=-1, double ypos=-1);
+ void show_verbose_time_cursor (nframes_t frame, double offset = 0, double xpos=-1, double ypos=-1);
+ void show_verbose_duration_cursor (nframes_t start, nframes_t end, double offset = 0, double xpos=-1, double ypos=-1);
/* Canvas event handlers */
void new_tempo_section ();
- void mouse_add_new_tempo_event (jack_nframes_t where);
- void mouse_add_new_meter_event (jack_nframes_t where);
+ void mouse_add_new_tempo_event (nframes_t where);
+ void mouse_add_new_meter_event (nframes_t where);
void remove_tempo_marker (ArdourCanvas::Item*);
void remove_meter_marker (ArdourCanvas::Item*);
void tempo_map_changed (ARDOUR::Change);
void redisplay_tempo ();
- void snap_to (jack_nframes_t& first, int32_t direction = 0, bool for_mark = false);
+ void snap_to (nframes_t& first, int32_t direction = 0, bool for_mark = false);
uint32_t bbt_beat_subdivision;
/* toolbar */
void region_selection_op (void (ARDOUR::Region::*pmf)(void*), void*);
void region_selection_op (void (ARDOUR::Region::*pmf)(bool), bool);
- bool audio_region_selection_covers (jack_nframes_t where);
+ bool audio_region_selection_covers (nframes_t where);
/* transport range select process */
enum RangeMarkerOp {
void drag_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event);
void end_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event);
- bool select_all_within (jack_nframes_t start, jack_nframes_t end, gdouble topy, gdouble boty, Selection::Operation op);
+ bool select_all_within (nframes_t start, nframes_t end, gdouble topy, gdouble boty, Selection::Operation op);
ArdourCanvas::SimpleRect *rubberband_rect;
void end_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event);
ArdourCanvas::SimpleRect *zoom_rect;
- void reposition_zoom_rect (jack_nframes_t start, jack_nframes_t end);
+ void reposition_zoom_rect (nframes_t start, nframes_t end);
/* diskstream/route display management */
int autoscroll_timeout_tag;
int autoscroll_direction;
uint32_t autoscroll_cnt;
- jack_nframes_t autoscroll_distance;
+ nframes_t autoscroll_distance;
static gint _autoscroll_canvas (void *);
bool autoscroll_canvas ();
void start_trim (ArdourCanvas::Item*, GdkEvent*);
void point_trim (GdkEvent*);
void trim_motion_callback (ArdourCanvas::Item*, GdkEvent*);
- void single_contents_trim (RegionView&, jack_nframes_t, bool, bool, bool);
- void single_start_trim (RegionView&, jack_nframes_t, bool, bool);
- void single_end_trim (RegionView&, jack_nframes_t, bool, bool);
+ void single_contents_trim (RegionView&, nframes_t, bool, bool, bool);
+ void single_start_trim (RegionView&, nframes_t, bool, bool);
+ void single_end_trim (RegionView&, nframes_t, bool, bool);
void trim_finished_callback (ArdourCanvas::Item*, GdkEvent*);
void thaw_region_after_trim (RegionView& rv);
ExportDialog *export_dialog;
ExportDialog *export_range_markers_dialog;
- void export_range (jack_nframes_t start, jack_nframes_t end);
+ void export_range (nframes_t start, nframes_t end);
void export_range_markers ();
int write_region_selection(RegionSelection&);
Gtk::Menu* edit_menu;
bool edit_menu_map_handler (GdkEventAny*);
- jack_nframes_t event_frame (GdkEvent*, double* px = 0, double* py = 0);
+ nframes_t event_frame (GdkEvent*, double* px = 0, double* py = 0);
void time_fx_motion (ArdourCanvas::Item*, GdkEvent*);
void start_time_fx (ArdourCanvas::Item*, GdkEvent*);
Gtk::VBox nudge_vbox;
AudioClock nudge_clock;
- jack_nframes_t get_nudge_distance (jack_nframes_t pos, jack_nframes_t& next);
+ nframes_t get_nudge_distance (nframes_t pos, nframes_t& next);
/* audio filters */
void
Editor::add_external_audio_action (ImportMode mode)
{
- jack_nframes_t& pos = edit_cursor->current_frame;
+ nframes_t& pos = edit_cursor->current_frame;
AudioTrack* track = 0;
if (!selection->tracks.empty()) {
}
void
-Editor::bring_in_external_audio (ImportMode mode, AudioTrack* track, jack_nframes_t& pos, bool prompt)
+Editor::bring_in_external_audio (ImportMode mode, AudioTrack* track, nframes_t& pos, bool prompt)
{
if (session == 0) {
MessageDialog msg (0, _("You can't import or embed an audiofile until you have a session loaded."));
}
void
-Editor::do_import (vector<Glib::ustring> paths, bool split, ImportMode mode, AudioTrack* track, jack_nframes_t& pos, bool prompt)
+Editor::do_import (vector<Glib::ustring> paths, bool split, ImportMode mode, AudioTrack* track, nframes_t& pos, bool prompt)
{
/* SFDB sets "multichan" to true to indicate "split channels"
so reverse the setting to match the way libardour
}
void
-Editor::do_embed (vector<Glib::ustring> paths, bool split, ImportMode mode, AudioTrack* track, jack_nframes_t& pos, bool prompt)
+Editor::do_embed (vector<Glib::ustring> paths, bool split, ImportMode mode, AudioTrack* track, nframes_t& pos, bool prompt)
{
bool multiple_files = paths.size() > 1;
bool check_sample_rate = true;
}
int
-Editor::import_sndfile (Glib::ustring path, ImportMode mode, AudioTrack* track, jack_nframes_t& pos)
+Editor::import_sndfile (Glib::ustring path, ImportMode mode, AudioTrack* track, nframes_t& pos)
{
interthread_progress_window->set_title (string_compose (_("ardour: importing %1"), path));
interthread_progress_window->set_position (Gtk::WIN_POS_MOUSE);
int
Editor::embed_sndfile (Glib::ustring path, bool split, bool multiple_files, bool& check_sample_rate, ImportMode mode,
- AudioTrack* track, jack_nframes_t& pos, bool prompt)
+ AudioTrack* track, nframes_t& pos, bool prompt)
{
boost::shared_ptr<AudioFileSource> source;
SourceList sources;
}
int
-Editor::finish_bringing_in_audio (boost::shared_ptr<AudioRegion> region, uint32_t in_chans, uint32_t out_chans, AudioTrack* track, jack_nframes_t& pos, ImportMode mode)
+Editor::finish_bringing_in_audio (boost::shared_ptr<AudioRegion> region, uint32_t in_chans, uint32_t out_chans, AudioTrack* track, nframes_t& pos, ImportMode mode)
{
switch (mode) {
case ImportAsRegion:
return;
}
- jack_nframes_t start = selection->time[clicked_selection].start;
- jack_nframes_t end = selection->time[clicked_selection].end;
+ nframes_t start = selection->time[clicked_selection].start;
+ nframes_t end = selection->time[clicked_selection].end;
Location* loc = transport_loop_location();
using namespace Gtkmm2ext;
using namespace Editing;
-/* XXX this is a hack. it ought to be the maximum value of an jack_nframes_t */
+/* XXX this is a hack. it ought to be the maximum value of an nframes_t */
const double max_canvas_coordinate = (double) JACK_MAX_FRAMES;
canvas_width = alloc.get_width();
canvas_height = alloc.get_height();
- zoom_range_clock.set ((jack_nframes_t) floor ((canvas_width * frames_per_unit)));
+ zoom_range_clock.set ((nframes_t) floor ((canvas_width * frames_per_unit)));
edit_cursor->set_position (edit_cursor->current_frame);
playhead_cursor->set_position (playhead_cursor->current_frame);
vector<ustring> paths;
string spath;
GdkEvent ev;
- jack_nframes_t frame;
+ nframes_t frame;
if (convert_drop_to_paths (paths, context, x, y, data, info, time)) {
goto out;
/* drop onto canvas background: create new tracks */
- jack_nframes_t pos = 0;
+ nframes_t pos = 0;
do_embed (paths, false, ImportAsTrack, 0, pos, false);
} else if ((tv = dynamic_cast<AudioTimeAxisView*>(tvp)) != 0) {
void
Editor::maybe_autoscroll (GdkEvent* event)
{
- jack_nframes_t rightmost_frame = leftmost_frame + current_page_frames();
- jack_nframes_t frame = drag_info.current_pointer_frame;
+ nframes_t rightmost_frame = leftmost_frame + current_page_frames();
+ nframes_t frame = drag_info.current_pointer_frame;
bool startit = false;
static int last_autoscroll_direction = 0;
bool
Editor::autoscroll_canvas ()
{
- jack_nframes_t new_frame;
- jack_nframes_t limit = max_frames - current_page_frames();
+ nframes_t new_frame;
+ nframes_t limit = max_frames - current_page_frames();
GdkEventMotion ev;
- jack_nframes_t target_frame;
+ nframes_t target_frame;
if (autoscroll_direction < 0) {
if (leftmost_frame < autoscroll_distance) {
/* after about a while, speed up a bit by changing the timeout interval */
- autoscroll_distance = (jack_nframes_t) floor (current_page_frames()/30.0f);
+ autoscroll_distance = (nframes_t) floor (current_page_frames()/30.0f);
} else if (autoscroll_cnt == 150) { /* 1.0 seconds */
- autoscroll_distance = (jack_nframes_t) floor (current_page_frames()/20.0f);
+ autoscroll_distance = (nframes_t) floor (current_page_frames()/20.0f);
} else if (autoscroll_cnt == 300) { /* 1.5 seconds */
/* after about another while, speed up by increasing the shift per callback */
- autoscroll_distance = (jack_nframes_t) floor (current_page_frames()/10.0f);
+ autoscroll_distance = (nframes_t) floor (current_page_frames()/10.0f);
}
stop_canvas_autoscroll ();
autoscroll_direction = dir;
- autoscroll_distance = (jack_nframes_t) floor (current_page_frames()/50.0);
+ autoscroll_distance = (nframes_t) floor (current_page_frames()/50.0);
autoscroll_cnt = 0;
/* do it right now, which will start the repeated callbacks */
event.button.x = wx;
event.button.y = wy;
- jack_nframes_t where = event_frame (&event, 0, 0);
+ nframes_t where = event_frame (&event, 0, 0);
temporal_zoom_to_frame (true, where);
return true;
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) {
event.button.x = wx;
event.button.y = wy;
- jack_nframes_t where = event_frame (&event, 0, 0);
+ nframes_t where = event_frame (&event, 0, 0);
temporal_zoom_to_frame (false, where);
return true;
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::Shift)) {
}
void
-Editor::Cursor::set_position (jack_nframes_t frame)
+Editor::Cursor::set_position (nframes_t frame)
{
double new_pos = editor.frame_to_unit (frame);
}
void
-Editor::export_range (jack_nframes_t start, jack_nframes_t end)
+Editor::export_range (nframes_t start, nframes_t end)
{
if (session) {
if (export_dialog == 0) {
Editor::write_region (string path, boost::shared_ptr<AudioRegion> region)
{
boost::shared_ptr<AudioFileSource> fs;
- const jack_nframes_t chunk_size = 4096;
- jack_nframes_t to_read;
+ const nframes_t chunk_size = 4096;
+ nframes_t to_read;
Sample buf[chunk_size];
gain_t gain_buffer[chunk_size];
- jack_nframes_t pos;
+ nframes_t pos;
char s[PATH_MAX+1];
uint32_t cnt;
vector<boost::shared_ptr<AudioFileSource> > sources;
pos = region->position();
while (to_read) {
- jack_nframes_t this_time;
+ nframes_t this_time;
this_time = min (to_read, chunk_size);
Editor::write_audio_range (AudioPlaylist& playlist, uint32_t channels, list<AudioRange>& range)
{
boost::shared_ptr<AudioFileSource> fs;
- const jack_nframes_t chunk_size = 4096;
- jack_nframes_t nframes;
+ const nframes_t chunk_size = 4096;
+ nframes_t nframes;
Sample buf[chunk_size];
gain_t gain_buffer[chunk_size];
- jack_nframes_t pos;
+ nframes_t pos;
char s[PATH_MAX+1];
uint32_t cnt;
string path;
pos = (*i).start;
while (nframes) {
- jack_nframes_t this_time;
+ nframes_t this_time;
this_time = min (nframes, chunk_size);
while (nframes) {
- jack_nframes_t this_time = min (nframes, chunk_size);
+ nframes_t this_time = min (nframes, chunk_size);
memset (buf, 0, sizeof (Sample) * this_time);
for (uint32_t n=0; n < channels; ++n) {
Editor::scroll_timeaxis_to_imageframe_item(const TimeAxisViewItem* item)
{
// GTK2FIX
- //jack_nframes_t offset = static_cast<jack_nframes_t>(frames_per_unit * (edit_hscroll_slider_width/2)) ;
- jack_nframes_t offset = 0;
+ //nframes_t offset = static_cast<nframes_t>(frames_per_unit * (edit_hscroll_slider_width/2)) ;
+ nframes_t offset = 0;
- jack_nframes_t x_pos = 0 ;
+ nframes_t x_pos = 0 ;
if(item->get_position() < offset)
{
x_pos = 0 ;
double cx, cy ;
MarkerView* mv = reinterpret_cast<MarkerView*>(drag_info.data) ;
- jack_nframes_t pending_region_position ;
- jack_nframes_t pointer_frame ;
+ nframes_t pending_region_position ;
+ nframes_t pointer_frame ;
pointer_frame = event_frame(event, &cx, &cy) ;
snap_to(pointer_frame) ;
- if (pointer_frame > (jack_nframes_t) drag_info.pointer_frame_offset)
+ if (pointer_frame > (nframes_t) drag_info.pointer_frame_offset)
{
pending_region_position = pointer_frame - drag_info.pointer_frame_offset ;
snap_to(pending_region_position) ;
ImageFrameView* ifv = reinterpret_cast<ImageFrameView*>(drag_info.data) ;
- jack_nframes_t pending_region_position;
- jack_nframes_t pointer_frame;
+ nframes_t pending_region_position;
+ nframes_t pointer_frame;
pointer_frame = event_frame(event, &cx, &cy) ;
snap_to(pointer_frame) ;
- if (pointer_frame > (jack_nframes_t) drag_info.pointer_frame_offset)
+ if (pointer_frame > (nframes_t) drag_info.pointer_frame_offset)
{
pending_region_position = pointer_frame - drag_info.pointer_frame_offset ;
snap_to(pending_region_position) ;
void
Editor::timeaxis_item_drag_finished_callback(ArdourCanvas::Item*, GdkEvent* event)
{
- jack_nframes_t where ;
+ nframes_t where ;
TimeAxisViewItem* tavi = reinterpret_cast<TimeAxisViewItem*>(drag_info.data) ;
bool item_x_movement = (drag_info.last_frame_position != tavi->get_position()) ;
{
ImageFrameView* ifv = reinterpret_cast<ImageFrameView*> (drag_info.data) ;
- jack_nframes_t start = 0 ;
- jack_nframes_t end = 0 ;
- jack_nframes_t pointer_frame = event_frame(event) ;
+ nframes_t start = 0 ;
+ nframes_t end = 0 ;
+ nframes_t pointer_frame = event_frame(event) ;
// chekc th eposition of the item is not locked
if(!ifv->get_position_locked()) {
}
// are we getting bigger or smaller?
- jack_nframes_t new_dur_val = end - start ;
+ nframes_t new_dur_val = end - start ;
// start handle, so a smaller pointer frame increases our component size
if(pointer_frame <= drag_info.grab_frame)
}
else
{
- jack_nframes_t temp = ifv->get_position() + ifv->get_duration() ;
+ nframes_t temp = ifv->get_position() + ifv->get_duration() ;
- ifv->set_position((jack_nframes_t) (temp - drag_info.cumulative_x_drag), this) ;
- ifv->set_duration((jack_nframes_t) drag_info.cumulative_x_drag, this) ;
+ ifv->set_position((nframes_t) (temp - drag_info.cumulative_x_drag), this) ;
+ ifv->set_duration((nframes_t) drag_info.cumulative_x_drag, this) ;
}
}
{
ImageFrameView* ifv = reinterpret_cast<ImageFrameView *> (drag_info.data) ;
- jack_nframes_t start = 0 ;
- jack_nframes_t end = 0 ;
- jack_nframes_t pointer_frame = event_frame(event) ;
- jack_nframes_t new_dur_val = 0 ;
+ nframes_t start = 0 ;
+ nframes_t end = 0 ;
+ nframes_t pointer_frame = event_frame(event) ;
+ nframes_t new_dur_val = 0 ;
snap_to(pointer_frame) ;
}
else
{
- jack_nframes_t new_duration = (jack_nframes_t)drag_info.cumulative_x_drag ;
+ nframes_t new_duration = (nframes_t)drag_info.cumulative_x_drag ;
if((new_duration <= ifv->get_max_duration()) && (new_duration >= ifv->get_min_duration()))
{
ifv->set_duration(new_duration, this) ;
{
MarkerView* mv = reinterpret_cast<MarkerView*> (drag_info.data) ;
- jack_nframes_t start = 0 ;
- jack_nframes_t end = 0 ;
- jack_nframes_t pointer_frame = event_frame(event) ;
+ nframes_t start = 0 ;
+ nframes_t end = 0 ;
+ nframes_t pointer_frame = event_frame(event) ;
// chekc th eposition of the item is not locked
if(!mv->get_position_locked())
}
// are we getting bigger or smaller?
- jack_nframes_t new_dur_val = end - start ;
+ nframes_t new_dur_val = end - start ;
if(pointer_frame <= drag_info.grab_frame)
{
}
else
{
- jack_nframes_t temp = mv->get_position() + mv->get_duration() ;
+ nframes_t temp = mv->get_position() + mv->get_duration() ;
- mv->set_position((jack_nframes_t) (temp - drag_info.cumulative_x_drag), this) ;
- mv->set_duration((jack_nframes_t) drag_info.cumulative_x_drag, this) ;
+ mv->set_position((nframes_t) (temp - drag_info.cumulative_x_drag), this) ;
+ mv->set_duration((nframes_t) drag_info.cumulative_x_drag, this) ;
}
}
{
MarkerView* mv = reinterpret_cast<MarkerView*> (drag_info.data) ;
- jack_nframes_t start = 0 ;
- jack_nframes_t end = 0 ;
- jack_nframes_t pointer_frame = event_frame(event) ;
- jack_nframes_t new_dur_val = 0 ;
+ nframes_t start = 0 ;
+ nframes_t end = 0 ;
+ nframes_t pointer_frame = event_frame(event) ;
+ nframes_t new_dur_val = 0 ;
snap_to(pointer_frame) ;
{
// we cant extend beyond the item we are marking
ImageFrameView* marked_item = mv->get_marked_item() ;
- jack_nframes_t marked_end = marked_item->get_position() + marked_item->get_duration() ;
+ nframes_t marked_end = marked_item->get_position() + marked_item->get_duration() ;
if(mv->get_max_duration_active() && (new_dur_val > mv->get_max_duration()))
{
}
else
{
- jack_nframes_t new_duration = (jack_nframes_t)drag_info.cumulative_x_drag ;
+ nframes_t new_duration = (nframes_t)drag_info.cumulative_x_drag ;
mv->set_duration(new_duration, this) ;
}
}
void
Editor::kbd_do_split (GdkEvent* ev)
{
- jack_nframes_t where = event_frame (ev);
+ nframes_t where = event_frame (ev);
if (entered_regionview) {
if (selection->regions.find (entered_regionview) != selection->regions.end()) {
void
Editor::kbd_do_set_sync_position (GdkEvent* ev)
{
- jack_nframes_t where = event_frame (ev);
+ nframes_t where = event_frame (ev);
snap_to (where);
if (entered_regionview) {
}
void
-Editor::LocationMarkers::set_position (jack_nframes_t startf,
- jack_nframes_t endf)
+Editor::LocationMarkers::set_position (nframes_t startf,
+ nframes_t endf)
{
start->set_position (startf);
if (end) { end->set_position (endf); }
}
void
-Editor::mouse_add_new_marker (jack_nframes_t where)
+Editor::mouse_add_new_marker (nframes_t where)
{
if (session) {
Location *location = new Location (where, where, "mark", Location::IsMark);
{
if (session && engine.running()) {
- jack_nframes_t frame;
+ nframes_t frame;
frame = session->audible_frame();
using namespace Gtk;
using namespace Editing;
-jack_nframes_t
+nframes_t
Editor::event_frame (GdkEvent* event, double* pcx, double* pcy)
{
double cx, cy;
bool
Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
- jack_nframes_t where = event_frame (event, 0, 0);
+ nframes_t where = event_frame (event, 0, 0);
track_canvas.grab_focus();
bool
Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
- jack_nframes_t where = event_frame (event, 0, 0);
+ nframes_t where = event_frame (event, 0, 0);
/* no action if we're recording */
void
Editor::set_edit_cursor (GdkEvent* event)
{
- jack_nframes_t pointer_frame = event_frame (event);
+ nframes_t pointer_frame = event_frame (event);
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
if (snap_type != SnapToEditCursor) {
void
Editor::set_playhead_cursor (GdkEvent* event)
{
- jack_nframes_t pointer_frame = event_frame (event);
+ nframes_t pointer_frame = event_frame (event);
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
snap_to (pointer_frame);
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
- drag_info.pointer_frame_offset = drag_info.grab_frame - ((jack_nframes_t) arv->audio_region()->fade_in().back()->when + arv->region()->position());
+ drag_info.pointer_frame_offset = drag_info.grab_frame - ((nframes_t) arv->audio_region()->fade_in().back()->when + arv->region()->position());
}
void
Editor::fade_in_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
{
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
- jack_nframes_t pos;
- jack_nframes_t fade_length;
+ nframes_t pos;
+ nframes_t fade_length;
if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
if (drag_info.first_move) return;
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
- jack_nframes_t pos;
- jack_nframes_t fade_length;
+ nframes_t pos;
+ nframes_t fade_length;
if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
- drag_info.pointer_frame_offset = drag_info.grab_frame - (arv->region()->length() - (jack_nframes_t) arv->audio_region()->fade_out().back()->when + arv->region()->position());
+ drag_info.pointer_frame_offset = drag_info.grab_frame - (arv->region()->length() - (nframes_t) arv->audio_region()->fade_out().back()->when + arv->region()->position());
}
void
Editor::fade_out_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
{
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
- jack_nframes_t pos;
- jack_nframes_t fade_length;
+ nframes_t pos;
+ nframes_t fade_length;
if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
if (drag_info.first_move) return;
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
- jack_nframes_t pos;
- jack_nframes_t fade_length;
+ nframes_t pos;
+ nframes_t fade_length;
if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
pos = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
Editor::cursor_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
{
Cursor* cursor = (Cursor *) drag_info.data;
- jack_nframes_t adjusted_frame;
+ nframes_t adjusted_frame;
if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
void
Editor::marker_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
{
- jack_nframes_t f_delta;
+ nframes_t f_delta;
Marker* marker = (Marker *) drag_info.data;
Location *real_location;
Location *copy_location;
bool move_both = false;
- jack_nframes_t newframe;
+ nframes_t newframe;
if (drag_info.pointer_frame_offset <= (long) drag_info.current_pointer_frame) {
newframe = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
}
newframe = 0;
}
- jack_nframes_t next = newframe;
+ nframes_t next = newframe;
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
snap_to (newframe, 0, true);
Editor::meter_marker_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
{
MeterMarker* marker = (MeterMarker *) drag_info.data;
- jack_nframes_t adjusted_frame;
+ nframes_t adjusted_frame;
if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
Editor::tempo_marker_drag_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
{
TempoMarker* marker = (TempoMarker *) drag_info.data;
- jack_nframes_t adjusted_frame;
+ nframes_t adjusted_frame;
if ((long)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
adjusted_frame = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
cy = min ((double) cp->line.height(), cy);
//translate cx to frames
- jack_nframes_t cx_frames = unit_to_frame (cx);
+ nframes_t cx_frames = unit_to_frame (cx);
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier()) && !drag_info.x_constrained) {
snap_to (cx_frames);
{
double cx;
double cy;
- jack_nframes_t frame_within_region;
+ nframes_t frame_within_region;
/* need to get x coordinate in terms of parent (TimeAxisItemView)
origin.
cx = event->button.x;
cy = event->button.y;
line->parent_group().w2i (cx, cy);
- frame_within_region = (jack_nframes_t) floor (cx * frames_per_unit);
+ frame_within_region = (nframes_t) floor (cx * frames_per_unit);
if (!line->control_points_adjacent (frame_within_region, current_line_drag_info.before,
current_line_drag_info.after)) {
speed = tv->get_diskstream()->speed();
}
- drag_info.last_frame_position = (jack_nframes_t) (clicked_regionview->region()->position() / speed);
+ drag_info.last_frame_position = (nframes_t) (clicked_regionview->region()->position() / speed);
drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
drag_info.last_trackview = &clicked_regionview->get_time_axis_view();
// we want a move threshold
}
drag_info.last_trackview = &clicked_regionview->get_time_axis_view();
- drag_info.last_frame_position = (jack_nframes_t) (clicked_regionview->region()->position() / speed);
+ drag_info.last_frame_position = (nframes_t) (clicked_regionview->region()->position() / speed);
drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
// we want a move threshold
drag_info.want_move_threshold = true;
speed = tv->get_diskstream()->speed();
}
- drag_info.last_frame_position = (jack_nframes_t) (clicked_regionview->region()->position() / speed);
+ drag_info.last_frame_position = (nframes_t) (clicked_regionview->region()->position() / speed);
drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
drag_info.last_trackview = &clicked_regionview->get_time_axis_view();
// we want a move threshold
double x_delta;
double y_delta = 0;
RegionView* rv = reinterpret_cast<RegionView*> (drag_info.data);
- jack_nframes_t pending_region_position = 0;
+ nframes_t pending_region_position = 0;
int32_t pointer_y_span = 0, canvas_pointer_y_span = 0, original_pointer_order;
int32_t visible_y_high = 0, visible_y_low = 512; //high meaning higher numbered.. not the height on the screen
bool clamp_y_axis = false;
newregion->set_locked (false);
- to_playlist->add_region (newregion, (jack_nframes_t) (rv->region()->position() * atv->get_diskstream()->speed()));
+ to_playlist->add_region (newregion, (nframes_t) (rv->region()->position() * atv->get_diskstream()->speed()));
c.disconnect ();
if ((int32_t)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
- jack_nframes_t sync_frame;
- jack_nframes_t sync_offset;
+ nframes_t sync_frame;
+ nframes_t sync_offset;
int32_t sync_dir;
pending_region_position = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
void
Editor::region_drag_finished_callback (ArdourCanvas::Item* item, GdkEvent* event)
{
- jack_nframes_t where;
+ nframes_t where;
RegionView* rv = reinterpret_cast<RegionView *> (drag_info.data);
pair<set<Playlist*>::iterator,bool> insert_result;
bool nocommit = true;
speed = atv->get_diskstream()->speed();
}
- regionview_x_movement = (drag_info.last_frame_position != (jack_nframes_t) (rv->region()->position()/speed));
+ regionview_x_movement = (drag_info.last_frame_position != (nframes_t) (rv->region()->position()/speed));
regionview_y_movement = (drag_info.last_trackview != &rv->get_time_axis_view());
//printf ("last_frame: %s position is %lu %g\n", rv->get_time_axis_view().name().c_str(), drag_info.last_frame_position, speed);
latest_regionview = 0;
- where = (jack_nframes_t) (unit_to_frame (ix1) * speed);
+ where = (nframes_t) (unit_to_frame (ix1) * speed);
boost::shared_ptr<Region> new_region (RegionFactory::create ((*i)->region()));
from_playlist->remove_region (((*i)->region()));
rv->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
rv->get_canvas_group()->i2w (ix1, iy1);
- where = (jack_nframes_t) (unit_to_frame (ix1) * ownspeed);
+ where = (nframes_t) (unit_to_frame (ix1) * ownspeed);
} else {
if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Alt))) {
- align_region (rv.region(), SyncPoint, (jack_nframes_t) (edit_cursor->current_frame * speed));
+ align_region (rv.region(), SyncPoint, (nframes_t) (edit_cursor->current_frame * speed));
} else if (Keyboard::modifier_state_equals (event->state, Keyboard::ModifierMask (Keyboard::Control|Keyboard::Shift))) {
- align_region (rv.region(), End, (jack_nframes_t) (edit_cursor->current_frame * speed));
+ align_region (rv.region(), End, (nframes_t) (edit_cursor->current_frame * speed));
} else {
- align_region (rv.region(), Start, (jack_nframes_t) (edit_cursor->current_frame * speed));
+ align_region (rv.region(), Start, (nframes_t) (edit_cursor->current_frame * speed));
}
}
}
void
-Editor::show_verbose_time_cursor (jack_nframes_t frame, double offset, double xpos, double ypos)
+Editor::show_verbose_time_cursor (nframes_t frame, double offset, double xpos, double ypos)
{
char buf[128];
SMPTE::Time smpte;
}
void
-Editor::show_verbose_duration_cursor (jack_nframes_t start, jack_nframes_t end, double offset, double xpos, double ypos)
+Editor::show_verbose_duration_cursor (nframes_t start, nframes_t end, double offset, double xpos, double ypos)
{
char buf[128];
SMPTE::Time smpte;
void
Editor::start_selection_op (ArdourCanvas::Item* item, GdkEvent* event, SelectionOp op)
{
- jack_nframes_t start = 0;
- jack_nframes_t end = 0;
+ nframes_t start = 0;
+ nframes_t end = 0;
if (session == 0) {
return;
void
Editor::drag_selection (ArdourCanvas::Item* item, GdkEvent* event)
{
- jack_nframes_t start = 0;
- jack_nframes_t end = 0;
- jack_nframes_t length;
- jack_nframes_t pending_position;
+ nframes_t start = 0;
+ nframes_t end = 0;
+ nframes_t length;
+ nframes_t pending_position;
if ((int32_t) drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
pending_position = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
speed = tv->get_diskstream()->speed();
}
- jack_nframes_t region_start = (jack_nframes_t) (clicked_regionview->region()->position() / speed);
- jack_nframes_t region_end = (jack_nframes_t) (clicked_regionview->region()->last_frame() / speed);
- jack_nframes_t region_length = (jack_nframes_t) (clicked_regionview->region()->length() / speed);
+ nframes_t region_start = (nframes_t) (clicked_regionview->region()->position() / speed);
+ nframes_t region_end = (nframes_t) (clicked_regionview->region()->last_frame() / speed);
+ nframes_t region_length = (nframes_t) (clicked_regionview->region()->length() / speed);
motion_frozen_playlists.clear();
Editor::trim_motion_callback (ArdourCanvas::Item* item, GdkEvent* event)
{
RegionView* rv = clicked_regionview;
- jack_nframes_t frame_delta = 0;
+ nframes_t frame_delta = 0;
bool left_direction;
bool obey_snap = !Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier());
}
case EndTrim:
- if ((left_direction == true) && (drag_info.current_pointer_frame > (jack_nframes_t) (rv->region()->last_frame()/speed))) {
+ if ((left_direction == true) && (drag_info.current_pointer_frame > (nframes_t) (rv->region()->last_frame()/speed))) {
break;
} else {
for (list<RegionView*>::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) {
switch (trim_op) {
case StartTrim:
- show_verbose_time_cursor((jack_nframes_t) (rv->region()->position()/speed), 10);
+ show_verbose_time_cursor((nframes_t) (rv->region()->position()/speed), 10);
break;
case EndTrim:
- show_verbose_time_cursor((jack_nframes_t) (rv->region()->last_frame()/speed), 10);
+ show_verbose_time_cursor((nframes_t) (rv->region()->last_frame()/speed), 10);
break;
case ContentsTrim:
show_verbose_time_cursor(drag_info.current_pointer_frame, 10);
}
void
-Editor::single_contents_trim (RegionView& rv, jack_nframes_t frame_delta, bool left_direction, bool swap_direction, bool obey_snap)
+Editor::single_contents_trim (RegionView& rv, nframes_t frame_delta, bool left_direction, bool swap_direction, bool obey_snap)
{
boost::shared_ptr<Region> region (rv.region());
return;
}
- jack_nframes_t new_bound;
+ nframes_t new_bound;
double speed = 1.0;
TimeAxisView* tvp = clicked_trackview;
if (left_direction) {
if (swap_direction) {
- new_bound = (jack_nframes_t) (region->position()/speed) + frame_delta;
+ new_bound = (nframes_t) (region->position()/speed) + frame_delta;
} else {
- new_bound = (jack_nframes_t) (region->position()/speed) - frame_delta;
+ new_bound = (nframes_t) (region->position()/speed) - frame_delta;
}
} else {
if (swap_direction) {
- new_bound = (jack_nframes_t) (region->position()/speed) - frame_delta;
+ new_bound = (nframes_t) (region->position()/speed) - frame_delta;
} else {
- new_bound = (jack_nframes_t) (region->position()/speed) + frame_delta;
+ new_bound = (nframes_t) (region->position()/speed) + frame_delta;
}
}
if (obey_snap) {
snap_to (new_bound);
}
- region->trim_start ((jack_nframes_t) (new_bound * speed), this);
+ region->trim_start ((nframes_t) (new_bound * speed), this);
rv.region_changed (StartChanged);
}
void
-Editor::single_start_trim (RegionView& rv, jack_nframes_t frame_delta, bool left_direction, bool obey_snap)
+Editor::single_start_trim (RegionView& rv, nframes_t frame_delta, bool left_direction, bool obey_snap)
{
boost::shared_ptr<Region> region (rv.region());
return;
}
- jack_nframes_t new_bound;
+ nframes_t new_bound;
double speed = 1.0;
TimeAxisView* tvp = clicked_trackview;
}
if (left_direction) {
- new_bound = (jack_nframes_t) (region->position()/speed) - frame_delta;
+ new_bound = (nframes_t) (region->position()/speed) - frame_delta;
} else {
- new_bound = (jack_nframes_t) (region->position()/speed) + frame_delta;
+ new_bound = (nframes_t) (region->position()/speed) + frame_delta;
}
if (obey_snap) {
snap_to (new_bound, (left_direction ? 0 : 1));
}
- region->trim_front ((jack_nframes_t) (new_bound * speed), this);
+ region->trim_front ((nframes_t) (new_bound * speed), this);
rv.region_changed (Change (LengthChanged|PositionChanged|StartChanged));
}
void
-Editor::single_end_trim (RegionView& rv, jack_nframes_t frame_delta, bool left_direction, bool obey_snap)
+Editor::single_end_trim (RegionView& rv, nframes_t frame_delta, bool left_direction, bool obey_snap)
{
boost::shared_ptr<Region> region (rv.region());
return;
}
- jack_nframes_t new_bound;
+ nframes_t new_bound;
double speed = 1.0;
TimeAxisView* tvp = clicked_trackview;
}
if (left_direction) {
- new_bound = (jack_nframes_t) ((region->last_frame() + 1)/speed) - frame_delta;
+ new_bound = (nframes_t) ((region->last_frame() + 1)/speed) - frame_delta;
} else {
- new_bound = (jack_nframes_t) ((region->last_frame() + 1)/speed) + frame_delta;
+ new_bound = (nframes_t) ((region->last_frame() + 1)/speed) + frame_delta;
}
if (obey_snap) {
snap_to (new_bound);
}
- region->trim_end ((jack_nframes_t) (new_bound * speed), this);
+ region->trim_end ((nframes_t) (new_bound * speed), this);
rv.region_changed (LengthChanged);
}
Editor::point_trim (GdkEvent* event)
{
RegionView* rv = clicked_regionview;
- jack_nframes_t new_bound = drag_info.current_pointer_frame;
+ nframes_t new_bound = drag_info.current_pointer_frame;
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
snap_to (new_bound);
void
Editor::drag_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event)
{
- jack_nframes_t start = 0;
- jack_nframes_t end = 0;
+ nframes_t start = 0;
+ nframes_t end = 0;
ArdourCanvas::SimpleRect *crect = (range_marker_op == CreateRangeMarker) ? range_bar_drag_rect: transport_bar_drag_rect;
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
if (Keyboard::no_modifier_keys_pressed (&event->button)) {
- jack_nframes_t start;
- jack_nframes_t end;
+ nframes_t start;
+ nframes_t end;
start = session->locations()->first_mark_before (drag_info.grab_frame);
end = session->locations()->first_mark_after (drag_info.grab_frame);
void
Editor::drag_mouse_zoom (ArdourCanvas::Item* item, GdkEvent* event)
{
- jack_nframes_t start;
- jack_nframes_t end;
+ nframes_t start;
+ nframes_t end;
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
snap_to (drag_info.current_pointer_frame);
}
void
-Editor::reposition_zoom_rect (jack_nframes_t start, jack_nframes_t end)
+Editor::reposition_zoom_rect (nframes_t start, nframes_t end)
{
double x1 = frame_to_pixel (start);
double x2 = frame_to_pixel (end);
void
Editor::drag_rubberband_select (ArdourCanvas::Item* item, GdkEvent* event)
{
- jack_nframes_t start;
- jack_nframes_t end;
+ nframes_t start;
+ nframes_t end;
double y1;
double y2;
return;
}
- jack_nframes_t newlen = drag_info.last_pointer_frame - clicked_regionview->region()->position();
+ nframes_t newlen = drag_info.last_pointer_frame - clicked_regionview->region()->position();
float percentage = (float) ((double) newlen - (double) clicked_regionview->region()->length()) / ((double) newlen) * 100.0f;
begin_reversible_command (_("timestretch"));
}
void
-Editor::mouse_brush_insert_region (RegionView* rv, jack_nframes_t pos)
+Editor::mouse_brush_insert_region (RegionView* rv, nframes_t pos)
{
/* no brushing without a useful snap setting */
double speed = atv->get_diskstream()->speed();
XMLNode &before = playlist->get_state();
- playlist->add_region (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (arv->audio_region())), (jack_nframes_t) (pos * speed));
+ playlist->add_region (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (arv->audio_region())), (nframes_t) (pos * speed));
XMLNode &after = playlist->get_state();
session->add_command(new MementoCommand<Playlist>(*playlist, &before, &after));
}
int
-Editor::ensure_cursor (jack_nframes_t *pos)
+Editor::ensure_cursor (nframes_t *pos)
{
*pos = edit_cursor->current_frame;
return 0;
}
void
-Editor::split_region_at (jack_nframes_t where)
+Editor::split_region_at (nframes_t where)
{
split_regions_at (where, selection->regions);
}
void
-Editor::split_regions_at (jack_nframes_t where, RegionSelection& regions)
+Editor::split_regions_at (nframes_t where, RegionSelection& regions)
{
begin_reversible_command (_("split"));
{
RegionView* rv;
boost::shared_ptr<Region> region;
- jack_nframes_t start = 0;
+ nframes_t start = 0;
if (selection->time.start () == selection->time.end_frame ()) {
{
TimeAxisView *tv;
boost::shared_ptr<Region> region;
- jack_nframes_t start;
+ nframes_t start;
if ((region = select_region_for_operation (next ? 1 : 0, &tv)) == 0) {
return;
{
TimeAxisView *tv;
boost::shared_ptr<Region> region;
- jack_nframes_t end;
+ nframes_t end;
if ((region = select_region_for_operation (previous ? -1 : 0, &tv)) == 0) {
return;
void
Editor::nudge_forward (bool next)
{
- jack_nframes_t distance;
- jack_nframes_t next_distance;
+ nframes_t distance;
+ nframes_t next_distance;
if (!session) return;
void
Editor::nudge_backward (bool next)
{
- jack_nframes_t distance;
- jack_nframes_t next_distance;
+ nframes_t distance;
+ nframes_t next_distance;
if (!session) return;
void
Editor::nudge_forward_capture_offset ()
{
- jack_nframes_t distance;
+ nframes_t distance;
if (!session) return;
void
Editor::nudge_backward_capture_offset ()
{
- jack_nframes_t distance;
+ nframes_t distance;
if (!session) return;
void
Editor::build_region_boundary_cache ()
{
- jack_nframes_t pos = 0;
+ nframes_t pos = 0;
RegionPoint point;
boost::shared_ptr<Region> r;
TrackViewList tracks;
}
}
- jack_nframes_t rpos;
+ nframes_t rpos;
switch (snap_type) {
case SnapToRegionStart:
}
boost::shared_ptr<Region>
-Editor::find_next_region (jack_nframes_t frame, RegionPoint point, int32_t dir, TrackViewList& tracks, TimeAxisView **ontrack)
+Editor::find_next_region (nframes_t frame, RegionPoint point, int32_t dir, TrackViewList& tracks, TimeAxisView **ontrack)
{
TrackViewList::iterator i;
- jack_nframes_t closest = max_frames;
+ nframes_t closest = max_frames;
boost::shared_ptr<Region> ret;
- jack_nframes_t rpos = 0;
+ nframes_t rpos = 0;
float track_speed;
- jack_nframes_t track_frame;
+ nframes_t track_frame;
AudioTimeAxisView *atav;
for (i = tracks.begin(); i != tracks.end(); ++i) {
- jack_nframes_t distance;
+ nframes_t distance;
boost::shared_ptr<Region> r;
track_speed = 1.0f;
Editor::cursor_to_region_point (Cursor* cursor, RegionPoint point, int32_t dir)
{
boost::shared_ptr<Region> r;
- jack_nframes_t pos = cursor->current_frame;
+ nframes_t pos = cursor->current_frame;
if (!session) {
return;
void
Editor::cursor_to_selection_start (Cursor *cursor)
{
- jack_nframes_t pos = 0;
+ nframes_t pos = 0;
switch (mouse_mode) {
case MouseObject:
if (!selection->regions.empty()) {
void
Editor::cursor_to_selection_end (Cursor *cursor)
{
- jack_nframes_t pos = 0;
+ nframes_t pos = 0;
switch (mouse_mode) {
case MouseObject:
void
Editor::playhead_backward ()
{
- jack_nframes_t pos;
- jack_nframes_t cnt;
+ nframes_t pos;
+ nframes_t cnt;
float prefix;
bool was_floating;
cnt = 1;
} else {
if (was_floating) {
- cnt = (jack_nframes_t) floor (prefix * session->frame_rate ());
+ cnt = (nframes_t) floor (prefix * session->frame_rate ());
} else {
- cnt = (jack_nframes_t) prefix;
+ cnt = (nframes_t) prefix;
}
}
pos = playhead_cursor->current_frame;
- if ((jack_nframes_t) pos < cnt) {
+ if ((nframes_t) pos < cnt) {
pos = 0;
} else {
pos -= cnt;
void
Editor::playhead_forward ()
{
- jack_nframes_t pos;
- jack_nframes_t cnt;
+ nframes_t pos;
+ nframes_t cnt;
bool was_floating;
float prefix;
cnt = 1;
} else {
if (was_floating) {
- cnt = (jack_nframes_t) floor (prefix * session->frame_rate ());
+ cnt = (nframes_t) floor (prefix * session->frame_rate ());
} else {
- cnt = (jack_nframes_t) floor (prefix);
+ cnt = (nframes_t) floor (prefix);
}
}
void
Editor::edit_cursor_backward ()
{
- jack_nframes_t pos;
- jack_nframes_t cnt;
+ nframes_t pos;
+ nframes_t cnt;
float prefix;
bool was_floating;
cnt = 1;
} else {
if (was_floating) {
- cnt = (jack_nframes_t) floor (prefix * session->frame_rate ());
+ cnt = (nframes_t) floor (prefix * session->frame_rate ());
} else {
- cnt = (jack_nframes_t) prefix;
+ cnt = (nframes_t) prefix;
}
}
pos = edit_cursor->current_frame;
- if ((jack_nframes_t) pos < cnt) {
+ if ((nframes_t) pos < cnt) {
pos = 0;
} else {
pos -= cnt;
void
Editor::edit_cursor_forward ()
{
- jack_nframes_t pos;
- jack_nframes_t cnt;
+ nframes_t pos;
+ nframes_t cnt;
bool was_floating;
float prefix;
cnt = 1;
} else {
if (was_floating) {
- cnt = (jack_nframes_t) floor (prefix * session->frame_rate ());
+ cnt = (nframes_t) floor (prefix * session->frame_rate ());
} else {
- cnt = (jack_nframes_t) floor (prefix);
+ cnt = (nframes_t) floor (prefix);
}
}
{
float prefix;
bool was_floating;
- jack_nframes_t frame;
+ nframes_t frame;
if (get_prefix (prefix, was_floating)) {
return;
}
if (was_floating) {
- frame = (jack_nframes_t) floor (prefix * session->frame_rate());
+ frame = (nframes_t) floor (prefix * session->frame_rate());
} else {
- frame = (jack_nframes_t) floor (prefix);
+ frame = (nframes_t) floor (prefix);
}
session->request_locate (frame);
void
Editor::scroll_backward (float pages)
{
- jack_nframes_t frame;
- jack_nframes_t one_page = (jack_nframes_t) rint (canvas_width * frames_per_unit);
+ nframes_t frame;
+ nframes_t one_page = (nframes_t) rint (canvas_width * frames_per_unit);
bool was_floating;
float prefix;
- jack_nframes_t cnt;
+ nframes_t cnt;
if (get_prefix (prefix, was_floating)) {
- cnt = (jack_nframes_t) floor (pages * one_page);
+ cnt = (nframes_t) floor (pages * one_page);
} else {
if (was_floating) {
- cnt = (jack_nframes_t) floor (prefix * session->frame_rate());
+ cnt = (nframes_t) floor (prefix * session->frame_rate());
} else {
- cnt = (jack_nframes_t) floor (prefix * one_page);
+ cnt = (nframes_t) floor (prefix * one_page);
}
}
void
Editor::scroll_forward (float pages)
{
- jack_nframes_t frame;
- jack_nframes_t one_page = (jack_nframes_t) rint (canvas_width * frames_per_unit);
+ nframes_t frame;
+ nframes_t one_page = (nframes_t) rint (canvas_width * frames_per_unit);
bool was_floating;
float prefix;
- jack_nframes_t cnt;
+ nframes_t cnt;
if (get_prefix (prefix, was_floating)) {
- cnt = (jack_nframes_t) floor (pages * one_page);
+ cnt = (nframes_t) floor (pages * one_page);
} else {
if (was_floating) {
- cnt = (jack_nframes_t) floor (prefix * session->frame_rate());
+ cnt = (nframes_t) floor (prefix * session->frame_rate());
} else {
- cnt = (jack_nframes_t) floor (prefix * one_page);
+ cnt = (nframes_t) floor (prefix * one_page);
}
}
{
if (!session) return;
- jack_nframes_t current_page = current_page_frames();
- jack_nframes_t current_leftmost = leftmost_frame;
- jack_nframes_t current_rightmost;
- jack_nframes_t current_center;
- jack_nframes_t new_page;
- jack_nframes_t leftmost_after_zoom = 0;
+ nframes_t current_page = current_page_frames();
+ nframes_t current_leftmost = leftmost_frame;
+ nframes_t current_rightmost;
+ nframes_t current_center;
+ nframes_t new_page;
+ nframes_t leftmost_after_zoom = 0;
double nfpu;
nfpu = fpu;
- new_page = (jack_nframes_t) floor (canvas_width * nfpu);
+ new_page = (nframes_t) floor (canvas_width * nfpu);
switch (zoom_focus) {
case ZoomFocusLeft:
return;
}
- jack_nframes_t start = selection->time[clicked_selection].start;
- jack_nframes_t end = selection->time[clicked_selection].end;
+ nframes_t start = selection->time[clicked_selection].start;
+ nframes_t end = selection->time[clicked_selection].end;
temporal_zoom_by_frame (start, end, "zoom to selection");
}
}
void
-Editor::temporal_zoom_by_frame (jack_nframes_t start, jack_nframes_t end, const string & op)
+Editor::temporal_zoom_by_frame (nframes_t start, nframes_t end, const string & op)
{
if (!session) return;
return;
}
- jack_nframes_t range = end - start;
+ nframes_t range = end - start;
double new_fpu = (double)range / (double)canvas_width;
// double p2 = 1.0;
// }
// new_fpu = p2;
- jack_nframes_t new_page = (jack_nframes_t) floor (canvas_width * new_fpu);
- jack_nframes_t middle = (jack_nframes_t) floor( (double)start + ((double)range / 2.0f ));
- jack_nframes_t new_leftmost = (jack_nframes_t) floor( (double)middle - ((double)new_page/2.0f));
+ nframes_t new_page = (nframes_t) floor (canvas_width * new_fpu);
+ nframes_t middle = (nframes_t) floor( (double)start + ((double)range / 2.0f ));
+ nframes_t new_leftmost = (nframes_t) floor( (double)middle - ((double)new_page/2.0f));
if (new_leftmost > middle) new_leftmost = 0;
}
void
-Editor::temporal_zoom_to_frame (bool coarser, jack_nframes_t frame)
+Editor::temporal_zoom_to_frame (bool coarser, nframes_t frame)
{
if (!session) return;
if (new_fpu == frames_per_unit) return;
- jack_nframes_t new_leftmost = frame - (jack_nframes_t)range_before;
+ nframes_t new_leftmost = frame - (nframes_t)range_before;
if (new_leftmost > frame) new_leftmost = 0;
return;
}
- jack_nframes_t start = selection->time[clicked_selection].start;
- jack_nframes_t end = selection->time[clicked_selection].end;
+ nframes_t start = selection->time[clicked_selection].start;
+ nframes_t end = selection->time[clicked_selection].end;
Location *location = new Location (start, end, "selection");
void
Editor::add_location_from_playhead_cursor ()
{
- jack_nframes_t where = session->audible_frame();
+ nframes_t where = session->audible_frame();
Location *location = new Location (where, where, "mark", Location::IsMark);
session->begin_reversible_command (_("add marker"));
}
bool
-Editor::select_all_within (jack_nframes_t start, jack_nframes_t end, double top, double bot, Selection::Operation op)
+Editor::select_all_within (nframes_t start, nframes_t end, double top, double bot, Selection::Operation op)
{
list<Selectable *> touched;
return;
}
- jack_nframes_t start = selection->time[clicked_selection].start;
- jack_nframes_t end = selection->time[clicked_selection].end;
+ nframes_t start = selection->time[clicked_selection].start;
+ nframes_t end = selection->time[clicked_selection].end;
if (end - start < 1) {
return;
void
Editor::select_all_selectables_using_cursor (Cursor *cursor, bool after)
{
- jack_nframes_t start;
- jack_nframes_t end;
+ nframes_t start;
+ nframes_t end;
list<Selectable *> touched;
if (after) {
void
Editor::select_all_selectables_between_cursors (Cursor *cursor, Cursor *other_cursor)
{
- jack_nframes_t start;
- jack_nframes_t end;
+ nframes_t start;
+ nframes_t end;
list<Selectable *> touched;
bool other_cursor_is_first = cursor->current_frame > other_cursor->current_frame;
void
Editor::set_mark ()
{
- jack_nframes_t pos;
+ nframes_t pos;
float prefix;
bool was_floating;
pos = session->audible_frame ();
} else {
if (was_floating) {
- pos = (jack_nframes_t) floor (prefix * session->frame_rate ());
+ pos = (nframes_t) floor (prefix * session->frame_rate ());
} else {
- pos = (jack_nframes_t) floor (prefix);
+ pos = (nframes_t) floor (prefix);
}
}
double wx, wy;
double cx, cy;
TimeAxisView *tv;
- jack_nframes_t where;
+ nframes_t where;
AudioTimeAxisView *atv = 0;
Playlist *playlist;
return;
}
- jack_nframes_t start = selection->time[clicked_selection].start;
- jack_nframes_t end = selection->time[clicked_selection].end;
+ nframes_t start = selection->time[clicked_selection].start;
+ nframes_t end = selection->time[clicked_selection].end;
- jack_nframes_t selection_cnt = end - start + 1;
+ nframes_t selection_cnt = end - start + 1;
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
boost::shared_ptr<AudioRegion> current;
boost::shared_ptr<Region> current_r;
Playlist *pl;
- jack_nframes_t internal_start;
+ nframes_t internal_start;
string new_name;
if ((pl = (*i)->playlist()) == 0) {
return;
}
- jack_nframes_t start = selection->time[clicked_selection].start;
- jack_nframes_t end = selection->time[clicked_selection].end;
+ nframes_t start = selection->time[clicked_selection].start;
+ nframes_t end = selection->time[clicked_selection].end;
for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
boost::shared_ptr<AudioRegion> current;
boost::shared_ptr<Region> current_r;
Playlist* playlist;
- jack_nframes_t internal_start;
+ nframes_t internal_start;
string new_name;
if ((playlist = (*i)->playlist()) == 0) {
double speed = atv->get_diskstream()->speed();
for (list<AudioRange>::iterator t = selection->time.begin(); t != selection->time.end(); ++t) {
- playlist->partition ((jack_nframes_t)((*t).start * speed), (jack_nframes_t)((*t).end * speed), true);
+ playlist->partition ((nframes_t)((*t).start * speed), (nframes_t)((*t).end * speed), true);
}
if (doing_undo)
double speed = atv->get_diskstream()->speed();
- playlist->partition ((jack_nframes_t)(loc.start() * speed), (jack_nframes_t)(loc.end() * speed), true);
+ playlist->partition ((nframes_t)(loc.start() * speed), (nframes_t)(loc.end() * speed), true);
if (doing_undo)
session->add_command(new MementoCommand<Playlist>(*playlist, before, &playlist->get_state()));
}
if (!playlists.empty()) {
- jack_nframes_t start;
- jack_nframes_t end;
- jack_nframes_t cnt;
+ nframes_t start;
+ nframes_t end;
+ nframes_t cnt;
begin_reversible_command (_("trim to selection"));
void
Editor::region_fill_track ()
{
- jack_nframes_t end;
+ nframes_t end;
if (!session || selection->regions.empty()) {
return;
TreeModel::iterator i = region_list_display.get_selection()->get_selected();
boost::shared_ptr<Region> region = (*i)[region_list_columns.region];
- jack_nframes_t start = selection->time[clicked_selection].start;
- jack_nframes_t end = selection->time[clicked_selection].end;
+ nframes_t start = selection->time[clicked_selection].start;
+ nframes_t end = selection->time[clicked_selection].end;
Playlist *playlist;
return;
}
- jack_nframes_t selection_length = end - start;
+ nframes_t selection_length = end - start;
float times = (float)selection_length / region->length();
begin_reversible_command (_("fill selection"));
}
void
-Editor::set_a_regions_sync_position (boost::shared_ptr<Region> region, jack_nframes_t position)
+Editor::set_a_regions_sync_position (boost::shared_ptr<Region> region, nframes_t position)
{
if (!region->covers (position)) {
};
void
-Editor::align_selection_relative (RegionPoint point, jack_nframes_t position)
+Editor::align_selection_relative (RegionPoint point, nframes_t position)
{
if (selection->regions.empty()) {
return;
}
- jack_nframes_t distance;
- jack_nframes_t pos = 0;
+ nframes_t distance;
+ nframes_t pos = 0;
int dir;
list<RegionView*> sorted;
}
void
-Editor::align_selection (RegionPoint point, jack_nframes_t position)
+Editor::align_selection (RegionPoint point, nframes_t position)
{
if (selection->regions.empty()) {
return;
}
void
-Editor::align_region (boost::shared_ptr<Region> region, RegionPoint point, jack_nframes_t position)
+Editor::align_region (boost::shared_ptr<Region> region, RegionPoint point, nframes_t position)
{
begin_reversible_command (_("align region"));
align_region_internal (region, point, position);
}
void
-Editor::align_region_internal (boost::shared_ptr<Region> region, RegionPoint point, jack_nframes_t position)
+Editor::align_region_internal (boost::shared_ptr<Region> region, RegionPoint point, nframes_t position)
{
XMLNode &before = region->playlist()->get_state();
TrackViewList *views = get_valid_views (selection->time.track, selection->time.group);
- jack_nframes_t start = selection->time[clicked_selection].start;
- jack_nframes_t end = selection->time[clicked_selection].end;
- jack_nframes_t cnt = end - start + 1;
+ nframes_t start = selection->time[clicked_selection].start;
+ nframes_t end = selection->time[clicked_selection].end;
+ nframes_t cnt = end - start + 1;
begin_reversible_command (_("bounce range"));
{
typedef std::map<AudioPlaylist*,AudioPlaylist*> PlaylistMapping;
PlaylistMapping pmap;
- jack_nframes_t first_position = max_frames;
+ nframes_t first_position = max_frames;
set<Playlist*> freezelist;
pair<set<Playlist*>::iterator,bool> insert_result;
event.button.x = wx;
event.button.y = wy;
- jack_nframes_t where = event_frame (&event, 0, 0);
+ nframes_t where = event_frame (&event, 0, 0);
snap_to (where);
paste_internal (where, 1);
}
void
-Editor::paste_internal (jack_nframes_t position, float times)
+Editor::paste_internal (nframes_t position, float times)
{
bool commit = false;
Editor::nudge_track (bool use_edit_cursor, bool forwards)
{
Playlist *playlist;
- jack_nframes_t distance;
- jack_nframes_t next_distance;
- jack_nframes_t start;
+ nframes_t distance;
+ nframes_t next_distance;
+ nframes_t start;
if (use_edit_cursor) {
start = edit_cursor->current_frame;
}
void
-Editor::brush (jack_nframes_t pos)
+Editor::brush (nframes_t pos)
{
RegionSelection sel;
snap_to (pos);
vector<ustring> paths;
if (convert_drop_to_paths (paths, context, x, y, data, info, time) == 0) {
- jack_nframes_t pos = 0;
+ nframes_t pos = 0;
do_embed (paths, false, ImportAsRegion, 0, pos, true);
context->drag_finish (true, false, time);
}
hide_verbose_canvas_cursor();
stop_canvas_autoscroll();
- jack_nframes_t where = leftmost_frame + pixel_to_frame (x);
+ nframes_t where = leftmost_frame + pixel_to_frame (x);
switch (ev->button) {
case 1:
track_canvas.c2w (x, y, wcx, wcy);
track_canvas.w2c (wcx, wcy, cx, cy);
- jack_nframes_t where = leftmost_frame + pixel_to_frame (x);
+ nframes_t where = leftmost_frame + pixel_to_frame (x);
/// ripped from maybe_autoscroll, and adapted to work here
- jack_nframes_t one_page = (jack_nframes_t) rint (canvas_width * frames_per_unit);
- jack_nframes_t rightmost_frame = leftmost_frame + one_page;
+ nframes_t one_page = (nframes_t) rint (canvas_width * frames_per_unit);
+ nframes_t rightmost_frame = leftmost_frame + one_page;
if (autoscroll_timeout_tag < 0) {
if (where > rightmost_frame) {
void
-Editor::popup_ruler_menu (jack_nframes_t where, ItemType t)
+Editor::popup_ruler_menu (nframes_t where, ItemType t)
{
using namespace Menu_Helpers;
an uint32_t (or larger) to a float ... what to do ?
*/
- jack_nframes_t page = (jack_nframes_t) floor (canvas_width * frames_per_unit);
- jack_nframes_t rightmost_frame = leftmost_frame + page;
+ nframes_t page = (nframes_t) floor (canvas_width * frames_per_unit);
+ nframes_t rightmost_frame = leftmost_frame + page;
if (ruler_shown[ruler_metric_smpte]) {
gtk_custom_ruler_set_range (GTK_CUSTOM_RULER(_smpte_ruler), leftmost_frame, rightmost_frame,
void
Editor::update_fixed_rulers ()
{
- jack_nframes_t rightmost_frame;
+ nframes_t rightmost_frame;
if (session == 0) {
return;
an uint32_t (or larger) to a float ... what to do ?
*/
- jack_nframes_t page = (jack_nframes_t) floor (canvas_width * frames_per_unit);
+ nframes_t page = (nframes_t) floor (canvas_width * frames_per_unit);
ruler_metrics[ruler_metric_smpte].units_per_pixel = frames_per_unit;
ruler_metrics[ruler_metric_frames].units_per_pixel = frames_per_unit;
an uint32_t (or larger) to a float ... what to do ?
*/
- jack_nframes_t page = (jack_nframes_t) floor (canvas_width * frames_per_unit);
+ nframes_t page = (nframes_t) floor (canvas_width * frames_per_unit);
ruler_metrics[ruler_metric_bbt].units_per_pixel = frames_per_unit;
if (ruler_shown[ruler_metric_bbt]) {
gint
Editor::metric_get_smpte (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
{
- jack_nframes_t range;
- jack_nframes_t pos;
- jack_nframes_t spacer;
- jack_nframes_t fr;
+ nframes_t range;
+ nframes_t pos;
+ nframes_t spacer;
+ nframes_t fr;
SMPTE::Time smpte;
gchar buf[16];
gint nmarks = 0;
fr = session->frame_rate();
- if (lower > (spacer = (jack_nframes_t)(128 * Editor::get_current_zoom ()))) {
+ if (lower > (spacer = (nframes_t)(128 * Editor::get_current_zoom ()))) {
lower = lower - spacer;
} else {
lower = 0;
}
upper = upper + spacer;
- range = (jack_nframes_t) floor (upper - lower);
+ range = (nframes_t) floor (upper - lower);
if (range < (2 * session->frames_per_smpte_frame())) { /* 0 - 2 frames */
show_bits = true;
} else if (range <= (fr / 4)) { /* 2 frames - 0.250 second */
show_frames = true;
mark_modulo = 1;
- nmarks = 1 + (range / (jack_nframes_t)session->frames_per_smpte_frame());
+ nmarks = 1 + (range / (nframes_t)session->frames_per_smpte_frame());
} else if (range <= (fr / 2)) { /* 0.25-0.5 second */
show_frames = true;
mark_modulo = 2;
- nmarks = 1 + (range / (jack_nframes_t)session->frames_per_smpte_frame());
+ nmarks = 1 + (range / (nframes_t)session->frames_per_smpte_frame());
} else if (range <= fr) { /* 0.5-1 second */
show_frames = true;
mark_modulo = 5;
- nmarks = 1 + (range / (jack_nframes_t)session->frames_per_smpte_frame());
+ nmarks = 1 + (range / (nframes_t)session->frames_per_smpte_frame());
} else if (range <= 2 * fr) { /* 1-2 seconds */
show_frames = true;
mark_modulo = 10;
- nmarks = 1 + (range / (jack_nframes_t)session->frames_per_smpte_frame());
+ nmarks = 1 + (range / (nframes_t)session->frames_per_smpte_frame());
} else if (range <= 8 * fr) { /* 2-8 seconds */
show_seconds = true;
mark_modulo = 1;
nmarks = 1 + 24;
} else {
- /* not possible if jack_nframes_t is a 32 bit quantity */
+ /* not possible if nframes_t is a 32 bit quantity */
show_hours = true;
mark_modulo = 4;
nmarks = 1 + 24;
}
- pos = (jack_nframes_t) floor (lower);
+ pos = (nframes_t) floor (lower);
*marks = (GtkCustomRulerMark *) g_malloc (sizeof(GtkCustomRulerMark) * nmarks);
gint nmarks;
char buf[64];
gint n;
- jack_nframes_t pos;
+ nframes_t pos;
bool bar_helper_on = true;
BBT_Time next_beat;
- jack_nframes_t next_beat_pos;
- jack_nframes_t ilower = (jack_nframes_t) floor (lower);
+ nframes_t next_beat_pos;
+ nframes_t ilower = (nframes_t) floor (lower);
if ((desirable_marks = maxchars / 7) == 0) {
return 0;
uint32_t tick = 0;
uint32_t skip;
uint32_t t;
- jack_nframes_t frame_skip;
+ nframes_t frame_skip;
double frame_skip_error;
double accumulated_error;
double position_of_helper;
next_beat_pos = session->tempo_map().frame_time(next_beat);
- frame_skip = (jack_nframes_t) floor (frame_skip_error = (session->frame_rate() * 60) / (bbt_beat_subdivision * (*i).tempo->beats_per_minute()));
+ frame_skip = (nframes_t) floor (frame_skip_error = (session->frame_rate() * 60) / (bbt_beat_subdivision * (*i).tempo->beats_per_minute()));
frame_skip_error -= frame_skip;
skip = (uint32_t) (Meter::ticks_per_beat / bbt_beat_subdivision);
(*marks)[n].label = g_strdup (buf);
- /* Error compensation for float to jack_nframes_t*/
+ /* Error compensation for float to nframes_t*/
accumulated_error += frame_skip_error;
if (accumulated_error > 1) {
pos += 1;
gint
Editor::metric_get_frames (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
{
- jack_nframes_t mark_interval;
- jack_nframes_t pos;
- jack_nframes_t ilower = (jack_nframes_t) floor (lower);
- jack_nframes_t iupper = (jack_nframes_t) floor (upper);
+ nframes_t mark_interval;
+ nframes_t pos;
+ nframes_t ilower = (nframes_t) floor (lower);
+ nframes_t iupper = (nframes_t) floor (upper);
gchar buf[16];
gint nmarks;
gint n;
}
static void
-sample_to_clock_parts ( jack_nframes_t sample,
- jack_nframes_t sample_rate,
+sample_to_clock_parts ( nframes_t sample,
+ nframes_t sample_rate,
long *hrs_p,
long *mins_p,
long *secs_p,
long *millisecs_p)
{
- jack_nframes_t left;
+ nframes_t left;
long hrs;
long mins;
long secs;
gint
Editor::metric_get_minsec (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint maxchars)
{
- jack_nframes_t range;
- jack_nframes_t fr;
- jack_nframes_t mark_interval;
- jack_nframes_t pos;
- jack_nframes_t spacer;
+ nframes_t range;
+ nframes_t fr;
+ nframes_t mark_interval;
+ nframes_t pos;
+ nframes_t spacer;
long hrs, mins, secs, millisecs;
gchar buf[16];
gint nmarks;
bool show_seconds = false;
bool show_minutes = false;
bool show_hours = false;
- jack_nframes_t ilower = (jack_nframes_t) floor (lower);
- jack_nframes_t iupper = (jack_nframes_t) floor (upper);
+ nframes_t ilower = (nframes_t) floor (lower);
+ nframes_t iupper = (nframes_t) floor (upper);
if (session == 0) {
return 0;
fr = session->frame_rate();
/* to prevent 'flashing' */
- if (lower > (spacer = (jack_nframes_t)(128 * Editor::get_current_zoom ()))) {
+ if (lower > (spacer = (nframes_t)(128 * Editor::get_current_zoom ()))) {
lower = lower - spacer;
} else {
lower = 0;
mark_modulo = 2;
} else {
- /* not possible if jack_nframes_t is a 32 bit quantity */
+ /* not possible if nframes_t is a 32 bit quantity */
mark_interval = 4 * 60 * 60 * fr; /* show 4 hrs */
}
}
void
-Editor::mouse_add_new_tempo_event (jack_nframes_t frame)
+Editor::mouse_add_new_tempo_event (nframes_t frame)
{
if (session == 0) {
return;
}
void
-Editor::mouse_add_new_meter_event (jack_nframes_t frame)
+Editor::mouse_add_new_meter_event (nframes_t frame)
{
if (session == 0) {
return;
}
void
-ExportDialog::set_range (jack_nframes_t start, jack_nframes_t end)
+ExportDialog::set_range (nframes_t start, nframes_t end)
{
spec.start_frame = start;
spec.end_frame = end;
}
void
-frames_to_cd_frames_string (char* buf, jack_nframes_t when, jack_nframes_t fr)
+frames_to_cd_frames_string (char* buf, nframes_t when, nframes_t fr)
{
long unsigned int remainder;
ExportDialog::sample_rate_chosen ()
{
string sr_str = sample_rate_combo.get_active_text();
- jack_nframes_t rate;
+ nframes_t rate;
if (sr_str == N_("22.05kHz")) {
rate = 22050;
~ExportDialog ();
void connect_to_session (ARDOUR::Session*);
- virtual void set_range (jack_nframes_t start, jack_nframes_t end);
+ virtual void set_range (nframes_t start, nframes_t end);
void start_export ();
protected:
// flush vector
range_markers_durations_aggregated.resize(0);
- jack_nframes_t duration_before_current_location = 0;
+ nframes_t duration_before_current_location = 0;
Locations::LocationList::iterator locationIter;
for (locationIter = locations.begin(); locationIter != locations.end(); ++locationIter) {
range_markers_durations_aggregated.push_back(
duration_before_current_location);
- jack_nframes_t duration =
+ nframes_t duration =
currentLocation->end() - currentLocation->start();
range_markers_durations.push_back(duration);
private:
// keeps the duration of all range_markers before the current
- vector<jack_nframes_t> range_markers_durations_aggregated;
- vector<jack_nframes_t> range_markers_durations;
+ vector<nframes_t> range_markers_durations_aggregated;
+ vector<nframes_t> range_markers_durations;
// duration of all range markers
- jack_nframes_t total_duration;
+ nframes_t total_duration;
// index of range marker, that get's exported right now
unsigned int current_range_marker_index;
void
-ExportSessionDialog::set_range (jack_nframes_t start, jack_nframes_t end)
+ExportSessionDialog::set_range (nframes_t start, nframes_t end)
{
ExportDialog::set_range (start, end);
{
public:
ExportSessionDialog (PublicEditor&);
- void set_range (jack_nframes_t start, jack_nframes_t end);
+ void set_range (nframes_t start, nframes_t end);
protected:
void export_audio_data();
}
void
-GainAutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, jack_nframes_t when, double y)
+GainAutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, nframes_t when, double y)
{
double x = 0;
~GainAutomationTimeAxisView();
- void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, jack_nframes_t, double);
+ void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, nframes_t, double);
private:
ARDOUR::Curve& curve;
* @param item the time axis item whos position has changed
*/
void
-ImageFrameSocketHandler::send_imageframe_view_position_change(jack_nframes_t pos, void* src, ImageFrameView* item)
+ImageFrameSocketHandler::send_imageframe_view_position_change(nframes_t pos, void* src, ImageFrameView* item)
{
// ENSURE_GUI_THREAD(bind (mem_fun(*this, &ImageFrameSocketHandler::send_imageframe_view_position_change), pos, src, item));
* @param item the item which has had a duration change
*/
void
-ImageFrameSocketHandler::send_imageframe_view_duration_change(jack_nframes_t dur, void* src, ImageFrameView* item)
+ImageFrameSocketHandler::send_imageframe_view_duration_change(nframes_t dur, void* src, ImageFrameView* item)
{
// ENSURE_GUI_THREAD(bind (mem_fun(*this, &ImageFrameSocketHandler::send_imageframe_view_duration_change), dur, src, item));
* @param item the time axis item whos position has changed
*/
void
-ImageFrameSocketHandler::send_marker_view_position_change(jack_nframes_t pos, void* src, MarkerView* item)
+ImageFrameSocketHandler::send_marker_view_position_change(nframes_t pos, void* src, MarkerView* item)
{
if(this == src || src == 0)
{
* @param item the time axis item whos position has changed
*/
void
-ImageFrameSocketHandler::send_marker_view_duration_change(jack_nframes_t dur, void* src, MarkerView* item)
+ImageFrameSocketHandler::send_marker_view_duration_change(nframes_t dur, void* src, MarkerView* item)
{
if(this == src || src == 0)
{
position += image_id_size ;
// get the start frame value
- jack_nframes_t start = strtoul((get_message_part(position,10,msg).c_str()),0,10) ;
+ nframes_t start = strtoul((get_message_part(position,10,msg).c_str()),0,10) ;
position += 10 ;
// get the duration value
- jack_nframes_t duration = strtoul((get_message_part(position,10,msg).c_str()),0,10) ;
+ nframes_t duration = strtoul((get_message_part(position,10,msg).c_str()),0,10) ;
position += 10 ;
//get the named time axis view we about to add an image to
this->decompose_imageframe_item_desc(msg, position, track_id, track_id_size, scene_id, scene_id_size, item_id, item_id_size) ;
- jack_nframes_t start_frame = strtoul(get_message_part(position, ardourvis::TIME_VALUE_CHARS, msg).c_str(), 0, 10) ;
+ nframes_t start_frame = strtoul(get_message_part(position, ardourvis::TIME_VALUE_CHARS, msg).c_str(), 0, 10) ;
position += ardourvis::TIME_VALUE_CHARS ;
// get the named time axis
this->decompose_imageframe_item_desc(msg, position, track_id, track_id_size, scene_id, scene_id_size, item_id, item_id_size) ;
- jack_nframes_t duration = strtoul(get_message_part(position,ardourvis::TIME_VALUE_CHARS,msg).c_str(),0,10) ;
+ nframes_t duration = strtoul(get_message_part(position,ardourvis::TIME_VALUE_CHARS,msg).c_str(),0,10) ;
position += ardourvis::TIME_VALUE_CHARS ;
// get the named time axis
this->decompose_imageframe_item_desc(msg, position, track_id, track_id_size, group_id, group_id_size, item_id, item_id_size) ;
- jack_nframes_t max_duration = strtoul(get_message_part(position,ardourvis::TIME_VALUE_CHARS,msg).c_str(),0,10) ;
+ nframes_t max_duration = strtoul(get_message_part(position,ardourvis::TIME_VALUE_CHARS,msg).c_str(),0,10) ;
position += ardourvis::TIME_VALUE_CHARS ;
int errcode ;
this->decompose_imageframe_item_desc(msg, position, track_id, track_id_size, group_id, group_id_size, item_id, item_id_size) ;
- jack_nframes_t min_duration = strtoul(get_message_part(position,ardourvis::TIME_VALUE_CHARS,msg).c_str(),0,10) ;
+ nframes_t min_duration = strtoul(get_message_part(position,ardourvis::TIME_VALUE_CHARS,msg).c_str(),0,10) ;
position += ardourvis::TIME_VALUE_CHARS ;
int errcode ;
* @param src the identity of the object that initiated the change
* @param item the time axis item whos position has changed
*/
- void send_imageframe_view_position_change(jack_nframes_t pos, void* src, ImageFrameView* item) ;
+ void send_imageframe_view_position_change(nframes_t pos, void* src, ImageFrameView* item) ;
/**
* Send a Image Frame View item duration changed message
* @param src the identity of the object that initiated the change
* @param item the item which has had a duration change
*/
- void send_imageframe_view_duration_change(jack_nframes_t dur, void* src, ImageFrameView* item) ;
+ void send_imageframe_view_duration_change(nframes_t dur, void* src, ImageFrameView* item) ;
/**
* Send a message indicating that an ImageFrameView has been renamed
* @param src the identity of the object that initiated the change
* @param item the time axis item whos position has changed
*/
- void send_marker_view_position_change(jack_nframes_t pos, void* src, MarkerView* item) ;
+ void send_marker_view_position_change(nframes_t pos, void* src, MarkerView* item) ;
/**
* Send a Marker View item duration changed message
* @param src the identity of the object that initiated the change
* @param item the time axis item whos position has changed
*/
- void send_marker_view_duration_change(jack_nframes_t dur, void* src, MarkerView* item) ;
+ void send_marker_view_duration_change(nframes_t dur, void* src, MarkerView* item) ;
/**
* Send a message indicating that a MarkerView has been renamed
* @param src the identity of the object that initiated the change
*/
ImageFrameView*
-ImageFrameTimeAxisGroup::add_imageframe_item(const string & frame_id, jack_nframes_t start, jack_nframes_t duration, unsigned char* rgb_data, uint32_t width, uint32_t height, uint32_t num_channels, void* src)
+ImageFrameTimeAxisGroup::add_imageframe_item(const string & frame_id, nframes_t start, nframes_t duration, unsigned char* rgb_data, uint32_t width, uint32_t height, uint32_t num_channels, void* src)
{
ImageFrameView* ifv = 0 ;
* @param num_channels the number of channles within the rgb_data
* @param src the identity of the object that initiated the change
*/
- ImageFrameView* add_imageframe_item(const string & item_id, jack_nframes_t start, jack_nframes_t duration, unsigned char* rgb_data, uint32_t width, uint32_t height, uint32_t num_channels, void* src) ;
+ ImageFrameView* add_imageframe_item(const string & item_id, nframes_t start, nframes_t duration, unsigned char* rgb_data, uint32_t width, uint32_t height, uint32_t num_channels, void* src) ;
/**
* Returns the named ImageFrameView or 0 if the named view does not exist on this view helper
{
if(selected_imageframe_group && selected_imageframe_view)
{
- selected_imageframe_view->set_duration((jack_nframes_t) (sec * _trackview.editor.current_session()->frame_rate()), this) ;
+ selected_imageframe_view->set_duration((nframes_t) (sec * _trackview.editor.current_session()->frame_rate()), this) ;
}
}
ImageFrameTimeAxisGroup* item_group,
double spu,
Gdk::Color& basic_color,
- jack_nframes_t start,
- jack_nframes_t duration,
+ nframes_t start,
+ nframes_t duration,
unsigned char* rgb_data,
uint32_t width,
uint32_t height,
* @return true if the position change was a success, false otherwise
*/
bool
-ImageFrameView::set_position(jack_nframes_t pos, void* src, double* delta)
+ImageFrameView::set_position(nframes_t pos, void* src, double* delta)
{
- jack_nframes_t old_pos = frame_position ;
+ nframes_t old_pos = frame_position ;
// do the standard stuff
bool ret = TimeAxisViewItem::set_position(pos, src, delta) ;
{
// calculate the offset of the marker
MarkerView* mv = (MarkerView*)*i ;
- jack_nframes_t marker_old_pos = mv->get_position() ;
+ nframes_t marker_old_pos = mv->get_position() ;
mv->set_position(pos + (marker_old_pos - old_pos), src) ;
}
* @return true if the duration change was succesful, false otherwise
*/
bool
-ImageFrameView::set_duration(jack_nframes_t dur, void* src)
+ImageFrameView::set_duration(nframes_t dur, void* src)
{
/* do the standard stuff */
bool ret = TimeAxisViewItem::set_duration(dur, src) ;
ImageFrameTimeAxisGroup* group,
double spu,
Gdk::Color& base_color,
- jack_nframes_t start,
- jack_nframes_t duration,
+ nframes_t start,
+ nframes_t duration,
unsigned char* rgb_data,
uint32_t width,
uint32_t height,
* @param src the identity of the object that initiated the change
* @return true if the position change was a success, false otherwise
*/
- virtual bool set_position(jack_nframes_t pos, void* src, double* delta = 0) ;
+ virtual bool set_position(nframes_t pos, void* src, double* delta = 0) ;
/**
* Sets the duration of this item
* @param src the identity of the object that initiated the change
* @return true if the duration change was succesful, false otherwise
*/
- virtual bool set_duration(jack_nframes_t dur, void* src) ;
+ virtual bool set_duration(nframes_t dur, void* src) ;
//---------------------------------------------------------------------------------------//
// Parent Component Methods
LocationUI::add_new_location()
{
if (session) {
- jack_nframes_t where = session->audible_frame();
+ nframes_t where = session->audible_frame();
Location *location = new Location (where, where, "mark", Location::IsMark);
session->begin_reversible_command (_("add marker"));
XMLNode &before = session->locations()->get_state();
LocationUI::add_new_range()
{
if (session) {
- jack_nframes_t where = session->audible_frame();
+ nframes_t where = session->audible_frame();
Location *location = new Location (where, where, "unnamed",
Location::IsRangeMarker);
session->begin_reversible_command (_("add range marker"));
#include "i18n.h"
Marker::Marker (PublicEditor& ed, ArdourCanvas::Group& parent, guint32 rgba, const string& annotation,
- Type type, jack_nframes_t frame, bool handle_events)
+ Type type, nframes_t frame, bool handle_events)
: editor (ed), _type(type)
{
}
void
-Marker::set_position (jack_nframes_t frame)
+Marker::set_position (nframes_t frame)
{
double new_unit_position = editor.frame_to_unit (frame);
new_unit_position -= shift;
Marker (PublicEditor& editor, ArdourCanvas::Group& parent, guint32 rgba, const string& text, Type,
- jack_nframes_t frame = 0, bool handle_events = true);
+ nframes_t frame = 0, bool handle_events = true);
virtual ~Marker ();
ArdourCanvas::Item& the_item() const;
- void set_position (jack_nframes_t);
+ void set_position (nframes_t);
void set_name (const string&);
void set_color_rgba (uint32_t rgba);
ArdourCanvas::Points *points;
double unit_position;
- jack_nframes_t frame_position;
+ nframes_t frame_position;
unsigned char shift; /* should be double, but its always small and integral */
Type _type;
* @param src the identity of the object that initiated the change
*/
MarkerView*
-MarkerTimeAxisView::add_marker_view(ImageFrameView* ifv, std::string mark_type, std::string mark_id, jack_nframes_t start, jack_nframes_t dur, void* src)
+MarkerTimeAxisView::add_marker_view(ImageFrameView* ifv, std::string mark_type, std::string mark_id, nframes_t start, nframes_t dur, void* src)
{
if(ifv->has_marker_view_item(mark_id))
{
{
if(get_selected_time_axis_item() != 0)
{
- get_selected_time_axis_item()->set_duration((jack_nframes_t) (sec * _trackview.editor.current_session()->frame_rate()), this) ;
+ get_selected_time_axis_item()->set_duration((nframes_t) (sec * _trackview.editor.current_session()->frame_rate()), this) ;
}
}
* @param duration the duration the new item should be placed upon the timeline
* @param src the identity of the object that initiated the change
*/
- MarkerView* add_marker_view(ImageFrameView* ifv, std::string mark_type, std::string mark_id, jack_nframes_t start, jack_nframes_t dur, void* src) ;
+ MarkerView* add_marker_view(ImageFrameView* ifv, std::string mark_type, std::string mark_id, nframes_t start, nframes_t dur, void* src) ;
/**
* Returns the named MarkerView or 0 if the named marker does not exist
Gdk::Color& basic_color,
std::string mark_type,
std::string mark_id,
- jack_nframes_t start,
- jack_nframes_t duration)
+ nframes_t start,
+ nframes_t duration)
: TimeAxisViewItem(mark_id, *parent,*tv,spu,basic_color,start,duration)
{
mark_type_text = mark_type ;
Gdk::Color& base_color,
std::string mark_type,
std::string mark_id,
- jack_nframes_t start,
- jack_nframes_t duration) ;
+ nframes_t start,
+ nframes_t duration) ;
/**
* Destructor
Session& s,
Route& r,
string name,
- jack_nframes_t long_over,
- jack_nframes_t short_over,
- jack_nframes_t meter_hold)
+ nframes_t long_over,
+ nframes_t short_over,
+ nframes_t meter_hold)
: engine (eng),
session (s),
_route (r),
ARDOUR::Session&,
ARDOUR::Route&,
string label,
- jack_nframes_t long_over,
- jack_nframes_t short_over,
- jack_nframes_t meter_hold);
+ nframes_t long_over,
+ nframes_t short_over,
+ nframes_t meter_hold);
void update (); /* called by meter timeout handler from ARDOUR_UI */
/* val is in msecs */
- Crossfade::set_short_xfade_length ((jack_nframes_t) floor (session->frame_rate() * (val / 1000.0)));
+ Crossfade::set_short_xfade_length ((nframes_t) floor (session->frame_rate() * (val / 1000.0)));
}
}
OptionEditor::smpte_offset_chosen()
{
if (session) {
- jack_nframes_t frames = smpte_offset_clock.current_duration();
+ nframes_t frames = smpte_offset_clock.current_duration();
session->set_smpte_offset (frames);
}
}
}
void
-PanAutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, jack_nframes_t when, double y)
+PanAutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, nframes_t when, double y)
{
if (lines.empty()) {
/* no data, possibly caused by no outputs/inputs */
~PanAutomationTimeAxisView();
- void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, jack_nframes_t, double);
+ void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, nframes_t, double);
void clear_lines ();
void add_line (AutomationLine&);
virtual void separate_region_from_selection () = 0;
virtual void toggle_playback (bool with_abort) = 0;
virtual void set_edit_menu (Gtk::Menu&) = 0;
- virtual jack_nframes_t unit_to_frame (double unit) = 0;
- virtual double frame_to_unit (jack_nframes_t frame) = 0;
+ virtual nframes_t unit_to_frame (double unit) = 0;
+ virtual double frame_to_unit (nframes_t frame) = 0;
virtual double frame_to_unit (double frame) = 0;
- virtual jack_nframes_t pixel_to_frame (double pixel) = 0;
- virtual gulong frame_to_pixel (jack_nframes_t frame) = 0;
+ virtual nframes_t pixel_to_frame (double pixel) = 0;
+ virtual gulong frame_to_pixel (nframes_t frame) = 0;
virtual Selection& get_selection() const = 0;
virtual Selection& get_cut_buffer() const = 0;
virtual void play_selection () = 0;
virtual void ensure_float (Gtk::Window&) = 0;
virtual void show_window () = 0;
virtual TrackViewList* get_valid_views (TimeAxisView*, ARDOUR::RouteGroup* grp = 0) = 0;
- virtual jack_nframes_t leftmost_position() const = 0;
- virtual jack_nframes_t current_page_frames() const = 0;
+ virtual nframes_t leftmost_position() const = 0;
+ virtual nframes_t current_page_frames() const = 0;
virtual void temporal_zoom_step (bool coarser) = 0;
virtual void scroll_tracks_down_line () = 0;
virtual void scroll_tracks_up_line () = 0;
virtual bool new_regionviews_display_gain () = 0;
virtual void prepare_for_cleanup () = 0;
- virtual void reposition_x_origin (jack_nframes_t frame) = 0;
+ virtual void reposition_x_origin (nframes_t frame) = 0;
virtual void remove_last_capture () = 0;
virtual void maximise_editing_space() = 0;
virtual void restore_editing_space() = 0;
}
void
-RedirectAutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, jack_nframes_t when, double y)
+RedirectAutomationTimeAxisView::add_automation_event (ArdourCanvas::Item* item, GdkEvent* event, nframes_t when, double y)
{
double x = 0;
~RedirectAutomationTimeAxisView();
- void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, jack_nframes_t, double);
+ void add_automation_event (ArdourCanvas::Item *item, GdkEvent *event, nframes_t, double);
guint32 show_at (double y, int& nth, Gtk::VBox *parent);
void hide ();
/* reset current start */
- jack_nframes_t ref = max_frames;
+ nframes_t ref = max_frames;
for (i = begin (); i != end(); ++i) {
if (region->first_frame() < ref) {
/* reset current end */
- jack_nframes_t ref = 0;
+ nframes_t ref = 0;
for (i = begin (); i != end(); ++i) {
if (region->first_frame() > ref) {
void clear_all();
- jack_nframes_t start () const {
+ nframes_t start () const {
return _current_start;
}
/* collides with list<>::end */
- jack_nframes_t end_frame () const {
+ nframes_t end_frame () const {
return _current_end;
}
void add_to_layer (RegionView *);
- jack_nframes_t _current_start;
- jack_nframes_t _current_end;
+ nframes_t _current_start;
+ nframes_t _current_end;
list<RegionView *> _bylayer;
};
}
bool
-RegionView::set_position (jack_nframes_t pos, void* src, double* ignored)
+RegionView::set_position (nframes_t pos, void* src, double* ignored)
{
double delta;
bool ret;
}
bool
-RegionView::set_duration (jack_nframes_t frames, void *src)
+RegionView::set_duration (nframes_t frames, void *src)
{
if (!TimeAxisViewItem::set_duration (frames, src)) {
return false;
}
int sync_dir;
- jack_nframes_t sync_offset;
+ nframes_t sync_offset;
sync_offset = _region->sync_offset (sync_dir);
virtual void set_height (double) = 0;
virtual void set_samples_per_unit (double);
- virtual bool set_duration (jack_nframes_t, void*);
+ virtual bool set_duration (nframes_t, void*);
void move (double xdelta, double ydelta);
void lower ();
void lower_to_bottom ();
- bool set_position(jack_nframes_t pos, void* src, double* delta = 0);
+ bool set_position(nframes_t pos, void* src, double* delta = 0);
virtual void show_region_editor () = 0;
virtual void hide_region_editor();
void
-RouteTimeAxisView::show_timestretch (jack_nframes_t start, jack_nframes_t end)
+RouteTimeAxisView::show_timestretch (nframes_t start, nframes_t end)
{
double x1;
double x2;
}
void
-RouteTimeAxisView::get_selectables (jack_nframes_t start, jack_nframes_t end, double top, double bot, list<Selectable*>& results)
+RouteTimeAxisView::get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& results)
{
double speed = 1.0;
speed = get_diskstream()->speed();
}
- jack_nframes_t start_adjusted = session_frame_to_track_frame(start, speed);
- jack_nframes_t end_adjusted = session_frame_to_track_frame(end, speed);
+ nframes_t start_adjusted = session_frame_to_track_frame(start, speed);
+ nframes_t end_adjusted = session_frame_to_track_frame(end, speed);
if (_view && ((top < 0.0 && bot < 0.0)) || touched (top, bot)) {
_view->get_selectables (start_adjusted, end_adjusted, results);
}
boost::shared_ptr<Region>
-RouteTimeAxisView::find_next_region (jack_nframes_t pos, RegionPoint point, int32_t dir)
+RouteTimeAxisView::find_next_region (nframes_t pos, RegionPoint point, int32_t dir)
{
boost::shared_ptr<Diskstream> stream;
Playlist *playlist;
}
bool
-RouteTimeAxisView::paste (jack_nframes_t pos, float times, Selection& selection, size_t nth)
+RouteTimeAxisView::paste (nframes_t pos, float times, Selection& selection, size_t nth)
{
if (!is_track()) {
return false;
void set_samples_per_unit (double);
void set_height (TimeAxisView::TrackHeight);
- void show_timestretch (jack_nframes_t start, jack_nframes_t end);
+ void show_timestretch (nframes_t start, nframes_t end);
void hide_timestretch ();
void selection_click (GdkEventButton*);
void set_selected_points (PointSelection&);
void set_selected_regionviews (RegionSelection&);
- void get_selectables (jack_nframes_t start, jack_nframes_t end, double top, double bot, list<Selectable *>&);
+ void get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable *>&);
void get_inverted_selectables (Selection&, list<Selectable*>&);
- boost::shared_ptr<ARDOUR::Region> find_next_region (jack_nframes_t pos, ARDOUR::RegionPoint, int32_t dir);
+ boost::shared_ptr<ARDOUR::Region> find_next_region (nframes_t pos, ARDOUR::RegionPoint, int32_t dir);
/* Editing operations */
bool cut_copy_clear (Selection&, Editing::CutCopyOp);
- bool paste (jack_nframes_t, float times, Selection&, size_t nth);
+ bool paste (nframes_t, float times, Selection&, size_t nth);
list<TimeAxisView*> get_child_list();
virtual void show_existing_automation ();
virtual void hide_all_automation ();
- void timestretch (jack_nframes_t start, jack_nframes_t end);
+ void timestretch (nframes_t start, nframes_t end);
void visual_click ();
void hide_click ();
}
long
-Selection::toggle (jack_nframes_t start, jack_nframes_t end)
+Selection::toggle (nframes_t start, nframes_t end)
{
AudioRangeComparator cmp;
}
long
-Selection::add (jack_nframes_t start, jack_nframes_t end)
+Selection::add (nframes_t start, nframes_t end)
{
AudioRangeComparator cmp;
}
void
-Selection::replace (uint32_t sid, jack_nframes_t start, jack_nframes_t end)
+Selection::replace (uint32_t sid, nframes_t start, nframes_t end)
{
for (list<AudioRange>::iterator i = time.begin(); i != time.end(); ++i) {
if ((*i).id == sid) {
}
void
-Selection::remove (jack_nframes_t start, jack_nframes_t end)
+Selection::remove (nframes_t start, nframes_t end)
{
}
}
long
-Selection::set (TimeAxisView* track, jack_nframes_t start, jack_nframes_t end)
+Selection::set (TimeAxisView* track, nframes_t start, nframes_t end)
{
if ((start == 0 && end == 0) || end < start) {
return 0;
void set (const list<TimeAxisView*>&);
void set (RegionView*);
void set (std::vector<RegionView*>&);
- long set (TimeAxisView*, jack_nframes_t, jack_nframes_t);
+ long set (TimeAxisView*, nframes_t, nframes_t);
void set (ARDOUR::AutomationList*);
void set (ARDOUR::Playlist*);
void set (const list<ARDOUR::Playlist*>&);
void toggle (const list<TimeAxisView*>&);
void toggle (RegionView*);
void toggle (std::vector<RegionView*>&);
- long toggle (jack_nframes_t, jack_nframes_t);
+ long toggle (nframes_t, nframes_t);
void toggle (ARDOUR::AutomationList*);
void toggle (ARDOUR::Playlist*);
void toggle (const list<ARDOUR::Playlist*>&);
void add (const list<TimeAxisView*>&);
void add (RegionView*);
void add (std::vector<RegionView*>&);
- long add (jack_nframes_t, jack_nframes_t);
+ long add (nframes_t, nframes_t);
void add (ARDOUR::AutomationList*);
void add (ARDOUR::Playlist*);
void add (const list<ARDOUR::Playlist*>&);
void remove (const list<TimeAxisView*>&);
void remove (RegionView*);
void remove (uint32_t selection_id);
- void remove (jack_nframes_t, jack_nframes_t);
+ void remove (nframes_t, nframes_t);
void remove (ARDOUR::AutomationList*);
void remove (ARDOUR::Playlist*);
void remove (const list<ARDOUR::Playlist*>&);
void remove (boost::shared_ptr<ARDOUR::Redirect>);
- void replace (uint32_t time_index, jack_nframes_t start, jack_nframes_t end);
+ void replace (uint32_t time_index, nframes_t start, nframes_t end);
void clear_regions();
void clear_tracks ();
if (rec_active && rec_rects.size() > 0) {
/* only update the last box */
RecBoxInfo & rect = rec_rects.back();
- jack_nframes_t at = _trackview.get_diskstream()->current_capture_end();
+ nframes_t at = _trackview.get_diskstream()->current_capture_end();
double xstart;
double xend;
}
void
-StreamView::get_selectables (jack_nframes_t start, jack_nframes_t end, list<Selectable*>& results)
+StreamView::get_selectables (nframes_t start, nframes_t end, list<Selectable*>& results)
{
for (list<RegionView*>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
if ((*i)->region()->coverage(start, end) != OverlapNone) {
struct RecBoxInfo {
ArdourCanvas::SimpleRect* rectangle;
- jack_nframes_t start;
- jack_nframes_t length;
+ nframes_t start;
+ nframes_t length;
};
class PublicEditor;
void foreach_regionview (sigc::slot<void,RegionView*> slot);
void set_selected_regionviews (RegionSelection&);
- void get_selectables (jack_nframes_t start, jack_nframes_t end, list<Selectable* >&);
+ void get_selectables (nframes_t start, nframes_t end, list<Selectable* >&);
void get_inverted_selectables (Selection&, list<Selectable* >& results);
void add_region_view (boost::shared_ptr<ARDOUR::Region>);
using namespace ARDOUR;
using namespace PBD;
-TempoDialog::TempoDialog (TempoMap& map, jack_nframes_t frame, const string & action)
+TempoDialog::TempoDialog (TempoMap& map, nframes_t frame, const string & action)
: ArdourDialog ("tempo dialog"),
bpm_frame (_("Beats per minute")),
ok_button (action),
}
-MeterDialog::MeterDialog (TempoMap& map, jack_nframes_t frame, const string & action)
+MeterDialog::MeterDialog (TempoMap& map, nframes_t frame, const string & action)
: ArdourDialog ("meter dialog"),
note_frame (_("Meter denominator")),
bpb_frame (_("Beats per bar")),
Gtk::Frame when_frame;
char buf[64];
- TempoDialog (ARDOUR::TempoMap&, jack_nframes_t, const string & action);
+ TempoDialog (ARDOUR::TempoMap&, nframes_t, const string & action);
TempoDialog (ARDOUR::TempoSection&, const string & action);
double get_bpm ();
Gtk::Frame when_frame;
char buf[64];
- MeterDialog (ARDOUR::TempoMap&, jack_nframes_t, const string & action);
+ MeterDialog (ARDOUR::TempoMap&, nframes_t, const string & action);
MeterDialog (ARDOUR::MeterSection&, const string & action);
double get_bpb ();
}
void
-TimeAxisView::show_timestretch (jack_nframes_t start, jack_nframes_t end)
+TimeAxisView::show_timestretch (nframes_t start, nframes_t end)
{
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
(*i)->show_timestretch (start, end);
selection_group->raise_to_top();
for (list<AudioRange>::iterator i = ts.begin(); i != ts.end(); ++i) {
- jack_nframes_t start, end, cnt;
+ nframes_t start, end, cnt;
start = (*i).start;
end = (*i).end;
}
void
-TimeAxisView::get_selectables (jack_nframes_t start, jack_nframes_t end, double top, double bot, list<Selectable*>& result)
+TimeAxisView::get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& result)
{
return;
}
virtual void show_selection (TimeSelection&);
virtual void hide_selection ();
virtual void reshow_selection (TimeSelection&);
- virtual void show_timestretch (jack_nframes_t start, jack_nframes_t end);
+ virtual void show_timestretch (nframes_t start, nframes_t end);
virtual void hide_timestretch ();
virtual void hide_dependent_views (TimeAxisViewItem&) {}
/* editing operations */
virtual bool cut_copy_clear (Selection&, Editing::CutCopyOp) { return false; }
- virtual bool paste (jack_nframes_t, float times, Selection&, size_t nth) { return false; }
+ virtual bool paste (nframes_t, float times, Selection&, size_t nth) { return false; }
virtual void set_selected_regionviews (RegionSelection&) {}
virtual void set_selected_points (PointSelection&) {}
- virtual boost::shared_ptr<ARDOUR::Region> find_next_region (jack_nframes_t pos, ARDOUR::RegionPoint, int32_t dir) {
+ virtual boost::shared_ptr<ARDOUR::Region> find_next_region (nframes_t pos, ARDOUR::RegionPoint, int32_t dir) {
return boost::shared_ptr<ARDOUR::Region> ();
}
void order_selection_trims (ArdourCanvas::Item *item, bool put_start_on_top);
- virtual void get_selectables (jack_nframes_t start, jack_nframes_t end, double top, double bot, list<Selectable*>& results);
+ virtual void get_selectables (nframes_t start, nframes_t end, double top, double bot, list<Selectable*>& results);
virtual void get_inverted_selectables (Selection&, list<Selectable *>& results);
/* state/serialization management */
* @param duration the duration of this item
*/
TimeAxisViewItem::TimeAxisViewItem(const string & it_name, ArdourCanvas::Group& parent, TimeAxisView& tv, double spu, Gdk::Color& base_color,
- jack_nframes_t start, jack_nframes_t duration,
+ nframes_t start, nframes_t duration,
Visibility vis)
: trackview (tv)
{
* @return true if the position change was a success, false otherwise
*/
bool
-TimeAxisViewItem::set_position(jack_nframes_t pos, void* src, double* delta)
+TimeAxisViewItem::set_position(nframes_t pos, void* src, double* delta)
{
if (position_locked) {
return false;
*
* @return the position of this item
*/
-jack_nframes_t
+nframes_t
TimeAxisViewItem::get_position() const
{
return frame_position;
* @return true if the duration change was succesful, false otherwise
*/
bool
-TimeAxisViewItem::set_duration (jack_nframes_t dur, void* src)
+TimeAxisViewItem::set_duration (nframes_t dur, void* src)
{
if ((dur > max_item_duration) || (dur < min_item_duration)) {
warning << string_compose (_("new duration %1 frames is out of bounds for %2"), get_item_name(), dur)
* Returns the duration of this item
*
*/
-jack_nframes_t
+nframes_t
TimeAxisViewItem::get_duration() const
{
return (item_duration);
* @param src the identity of the object that initiated the change
*/
void
-TimeAxisViewItem::set_max_duration(jack_nframes_t dur, void* src)
+TimeAxisViewItem::set_max_duration(nframes_t dur, void* src)
{
max_item_duration = dur ;
MaxDurationChanged(max_item_duration, src) ; /* EMIT_SIGNAL */
*
* @return the maximum duration that this item may be set to
*/
-jack_nframes_t
+nframes_t
TimeAxisViewItem::get_max_duration() const
{
return (max_item_duration) ;
* @param src the identity of the object that initiated the change
*/
void
-TimeAxisViewItem::set_min_duration(jack_nframes_t dur, void* src)
+TimeAxisViewItem::set_min_duration(nframes_t dur, void* src)
{
min_item_duration = dur ;
MinDurationChanged(max_item_duration, src) ; /* EMIT_SIGNAL */
*
* @return the nimum duration that this item mey be set to
*/
-jack_nframes_t
+nframes_t
TimeAxisViewItem::get_min_duration() const
{
return(min_item_duration) ;
* @param src the identity of the object that initiated the change
* @return true if the position change was a success, false otherwise
*/
- virtual bool set_position(jack_nframes_t pos, void* src, double* delta = 0) ;
+ virtual bool set_position(nframes_t pos, void* src, double* delta = 0) ;
/**
* Return the position of this item upon the timeline
*
* @return the position of this item
*/
- jack_nframes_t get_position() const ;
+ nframes_t get_position() const ;
/**
* Sets the duration of this item
* @param src the identity of the object that initiated the change
* @return true if the duration change was succesful, false otherwise
*/
- virtual bool set_duration(jack_nframes_t dur, void* src) ;
+ virtual bool set_duration(nframes_t dur, void* src) ;
/**
* Returns the duration of this item
*
*/
- jack_nframes_t get_duration() const ;
+ nframes_t get_duration() const ;
/**
* Sets the maximum duration that this item make have.
* @param dur the new maximum duration
* @param src the identity of the object that initiated the change
*/
- virtual void set_max_duration(jack_nframes_t dur, void* src) ;
+ virtual void set_max_duration(nframes_t dur, void* src) ;
/**
* Returns the maxmimum duration that this item may be set to
*
* @return the maximum duration that this item may be set to
*/
- jack_nframes_t get_max_duration() const ;
+ nframes_t get_max_duration() const ;
/**
* Sets the minimu duration that this item may be set to
* @param the minimum duration that this item may be set to
* @param src the identity of the object that initiated the change
*/
- virtual void set_min_duration(jack_nframes_t dur, void* src) ;
+ virtual void set_min_duration(nframes_t dur, void* src) ;
/**
* Returns the minimum duration that this item mey be set to
*
* @return the nimum duration that this item mey be set to
*/
- jack_nframes_t get_min_duration() const ;
+ nframes_t get_min_duration() const ;
/**
* Sets whether the position of this Item is locked to its current position
sigc::signal<void,std::string,std::string,void*> NameChanged ;
/** Emiited when the position of this item changes */
- sigc::signal<void,jack_nframes_t,void*> PositionChanged ;
+ sigc::signal<void,nframes_t,void*> PositionChanged ;
/** Emitted when the position lock of this item is changed */
sigc::signal<void,bool,void*> PositionLockChanged ;
/** Emitted when the duration of this item changes */
- sigc::signal<void,jack_nframes_t,void*> DurationChanged ;
+ sigc::signal<void,nframes_t,void*> DurationChanged ;
/** Emitted when the maximum item duration is changed */
- sigc::signal<void,jack_nframes_t,void*> MaxDurationChanged ;
+ sigc::signal<void,nframes_t,void*> MaxDurationChanged ;
/** Emitted when the mionimum item duration is changed */
- sigc::signal<void,jack_nframes_t,void*> MinDurationChanged ;
+ sigc::signal<void,nframes_t,void*> MinDurationChanged ;
protected:
* @param duration the duration of this item
*/
TimeAxisViewItem(const std::string & it_name, ArdourCanvas::Group& parent, TimeAxisView& tv, double spu, Gdk::Color& base_color,
- jack_nframes_t start, jack_nframes_t duration, Visibility v = Visibility (0));
+ nframes_t start, nframes_t duration, Visibility v = Visibility (0));
/**
* Calculates some contrasting color for displaying various parts of this item, based upon the base color
bool position_locked ;
/** The posotion of this item on the timeline */
- jack_nframes_t frame_position ;
+ nframes_t frame_position ;
/** the duration of this item upon the timeline */
- jack_nframes_t item_duration ;
+ nframes_t item_duration ;
/** the maximum duration that we allow this item to take */
- jack_nframes_t max_item_duration ;
+ nframes_t max_item_duration ;
/** the minimu duration that we allow this item to take */
- jack_nframes_t min_item_duration ;
+ nframes_t min_item_duration ;
/** indicates whether this Max Duration constraint is active */
bool max_duration_active ;
return changed;
}
-jack_nframes_t
+nframes_t
TimeSelection::start ()
{
if (empty()) {
return 0;
}
- jack_nframes_t first = max_frames;
+ nframes_t first = max_frames;
for (std::list<AudioRange>::iterator i = begin(); i != end(); ++i) {
if ((*i).start < first) {
return first;
}
-jack_nframes_t
+nframes_t
TimeSelection::end_frame ()
{
- jack_nframes_t last = 0;
+ nframes_t last = 0;
/* XXX make this work like RegionSelection: no linear search needed */
return last;
}
-jack_nframes_t
+nframes_t
TimeSelection::length()
{
return end_frame() - start() + 1;
ARDOUR::AudioRange& operator[](uint32_t);
- jack_nframes_t start();
- jack_nframes_t end_frame();
- jack_nframes_t length();
+ nframes_t start();
+ nframes_t end_frame();
+ nframes_t length();
bool consolidate ();
};
// Super class methods not handled by VisualTimeAxis
void
-VisualTimeAxis::show_timestretch (jack_nframes_t start, jack_nframes_t end)
+VisualTimeAxis::show_timestretch (nframes_t start, nframes_t end)
{
// Not handled by purely visual TimeAxis
}
*
* @todo should VisualTimeAxis handle this?
*/
- void show_timestretch (jack_nframes_t start, jack_nframes_t end);
+ void show_timestretch (nframes_t start, nframes_t end);
/**
* Not handle by purely visual TimeAxis
extern OSC* osc;
- static const jack_nframes_t max_frames = JACK_MAX_FRAMES;
+ static const nframes_t max_frames = JACK_MAX_FRAMES;
int init (bool with_vst, bool try_optimization);
int cleanup ();
}
}
- static void swap_by_ptr (Sample *first, Sample *last, jack_nframes_t n) {
+ static void swap_by_ptr (Sample *first, Sample *last, nframes_t n) {
while (n--) {
Sample tmp = *first;
*first++ = *last;
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:
friend class Auditioner;
- int seek (jack_nframes_t which_sample, bool complete_refill = false);
+ int seek (nframes_t which_sample, bool complete_refill = false);
protected:
friend class AudioTrack;
- 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:
RingBufferNPT<CaptureTransition> * capture_transition_buf;
// the following are used in the butler thread only
- jack_nframes_t curr_capture_cnt;
+ nframes_t curr_capture_cnt;
};
/* The two central butler operations */
int do_refill_with_alloc();
int read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
- jack_nframes_t& start, jack_nframes_t cnt,
+ nframes_t& start, nframes_t cnt,
ChannelInfo& channel_info, int channel, bool reversed);
void finish_capture (bool rec_monitors_input);
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 setup_destructive_playlist ();
void use_destructive_playlist ();
AudioTrack (Session&, const XMLNode&);
~AudioTrack ();
- 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);
boost::shared_ptr<AudioDiskstream> audio_diskstream() const;
int use_diskstream (string name);
int use_diskstream (const PBD::ID& id);
- int export_stuff (vector<Sample*>& buffers, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t end_frame);
+ int export_stuff (vector<Sample*>& buffers, uint32_t nbufs, 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);
protected:
XMLNode& state (bool full);
- void passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame,
- jack_nframes_t nframes, jack_nframes_t offset, int declick,
+ void passthru_silence (nframes_t start_frame, nframes_t end_frame,
+ nframes_t nframes, nframes_t offset, int declick,
bool meter);
uint32_t n_process_buffers ();
const char * maker () const;
uint32_t parameter_count () const;
float default_value (uint32_t port);
- jack_nframes_t latency () const;
+ nframes_t latency () const;
void set_parameter (uint32_t which, float val);
float get_parameter (uint32_t which) const;
uint32_t nth_parameter (uint32_t which, bool& ok) const;
void activate ();
void deactivate ();
- void set_block_size (jack_nframes_t nframes);
+ void set_block_size (nframes_t nframes);
- int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, jack_nframes_t nframes, jack_nframes_t offset);
+ int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset);
std::set<uint32_t> automatable() const;
void store_state (ARDOUR::PluginState&);
void restore_state (ARDOUR::PluginState&);
Glib::Mutex& process_lock() { return _process_lock; }
- jack_nframes_t frame_rate();
- jack_nframes_t frames_per_cycle();
+ nframes_t frame_rate();
+ nframes_t frames_per_cycle();
int usecs_per_cycle () const { return _usecs_per_cycle; }
- bool get_sync_offset (jack_nframes_t& offset) const;
+ bool get_sync_offset (nframes_t& offset) const;
- jack_nframes_t frames_since_cycle_start () {
+ nframes_t frames_since_cycle_start () {
if (!_running || !_jack) return 0;
return jack_frames_since_cycle_start (_jack);
}
- jack_nframes_t frame_time () {
+ nframes_t frame_time () {
if (!_running || !_jack) return 0;
return jack_frame_time (_jack);
}
- jack_nframes_t transport_frame () const {
+ nframes_t transport_frame () const {
if (!_running || !_jack) return 0;
return jack_get_current_transport_frame (_jack);
}
- int request_buffer_size (jack_nframes_t);
+ int request_buffer_size (nframes_t);
- jack_nframes_t set_monitor_check_interval (jack_nframes_t);
+ nframes_t set_monitor_check_interval (nframes_t);
float get_cpu_load() {
if (!_running || !_jack) return 0;
return get_nth_physical (n, JackPortIsOutput);
}
- jack_nframes_t get_port_total_latency (const Port&);
+ nframes_t get_port_total_latency (const Port&);
void update_total_latencies ();
/* the caller may not delete the object pointed to by
void transport_start ();
void transport_stop ();
- void transport_locate (jack_nframes_t);
+ void transport_locate (nframes_t);
TransportState transport_state ();
int reset_timebase ();
the regular process() call to session->process() is not made.
*/
- sigc::signal<int,jack_nframes_t> Freewheel;
+ sigc::signal<int,nframes_t> Freewheel;
sigc::signal<void> Xrun;
/* this signal is emitted if the sample rate changes */
- sigc::signal<void,jack_nframes_t> SampleRateChanged;
+ sigc::signal<void,nframes_t> SampleRateChanged;
/* this signal is sent if JACK ever disconnects us */
bool session_remove_pending;
bool _running;
bool _has_run;
- jack_nframes_t _buffer_size;
- jack_nframes_t _frame_rate;
- jack_nframes_t monitor_check_interval;
- jack_nframes_t last_monitor_check;
- jack_nframes_t _processed_frames;
+ nframes_t _buffer_size;
+ nframes_t _frame_rate;
+ nframes_t monitor_check_interval;
+ nframes_t last_monitor_check;
+ nframes_t _processed_frames;
bool _freewheeling;
bool _freewheel_thread_registered;
- sigc::slot<int,jack_nframes_t> freewheel_action;
+ sigc::slot<int,nframes_t> freewheel_action;
bool reconnect_on_halt;
int _usecs_per_cycle;
typedef std::set<Port*> Ports;
SerializedRCUManager<Ports> ports;
- int process_callback (jack_nframes_t nframes);
+ int process_callback (nframes_t nframes);
void remove_all_ports ();
typedef std::pair<std::string,std::string> PortConnection;
static int _xrun_callback (void *arg);
static int _graph_order_callback (void *arg);
- static int _process_callback (jack_nframes_t nframes, void *arg);
- static int _sample_rate_callback (jack_nframes_t nframes, void *arg);
- static int _bufsize_callback (jack_nframes_t nframes, void *arg);
- static void _jack_timebase_callback (jack_transport_state_t, jack_nframes_t, jack_position_t*, int, void*);
+ static int _process_callback (nframes_t nframes, void *arg);
+ static int _sample_rate_callback (nframes_t nframes, void *arg);
+ static int _bufsize_callback (nframes_t nframes, void *arg);
+ static void _jack_timebase_callback (jack_transport_state_t, nframes_t, jack_position_t*, int, void*);
static int _jack_sync_callback (jack_transport_state_t, jack_position_t*, void *arg);
static void _freewheel_callback (int , void *arg);
- void jack_timebase_callback (jack_transport_state_t, jack_nframes_t, jack_position_t*, int);
+ void jack_timebase_callback (jack_transport_state_t, nframes_t, jack_position_t*, int);
int jack_sync_callback (jack_transport_state_t, jack_position_t*);
- int jack_bufsize_callback (jack_nframes_t);
- int jack_sample_rate_callback (jack_nframes_t);
+ int jack_bufsize_callback (nframes_t);
+ int jack_sample_rate_callback (nframes_t);
static void halted (void *);
for files used in destructive recording.
*/
- 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() {}
- virtual int update_header (jack_nframes_t when, struct tm&, time_t) = 0;
+ virtual int update_header (nframes_t when, struct tm&, time_t) = 0;
virtual int flush_header () = 0;
int move_to_trash (const string trash_dir_name);
static void set_bwf_serial_number (int);
static void set_search_path (string);
- static void set_header_position_offset (jack_nframes_t offset );
+ static void set_header_position_offset (nframes_t offset );
static sigc::signal<void> HeaderPositionOffsetChanged;
static uint64_t header_position_offset;
- virtual void set_timeline_position (jack_nframes_t pos);
+ virtual void set_timeline_position (nframes_t pos);
virtual void set_header_timeline_position () = 0;
bool find (std::string path, bool must_exist, bool& is_new);
AudioPlaylist (Session&, const XMLNode&, bool hidden = false);
AudioPlaylist (Session&, string name, bool hidden = false);
AudioPlaylist (const AudioPlaylist&, string name, bool hidden = false);
- AudioPlaylist (const AudioPlaylist&, jack_nframes_t start, jack_nframes_t cnt, string name, bool hidden = false);
+ AudioPlaylist (const AudioPlaylist&, nframes_t start, nframes_t cnt, string name, bool hidden = false);
void clear (bool with_save = true);
- jack_nframes_t read (Sample *dst, Sample *mixdown, float *gain_buffer, jack_nframes_t start, jack_nframes_t cnt, uint32_t chan_n=0);
+ nframes_t read (Sample *dst, Sample *mixdown, float *gain_buffer, nframes_t start, nframes_t cnt, uint32_t chan_n=0);
int set_state (const XMLNode&);
UndoAction get_memento() const;
sigc::signal<void,Crossfade *> NewCrossfade;
template<class T> void foreach_crossfade (T *t, void (T::*func)(Crossfade *));
- void crossfades_at (jack_nframes_t frame, Crossfades&);
+ void crossfades_at (nframes_t frame, Crossfades&);
template<class T> void apply_to_history (T& obj, void (T::*method)(const ARDOUR::StateManager::StateMap&, state_id_t)) {
RegionLock rlock (this);
Curve& fade_out() { return _fade_out; }
Curve& envelope() { return _envelope; }
- jack_nframes_t read_peaks (PeakData *buf, jack_nframes_t npeaks,
- jack_nframes_t offset, jack_nframes_t cnt,
+ nframes_t read_peaks (PeakData *buf, nframes_t npeaks,
+ nframes_t offset, nframes_t cnt,
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, jack_nframes_t position, jack_nframes_t cnt,
+ virtual nframes_t read_at (Sample *buf, Sample *mixdown_buf,
+ float *gain_buf, nframes_t position, nframes_t cnt,
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 (Sample *buf, Sample *mixdown_buf,
+ nframes_t master_read_at (Sample *buf, Sample *mixdown_buf,
float *gain_buf,
- jack_nframes_t position, jack_nframes_t cnt, uint32_t chan_n=0) const;
+ nframes_t position, nframes_t cnt, uint32_t chan_n=0) const;
XMLNode& state (bool);
int set_state (const XMLNode&);
- static void set_default_fade (float steepness, jack_nframes_t len);
+ static void set_default_fade (float steepness, nframes_t len);
enum FadeShape {
Linear,
void set_fade_in_active (bool yn);
void set_fade_in_shape (FadeShape);
- void set_fade_in_length (jack_nframes_t);
- void set_fade_in (FadeShape, jack_nframes_t);
+ void set_fade_in_length (nframes_t);
+ void set_fade_in (FadeShape, nframes_t);
void set_fade_out_active (bool yn);
void set_fade_out_shape (FadeShape);
- void set_fade_out_length (jack_nframes_t);
- void set_fade_out (FadeShape, jack_nframes_t);
+ void set_fade_out_length (nframes_t);
+ void set_fade_out (FadeShape, nframes_t);
void set_envelope_active (bool yn);
private:
friend class RegionFactory;
- AudioRegion (boost::shared_ptr<AudioSource>, jack_nframes_t start, jack_nframes_t length);
- AudioRegion (boost::shared_ptr<AudioSource>, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
- AudioRegion (SourceList &, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
- AudioRegion (boost::shared_ptr<const AudioRegion>, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
+ AudioRegion (boost::shared_ptr<AudioSource>, nframes_t start, nframes_t length);
+ AudioRegion (boost::shared_ptr<AudioSource>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
+ AudioRegion (SourceList &, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
+ AudioRegion (boost::shared_ptr<const AudioRegion>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
AudioRegion (boost::shared_ptr<const AudioRegion>);
AudioRegion (boost::shared_ptr<AudioSource>, const XMLNode&);
AudioRegion (SourceList &, const XMLNode&);
void recompute_gain_at_end ();
void recompute_gain_at_start ();
- jack_nframes_t _read_at (const SourceList&, Sample *buf, Sample *mixdown_buffer,
- float *gain_buffer, jack_nframes_t position, jack_nframes_t cnt,
+ nframes_t _read_at (const SourceList&, Sample *buf, Sample *mixdown_buffer,
+ float *gain_buffer, nframes_t position, nframes_t cnt,
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;
- bool verify_start (jack_nframes_t position);
- bool verify_length (jack_nframes_t position);
- bool verify_start_mutable (jack_nframes_t& start);
- bool verify_start_and_length (jack_nframes_t start, jack_nframes_t length);
+ bool verify_start (nframes_t position);
+ bool verify_length (nframes_t position);
+ bool verify_start_mutable (nframes_t& start);
+ bool verify_start_and_length (nframes_t start, nframes_t length);
void recompute_at_start ();
void recompute_at_end ();
namespace ARDOUR {
-const jack_nframes_t frames_per_peak = 256;
+const nframes_t frames_per_peak = 256;
class AudioSource : public Source
{
so its here in AudioSource for now.
*/
- virtual jack_nframes_t natural_position() const { return 0; }
+ virtual nframes_t natural_position() const { return 0; }
/* returns the number of items in this `audio_source' */
- virtual jack_nframes_t length() const {
+ virtual nframes_t length() const {
return _length;
}
- virtual jack_nframes_t available_peaks (double zoom) const;
+ virtual nframes_t available_peaks (double zoom) const;
- 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 nframes_t read (Sample *dst, nframes_t start, nframes_t cnt) const;
+ virtual nframes_t write (Sample *src, nframes_t cnt);
virtual float sample_rate () const = 0;
uint32_t read_data_count() const { return _read_data_count; }
uint32_t write_data_count() const { return _write_data_count; }
- int read_peaks (PeakData *peaks, jack_nframes_t npeaks, jack_nframes_t start, jack_nframes_t cnt, double samples_per_unit) const;
+ int read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nframes_t cnt, double samples_per_unit) const;
int build_peaks ();
bool peaks_ready (sigc::slot<void>, sigc::connection&) const;
mutable sigc::signal<void> PeaksReady;
- mutable sigc::signal<void,jack_nframes_t,jack_nframes_t> PeakRangeReady;
+ mutable sigc::signal<void,nframes_t,nframes_t> PeakRangeReady;
XMLNode& get_state ();
int set_state (const XMLNode&);
static void stop_peak_thread ();
int rename_peakfile (std::string newpath);
+ void touch_peakfile ();
static void set_build_missing_peakfiles (bool yn) {
_build_missing_peakfiles = yn;
bool _peaks_built;
mutable Glib::Mutex _lock;
- jack_nframes_t _length;
+ nframes_t _length;
bool next_peak_clear_should_notify;
string peakpath;
string _captured_for;
int initialize_peakfile (bool newfile, string path);
void build_peaks_from_scratch ();
- int do_build_peak (jack_nframes_t, jack_nframes_t);
+ int do_build_peak (nframes_t, nframes_t);
- 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 nframes_t read_unlocked (Sample *dst, nframes_t start, nframes_t cnt) const = 0;
+ virtual nframes_t write_unlocked (Sample *dst, nframes_t cnt) = 0;
virtual string peak_path(string audio_path) = 0;
virtual string old_peak_path(string audio_path) = 0;
- void update_length (jack_nframes_t pos, jack_nframes_t cnt);
+ void update_length (nframes_t pos, nframes_t cnt);
static pthread_t peak_thread;
static bool have_peak_thread;
static void clear_queue_for_peaks ();
struct PeakBuildRecord {
- jack_nframes_t frame;
- jack_nframes_t cnt;
+ nframes_t frame;
+ nframes_t cnt;
- PeakBuildRecord (jack_nframes_t f, jack_nframes_t c)
+ PeakBuildRecord (nframes_t f, nframes_t c)
: frame (f), cnt (c) {}
PeakBuildRecord (const PeakBuildRecord& other) {
frame = other.frame;
ARDOUR::AudioPlaylist& prepare_playlist ();
void audition_current_playlist ();
- int play_audition (jack_nframes_t nframes);
+ int play_audition (nframes_t nframes);
void cancel_audition () {
g_atomic_int_set (&_active, 0);
private:
boost::shared_ptr<AudioRegion> the_region;
- jack_nframes_t current_frame;
+ nframes_t current_frame;
mutable gint _active;
Glib::Mutex lock;
- jack_nframes_t length;
+ nframes_t length;
void drop_ports ();
static void *_drop_ports (void *);
CONFIG_VARIABLE (float, smpte_frames_per_second, "smpte-frames-per-second", 30.0f)
CONFIG_VARIABLE (float, video_pullup, "video-pullup", 0.0f)
CONFIG_VARIABLE (bool, smpte_drop_frames, "smpte-drop-frames", false)
-CONFIG_VARIABLE (jack_nframes_t, preroll, "preroll", 0)
-CONFIG_VARIABLE (jack_nframes_t, postroll, "postroll", 0)
-CONFIG_VARIABLE (jack_nframes_t, over_length_short, "over-length-short", 2)
-CONFIG_VARIABLE (jack_nframes_t, over_length_long, "over-length-long", 10)
+CONFIG_VARIABLE (nframes_t, preroll, "preroll", 0)
+CONFIG_VARIABLE (nframes_t, postroll, "postroll", 0)
+CONFIG_VARIABLE (nframes_t, over_length_short, "over-length-short", 2)
+CONFIG_VARIABLE (nframes_t, over_length_long, "over-length-long", 10)
CONFIG_VARIABLE (bool, full_xfades_unmuted, "full-xfades-unmuted", true)
CONFIG_VARIABLE (float, short_xfade_seconds, "short-xfade-seconds", 0.015)
CONFIG_VARIABLE (SlaveSource, slave_source, "slave-source", None)
~CoreAudioSource ();
float sample_rate() const;
- int update_header (jack_nframes_t when, struct tm&, time_t);
+ int update_header (nframes_t when, struct tm&, time_t);
int flush_header () {return 0;};
void set_header_timeline_position () {};
protected:
- 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)
- { return 0; }
-
+ nframes_t read_unlocked (Sample *dst, nframes_t start, nframes_t cnt) const;
+ nframes_t write_unlocked (Sample *dst, nframes_t cnt) { return 0; }
private:
mutable CAAudioFile af;
uint16_t n_channels;
mutable float *tmpbuf;
- mutable jack_nframes_t tmpbufsize;
+ mutable nframes_t tmpbufsize;
mutable Glib::Mutex _tmpbuf_lock;
void init (const string &str);
UndoAction fade_in_memento;
UndoAction fade_out_memento;
- jack_nframes_t position;
- jack_nframes_t length;
+ nframes_t position;
+ nframes_t length;
AnchorPoint anchor_point;
bool follow_overlap;
bool active;
/* constructor for "fixed" xfades at each end of an internal overlap */
Crossfade (boost::shared_ptr<ARDOUR::AudioRegion> in, boost::shared_ptr<ARDOUR::AudioRegion> out,
- jack_nframes_t position,
- jack_nframes_t initial_length,
+ nframes_t position,
+ nframes_t initial_length,
AnchorPoint);
/* constructor for xfade between two regions that are overlapped in any way
boost::shared_ptr<ARDOUR::AudioRegion> in() const { return _in; }
boost::shared_ptr<ARDOUR::AudioRegion> out() const { return _out; }
- jack_nframes_t read_at (Sample *buf, Sample *mixdown_buffer,
- float *gain_buffer, jack_nframes_t position, jack_nframes_t cnt,
+ nframes_t read_at (Sample *buf, Sample *mixdown_buffer,
+ float *gain_buffer, nframes_t position, nframes_t cnt,
uint32_t chan_n,
- jack_nframes_t read_frames = 0,
- jack_nframes_t skip_frames = 0);
+ nframes_t read_frames = 0,
+ nframes_t skip_frames = 0);
bool refresh ();
return (_in == a && _out == b) || (_in == b && _out == a);
}
- jack_nframes_t length() const { return _length; }
- jack_nframes_t overlap_length() const;
- jack_nframes_t position() const { return _position; }
+ nframes_t length() const { return _length; }
+ nframes_t overlap_length() const;
+ nframes_t position() const { return _position; }
sigc::signal<void,Crossfade*> Invalidated;
- bool covers (jack_nframes_t frame) const {
+ bool covers (nframes_t frame) const {
return _position <= frame && frame < _position + _length;
}
- OverlapType coverage (jack_nframes_t start, jack_nframes_t end) const;
+ OverlapType coverage (nframes_t start, nframes_t end) const;
UndoAction get_memento() const;
- static void set_buffer_size (jack_nframes_t);
+ static void set_buffer_size (nframes_t);
bool active () const { return _active; }
void set_active (bool yn);
Curve& fade_in() { return _fade_in; }
Curve& fade_out() { return _fade_out; }
- jack_nframes_t set_length (jack_nframes_t);
+ nframes_t set_length (nframes_t);
- static jack_nframes_t short_xfade_length() { return _short_xfade_length; }
- static void set_short_xfade_length (jack_nframes_t n);
+ static nframes_t short_xfade_length() { return _short_xfade_length; }
+ static void set_short_xfade_length (nframes_t n);
static Change ActiveChanged;
friend struct CrossfadeComparePtr;
friend class AudioPlaylist;
- static jack_nframes_t _short_xfade_length;
+ static nframes_t _short_xfade_length;
boost::shared_ptr<ARDOUR::AudioRegion> _in;
boost::shared_ptr<ARDOUR::AudioRegion> _out;
bool _active;
bool _in_update;
OverlapType overlap_type;
- jack_nframes_t _length;
- jack_nframes_t _position;
+ nframes_t _length;
+ nframes_t _position;
AnchorPoint _anchor_point;
bool _follow_overlap;
bool _fixed;
class DestructiveFileSource : public SndFileSource {
public:
- DestructiveFileSource (Session&, std::string path, SampleFormat samp_format, HeaderFormat hdr_format, jack_nframes_t rate,
+ DestructiveFileSource (Session&, std::string path, SampleFormat samp_format, HeaderFormat hdr_format, nframes_t rate,
Flag flags = AudioFileSource::Flag (AudioFileSource::Writable));
DestructiveFileSource (Session&, std::string path, Flag flags);
DestructiveFileSource (Session&, const XMLNode&);
~DestructiveFileSource ();
- jack_nframes_t last_capture_start_frame() const;
- void mark_capture_start (jack_nframes_t);
+ nframes_t last_capture_start_frame() const;
+ void mark_capture_start (nframes_t);
void mark_capture_end ();
void clear_capture_marks();
XMLNode& get_state ();
- static void setup_standard_crossfades (jack_nframes_t sample_rate);
+ static void setup_standard_crossfades (nframes_t sample_rate);
protected:
- jack_nframes_t write_unlocked (Sample *src, jack_nframes_t cnt);
+ nframes_t write_unlocked (Sample *src, nframes_t cnt);
virtual void handle_header_position_change ();
private:
- static jack_nframes_t xfade_frames;
+ static nframes_t xfade_frames;
static gain_t* out_coefficient;
static gain_t* in_coefficient;
bool _capture_start;
bool _capture_end;
- jack_nframes_t capture_start_frame;
- jack_nframes_t file_pos; // unit is frames
+ nframes_t capture_start_frame;
+ nframes_t file_pos; // unit is frames
Sample* xfade_buf;
void init ();
- jack_nframes_t crossfade (Sample* data, jack_nframes_t cnt, int dir);
- void set_timeline_position (jack_nframes_t);
+ nframes_t crossfade (Sample* data, nframes_t cnt, int dir);
+ void set_timeline_position (nframes_t);
};
}
void set_align_style (AlignStyle);
void set_persistent_align_style (AlignStyle a) { _persistent_alignment_style = a; }
- jack_nframes_t roll_delay() const { return _roll_delay; }
- void set_roll_delay (jack_nframes_t);
+ nframes_t roll_delay() const { return _roll_delay; }
+ void set_roll_delay (nframes_t);
bool record_enabled() const { return g_atomic_int_get (&_record_enabled); }
virtual void set_record_enabled (bool yn) = 0;
virtual int use_new_playlist () = 0;
virtual int use_copy_playlist () = 0;
- jack_nframes_t current_capture_start() const { return capture_start_frame; }
- jack_nframes_t current_capture_end() const { return capture_start_frame + capture_captured; }
- jack_nframes_t get_capture_start_frame (uint32_t n=0);
- jack_nframes_t get_captured_frames (uint32_t n=0);
+ nframes_t current_capture_start() const { return capture_start_frame; }
+ nframes_t current_capture_end() const { return capture_start_frame + capture_captured; }
+ nframes_t get_capture_start_frame (uint32_t n=0);
+ nframes_t get_captured_frames (uint32_t n=0);
uint32_t n_channels() { return _n_channels; }
- static jack_nframes_t disk_io_frames() { return disk_io_chunk_frames; }
+ static 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 */
// FIXME: makes sense for all diskstream types?
virtual void monitor_input (bool) {}
- jack_nframes_t capture_offset() const { return _capture_offset; }
+ nframes_t capture_offset() const { return _capture_offset; }
virtual void set_capture_offset ();
bool slaved() const { return _slaved; }
virtual void set_pending_overwrite (bool) = 0;
virtual int overwrite_existing_buffers () = 0;
- virtual void set_block_size (jack_nframes_t) = 0;
- virtual int internal_playback_seek (jack_nframes_t distance) = 0;
- virtual int can_internal_playback_seek (jack_nframes_t distance) = 0;
+ virtual void set_block_size (nframes_t) = 0;
+ virtual int internal_playback_seek (nframes_t distance) = 0;
+ virtual int can_internal_playback_seek (nframes_t distance) = 0;
virtual int rename_write_sources () = 0;
virtual void reset_write_sources (bool, bool force = false) = 0;
virtual void non_realtime_input_change () = 0;
protected:
friend class Auditioner;
- virtual int seek (jack_nframes_t which_sample, bool complete_refill = false) = 0;
+ virtual int seek (nframes_t which_sample, bool complete_refill = false) = 0;
protected:
friend class Track;
virtual void prepare ();
- virtual int process (jack_nframes_t transport_frame, jack_nframes_t nframes, jack_nframes_t offset, bool can_record, bool rec_monitors_input) = 0;
- virtual bool commit (jack_nframes_t nframes) = 0;
+ virtual int process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input) = 0;
+ virtual bool commit (nframes_t nframes) = 0;
virtual void recover (); /* called if commit will not be called, but process was */
//private:
struct CaptureTransition {
TransitionType type;
- jack_nframes_t capture_val; ///< The start or end file frame position
+ nframes_t capture_val; ///< The start or end file frame position
};
/* The two central butler operations */
virtual int use_pending_capture_data (XMLNode& node) = 0;
virtual void get_input_sources () = 0;
- virtual void check_record_status (jack_nframes_t transport_frame, jack_nframes_t nframes, bool can_record) = 0;
+ virtual void check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record) = 0;
virtual void set_align_style_from_io() {}
virtual void setup_destructive_playlist () = 0;
virtual void use_destructive_playlist () = 0;
- static jack_nframes_t disk_io_chunk_frames;
+ static nframes_t disk_io_chunk_frames;
vector<CaptureInfo*> capture_info;
Glib::Mutex capture_info_lock;
bool _seek_required;
bool force_refill;
- jack_nframes_t capture_start_frame;
- jack_nframes_t capture_captured;
+ nframes_t capture_start_frame;
+ nframes_t capture_captured;
bool was_recording;
- jack_nframes_t adjust_capture_position;
- jack_nframes_t _capture_offset;
- jack_nframes_t _roll_delay;
- jack_nframes_t first_recordable_frame;
- jack_nframes_t last_recordable_frame;
+ nframes_t adjust_capture_position;
+ nframes_t _capture_offset;
+ nframes_t _roll_delay;
+ nframes_t first_recordable_frame;
+ nframes_t last_recordable_frame;
int last_possibly_recording;
AlignStyle _alignment_style;
bool _scrubbing;
bool _slaved;
bool _processed;
Location* loop_location;
- jack_nframes_t overwrite_frame;
+ nframes_t overwrite_frame;
off_t overwrite_offset;
bool pending_overwrite;
bool overwrite_queued;
IOChange input_change_pending;
- jack_nframes_t wrap_buffer_size;
- jack_nframes_t speed_buffer_size;
+ nframes_t wrap_buffer_size;
+ nframes_t speed_buffer_size;
uint64_t last_phase;
uint64_t phi;
- jack_nframes_t file_frame;
- jack_nframes_t playback_sample;
- jack_nframes_t playback_distance;
+ nframes_t file_frame;
+ nframes_t playback_sample;
+ nframes_t playback_distance;
uint32_t _read_data_count;
uint32_t _write_data_count;
Glib::Mutex state_lock;
- jack_nframes_t scrub_start;
- jack_nframes_t scrub_buffer_size;
- jack_nframes_t scrub_offset;
+ nframes_t scrub_start;
+ nframes_t scrub_buffer_size;
+ nframes_t scrub_offset;
sigc::connection ports_created_c;
sigc::connection plmod_connection;
void clear ();
- int prepare (jack_nframes_t blocksize, jack_nframes_t frame_rate);
+ int prepare (nframes_t blocksize, nframes_t frame_rate);
- int process (jack_nframes_t nframes);
+ int process (nframes_t nframes);
/* set by the user */
string path;
- jack_nframes_t sample_rate;
+ nframes_t sample_rate;
int src_quality;
SNDFILE* out;
uint32_t channels;
AudioExportPortMap port_map;
- jack_nframes_t start_frame;
- jack_nframes_t end_frame;
+ nframes_t start_frame;
+ nframes_t end_frame;
GDitherType dither_type;
bool do_freewheel;
/* used exclusively during export */
- jack_nframes_t frame_rate;
+ nframes_t frame_rate;
GDither dither;
float* dataF;
float* dataF2;
float* leftoverF;
- jack_nframes_t leftover_frames;
- jack_nframes_t max_leftover_frames;
+ nframes_t leftover_frames;
+ nframes_t max_leftover_frames;
void* output_data;
- jack_nframes_t out_samples_max;
+ nframes_t out_samples_max;
uint32_t sample_bytes;
uint32_t data_width;
- jack_nframes_t total_frames;
+ nframes_t total_frames;
SF_INFO sfinfo;
SRC_DATA src_data;
SRC_STATE* src_state;
- jack_nframes_t pos;
+ nframes_t pos;
sigc::connection freewheel_connection;
Gain (const Gain&);
Gain& operator= (const Gain&);
- static void fill_linear_fade_in (Gain& curve, jack_nframes_t frames);
- static void fill_linear_volume_fade_in (Gain& curve, jack_nframes_t frames);
- static void fill_linear_fade_out (Gain& curve, jack_nframes_t frames);
- static void fill_linear_volume_fade_out (Gain& curve, jack_nframes_t frames);
+ static void fill_linear_fade_in (Gain& curve, nframes_t frames);
+ static void fill_linear_volume_fade_in (Gain& curve, nframes_t frames);
+ static void fill_linear_fade_out (Gain& curve, nframes_t frames);
+ static void fill_linear_volume_fade_out (Gain& curve, nframes_t frames);
};
virtual ~Insert() { }
- virtual void run (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset) = 0;
+ virtual void run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset) = 0;
virtual void activate () {}
virtual void deactivate () {}
int set_state(const XMLNode&);
void init ();
- void run (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset);
+ void run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset);
- jack_nframes_t latency();
+ nframes_t latency();
uint32_t output_streams() const;
uint32_t input_streams() const;
StateManager::State* state_factory (std::string why) const;
Change restore_state (StateManager::State&);
- void run (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset);
- void silence (jack_nframes_t nframes, jack_nframes_t offset);
+ void run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset);
+ void silence (nframes_t nframes, nframes_t offset);
void activate ();
void deactivate ();
- void set_block_size (jack_nframes_t nframes);
+ void set_block_size (nframes_t nframes);
uint32_t output_streams() const;
uint32_t input_streams() const;
string describe_parameter (uint32_t);
- jack_nframes_t latency();
+ nframes_t latency();
- void transport_stopped (jack_nframes_t now);
- void automation_snapshot (jack_nframes_t now);
+ void transport_stopped (nframes_t now);
+ void automation_snapshot (nframes_t now);
protected:
void store_state (PluginInsertState&) const;
void parameter_changed (uint32_t, float);
vector<boost::shared_ptr<Plugin> > _plugins;
- void automation_run (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset);
- void connect_and_run (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset, bool with_auto, jack_nframes_t now = 0);
+ void automation_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset);
+ void connect_and_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset, bool with_auto, nframes_t now = 0);
void init ();
void set_automatable ();
const string& name() const { return _name; }
virtual int set_name (string str, void *src);
- virtual void silence (jack_nframes_t, jack_nframes_t offset);
+ virtual void silence (nframes_t, nframes_t offset);
// These should be moved in to a separate object that manipulates an IO
- void pan (vector<Sample*>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset, gain_t gain_coeff);
- void pan_automated (vector<Sample*>& bufs, uint32_t nbufs, jack_nframes_t start_frame, jack_nframes_t end_frame,
- jack_nframes_t nframes, jack_nframes_t offset);
- void collect_input (vector<Sample*>&, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset);
- void deliver_output (vector<Sample*>&, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset);
- void deliver_output_no_pan (vector<Sample*>&, uint32_t nbufs, 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 pan (vector<Sample*>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset, gain_t gain_coeff);
+ void pan_automated (vector<Sample*>& bufs, uint32_t nbufs, nframes_t start_frame, nframes_t end_frame,
+ nframes_t nframes, nframes_t offset);
+ void collect_input (vector<Sample*>&, uint32_t nbufs, nframes_t nframes, nframes_t offset);
+ void deliver_output (vector<Sample*>&, uint32_t nbufs, nframes_t nframes, nframes_t offset);
+ void deliver_output_no_pan (vector<Sample*>&, uint32_t nbufs, 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 uint32_t n_process_buffers () { return 0; }
int disconnect_inputs (void *src);
int disconnect_outputs (void *src);
- jack_nframes_t output_latency() const;
- jack_nframes_t input_latency() const;
- void set_port_latency (jack_nframes_t);
+ nframes_t output_latency() const;
+ nframes_t input_latency() const;
+ void set_port_latency (nframes_t);
Port *output (uint32_t n) const {
if (n < _noutputs) {
AutoStyle gain_automation_style () const { return _gain_automation_curve.automation_style(); }
sigc::signal<void> gain_automation_style_changed;
- 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;
}
- virtual void transport_stopped (jack_nframes_t now);
- virtual void automation_snapshot (jack_nframes_t now);
+ virtual void transport_stopped (nframes_t now);
+ virtual void automation_snapshot (nframes_t now);
ARDOUR::Curve& gain_automation_curve () { return _gain_automation_curve; }
virtual uint32_t pans_required() const { return _ninputs; }
- static void apply_declick (vector<Sample*>&, uint32_t nbufs, jack_nframes_t nframes,
+ static void apply_declick (vector<Sample*>&, uint32_t nbufs, nframes_t nframes,
gain_t initial, gain_t target, bool invert_polarity);
struct GainControllable : public PBD::Controllable {
/* automation */
- jack_nframes_t last_automation_snapshot;
- static jack_nframes_t _automation_interval;
+ nframes_t last_automation_snapshot;
+ static nframes_t _automation_interval;
AutoState _gain_automation_state;
AutoStyle _gain_automation_style;
class LadspaPlugin : public ARDOUR::Plugin
{
public:
- LadspaPlugin (void *module, ARDOUR::AudioEngine&, ARDOUR::Session&, uint32_t index, jack_nframes_t sample_rate);
+ LadspaPlugin (void *module, ARDOUR::AudioEngine&, ARDOUR::Session&, uint32_t index, nframes_t sample_rate);
LadspaPlugin (const LadspaPlugin &);
~LadspaPlugin ();
const char * maker() const { return descriptor->Maker; }
uint32_t parameter_count() const { return descriptor->PortCount; }
float default_value (uint32_t port);
- jack_nframes_t latency() const;
+ nframes_t latency() const;
void set_parameter (uint32_t port, float val);
float get_parameter (uint32_t port) const;
int get_parameter_descriptor (uint32_t which, ParameterDescriptor&) const;
descriptor->cleanup (handle);
}
}
- void set_block_size (jack_nframes_t nframes) {}
+ void set_block_size (nframes_t nframes) {}
- int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, jack_nframes_t nframes, jack_nframes_t offset);
+ int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset);
void store_state (ARDOUR::PluginState&);
void restore_state (ARDOUR::PluginState&);
string describe_parameter (uint32_t);
void *module;
const LADSPA_Descriptor *descriptor;
LADSPA_Handle handle;
- jack_nframes_t sample_rate;
+ nframes_t sample_rate;
LADSPA_Data *control_data;
LADSPA_Data *shadow_data;
LADSPA_Data *latency_control_port;
uint32_t _index;
bool was_activated;
- void init (void *mod, uint32_t index, jack_nframes_t rate);
- void run (jack_nframes_t nsamples);
+ void init (void *mod, uint32_t index, nframes_t rate);
+ void run (nframes_t nsamples);
void latency_compute_run ();
};
IsStart = 0x80
};
- Location (jack_nframes_t sample_start,
- jack_nframes_t sample_end,
+ Location (nframes_t sample_start,
+ nframes_t sample_end,
const string &name,
Flags bits = Flags(0))
Location (const XMLNode&);
Location* operator= (const Location& other);
- jack_nframes_t start() { return _start; }
- jack_nframes_t end() { return _end; }
- jack_nframes_t length() { return _end - _start; }
+ nframes_t start() { return _start; }
+ nframes_t end() { return _end; }
+ nframes_t length() { return _end - _start; }
- int set_start (jack_nframes_t s);
- int set_end (jack_nframes_t e);
- int set (jack_nframes_t start, jack_nframes_t end);
+ int set_start (nframes_t s);
+ int set_end (nframes_t e);
+ int set (nframes_t start, nframes_t end);
const string& name() { return _name; }
void set_name (const string &str) { _name = str; name_changed(this); }
private:
string _name;
- jack_nframes_t _start;
- jack_nframes_t _end;
+ nframes_t _start;
+ nframes_t _end;
uint32_t _flags;
void set_mark (bool yn);
int set_current (Location *, bool want_lock = true);
Location *current () const { return current_location; }
- Location *first_location_before (jack_nframes_t);
- Location *first_location_after (jack_nframes_t);
+ Location *first_location_before (nframes_t);
+ Location *first_location_after (nframes_t);
- jack_nframes_t first_mark_before (jack_nframes_t);
- jack_nframes_t first_mark_after (jack_nframes_t);
+ nframes_t first_mark_before (nframes_t);
+ nframes_t first_mark_after (nframes_t);
sigc::signal<void,Location*> current_changed;
sigc::signal<void> changed;
extern "C" {
/* SSE functions */
- float x86_sse_compute_peak (ARDOUR::Sample *buf, jack_nframes_t nsamples, float current);
+ float x86_sse_compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current);
- void x86_sse_apply_gain_to_buffer (ARDOUR::Sample *buf, jack_nframes_t nframes, float gain);
+ void x86_sse_apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain);
- void x86_sse_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes, float gain);
+ void x86_sse_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain);
- void x86_sse_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes);
+ void x86_sse_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes);
}
/* debug wrappers for SSE functions */
-float debug_compute_peak (ARDOUR::Sample *buf, jack_nframes_t nsamples, float current);
+float debug_compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current);
-void debug_apply_gain_to_buffer (ARDOUR::Sample *buf, jack_nframes_t nframes, float gain);
+void debug_apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain);
-void debug_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes, float gain);
+void debug_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain);
-void debug_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes);
+void debug_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes);
#endif
#if defined (__APPLE__)
-float veclib_compute_peak (ARDOUR::Sample *buf, jack_nframes_t nsamples, float current);
+float veclib_compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current);
-void veclib_apply_gain_to_buffer (ARDOUR::Sample *buf, jack_nframes_t nframes, float gain);
+void veclib_apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain);
-void veclib_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes, float gain);
+void veclib_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain);
-void veclib_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes);
+void veclib_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes);
#endif
/* non-optimized functions */
-float compute_peak (ARDOUR::Sample *buf, jack_nframes_t nsamples, float current);
+float compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current);
-void apply_gain_to_buffer (ARDOUR::Sample *buf, jack_nframes_t nframes, float gain);
+void apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain);
-void mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes, float gain);
+void mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain);
-void mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes);
+void mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes);
#endif /* __ardour_mix_h__ */
/* the basic panner API */
- virtual void distribute (Sample* src, Sample** obufs, gain_t gain_coeff, jack_nframes_t nframes) = 0;
+ virtual void distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nframes_t nframes) = 0;
virtual void distribute_automated (Sample* src, Sample** obufs,
- jack_nframes_t start, jack_nframes_t end, jack_nframes_t nframes, pan_t** buffers) = 0;
+ nframes_t start, nframes_t end, nframes_t nframes, pan_t** buffers) = 0;
/* automation */
- virtual void snapshot (jack_nframes_t now) = 0;
- virtual void transport_stopped (jack_nframes_t frame) = 0;
+ virtual void snapshot (nframes_t now) = 0;
+ virtual void transport_stopped (nframes_t frame) = 0;
virtual void set_automation_state (AutoState) = 0;
virtual void set_automation_style (AutoStyle) = 0;
and a type name. See EqualPowerStereoPanner as an example.
*/
- void distribute (Sample* src, Sample** obufs, gain_t gain_coeff, jack_nframes_t nframes);
+ void distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nframes_t nframes);
int load (istream&, string path, uint32_t&);
int save (ostream&) const;
- void snapshot (jack_nframes_t now);
- void transport_stopped (jack_nframes_t frame);
+ void snapshot (nframes_t now);
+ void transport_stopped (nframes_t frame);
void set_automation_state (AutoState);
void set_automation_style (AutoStyle);
~EqualPowerStereoPanner ();
void distribute_automated (Sample* src, Sample** obufs,
- jack_nframes_t start, jack_nframes_t end, jack_nframes_t nframes, pan_t** buffers);
+ nframes_t start, nframes_t end, nframes_t nframes, pan_t** buffers);
void get_current_coefficients (pan_t*) const;
void get_desired_coefficients (pan_t*) const;
Multi2dPanner (Panner& parent);
~Multi2dPanner ();
- void snapshot (jack_nframes_t now);
- void transport_stopped (jack_nframes_t frame);
+ void snapshot (nframes_t now);
+ void transport_stopped (nframes_t frame);
void set_automation_state (AutoState);
void set_automation_style (AutoStyle);
Curve& automation() { return _automation; }
- void distribute (Sample* src, Sample** obufs, gain_t gain_coeff, jack_nframes_t nframes);
+ void distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nframes_t nframes);
void distribute_automated (Sample* src, Sample** obufs,
- jack_nframes_t start, jack_nframes_t end, jack_nframes_t nframes, pan_t** buffers);
+ nframes_t start, nframes_t end, nframes_t nframes, pan_t** buffers);
int load (istream&, string path, uint32_t&);
int save (ostream&) const;
void clear ();
void reset (uint32_t noutputs, uint32_t npans);
- void snapshot (jack_nframes_t now);
- void transport_stopped (jack_nframes_t frame);
+ void snapshot (nframes_t now);
+ void transport_stopped (nframes_t frame);
void clear_automation ();
#include <ardour/utils.h>
static inline float
-compute_peak (ARDOUR::Sample *buf, jack_nframes_t nsamples, float current)
+compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current)
{
- for (jack_nframes_t i = 0; i < nsamples; ++i) {
+ for (nframes_t i = 0; i < nsamples; ++i) {
current = f_max (current, fabsf (buf[i]));
}
return current;
Playlist (Session&, const XMLNode&, bool hidden = false);
Playlist (Session&, string name, bool hidden = false);
Playlist (const Playlist&, string name, bool hidden = false);
- Playlist (const Playlist&, jack_nframes_t start, jack_nframes_t cnt, string name, bool hidden = false);
+ Playlist (const Playlist&, nframes_t start, nframes_t cnt, string name, bool hidden = false);
virtual void clear (bool with_save = true);
virtual void dump () const;
bool hidden() const { return _hidden; }
bool empty() const;
- jack_nframes_t get_maximum_extent () const;
+ nframes_t get_maximum_extent () const;
layer_t top_layer() const;
EditMode get_edit_mode() const { return _edit_mode; }
/* Editing operations */
- void add_region (boost::shared_ptr<Region>, jack_nframes_t position, float times = 1, bool with_save = true);
+ void add_region (boost::shared_ptr<Region>, nframes_t position, float times = 1, bool with_save = true);
void remove_region (boost::shared_ptr<Region>);
void get_equivalent_regions (boost::shared_ptr<Region>, std::vector<boost::shared_ptr<Region> >&);
void get_region_list_equivalent_regions (boost::shared_ptr<Region>, std::vector<boost::shared_ptr<Region> >&);
- void replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, jack_nframes_t pos);
- void split_region (boost::shared_ptr<Region>, jack_nframes_t position);
- void partition (jack_nframes_t start, jack_nframes_t end, bool just_top_level);
- void duplicate (boost::shared_ptr<Region>, jack_nframes_t position, float times);
- void nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwards);
+ void replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, nframes_t pos);
+ void split_region (boost::shared_ptr<Region>, nframes_t position);
+ void partition (nframes_t start, nframes_t end, bool just_top_level);
+ void duplicate (boost::shared_ptr<Region>, nframes_t position, float times);
+ void nudge_after (nframes_t start, nframes_t distance, bool forwards);
boost::shared_ptr<Region> find_region (const PBD::ID&) const;
Playlist* cut (list<AudioRange>&, bool result_is_hidden = true);
Playlist* copy (list<AudioRange>&, bool result_is_hidden = true);
- int paste (Playlist&, jack_nframes_t position, float times);
+ int paste (Playlist&, nframes_t position, float times);
uint32_t read_data_count() { return _read_data_count; }
- RegionList* regions_at (jack_nframes_t frame);
- RegionList* regions_touched (jack_nframes_t start, jack_nframes_t end);
- boost::shared_ptr<Region> top_region_at (jack_nframes_t frame);
+ RegionList* regions_at (nframes_t frame);
+ RegionList* regions_touched (nframes_t start, nframes_t end);
+ boost::shared_ptr<Region> top_region_at (nframes_t frame);
- boost::shared_ptr<Region> find_next_region (jack_nframes_t frame, RegionPoint point, int dir);
+ boost::shared_ptr<Region> find_next_region (nframes_t frame, RegionPoint point, int dir);
template<class T> void foreach_region (T *t, void (T::*func)(boost::shared_ptr<Region>, void *), void *arg);
template<class T> void foreach_region (T *t, void (T::*func)(boost::shared_ptr<Region>));
uint32_t _read_data_count;
PBD::ID _orig_diskstream_id;
uint64_t layer_op_counter;
- jack_nframes_t freeze_length;
+ nframes_t freeze_length;
void init (bool hide);
void save_state (std::string why);
void maybe_save_state (std::string why);
- void add_region_internal (boost::shared_ptr<Region>, jack_nframes_t position, bool delay_sort = false);
+ void add_region_internal (boost::shared_ptr<Region>, nframes_t position, bool delay_sort = false);
int remove_region_internal (boost::shared_ptr<Region>, bool delay_sort = false);
- RegionList *find_regions_at (jack_nframes_t frame);
+ RegionList *find_regions_at (nframes_t frame);
void copy_regions (RegionList&) const;
- void partition_internal (jack_nframes_t start, jack_nframes_t end, bool cutting, RegionList& thawlist);
+ void partition_internal (nframes_t start, nframes_t end, bool cutting, RegionList& thawlist);
- jack_nframes_t _get_maximum_extent() const;
+ nframes_t _get_maximum_extent() const;
- Playlist* cut_copy (Playlist* (Playlist::*pmf)(jack_nframes_t, jack_nframes_t, bool),
+ Playlist* cut_copy (Playlist* (Playlist::*pmf)(nframes_t, nframes_t, bool),
list<AudioRange>& ranges, bool result_is_hidden);
- Playlist *cut (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden);
- Playlist *copy (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden);
+ Playlist *cut (nframes_t start, nframes_t cnt, bool result_is_hidden);
+ Playlist *copy (nframes_t start, nframes_t cnt, bool result_is_hidden);
int move_region_to_layer (layer_t, boost::shared_ptr<Region> r, int dir);
void relayer ();
- static Playlist* copyPlaylist (const Playlist&, jack_nframes_t start, jack_nframes_t length,
+ static Playlist* copyPlaylist (const Playlist&, nframes_t start, nframes_t length,
string name, bool result_is_hidden);
void unset_freeze_parent (Playlist*);
virtual const char * maker() const = 0;
virtual uint32_t parameter_count () const = 0;
virtual float default_value (uint32_t port) = 0;
- virtual jack_nframes_t latency() const = 0;
+ virtual nframes_t latency() const = 0;
virtual void set_parameter (uint32_t which, float val) = 0;
virtual float get_parameter(uint32_t which) const = 0;
virtual uint32_t nth_parameter (uint32_t which, bool& ok) const = 0;
virtual void activate () = 0;
virtual void deactivate () = 0;
- virtual void set_block_size (jack_nframes_t nframes) = 0;
+ virtual void set_block_size (nframes_t nframes) = 0;
- virtual int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, jack_nframes_t nframes, jack_nframes_t offset) = 0;
+ virtual int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset) = 0;
virtual std::set<uint32_t> automatable() const = 0;
virtual void store_state (ARDOUR::PluginState&) = 0;
virtual void restore_state (ARDOUR::PluginState&) = 0;
free (_port);
}
- Sample *get_buffer (jack_nframes_t nframes) {
+ Sample *get_buffer (nframes_t nframes) {
if (_flags & JackPortIsOutput) {
return _buffer;
} else {
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);
bool receives_input() const {
return _flags & JackPortIsInput;
jack_port_request_monitor (_port, yn);
}
- jack_nframes_t latency () const {
+ nframes_t latency () const {
return jack_port_get_latency (_port);
}
- void set_latency (jack_nframes_t nframes) {
+ void set_latency (nframes_t nframes) {
jack_port_set_latency (_port, nframes);
}
bool is_silent() const { return _silent; }
/** Assumes that the port is an audio output port */
- void silence (jack_nframes_t nframes, jack_nframes_t offset) {
+ void silence (nframes_t nframes, nframes_t offset) {
if (!_silent) {
memset (_buffer + offset, 0, sizeof (Sample) * nframes);
if (offset == 0) {
bool _last_monitor : 1;
bool _silent : 1;
jack_port_t *_port;
- jack_nframes_t _overlen;
+ nframes_t _overlen;
jack_default_audio_sample_t _peak;
float _peak_db;
uint32_t _short_overs;
uint32_t _long_overs;
unsigned short _metering;
- 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
Placement placement() const { return _placement; }
void set_placement (Placement, void *src);
- virtual void run (vector<Sample *>& ibufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset) = 0;
+ virtual void run (vector<Sample *>& ibufs, uint32_t nbufs, nframes_t nframes, nframes_t offset) = 0;
virtual void activate () = 0;
virtual void deactivate () = 0;
- virtual jack_nframes_t latency() { return 0; }
+ virtual nframes_t latency() { return 0; }
- virtual void set_block_size (jack_nframes_t nframes) {}
+ virtual void set_block_size (nframes_t nframes) {}
sigc::signal<void,Redirect*,void*> active_changed;
sigc::signal<void,Redirect*,void*> placement_changed;
void mark_automation_visible (uint32_t, bool);
AutomationList& automation_list (uint32_t);
- bool find_next_event (jack_nframes_t, jack_nframes_t, ControlEvent&) const;
+ bool find_next_event (nframes_t, nframes_t, ControlEvent&) const;
- virtual void transport_stopped (jack_nframes_t frame) {};
+ virtual void transport_stopped (nframes_t frame) {};
protected:
void set_placement (const string&, void *src);
{
RegionState (std::string why) : StateManager::State (why) {}
- jack_nframes_t _start;
- jack_nframes_t _length;
- jack_nframes_t _position;
+ nframes_t _start;
+ nframes_t _length;
+ nframes_t _position;
uint32_t _flags;
- jack_nframes_t _sync_position;
+ nframes_t _sync_position;
layer_t _layer;
string _name;
mutable RegionEditState _first_edit;
string name() const { return _name; }
void set_name (string str);
- jack_nframes_t position () const { return _position; }
- jack_nframes_t start () const { return _start; }
- jack_nframes_t length() const { return _length; }
+ nframes_t position () const { return _position; }
+ nframes_t start () const { return _start; }
+ nframes_t length() const { return _length; }
layer_t layer () const { return _layer; }
- jack_nframes_t sync_offset(int& dir) const;
- jack_nframes_t sync_position() const;
+ nframes_t sync_offset(int& dir) const;
+ nframes_t sync_position() const;
- jack_nframes_t adjust_to_sync (jack_nframes_t);
+ nframes_t adjust_to_sync (nframes_t);
/* first_frame() is an alias; last_frame() just hides some math */
- jack_nframes_t first_frame() const { return _position; }
- jack_nframes_t last_frame() const { return _position + _length - 1; }
+ nframes_t first_frame() const { return _position; }
+ nframes_t last_frame() const { return _position + _length - 1; }
bool hidden() const { return _flags & Hidden; }
bool muted() const { return _flags & Muted; }
void freeze ();
void thaw (const string& why);
- bool covers (jack_nframes_t frame) const {
- return _position <= frame && frame < _position + _length;
+ bool covers (nframes_t frame) const {
+ return first_frame() <= frame && frame < last_frame();
}
- OverlapType coverage (jack_nframes_t start, jack_nframes_t end) const {
- return ARDOUR::coverage (_position, _position + _length - 1, start, end);
+ OverlapType coverage (nframes_t start, nframes_t end) const {
+ return ARDOUR::coverage (first_frame(), last_frame(), start, end);
}
bool equivalent (boost::shared_ptr<const Region>) const;
/* EDITING OPERATIONS */
- void set_length (jack_nframes_t, void *src);
- void set_start (jack_nframes_t, void *src);
- void set_position (jack_nframes_t, void *src);
- void set_position_on_top (jack_nframes_t, void *src);
- void special_set_position (jack_nframes_t);
+ void set_length (nframes_t, void *src);
+ void set_start (nframes_t, void *src);
+ void set_position (nframes_t, void *src);
+ void set_position_on_top (nframes_t, void *src);
+ void special_set_position (nframes_t);
void nudge_position (long, void *src);
void move_to_natural_position (void *src);
- void trim_start (jack_nframes_t new_position, void *src);
- void trim_front (jack_nframes_t new_position, void *src);
- void trim_end (jack_nframes_t new_position, void *src);
- void trim_to (jack_nframes_t position, jack_nframes_t length, void *src);
+ void trim_start (nframes_t new_position, void *src);
+ void trim_front (nframes_t new_position, void *src);
+ void trim_end (nframes_t new_position, void *src);
+ void trim_to (nframes_t position, nframes_t length, void *src);
void set_layer (layer_t l); /* ONLY Playlist can call this */
void raise ();
void raise_to_top ();
void lower_to_bottom ();
- void set_sync_position (jack_nframes_t n);
+ void set_sync_position (nframes_t n);
void clear_sync_position ();
void set_hidden (bool yn);
void set_muted (bool yn);
protected:
friend class RegionFactory;
- Region (jack_nframes_t start, jack_nframes_t length,
+ Region (nframes_t start, nframes_t length,
const string& name, layer_t = 0, Flag flags = DefaultFlags);
- Region (boost::shared_ptr<const Region>, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Flag flags = DefaultFlags);
+ Region (boost::shared_ptr<const Region>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Flag flags = DefaultFlags);
Region (boost::shared_ptr<const Region>);
Region (const XMLNode&);
void store_state (RegionState&) const;
Change restore_and_return_flags (RegionState&);
- void trim_to_internal (jack_nframes_t position, jack_nframes_t length, void *src);
+ void trim_to_internal (nframes_t position, nframes_t length, void *src);
bool copied() const { return _flags & Copied; }
void maybe_uncopy ();
void first_edit ();
- virtual bool verify_start (jack_nframes_t) = 0;
- virtual bool verify_start_and_length (jack_nframes_t, jack_nframes_t) = 0;
- virtual bool verify_start_mutable (jack_nframes_t&_start) = 0;
- virtual bool verify_length (jack_nframes_t) = 0;
+ virtual bool verify_start (nframes_t) = 0;
+ virtual bool verify_start_and_length (nframes_t, nframes_t) = 0;
+ virtual bool verify_start_mutable (nframes_t&_start) = 0;
+ virtual bool verify_length (nframes_t) = 0;
virtual void recompute_at_start () = 0;
virtual void recompute_at_end () = 0;
- jack_nframes_t _start;
- jack_nframes_t _length;
- jack_nframes_t _position;
+ nframes_t _start;
+ nframes_t _length;
+ nframes_t _position;
Flag _flags;
- jack_nframes_t _sync_position;
+ nframes_t _sync_position;
layer_t _layer;
string _name;
mutable RegionEditState _first_edit;
static sigc::signal<void,boost::shared_ptr<Region> > CheckNewRegion;
- static boost::shared_ptr<Region> create (boost::shared_ptr<Region>, jack_nframes_t start,
- jack_nframes_t length, std::string name,
+ static boost::shared_ptr<Region> create (boost::shared_ptr<Region>, nframes_t start,
+ nframes_t length, std::string name,
layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
- static boost::shared_ptr<Region> create (boost::shared_ptr<AudioRegion>, jack_nframes_t start,
- jack_nframes_t length, std::string name,
+ static boost::shared_ptr<Region> create (boost::shared_ptr<AudioRegion>, nframes_t start,
+ nframes_t length, std::string name,
layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
- static boost::shared_ptr<Region> create (boost::shared_ptr<Source>, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
- static boost::shared_ptr<Region> create (SourceList &, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
+ static boost::shared_ptr<Region> create (boost::shared_ptr<Source>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
+ static boost::shared_ptr<Region> create (SourceList &, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
static boost::shared_ptr<Region> create (boost::shared_ptr<Region>);
static boost::shared_ptr<Region> create (Session&, XMLNode&, bool);
static boost::shared_ptr<Region> create (SourceList &, const XMLNode&);
/* these are the core of the API of a Route. see the protected sections as well */
- virtual 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);
+ virtual 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);
- virtual 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);
+ virtual 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);
- virtual 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);
+ virtual int silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
+ nframes_t offset, bool can_record, bool rec_monitors_input);
virtual void toggle_monitor_input ();
virtual bool can_record() { return false; }
virtual void set_record_enable (bool yn, void *src) {}
void all_redirects_flip();
void all_redirects_active (bool state);
- virtual jack_nframes_t update_total_latency();
- jack_nframes_t signal_latency() const { return _own_latency; }
- virtual void set_latency_delay (jack_nframes_t);
+ virtual nframes_t update_total_latency();
+ nframes_t signal_latency() const { return _own_latency; }
+ virtual void set_latency_delay (nframes_t);
sigc::signal<void,void*> solo_changed;
sigc::signal<void,void*> solo_safe_changed;
return _mute_control;
}
- void automation_snapshot (jack_nframes_t now);
+ void automation_snapshot (nframes_t now);
void protect_automation ();
friend class Session;
void set_solo_mute (bool yn);
- void set_block_size (jack_nframes_t nframes);
+ void set_block_size (nframes_t nframes);
bool has_external_redirects() const;
void curve_reallocate ();
gain_t desired_solo_gain;
gain_t desired_mute_gain;
- jack_nframes_t check_initial_delay (jack_nframes_t, jack_nframes_t&, jack_nframes_t&);
+ nframes_t check_initial_delay (nframes_t, nframes_t&, nframes_t&);
- jack_nframes_t _initial_delay;
- jack_nframes_t _roll_delay;
- jack_nframes_t _own_latency;
+ nframes_t _initial_delay;
+ nframes_t _roll_delay;
+ nframes_t _own_latency;
RedirectList _redirects;
Glib::RWLock redirect_lock;
IO *_control_outs;
ToggleControllable _solo_control;
ToggleControllable _mute_control;
- void passthru (jack_nframes_t start_frame, jack_nframes_t end_frame,
- jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter_inputs);
+ void passthru (nframes_t start_frame, nframes_t end_frame,
+ nframes_t nframes, nframes_t offset, int declick, bool meter_inputs);
void process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
- 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);
protected:
virtual XMLNode& state(bool);
- void silence (jack_nframes_t nframes, jack_nframes_t offset);
+ void silence (nframes_t nframes, nframes_t offset);
sigc::connection input_signal_connection;
state_id_t _current_state_id;
Send (const Send&);
~Send ();
- void run (vector<Sample *> &bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset);
+ void run (vector<Sample *> &bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset);
void activate() {}
void deactivate () {}
Type type;
Action action;
- jack_nframes_t action_frame;
- jack_nframes_t target_frame;
+ nframes_t action_frame;
+ nframes_t target_frame;
float speed;
union {
list<AudioRange> audio_range;
list<MusicRange> music_range;
- Event(Type t, Action a, jack_nframes_t when, jack_nframes_t where, float spd, bool yn = false)
+ Event(Type t, Action a, nframes_t when, nframes_t where, float spd, bool yn = false)
: type (t),
action (a),
action_frame (when),
pool.release (ptr);
}
- static const jack_nframes_t Immediate = 0;
+ static const nframes_t Immediate = 0;
private:
static MultiAllocSingleReleasePool pool;
uint32_t master_out_channels,
uint32_t n_physical_in,
uint32_t n_physical_out,
- jack_nframes_t initial_length);
+ nframes_t initial_length);
virtual ~Session ();
static string change_audio_path_by_name (string oldpath, string oldname, string newname, bool destructive);
string audio_path_from_name (string, uint32_t nchans, uint32_t chan, bool destructive);
- void process (jack_nframes_t nframes);
+ void process (nframes_t nframes);
vector<Sample*>& get_passthru_buffers() { return _passthru_buffers; }
vector<Sample*>& get_silent_buffers (uint32_t howmany);
/* Transport mechanism signals */
sigc::signal<void> TransportStateChange; /* generic */
- sigc::signal<void,jack_nframes_t> PositionChanged; /* sent after any non-sequential motion */
+ sigc::signal<void,nframes_t> PositionChanged; /* sent after any non-sequential motion */
sigc::signal<void> DurationChanged;
sigc::signal<void> HaltOnXrun;
sigc::signal<void,RouteList&> RouteAdded;
void request_roll ();
- void request_bounded_roll (jack_nframes_t start, jack_nframes_t end);
+ void request_bounded_roll (nframes_t start, nframes_t end);
void request_stop (bool abort = false);
- void request_locate (jack_nframes_t frame, bool with_roll = false);
+ void request_locate (nframes_t frame, bool with_roll = false);
void request_play_loop (bool yn);
- jack_nframes_t last_transport_start() const { return _last_roll_location; }
+ nframes_t last_transport_start() const { return _last_roll_location; }
void goto_end () { request_locate (end_location->start(), false);}
void goto_start () { request_locate (start_location->start(), false); }
- void set_session_start (jack_nframes_t start) { start_location->set_start(start); }
- void set_session_end (jack_nframes_t end) { end_location->set_start(end); _end_location_is_free = false; }
+ void set_session_start (nframes_t start) { start_location->set_start(start); }
+ void set_session_end (nframes_t end) { end_location->set_start(end); _end_location_is_free = false; }
void use_rf_shuttle_speed ();
void request_transport_speed (float speed);
void request_overwrite_buffer (Diskstream*);
int remove_region_from_region_list (boost::shared_ptr<Region>);
- jack_nframes_t get_maximum_extent () const;
- jack_nframes_t current_end_frame() const { return end_location->start(); }
- jack_nframes_t current_start_frame() const { return start_location->start(); }
- jack_nframes_t frame_rate() const { return _current_frame_rate; }
- jack_nframes_t frames_per_hour() const { return _frames_per_hour; }
+ nframes_t get_maximum_extent () const;
+ nframes_t current_end_frame() const { return end_location->start(); }
+ nframes_t current_start_frame() const { return start_location->start(); }
+ nframes_t frame_rate() const { return _current_frame_rate; }
+ nframes_t frames_per_hour() const { return _frames_per_hour; }
double frames_per_smpte_frame() const { return _frames_per_smpte_frame; }
- jack_nframes_t smpte_frames_per_hour() const { return _smpte_frames_per_hour; }
+ nframes_t smpte_frames_per_hour() const { return _smpte_frames_per_hour; }
/* Locations */
void reset_input_monitor_state ();
- void add_event (jack_nframes_t action_frame, Event::Type type, jack_nframes_t target_frame = 0);
- void remove_event (jack_nframes_t frame, Event::Type type);
+ void add_event (nframes_t action_frame, Event::Type type, nframes_t target_frame = 0);
+ void remove_event (nframes_t frame, Event::Type type);
void clear_events (Event::Type type);
- jack_nframes_t get_block_size() const { return current_block_size; }
- jack_nframes_t worst_output_latency () const { return _worst_output_latency; }
- jack_nframes_t worst_input_latency () const { return _worst_input_latency; }
- jack_nframes_t worst_track_latency () const { return _worst_track_latency; }
+ nframes_t get_block_size() const { return current_block_size; }
+ nframes_t worst_output_latency () const { return _worst_output_latency; }
+ nframes_t worst_input_latency () const { return _worst_input_latency; }
+ nframes_t worst_track_latency () const { return _worst_track_latency; }
int save_state (string snapshot_name, bool pending = false);
int restore_state (string snapshot_name);
/* Time */
- jack_nframes_t transport_frame () const {return _transport_frame; }
- jack_nframes_t audible_frame () const;
+ nframes_t transport_frame () const {return _transport_frame; }
+ nframes_t audible_frame () const;
enum SmpteFormat {
smpte_23976,
void sync_time_vars();
- void bbt_time (jack_nframes_t when, BBT_Time&);
- void smpte_to_sample( SMPTE::Time& smpte, jack_nframes_t& sample, bool use_offset, bool use_subframes ) const;
- void sample_to_smpte( jack_nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes ) const;
+ void bbt_time (nframes_t when, BBT_Time&);
+ void smpte_to_sample( SMPTE::Time& smpte, nframes_t& sample, bool use_offset, bool use_subframes ) const;
+ void sample_to_smpte( nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes ) const;
void smpte_time (SMPTE::Time &);
- void smpte_time (jack_nframes_t when, SMPTE::Time&);
- void smpte_time_subframes (jack_nframes_t when, SMPTE::Time&);
+ void smpte_time (nframes_t when, SMPTE::Time&);
+ void smpte_time_subframes (nframes_t when, SMPTE::Time&);
- void smpte_duration (jack_nframes_t, SMPTE::Time&) const;
- void smpte_duration_string (char *, jack_nframes_t) const;
+ void smpte_duration (nframes_t, SMPTE::Time&) const;
+ void smpte_duration_string (char *, nframes_t) const;
- void set_smpte_offset (jack_nframes_t);
- jack_nframes_t smpte_offset () const { return _smpte_offset; }
+ void set_smpte_offset (nframes_t);
+ nframes_t smpte_offset () const { return _smpte_offset; }
void set_smpte_offset_negative (bool);
bool smpte_offset_negative () const { return _smpte_offset_negative; }
- jack_nframes_t convert_to_frames_at (jack_nframes_t position, AnyTime&);
+ nframes_t convert_to_frames_at (nframes_t position, AnyTime&);
static sigc::signal<void> StartTimeChanged;
static sigc::signal<void> EndTimeChanged;
bool transport_stopped() const { return _transport_speed == 0.0f; }
bool transport_rolling() const { return _transport_speed != 0.0f; }
- int jack_slave_sync (jack_nframes_t);
+ int jack_slave_sync (nframes_t);
TempoMap& tempo_map() { return *_tempo_map; }
string build_tmp_convert_name (string file);
SlaveSource post_export_slave;
- jack_nframes_t post_export_position;
+ nframes_t post_export_position;
int start_audio_export (ARDOUR::AudioExportSpecification&);
int stop_audio_export (ARDOUR::AudioExportSpecification&);
/* flattening stuff */
- int write_one_audio_track (AudioTrack&,
jack_nframes_t start, jack_nframes_t cnt, bool overwrite, vector<boost::shared_ptr<AudioSource> >&,
+ int write_one_audio_track (AudioTrack&,
nframes_t start, nframes_t cnt, bool overwrite, vector<boost::shared_ptr<AudioSource> >&,
InterThreadInfo& wot);
int freeze (InterThreadInfo&);
/* s/w "RAID" management */
- jack_nframes_t available_capture_duration();
+ nframes_t available_capture_duration();
/* I/O Connections */
/* Scrubbing */
- void start_scrub (jack_nframes_t where);
+ void start_scrub (nframes_t where);
void stop_scrub ();
void set_scrub_speed (float);
- jack_nframes_t scrub_buffer_size() const;
+ nframes_t scrub_buffer_size() const;
sigc::signal<void> ScrubReady;
/* History (for editors, mixers, UIs etc.) */
void* ptr,
float opt);
- typedef float (*compute_peak_t) (Sample *, jack_nframes_t, float);
- typedef void (*apply_gain_to_buffer_t) (Sample *, jack_nframes_t, float);
- typedef void (*mix_buffers_with_gain_t) (Sample *, Sample *, jack_nframes_t, float);
- typedef void (*mix_buffers_no_gain_t) (Sample *, Sample *, jack_nframes_t);
+ typedef float (*compute_peak_t) (Sample *, nframes_t, float);
+ typedef void (*apply_gain_to_buffer_t) (Sample *, nframes_t, float);
+ typedef void (*mix_buffers_with_gain_t) (Sample *, Sample *, nframes_t, float);
+ typedef void (*mix_buffers_no_gain_t) (Sample *, Sample *, nframes_t);
static compute_peak_t compute_peak;
static apply_gain_to_buffer_t apply_gain_to_buffer;
protected:
friend class AudioEngine;
- void set_block_size (jack_nframes_t nframes);
- void set_frame_rate (jack_nframes_t nframes);
+ void set_block_size (nframes_t nframes);
+ void set_frame_rate (nframes_t nframes);
protected:
friend class Diskstream;
void update_latency_compensation (bool, bool);
private:
- int create (bool& new_session, string* mix_template, jack_nframes_t initial_length);
+ int create (bool& new_session, string* mix_template, nframes_t initial_length);
static const char* _template_suffix;
static const char* _statefile_suffix;
maximise cache hits
*/
- typedef void (Session::*process_function_type)(jack_nframes_t);
+ typedef void (Session::*process_function_type)(nframes_t);
AudioEngine &_engine;
mutable gint processing_prohibited;
process_function_type process_function;
process_function_type last_process_function;
bool waiting_for_sync_offset;
- jack_nframes_t _base_frame_rate;
- jack_nframes_t _current_frame_rate; //this includes video pullup offset
+ nframes_t _base_frame_rate;
+ nframes_t _current_frame_rate; //this includes video pullup offset
int transport_sub_state;
mutable gint _record_status;
- jack_nframes_t _transport_frame;
+ nframes_t _transport_frame;
Location* end_location;
Location* start_location;
Slave *_slave;
volatile float _transport_speed;
volatile float _desired_transport_speed;
float _last_transport_speed;
- jack_nframes_t _last_slave_transport_frame;
- jack_nframes_t maximum_output_latency;
- jack_nframes_t last_stop_frame;
+ nframes_t _last_slave_transport_frame;
+ nframes_t maximum_output_latency;
+ nframes_t last_stop_frame;
vector<Sample *> _passthru_buffers;
vector<Sample *> _silent_buffers;
vector<Sample *> _send_buffers;
- jack_nframes_t current_block_size;
- jack_nframes_t _worst_output_latency;
- jack_nframes_t _worst_input_latency;
- jack_nframes_t _worst_track_latency;
+ nframes_t current_block_size;
+ nframes_t _worst_output_latency;
+ nframes_t _worst_input_latency;
+ nframes_t _worst_track_latency;
bool _have_captured;
float _meter_hold;
float _meter_falloff;
void ensure_passthru_buffers (uint32_t howmany);
- void process_scrub (jack_nframes_t);
- void process_without_events (jack_nframes_t);
- void process_with_events (jack_nframes_t);
- void process_audition (jack_nframes_t);
- int process_export (jack_nframes_t, ARDOUR::AudioExportSpecification*);
+ void process_scrub (nframes_t);
+ void process_without_events (nframes_t);
+ void process_with_events (nframes_t);
+ void process_audition (nframes_t);
+ int process_export (nframes_t, ARDOUR::AudioExportSpecification*);
/* slave tracking */
};
SlaveState slave_state;
- jack_nframes_t slave_wait_end;
+ nframes_t slave_wait_end;
void reset_slave_state ();
- bool follow_slave (jack_nframes_t, jack_nframes_t);
+ bool follow_slave (nframes_t, nframes_t);
void set_slave_source (SlaveSource);
bool _exporting;
int prepare_to_export (ARDOUR::AudioExportSpecification&);
void prepare_diskstreams ();
- void commit_diskstreams (jack_nframes_t, bool& session_requires_butler);
- int process_routes (jack_nframes_t, jack_nframes_t);
- int silent_process_routes (jack_nframes_t, jack_nframes_t);
+ void commit_diskstreams (nframes_t, bool& session_requires_butler);
+ int process_routes (nframes_t, nframes_t);
+ int silent_process_routes (nframes_t, nframes_t);
bool get_rec_monitors_input () {
if (actively_recording()) {
}
}
- bool maybe_stop (jack_nframes_t limit) {
+ bool maybe_stop (nframes_t limit) {
if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
stop_transport ();
return true;
return false;
}
- bool maybe_sync_start (jack_nframes_t&, jack_nframes_t&);
+ bool maybe_sync_start (nframes_t&, nframes_t&);
void check_declick_out ();
bool session_midi_feedback;
bool play_loop;
bool loop_changing;
- jack_nframes_t last_loopend;
+ nframes_t last_loopend;
RingBuffer<Event*> pending_events;
XMLNode& get_options () const;
int load_state (string snapshot_name);
- jack_nframes_t _last_roll_location;
- jack_nframes_t _last_record_location;
+ nframes_t _last_roll_location;
+ nframes_t _last_record_location;
bool pending_locate_roll;
- jack_nframes_t pending_locate_frame;
+ nframes_t pending_locate_frame;
bool pending_locate_flush;
bool pending_abort;
uint32_t rf_scale;
void set_rf_speed (float speed);
- void reset_rf_scale (jack_nframes_t frames_moved);
+ void reset_rf_scale (nframes_t frames_moved);
Locations _locations;
void locations_changed ();
void dump_events () const;
void queue_event (Event *ev);
void merge_event (Event*);
- void replace_event (Event::Type, jack_nframes_t action_frame, jack_nframes_t target = 0);
+ void replace_event (Event::Type, nframes_t action_frame, nframes_t target = 0);
bool _replace_event (Event*);
bool _remove_event (Event *);
void _clear_event_type (Event::Type);
/* MIDI Machine Control */
- void deliver_mmc (MIDI::MachineControl::Command, jack_nframes_t);
+ void deliver_mmc (MIDI::MachineControl::Command, nframes_t);
void deliver_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes);
void deliver_data (MIDI::Port* port, MIDI::byte*, int32_t size);
MIDI::byte mtc_msg[16];
MIDI::byte mtc_smpte_bits; /* encoding of SMTPE type for MTC */
MIDI::byte midi_msg[16];
- jack_nframes_t outbound_mtc_smpte_frame;
+ nframes_t outbound_mtc_smpte_frame;
SMPTE::Time transmitting_smpte_time;
int next_quarter_frame_to_send;
double _frames_per_smpte_frame; /* has to be floating point because of drop frame */
- jack_nframes_t _frames_per_hour;
- jack_nframes_t _smpte_frames_per_hour;
- jack_nframes_t _smpte_offset;
+ nframes_t _frames_per_hour;
+ nframes_t _smpte_frames_per_hour;
+ nframes_t _smpte_offset;
bool _smpte_offset_negative;
/* cache the most-recently requested time conversions.
*/
bool last_smpte_valid;
- jack_nframes_t last_smpte_when;
+ nframes_t last_smpte_when;
SMPTE::Time last_smpte;
int send_full_time_code ();
void send_full_time_code_in_another_thread ();
void send_midi_time_code_in_another_thread ();
void send_time_code_in_another_thread (bool full);
- void send_mmc_in_another_thread (MIDI::MachineControl::Command, jack_nframes_t frame = 0);
+ void send_mmc_in_another_thread (MIDI::MachineControl::Command, nframes_t frame = 0);
- jack_nframes_t adjust_apparent_position (jack_nframes_t frames);
+ nframes_t adjust_apparent_position (nframes_t frames);
void reset_record_status ();
- int no_roll (jack_nframes_t nframes, jack_nframes_t offset);
+ int no_roll (nframes_t nframes, nframes_t offset);
bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work); }
bool process_can_proceed() const { return !(post_transport_work & ProcessCannotProceedMask); }
Type type;
MIDI::MachineControl::Command mmc_cmd;
- jack_nframes_t locate_frame;
+ nframes_t locate_frame;
// for SendMessage type
void set_play_loop (bool yn);
void overwrite_some_buffers (Diskstream*);
void flush_all_redirects ();
- void locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
- void start_locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
- void force_locate (jack_nframes_t frame, bool with_roll = false);
+ void locate (nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
+ void start_locate (nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
+ void force_locate (nframes_t frame, bool with_roll = false);
void set_diskstream_speed (Diskstream*, float speed);
void set_transport_speed (float speed, bool abort = false);
void stop_transport (bool abort = false);
/* FLATTEN */
- int flatten_one_track (AudioTrack&, jack_nframes_t start, jack_nframes_t cnt);
+ int flatten_one_track (AudioTrack&, nframes_t start, nframes_t cnt);
/* INSERT AND SEND MANAGEMENT */
void set_global_solo (GlobalRouteBooleanState s, void *src);
void set_global_record_enable (GlobalRouteBooleanState s, void *src);
- void jack_timebase_callback (jack_transport_state_t, jack_nframes_t, jack_position_t*, int);
+ void jack_timebase_callback (jack_transport_state_t, nframes_t, jack_position_t*, int);
int jack_sync_callback (jack_transport_state_t, jack_position_t*);
void record_enable_change_all (bool yn);
/* click track */
struct Click {
- jack_nframes_t start;
- jack_nframes_t duration;
- jack_nframes_t offset;
+ nframes_t start;
+ nframes_t duration;
+ nframes_t offset;
const Sample *data;
- Click (jack_nframes_t s, jack_nframes_t d, const Sample *b)
+ Click (nframes_t s, nframes_t d, const Sample *b)
: start (s), duration (d), data (b) { offset = 0; }
void *operator new(size_t ignored) {
boost::shared_ptr<IO> _click_io;
Sample* click_data;
Sample* click_emphasis_data;
- jack_nframes_t click_length;
- jack_nframes_t click_emphasis_length;
+ nframes_t click_length;
+ nframes_t click_emphasis_length;
mutable Glib::RWLock click_lock;
static const Sample default_click[];
- static const jack_nframes_t default_click_length;
+ static const nframes_t default_click_length;
static const Sample default_click_emphasis[];
- static const jack_nframes_t default_click_emphasis_length;
+ static const nframes_t default_click_emphasis_length;
Click *get_click();
void setup_click_sounds (int which);
void clear_clicks ();
- void click (jack_nframes_t start, jack_nframes_t nframes, jack_nframes_t offset);
+ void click (nframes_t start, nframes_t nframes, nframes_t offset);
vector<Route*> master_outs;
gain_t* _gain_automation_buffer;
pan_t** _pan_automation_buffer;
- void allocate_pan_automation_buffers (jack_nframes_t nframes, uint32_t howmany, bool force);
+ void allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force);
uint32_t _npan_buffers;
/* VST support */
Slave() { }
virtual ~Slave() {}
- virtual bool speed_and_position (float&, jack_nframes_t&) = 0;
+ virtual bool speed_and_position (float&, nframes_t&) = 0;
virtual bool locked() const = 0;
virtual bool ok() const = 0;
virtual bool starting() const { return false; }
- virtual jack_nframes_t resolution() const = 0;
+ virtual nframes_t resolution() const = 0;
virtual bool requires_seekahead () const = 0;
};
~MTC_Slave ();
void rebind (MIDI::Port&);
- bool speed_and_position (float&, jack_nframes_t&);
+ bool speed_and_position (float&, nframes_t&);
bool locked() const;
bool ok() const;
void handle_locate (const MIDI::byte*);
- jack_nframes_t resolution() const;
+ nframes_t resolution() const;
bool requires_seekahead () const { return true; }
private:
int guard1;
//SMPTE_Time mtc;
- jack_nframes_t position;
- jack_nframes_t timestamp;
+ nframes_t position;
+ nframes_t timestamp;
int guard2;
SafeTime() {
};
SafeTime current;
- jack_nframes_t mtc_frame; /* current time */
- jack_nframes_t last_inbound_frame; /* when we got it; audio clocked */
+ nframes_t mtc_frame; /* current time */
+ nframes_t last_inbound_frame; /* when we got it; audio clocked */
float mtc_speed;
- jack_nframes_t first_mtc_frame;
- jack_nframes_t first_mtc_time;
+ nframes_t first_mtc_frame;
+ nframes_t first_mtc_time;
static const int32_t accumulator_size = 128;
float accumulator[accumulator_size];
ADAT_Slave () {}
~ADAT_Slave () {}
- bool speed_and_position (float& speed, jack_nframes_t& pos) {
+ bool speed_and_position (float& speed, nframes_t& pos) {
speed = 0;
pos = 0;
return false;
bool locked() const { return false; }
bool ok() const { return false; }
- jack_nframes_t resolution() const { return 1; }
+ nframes_t resolution() const { return 1; }
bool requires_seekahead () const { return true; }
};
JACK_Slave (jack_client_t*);
~JACK_Slave ();
- bool speed_and_position (float& speed, jack_nframes_t& pos);
+ bool speed_and_position (float& speed, nframes_t& pos);
bool starting() const { return _starting; }
bool locked() const;
bool ok() const;
- jack_nframes_t resolution() const { return 1; }
+ nframes_t resolution() const { return 1; }
bool requires_seekahead () const { return false; }
private:
/* constructor to be called for new in-session files */
- SndFileSource (Session&, std::string path, SampleFormat samp_format, HeaderFormat hdr_format, jack_nframes_t rate,
+ SndFileSource (Session&, std::string path, SampleFormat samp_format, HeaderFormat hdr_format, nframes_t rate,
Flag flags = AudioFileSource::Flag (AudioFileSource::Writable|
AudioFileSource::Removable|
AudioFileSource::RemovableIfEmpty|
~SndFileSource ();
float sample_rate () const;
- int update_header (jack_nframes_t when, struct tm&, time_t);
+ int update_header (nframes_t when, struct tm&, time_t);
int flush_header ();
- jack_nframes_t natural_position () const;
+ nframes_t natural_position () const;
protected:
void set_header_timeline_position ();
- 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);
+ nframes_t read_unlocked (Sample *dst, nframes_t start, nframes_t cnt) const;
+ nframes_t write_unlocked (Sample *dst, nframes_t cnt);
- jack_nframes_t write_float (Sample* data, jack_nframes_t pos, jack_nframes_t cnt);
+ nframes_t write_float (Sample* data, nframes_t pos, nframes_t cnt);
private:
SNDFILE *sf;
SF_BROADCAST_INFO *_broadcast_info;
mutable float *interleave_buf;
- mutable jack_nframes_t interleave_bufsize;
+ mutable nframes_t interleave_bufsize;
void init (const string &str);
int open();
void close();
- int setup_broadcast_info (jack_nframes_t when, struct tm&, time_t);
+ int setup_broadcast_info (nframes_t when, struct tm&, time_t);
};
} // namespace ARDOUR
// MIDI sources will have to be hacked in here somehow
static boost::shared_ptr<Source> createReadable (Session&, std::string idstr, AudioFileSource::Flag flags, bool announce = true);
- static boost::shared_ptr<Source> createWritable (Session&, std::string name, bool destructive, jack_nframes_t rate, bool announce = true);
+ static boost::shared_ptr<Source> createWritable (Session&, std::string name, bool destructive, nframes_t rate, bool announce = true);
};
}
}
double beats_per_minute () const { return _beats_per_minute; }
- double frames_per_beat (jack_nframes_t sr) const {
+ double frames_per_beat (nframes_t sr) const {
return ((60.0 * sr) / _beats_per_minute);
}
double beats_per_bar () const { return _beats_per_bar; }
double note_divisor() const { return _note_type; }
- double frames_per_bar (const Tempo&, jack_nframes_t sr) const;
+ double frames_per_bar (const Tempo&, nframes_t sr) const;
protected:
virtual ~MetricSection() {}
const BBT_Time& start() const { return _start; }
- const jack_nframes_t frame() const { return _frame; }
+ const nframes_t frame() const { return _frame; }
void set_movable (bool yn) { _movable = yn; }
bool movable() const { return _movable; }
- virtual void set_frame (jack_nframes_t f) {
+ virtual void set_frame (nframes_t f) {
_frame = f;
};
private:
BBT_Time _start;
- jack_nframes_t _frame;
+ nframes_t _frame;
bool _movable;
};
{
public:
- TempoMap (jack_nframes_t frame_rate);
+ TempoMap (nframes_t frame_rate);
~TempoMap();
/* measure-based stuff */
struct BBTPoint {
BBTPointType type;
- jack_nframes_t frame;
+ nframes_t frame;
const Meter* meter;
const Tempo* tempo;
uint32_t bar;
uint32_t beat;
- BBTPoint (const Meter& m, const Tempo& t, jack_nframes_t f, BBTPointType ty, uint32_t b, uint32_t e)
+ BBTPoint (const Meter& m, const Tempo& t, nframes_t f, BBTPointType ty, uint32_t b, uint32_t e)
: type (ty), frame (f), meter (&m), tempo (&t), bar (b), beat (e) {}
};
(obj.*method)(*metrics);
}
- BBTPointList *get_points (jack_nframes_t start, jack_nframes_t end) const;
+ BBTPointList *get_points (nframes_t start, nframes_t end) const;
- void bbt_time (jack_nframes_t when, BBT_Time&) const;
- jack_nframes_t frame_time (const BBT_Time&) const;
- jack_nframes_t bbt_duration_at (jack_nframes_t, const BBT_Time&, int dir) const;
+ void bbt_time (nframes_t when, BBT_Time&) const;
+ nframes_t frame_time (const BBT_Time&) const;
+ nframes_t bbt_duration_at (nframes_t, const BBT_Time&, int dir) const;
static const Tempo& default_tempo() { return _default_tempo; }
static const Meter& default_meter() { return _default_meter; }
- const Tempo& tempo_at (jack_nframes_t);
- const Meter& meter_at (jack_nframes_t);
+ const Tempo& tempo_at (nframes_t);
+ const Meter& meter_at (nframes_t);
void add_tempo(const Tempo&, BBT_Time where);
void add_meter(const Meter&, BBT_Time where);
void replace_meter (MeterSection& existing, const Meter& replacement);
- jack_nframes_t round_to_bar (jack_nframes_t frame, int dir);
+ nframes_t round_to_bar (nframes_t frame, int dir);
- jack_nframes_t round_to_beat (jack_nframes_t frame, int dir);
+ nframes_t round_to_beat (nframes_t frame, int dir);
- jack_nframes_t round_to_beat_subdivision (jack_nframes_t fr, int sub_num);
+ nframes_t round_to_beat_subdivision (nframes_t fr, int sub_num);
- jack_nframes_t round_to_tick (jack_nframes_t frame, int dir);
+ nframes_t round_to_tick (nframes_t frame, int dir);
- void set_length (jack_nframes_t frames);
+ void set_length (nframes_t frames);
XMLNode& get_state (void);
int set_state (const XMLNode&);
void set_tempo (const Tempo& t) { _tempo = &t; }
void set_meter (const Meter& m) { _meter = &m; }
- void set_frame (jack_nframes_t f) { _frame = f; }
+ void set_frame (nframes_t f) { _frame = f; }
void set_start (const BBT_Time& t) { _start = t; }
const Meter& meter() const { return *_meter; }
const Tempo& tempo() const { return *_tempo; }
- jack_nframes_t frame() const { return _frame; }
+ nframes_t frame() const { return _frame; }
const BBT_Time& start() const { return _start; }
private:
const Meter* _meter;
const Tempo* _tempo;
- jack_nframes_t _frame;
+ nframes_t _frame;
BBT_Time _start;
};
Metric metric_at (BBT_Time bbt) const;
- Metric metric_at (jack_nframes_t) const;
- void bbt_time_with_metric (jack_nframes_t, BBT_Time&, const Metric&) const;
+ Metric metric_at (nframes_t) const;
+ void bbt_time_with_metric (nframes_t, BBT_Time&, const Metric&) const;
private:
static Tempo _default_tempo;
static Meter _default_meter;
Metrics *metrics;
- jack_nframes_t _frame_rate;
- jack_nframes_t last_bbt_when;
+ nframes_t _frame_rate;
+ nframes_t last_bbt_when;
bool last_bbt_valid;
BBT_Time last_bbt;
mutable Glib::RWLock lock;
void timestamp_metrics ();
- jack_nframes_t round_to_type (jack_nframes_t fr, int dir, BBTPointType);
+ nframes_t round_to_type (nframes_t fr, int dir, BBTPointType);
- jack_nframes_t frame_time_unlocked (const BBT_Time&) const;
+ nframes_t frame_time_unlocked (const BBT_Time&) const;
- void bbt_time_unlocked (jack_nframes_t, BBT_Time&) const;
+ void bbt_time_unlocked (nframes_t, BBT_Time&) const;
- jack_nframes_t bbt_duration_at_unlocked (const BBT_Time& when, const BBT_Time& bbt, int dir) const;
+ nframes_t bbt_duration_at_unlocked (const BBT_Time& when, const BBT_Time& bbt, int dir) const;
const MeterSection& first_meter() const;
const TempoSection& first_tempo() const;
- jack_nframes_t count_frames_between (const BBT_Time&, const BBT_Time&) const;
- jack_nframes_t count_frames_between_metrics (const Meter&, const Tempo&, const BBT_Time&, const BBT_Time&) const;
+ nframes_t count_frames_between (const BBT_Time&, const BBT_Time&) const;
+ nframes_t count_frames_between_metrics (const Meter&, const Tempo&, const BBT_Time&, const BBT_Time&) const;
int move_metric_section (MetricSection&, const BBT_Time& to);
void do_insert (MetricSection* section);
int set_name (string str, void *src);
- virtual 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) = 0;
+ virtual 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) = 0;
- virtual 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) = 0;
+ virtual 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) = 0;
- virtual 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) = 0;
+ virtual int silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
+ nframes_t offset, bool can_record, bool rec_monitors_input) = 0;
void toggle_monitor_input ();
TrackMode mode() const { return _mode; }
void set_mode (TrackMode m);
- jack_nframes_t update_total_latency();
- void set_latency_delay (jack_nframes_t);
+ nframes_t update_total_latency();
+ void set_latency_delay (nframes_t);
enum FreezeState {
NoFreeze,
virtual void unfreeze () = 0;
virtual void bounce (InterThreadInfo&) = 0;
- virtual void bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo&) = 0;
+ virtual void bounce_range (nframes_t start, nframes_t end, InterThreadInfo&) = 0;
XMLNode& get_state();
XMLNode& get_template();
virtual XMLNode& state (bool full) = 0;
- virtual void passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame,
- jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter) = 0;
+ virtual void passthru_silence (nframes_t start_frame, nframes_t end_frame,
+ nframes_t nframes, nframes_t offset, int declick, bool meter) = 0;
virtual uint32_t n_process_buffers () = 0;
typedef int intptr_t;
#endif
+/* at some point move this into the ARDOUR namespace,
+ but for now its outside because it replaces the
+ old global "jack_nframes_t"
+*/
+
+typedef uint32_t nframes_t;
+
namespace ARDOUR {
class Source;
OverlapExternal // overlap extends to (at least) begin+end
};
- OverlapType coverage (jack_nframes_t start_a, jack_nframes_t end_a,
- jack_nframes_t start_b, jack_nframes_t end_b);
+ OverlapType coverage (nframes_t start_a, nframes_t end_a,
+ nframes_t start_b, nframes_t end_b);
enum AutomationType {
GainAutomation = 0x1,
BBT_Time bbt;
union {
- jack_nframes_t frames;
+ nframes_t frames;
double seconds;
};
};
struct AudioRange {
- jack_nframes_t start;
- jack_nframes_t end;
+ nframes_t start;
+ nframes_t end;
uint32_t id;
- AudioRange (jack_nframes_t s, jack_nframes_t e, uint32_t i) : start (s), end (e) , id (i) {}
+ AudioRange (nframes_t s, nframes_t e, uint32_t i) : start (s), end (e) , id (i) {}
- jack_nframes_t length() { return end - start + 1; }
+ nframes_t length() { return end - start + 1; }
bool operator== (const AudioRange& other) const {
return start == other.start && end == other.end && id == other.id;
return start == other.start && end == other.end;
}
- OverlapType coverage (jack_nframes_t s, jack_nframes_t e) const {
+ OverlapType coverage (nframes_t s, nframes_t e) const {
return ARDOUR::coverage (start, end, s, e);
}
};
std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
-static inline jack_nframes_t
-session_frame_to_track_frame (jack_nframes_t session_frame, double speed)
+static inline nframes_t
+session_frame_to_track_frame (nframes_t session_frame, double speed)
{
- return (jack_nframes_t)( (double)session_frame * speed );
+ return (nframes_t)( (double)session_frame * speed );
}
-static inline jack_nframes_t
-track_frame_to_session_frame (jack_nframes_t track_frame, double speed)
+static inline nframes_t
+track_frame_to_session_frame (nframes_t track_frame, double speed)
{
- return (jack_nframes_t)( (double)track_frame / speed );
+ return (nframes_t)( (double)track_frame / speed );
}
std::string region_name_from_path (std::string path);
std::string path_expand (std::string);
-void compute_equal_power_fades (jack_nframes_t nframes, float* in, float* out);
+void compute_equal_power_fades (nframes_t nframes, float* in, float* out);
const char* slave_source_to_string (ARDOUR::SlaveSource src);
ARDOUR::SlaveSource string_to_slave_source (std::string str);
const char * maker() const;
uint32_t parameter_count() const;
float default_value (uint32_t port);
- jack_nframes_t latency() const;
+ nframes_t latency() const;
void set_parameter (uint32_t port, float val);
float get_parameter (uint32_t port) const;
int get_parameter_descriptor (uint32_t which, ParameterDescriptor&) const;
uint32_t nth_parameter (uint32_t port, bool& ok) const;
void activate ();
void deactivate ();
- void set_block_size (jack_nframes_t nframes);
- int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, jack_nframes_t nframes, jack_nframes_t offset);
+ void set_block_size (nframes_t nframes);
+ int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset);
void store_state (ARDOUR::PluginState&);
void restore_state (ARDOUR::PluginState&);
string describe_parameter (uint32_t);
/* 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());
}
/* a single full-sized region */
- cerr << "setup DS using " << srcs.front()->natural_position () << endl;
-
- boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames, _name));
+ boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name));
_playlist->add_region (region, srcs.front()->natural_position());
}
with the (presumed single, full-extent) region.
*/
- Playlist::RegionList* rl = _playlist->regions_at (0);
+ boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
- if (rl->empty()) {
+ if (!rp) {
reset_write_sources (false, true);
return;
}
- boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rl->front());
+ boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
if (region == 0) {
throw failed_constructor();
}
- delete rl;
-
uint32_t n;
ChannelList::iterator chan;
}
void
-AudioDiskstream::check_record_status (jack_nframes_t transport_frame, jack_nframes_t nframes, bool can_record)
+AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
{
int possibly_recording;
int rolling;
}
int
-AudioDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes, jack_nframes_t offset, bool can_record, bool rec_monitors_input)
+AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input)
{
uint32_t n;
ChannelList::iterator c;
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;
} else {
- jack_nframes_t total = chan.capture_vector.len[0] + chan.capture_vector.len[1];
+ nframes_t total = chan.capture_vector.len[0] + chan.capture_vector.len[1];
if (rec_nframes > total) {
DiskOverrun ();
}
Sample* buf = _io->input (n)->get_buffer (nframes) + offset;
- jack_nframes_t first = chan.capture_vector.len[0];
+ nframes_t first = chan.capture_vector.len[0];
memcpy (chan.capture_wrap_buffer, buf, sizeof (Sample) * first);
memcpy (chan.capture_vector.buf[0], buf, sizeof (Sample) * first);
/* 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;
}
chan.current_playback_buffer = chan.playback_vector.buf[0];
} else {
- jack_nframes_t total = chan.playback_vector.len[0] + chan.playback_vector.len[1];
+ nframes_t total = chan.playback_vector.len[0] + chan.playback_vector.len[1];
if (necessary_samples > total) {
DiskUnderrun ();
if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
uint64_t phase = last_phase;
- jack_nframes_t i = 0;
+ nframes_t i = 0;
// Linearly interpolate into the alt buffer
// using 40.24 fixp maths (swh)
i = 0;
phase = last_phase;
- for (jack_nframes_t outsample = 0; outsample < nframes; ++outsample) {
+ for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
i = phase >> 24;
fr = (phase & 0xFFFFFF) / 16777216.0f;
chan.speed_buffer[outsample] =
}
bool
-AudioDiskstream::commit (jack_nframes_t nframes)
+AudioDiskstream::commit (nframes_t nframes)
{
bool need_butler = false;
overwrite_queued = false;
/* assume all are the same size */
- jack_nframes_t size = channels[0].playback_buf->bufsize();
+ nframes_t size = channels[0].playback_buf->bufsize();
mixdown_buffer = new Sample[size];
gain_buffer = new float[size];
size--;
uint32_t n=0;
- jack_nframes_t start;
+ nframes_t start;
for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan, ++n) {
start = overwrite_frame;
- jack_nframes_t cnt = size;
+ nframes_t cnt = size;
/* to fill the buffer without resetting the playback sample, we need to
do it one or two chunks (normally two).
*/
- jack_nframes_t to_read = size - overwrite_offset;
+ nframes_t to_read = size - overwrite_offset;
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"),
}
int
-AudioDiskstream::seek (jack_nframes_t frame, bool complete_refill)
+AudioDiskstream::seek (nframes_t frame, bool complete_refill)
{
Glib::Mutex::Lock lm (state_lock);
uint32_t n;
}
int
-AudioDiskstream::can_internal_playback_seek (jack_nframes_t distance)
+AudioDiskstream::can_internal_playback_seek (nframes_t distance)
{
ChannelList::iterator chan;
}
int
-AudioDiskstream::internal_playback_seek (jack_nframes_t distance)
+AudioDiskstream::internal_playback_seek (nframes_t distance)
{
ChannelList::iterator chan;
}
int
-AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, jack_nframes_t& start, jack_nframes_t cnt,
+AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
ChannelInfo& channel_info, int channel, 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;
- jack_nframes_t offset = 0;
+ nframes_t loop_end = 0;
+ nframes_t loop_start = 0;
+ nframes_t loop_length = 0;
+ nframes_t offset = 0;
Location *loc = 0;
if (!reversed) {
AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
{
int32_t ret = 0;
- jack_nframes_t to_read;
+ nframes_t to_read;
RingBufferNPT<Sample>::rw_vector vector;
bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
- jack_nframes_t total_space;
- jack_nframes_t zero_fill;
+ nframes_t total_space;
+ nframes_t zero_fill;
uint32_t chan_n;
ChannelList::iterator i;
- jack_nframes_t ts;
+ nframes_t ts;
assert(mixdown_buffer);
assert(gain_buffer);
}
}
- jack_nframes_t file_frame_tmp = 0;
+ nframes_t file_frame_tmp = 0;
for (chan_n = 0, i = channels.begin(); i != channels.end(); ++i, ++chan_n) {
ChannelInfo& chan (*i);
Sample* buf1;
Sample* buf2;
- jack_nframes_t len1, len2;
+ nframes_t len1, len2;
chan.playback_buf->get_write_vector (&vector);
int32_t ret = 0;
RingBufferNPT<Sample>::rw_vector vector;
RingBufferNPT<CaptureTransition>::rw_vector transvec;
- jack_nframes_t total;
+ nframes_t total;
_write_data_count = 0;
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]);
// check the transition buffer when recording destructive
// important that we get this after the capture buf
of vector.len[1] to be flushed to disk as well.
*/
- to_write = min ((jack_nframes_t)(disk_io_chunk_frames - to_write), (jack_nframes_t) vector.len[1]);
+ to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
if ((*chan).write_source->write (vector.buf[1], to_write) != to_write) {
error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
bool more_work = true;
int err = 0;
boost::shared_ptr<AudioRegion> region;
- jack_nframes_t total_capture;
+ nframes_t total_capture;
SourceList srcs;
SourceList::iterator src;
ChannelList::iterator chan;
}
void
-AudioDiskstream::set_block_size (jack_nframes_t nframes)
+AudioDiskstream::set_block_size (nframes_t nframes)
{
if (_session.get_block_size() > speed_buffer_size) {
speed_buffer_size = _session.get_block_size();
*/
double sp = max (fabsf (_actual_speed), 1.2f);
- jack_nframes_t required_wrap_size = (jack_nframes_t) floor (_session.get_block_size() * sp) + 1;
+ nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
if (required_wrap_size > wrap_buffer_size) {
boost::shared_ptr<AudioFileSource> fs;
boost::shared_ptr<AudioFileSource> first_fs;
SourceList pending_sources;
- jack_nframes_t position;
+ nframes_t position;
if ((prop = node.property (X_("at"))) == 0) {
return -1;
}
}
-AudioPlaylist::AudioPlaylist (const AudioPlaylist& other, jack_nframes_t start, jack_nframes_t cnt, string name, bool hidden)
+AudioPlaylist::AudioPlaylist (const AudioPlaylist& other, nframes_t start, nframes_t cnt, string name, bool hidden)
: Playlist (other, start, cnt, name, hidden)
{
save_state (_("initial state"));
}
};
-jack_nframes_t
-AudioPlaylist::read (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, jack_nframes_t start,
- jack_nframes_t cnt, unsigned chan_n)
+nframes_t
+AudioPlaylist::read (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, nframes_t start,
+ nframes_t cnt, unsigned chan_n)
{
- jack_nframes_t ret = cnt;
- jack_nframes_t end;
- jack_nframes_t read_frames;
- jack_nframes_t skip_frames;
+ nframes_t ret = cnt;
+ nframes_t end;
+ nframes_t read_frames;
+ nframes_t skip_frames;
/* optimizing this memset() away involves a lot of conditionals
that may well cause more of a hit due to cache misses
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
if ((*i)->coverage (start, end) != OverlapNone) {
-
relevant_regions[(*i)->layer()].push_back (*i);
relevant_layers.push_back ((*i)->layer());
}
audio engineering.
*/
- jack_nframes_t xfade_length = min ((jack_nframes_t) 720, top->length());
+ nframes_t xfade_length = min ((nframes_t) 720, top->length());
/* in, out */
xfade = new Crossfade (top, bottom, xfade_length, top->first_frame(), StartOfIn);
}
void
-AudioPlaylist::crossfades_at (jack_nframes_t frame, Crossfades& clist)
+AudioPlaylist::crossfades_at (nframes_t frame, Crossfades& clist)
{
RegionLock rlock (this);
for (Crossfades::iterator i = _crossfades.begin(); i != _crossfades.end(); ++i) {
- jack_nframes_t start, end;
+ nframes_t start, end;
start = (*i)->position();
end = start + (*i)->overlap_length(); // not length(), important difference
}
void
-AudioTrack::passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter)
+AudioTrack::passthru_silence (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter)
{
uint32_t nbufs = n_process_buffers ();
process_output_buffers (_session.get_silent_buffers (nbufs), nbufs, start_frame, end_frame, nframes, offset, true, declick, meter);
}
int
-AudioTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset,
+AudioTrack::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() == 0) {
}
int
-AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset, int declick,
+AudioTrack::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;
Sample* b;
Sample* tmpb;
- jack_nframes_t transport_frame;
+ nframes_t transport_frame;
boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
{
}
int
-AudioTrack::silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset,
+AudioTrack::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() == 0 && _redirects.empty()) {
}
int
-AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, jack_nframes_t start, jack_nframes_t nframes)
+AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, nframes_t start, nframes_t nframes)
{
gain_t gain_automation[nframes];
gain_t gain_buffer[nframes];
for (bi = buffers.begin(); bi != buffers.end(); ++bi) {
Sample *b = *bi;
- for (jack_nframes_t n = 0; n < nframes; ++n) {
+ for (nframes_t n = 0; n < nframes; ++n) {
b[n] *= gain_automation[n];
}
}
for (bi = buffers.begin(); bi != buffers.end(); ++bi) {
Sample *b = *bi;
- for (jack_nframes_t n = 0; n < nframes; ++n) {
+ for (nframes_t n = 0; n < nframes; ++n) {
b[n] *= this_gain;
}
}
void
-AudioTrack::bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo& itt)
+AudioTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt)
{
vector<boost::shared_ptr<AudioSource> > srcs;
_session.write_one_audio_track (*this, start, end, false, srcs, itt);
return 0;
}
-jack_nframes_t
+nframes_t
AUPlugin::latency () const
{
return unit->Latency ();
}
void
-AUPlugin::set_block_size (jack_nframes_t nframes)
+AUPlugin::set_block_size (nframes_t nframes)
{
}
int
-AUPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, jack_nframes_t nframes, jack_nframes_t offset)
+AUPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset)
{
AudioUnitRenderActionFlags flags = 0;
AudioTimeStamp ts;
using namespace ARDOUR;
using namespace PBD;
-jack_nframes_t Port::_short_over_length = 2;
-jack_nframes_t Port::_long_over_length = 10;
+nframes_t Port::_short_over_length = 2;
+nframes_t Port::_long_over_length = 10;
AudioEngine::AudioEngine (string client_name)
: ports (new Ports)
if (!_running) {
if (session) {
- jack_nframes_t blocksize = jack_get_buffer_size (_jack);
+ nframes_t blocksize = jack_get_buffer_size (_jack);
session->set_block_size (blocksize);
session->set_frame_rate (jack_get_sample_rate (_jack));
bool
-AudioEngine::get_sync_offset (jack_nframes_t& offset) const
+AudioEngine::get_sync_offset (nframes_t& offset) const
{
#ifdef HAVE_JACK_VIDEO_SUPPORT
}
void
-AudioEngine::_jack_timebase_callback (jack_transport_state_t state, jack_nframes_t nframes,
+AudioEngine::_jack_timebase_callback (jack_transport_state_t state, nframes_t nframes,
jack_position_t* pos, int new_position, void *arg)
{
static_cast<AudioEngine*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
}
void
-AudioEngine::jack_timebase_callback (jack_transport_state_t state, jack_nframes_t nframes,
+AudioEngine::jack_timebase_callback (jack_transport_state_t state, nframes_t nframes,
jack_position_t* pos, int new_position)
{
if (session && session->synced_to_jack()) {
}
int
-AudioEngine::_process_callback (jack_nframes_t nframes, void *arg)
+AudioEngine::_process_callback (nframes_t nframes, void *arg)
{
return static_cast<AudioEngine *> (arg)->process_callback (nframes);
}
}
int
-AudioEngine::process_callback (jack_nframes_t nframes)
+AudioEngine::process_callback (nframes_t nframes)
{
// CycleTimer ct ("AudioEngine::process");
Glib::Mutex::Lock tm (_process_lock, Glib::TRY_LOCK);
- jack_nframes_t next_processed_frames;
+ nframes_t next_processed_frames;
/* handle wrap around of total frames counter */
}
int
-AudioEngine::_sample_rate_callback (jack_nframes_t nframes, void *arg)
+AudioEngine::_sample_rate_callback (nframes_t nframes, void *arg)
{
return static_cast<AudioEngine *> (arg)->jack_sample_rate_callback (nframes);
}
int
-AudioEngine::jack_sample_rate_callback (jack_nframes_t nframes)
+AudioEngine::jack_sample_rate_callback (nframes_t nframes)
{
_frame_rate = nframes;
_usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0);
}
int
-AudioEngine::_bufsize_callback (jack_nframes_t nframes, void *arg)
+AudioEngine::_bufsize_callback (nframes_t nframes, void *arg)
{
return static_cast<AudioEngine *> (arg)->jack_bufsize_callback (nframes);
}
int
-AudioEngine::jack_bufsize_callback (jack_nframes_t nframes)
+AudioEngine::jack_bufsize_callback (nframes_t nframes)
{
_buffer_size = nframes;
_usecs_per_cycle = (int) floor ((((double) nframes / frame_rate())) * 1000000.0);
}
-jack_nframes_t
+nframes_t
AudioEngine::frame_rate ()
{
if (_jack) {
}
}
-jack_nframes_t
+nframes_t
AudioEngine::frames_per_cycle ()
{
if (_jack) {
return ret;
}
-jack_nframes_t
+nframes_t
AudioEngine::get_port_total_latency (const Port& port)
{
if (!_jack) {
}
void
-AudioEngine::transport_locate (jack_nframes_t where)
+AudioEngine::transport_locate (nframes_t where)
{
// cerr << "tell JACK to locate to " << where << endl;
if (_jack) {
if (session) {
- jack_nframes_t blocksize = jack_get_buffer_size (_jack);
+ nframes_t blocksize = jack_get_buffer_size (_jack);
session->set_block_size (blocksize);
session->set_frame_rate (jack_get_sample_rate (_jack));
}
}
int
-AudioEngine::request_buffer_size (jack_nframes_t nframes)
+AudioEngine::request_buffer_size (nframes_t nframes)
{
if (_jack) {
int ret = jack_set_buffer_size (_jack, nframes);
bool is_new = false;
_length = 0;
+ timeline_position = 0;
next_peak_clear_should_notify = false;
if (!find (pathstr, must_exist, is_new)) {
}
void
-AudioFileSource::set_header_position_offset (jack_nframes_t offset)
+AudioFileSource::set_header_position_offset (nframes_t offset)
{
header_position_offset = offset;
HeaderPositionOffsetChanged ();
}
void
-AudioFileSource::set_timeline_position (jack_nframes_t pos)
+AudioFileSource::set_timeline_position (nframes_t pos)
{
timeline_position = pos;
}
{
}
-AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, jack_nframes_t start, jack_nframes_t length)
+AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, nframes_t start, nframes_t length)
: Region (start, length, PBD::basename_nosuffix(src->name()), 0, Region::Flag(Region::DefaultFlags|Region::External)),
_fade_in (0.0, 2.0, 1.0, false),
_fade_out (0.0, 2.0, 1.0, false),
_envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed));
}
-AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Flag flags)
+AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, nframes_t start, nframes_t length, const string& name, layer_t layer, Flag flags)
: Region (start, length, name, layer, flags),
_fade_in (0.0, 2.0, 1.0, false),
_fade_out (0.0, 2.0, 1.0, false),
_envelope.StateChanged.connect (mem_fun (*this, &AudioRegion::envelope_changed));
}
-AudioRegion::AudioRegion (SourceList& srcs, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Flag flags)
+AudioRegion::AudioRegion (SourceList& srcs, nframes_t start, nframes_t length, const string& name, layer_t layer, Flag flags)
: Region (start, length, name, layer, flags),
_fade_in (0.0, 2.0, 1.0, false),
_fade_out (0.0, 2.0, 1.0, false),
}
-AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other, jack_nframes_t offset, jack_nframes_t length, const string& name, layer_t layer, Flag flags)
+AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags)
: Region (other, offset, length, name, layer, flags),
_fade_in (other->_fade_in),
_fade_out (other->_fade_out),
}
bool
-AudioRegion::verify_length (jack_nframes_t len)
+AudioRegion::verify_length (nframes_t len)
{
if (boost::dynamic_pointer_cast<DestructiveFileSource>(source())) {
return true;
}
bool
-AudioRegion::verify_start_and_length (jack_nframes_t new_start, jack_nframes_t new_length)
+AudioRegion::verify_start_and_length (nframes_t new_start, nframes_t new_length)
{
if (boost::dynamic_pointer_cast<DestructiveFileSource>(source())) {
return true;
return true;
}
bool
-AudioRegion::verify_start (jack_nframes_t pos)
+AudioRegion::verify_start (nframes_t pos)
{
if (boost::dynamic_pointer_cast<DestructiveFileSource>(source())) {
return true;
}
bool
-AudioRegion::verify_start_mutable (jack_nframes_t& new_start)
+AudioRegion::verify_start_mutable (nframes_t& new_start)
{
if (boost::dynamic_pointer_cast<DestructiveFileSource>(source())) {
return true;
}
}
-jack_nframes_t
-AudioRegion::read_peaks (PeakData *buf, jack_nframes_t npeaks, jack_nframes_t offset, jack_nframes_t cnt, uint32_t chan_n, double samples_per_unit) const
+nframes_t
+AudioRegion::read_peaks (PeakData *buf, nframes_t npeaks, nframes_t offset, nframes_t cnt, uint32_t chan_n, double samples_per_unit) const
{
if (chan_n >= sources.size()) {
return 0;
return 0;
} else {
if (_scale_amplitude != 1.0) {
- for (jack_nframes_t n = 0; n < npeaks; ++n) {
+ for (nframes_t n = 0; n < npeaks; ++n) {
buf[n].max *= _scale_amplitude;
buf[n].min *= _scale_amplitude;
}
}
}
-jack_nframes_t
-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
+nframes_t
+AudioRegion::read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, nframes_t position,
+ nframes_t cnt,
+ uint32_t chan_n, nframes_t read_frames, nframes_t skip_frames) const
{
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, jack_nframes_t position,
- jack_nframes_t cnt, uint32_t chan_n) const
+nframes_t
+AudioRegion::master_read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, nframes_t position,
+ nframes_t cnt, uint32_t chan_n) const
{
return _read_at (master_sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, 0, 0);
}
-jack_nframes_t
+nframes_t
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
+ nframes_t position, nframes_t cnt,
+ uint32_t chan_n, nframes_t read_frames, nframes_t skip_frames) const
{
- jack_nframes_t internal_offset;
- jack_nframes_t buf_offset;
- jack_nframes_t to_read;
-
+ nframes_t internal_offset;
+ nframes_t buf_offset;
+ nframes_t to_read;
+
/* precondition: caller has verified that we cover the desired section */
if (chan_n >= sources.size()) {
if (internal_offset >= _length) {
return 0; /* read nothing */
}
-
if ((to_read = min (cnt, _length - internal_offset)) == 0) {
return 0; /* read nothing */
if (_flags & FadeIn) {
- jack_nframes_t fade_in_length = (jack_nframes_t) _fade_in.back()->when;
+ nframes_t fade_in_length = (nframes_t) _fade_in.back()->when;
/* see if this read is within the fade in */
if (internal_offset < fade_in_length) {
- jack_nframes_t limit;
+ nframes_t limit;
limit = min (to_read, fade_in_length - internal_offset);
_fade_in.get_vector (internal_offset, internal_offset+limit, gain_buffer, limit);
- for (jack_nframes_t n = 0; n < limit; ++n) {
+ for (nframes_t n = 0; n < limit; ++n) {
mixdown_buffer[n] *= gain_buffer[n];
}
}
if (_flags & FadeOut) {
-
-
-
/* see if some part of this read is within the fade out */
/* ................. >| REGION
*/
- jack_nframes_t fade_out_length = (jack_nframes_t) _fade_out.back()->when;
- jack_nframes_t fade_interval_start = max(internal_offset, _length-fade_out_length);
- jack_nframes_t fade_interval_end = min(internal_offset + to_read, _length);
+ nframes_t fade_out_length = (nframes_t) _fade_out.back()->when;
+ nframes_t fade_interval_start = max(internal_offset, _length-fade_out_length);
+ nframes_t fade_interval_end = min(internal_offset + to_read, _length);
if (fade_interval_end > fade_interval_start) {
/* (part of the) the fade out is in this buffer */
- jack_nframes_t limit = fade_interval_end - fade_interval_start;
- jack_nframes_t curve_offset = fade_interval_start - (_length-fade_out_length);
- jack_nframes_t fade_offset = fade_interval_start - internal_offset;
+ nframes_t limit = fade_interval_end - fade_interval_start;
+ nframes_t curve_offset = fade_interval_start - (_length-fade_out_length);
+ nframes_t fade_offset = fade_interval_start - internal_offset;
_fade_out.get_vector (curve_offset,curve_offset+limit, gain_buffer, limit);
- for (jack_nframes_t n = 0, m = fade_offset; n < limit; ++n, ++m) {
+ for (nframes_t n = 0, m = fade_offset; n < limit; ++n, ++m) {
mixdown_buffer[m] *= gain_buffer[n];
}
}
_envelope.get_vector (internal_offset, internal_offset + to_read, gain_buffer, to_read);
if (_scale_amplitude != 1.0f) {
- for (jack_nframes_t n = 0; n < to_read; ++n) {
+ for (nframes_t n = 0; n < to_read; ++n) {
mixdown_buffer[n] *= gain_buffer[n] * _scale_amplitude;
}
} else {
- for (jack_nframes_t n = 0; n < to_read; ++n) {
+ for (nframes_t n = 0; n < to_read; ++n) {
mixdown_buffer[n] *= gain_buffer[n];
}
}
buf += buf_offset;
- for (jack_nframes_t n = 0; n < to_read; ++n) {
+ for (nframes_t n = 0; n < to_read; ++n) {
buf[n] += mixdown_buffer[n];
}
}
void
AudioRegion::set_fade_in_shape (FadeShape shape)
{
- set_fade_in (shape, (jack_nframes_t) _fade_in.back()->when);
+ set_fade_in (shape, (nframes_t) _fade_in.back()->when);
}
void
AudioRegion::set_fade_out_shape (FadeShape shape)
{
- set_fade_out (shape, (jack_nframes_t) _fade_out.back()->when);
+ set_fade_out (shape, (nframes_t) _fade_out.back()->when);
}
void
-AudioRegion::set_fade_in (FadeShape shape, jack_nframes_t len)
+AudioRegion::set_fade_in (FadeShape shape, nframes_t len)
{
_fade_in.freeze ();
_fade_in.clear ();
}
void
-AudioRegion::set_fade_out (FadeShape shape, jack_nframes_t len)
+AudioRegion::set_fade_out (FadeShape shape, nframes_t len)
{
_fade_out.freeze ();
_fade_out.clear ();
}
void
-AudioRegion::set_fade_in_length (jack_nframes_t len)
+AudioRegion::set_fade_in_length (nframes_t len)
{
bool changed = _fade_in.extend_to (len);
}
void
-AudioRegion::set_fade_out_length (jack_nframes_t len)
+AudioRegion::set_fade_out_length (nframes_t len)
{
bool changed = _fade_out.extend_to (len);
int
AudioRegion::exportme (Session& session, AudioExportSpecification& spec)
{
- const jack_nframes_t blocksize = 4096;
- jack_nframes_t to_read;
+ const nframes_t blocksize = 4096;
+ nframes_t to_read;
int status = -1;
spec.channels = sources.size();
goto out;
}
- for (jack_nframes_t x = 0; x < to_read; ++x) {
+ for (nframes_t x = 0; x < to_read; ++x) {
spec.dataF[chan+(x*spec.channels)] = buf[x];
}
}
void
AudioRegion::normalize_to (float target_dB)
{
- const jack_nframes_t blocksize = 64 * 1024;
+ const nframes_t blocksize = 64 * 1024;
Sample buf[blocksize];
- jack_nframes_t fpos;
- jack_nframes_t fend;
- jack_nframes_t to_read;
+ nframes_t fpos;
+ nframes_t fend;
+ nframes_t to_read;
double maxamp = 0;
gain_t target = dB_to_coefficient (target_dB);
void
AudioRegion::source_offset_changed ()
{
- if (boost::dynamic_pointer_cast<DestructiveFileSource> (source())) {
+ if (boost::dynamic_pointer_cast<DestructiveFileSource>(sources.front())) {
set_start (source()->natural_position(), this);
set_position (source()->natural_position(), this);
} else {
int region_read_peaks_from_c (void *arg, uint32_t npeaks, uint32_t start, uint32_t cnt, intptr_t data, uint32_t n_chan, double samples_per_unit)
{
- return ((AudioRegion *) arg)->read_peaks ((PeakData *) data, (jack_nframes_t) npeaks, (jack_nframes_t) start, (jack_nframes_t) cnt, n_chan,samples_per_unit);
+ return ((AudioRegion *) arg)->read_peaks ((PeakData *) data, (nframes_t) npeaks, (nframes_t) start, (nframes_t) cnt, n_chan,samples_per_unit);
}
uint32_t region_length_from_c (void *arg)
#include <fcntl.h>
#include <poll.h>
#include <float.h>
+#include <utime.h>
#include <cerrno>
#include <ctime>
#include <cmath>
return ret;
}
+void
+AudioSource::touch_peakfile ()
+{
+ struct stat statbuf;
+
+ if (stat (peakpath.c_str(), &statbuf) != 0 || statbuf.st_size == 0) {
+ return;
+ }
+
+ struct utimbuf tbuf;
+
+ tbuf.actime = statbuf.st_atime;
+ tbuf.modtime = time ((time_t) 0);
+
+ utime (peakpath.c_str(), &tbuf);
+}
+
int
AudioSource::rename_peakfile (string newpath)
{
error << string_compose(_("AudioSource: cannot stat peakfile \"%1\""), peakpath) << endmsg;
return -1;
}
-
} else {
/* we found it in the peaks dir */
return 0;
}
-jack_nframes_t
-AudioSource::read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
+nframes_t
+AudioSource::read (Sample *dst, nframes_t start, nframes_t cnt) const
{
Glib::Mutex::Lock lm (_lock);
return read_unlocked (dst, start, cnt);
}
-jack_nframes_t
-AudioSource::write (Sample *dst, jack_nframes_t cnt)
+nframes_t
+AudioSource::write (Sample *dst, nframes_t cnt)
{
Glib::Mutex::Lock lm (_lock);
return write_unlocked (dst, cnt);
}
int
-AudioSource::read_peaks (PeakData *peaks, jack_nframes_t npeaks, jack_nframes_t start, jack_nframes_t cnt, double samples_per_visual_peak) const
+AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nframes_t cnt, double samples_per_visual_peak) const
{
Glib::Mutex::Lock lm (_lock);
double scale;
PeakData::PeakDatum xmin;
int32_t to_read;
uint32_t nread;
- jack_nframes_t zero_fill = 0;
+ nframes_t zero_fill = 0;
int ret = -1;
PeakData* staging = 0;
Sample* raw_staging = 0;
if (cnt > _length - start) {
// cerr << "too close to end @ " << _length << " given " << start << " + " << cnt << endl;
cnt = _length - start;
- jack_nframes_t old = npeaks;
- npeaks = min ((jack_nframes_t) floor (cnt / samples_per_visual_peak), npeaks);
+ nframes_t old = npeaks;
+ npeaks = min ((nframes_t) floor (cnt / samples_per_visual_peak), npeaks);
zero_fill = old - npeaks;
}
if (npeaks == cnt) {
- // cerr << "RAW DATA\n";
+ cerr << "RAW DATA\n";
/* no scaling at all, just get the sample data and duplicate it for
both max and min peak values.
return -1;
}
- for (jack_nframes_t i = 0; i < npeaks; ++i) {
+ for (nframes_t i = 0; i < npeaks; ++i) {
peaks[i].max = raw_staging[i];
peaks[i].min = raw_staging[i];
}
}
- jack_nframes_t tnp;
+ nframes_t tnp;
if (scale < 1.0) {
/* compute the rounded up frame position */
- jack_nframes_t current_frame = start;
- jack_nframes_t current_stored_peak = (jack_nframes_t) ceil (current_frame / (double) frames_per_peak);
+ nframes_t current_frame = start;
+ nframes_t current_stored_peak = (nframes_t) ceil (current_frame / (double) frames_per_peak);
uint32_t next_visual_peak = (uint32_t) ceil (current_frame / samples_per_visual_peak);
double next_visual_peak_frame = next_visual_peak * samples_per_visual_peak;
- uint32_t stored_peak_before_next_visual_peak = (jack_nframes_t) next_visual_peak_frame / frames_per_peak;
+ uint32_t stored_peak_before_next_visual_peak = (nframes_t) next_visual_peak_frame / frames_per_peak;
uint32_t nvisual_peaks = 0;
uint32_t stored_peaks_read = 0;
uint32_t i = 0;
if (i == stored_peaks_read) {
uint32_t start_byte = current_stored_peak * sizeof(PeakData);
- tnp = min ((_length/frames_per_peak - current_stored_peak), (jack_nframes_t) expected_peaks);
+ tnp = min ((_length/frames_per_peak - current_stored_peak), (nframes_t) expected_peaks);
to_read = min (chunksize, tnp);
off_t fend = lseek (peakfile, 0, SEEK_END);
data on the fly.
*/
- jack_nframes_t frames_read = 0;
- jack_nframes_t current_frame = start;
- jack_nframes_t i = 0;
- jack_nframes_t nvisual_peaks = 0;
- jack_nframes_t chunksize = (jack_nframes_t) min (cnt, (jack_nframes_t) 4096);
+ nframes_t frames_read = 0;
+ nframes_t current_frame = start;
+ nframes_t i = 0;
+ nframes_t nvisual_peaks = 0;
+ nframes_t chunksize = (nframes_t) min (cnt, (nframes_t) 4096);
raw_staging = new Sample[chunksize];
- jack_nframes_t frame_pos = start;
+ nframes_t frame_pos = start;
double pixel_pos = floor (frame_pos / samples_per_visual_peak);
double next_pixel_pos = ceil (frame_pos / samples_per_visual_peak);
double pixels_per_frame = 1.0 / samples_per_visual_peak;
if (i == frames_read) {
to_read = min (chunksize, (_length - current_frame));
-
+
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)
}
int
-AudioSource::do_build_peak (jack_nframes_t first_frame, jack_nframes_t cnt)
+AudioSource::do_build_peak (nframes_t first_frame, nframes_t cnt)
{
- jack_nframes_t current_frame;
+ nframes_t current_frame;
Sample buf[frames_per_peak];
Sample xmin, xmax;
uint32_t peaki;
PeakData* peakbuf;
- jack_nframes_t frames_read;
- jack_nframes_t frames_to_read;
+ nframes_t frames_read;
+ nframes_t frames_to_read;
off_t first_peak_byte;
int peakfile = -1;
int ret = -1;
xmin = buf[0];
xmax = buf[0];
- for (jack_nframes_t n = 1; n < frames_read; ++n) {
+ for (nframes_t n = 1; n < frames_read; ++n) {
xmax = max (xmax, buf[n]);
xmin = min (xmin, buf[n]);
}
}
-jack_nframes_t
+nframes_t
AudioSource::available_peaks (double zoom_factor) const
{
int peakfile;
}
void
-AudioSource::update_length (jack_nframes_t pos, jack_nframes_t cnt)
+AudioSource::update_length (nframes_t pos, nframes_t cnt)
{
if (pos + cnt > _length) {
_length = pos+cnt;
}
int
-Auditioner::play_audition (jack_nframes_t nframes)
+Auditioner::play_audition (nframes_t nframes)
{
bool need_butler;
- jack_nframes_t this_nframes;
+ nframes_t this_nframes;
int ret;
if (g_atomic_int_get (&_active) == 0) {
XMLNode *pointnode = new XMLNode ("point");
- snprintf (buf, sizeof (buf), "%" PRIu32, (jack_nframes_t) floor ((*i)->when));
+ snprintf (buf, sizeof (buf), "%" PRIu32, (nframes_t) floor ((*i)->when));
pointnode->add_property ("x", buf);
snprintf (buf, sizeof (buf), "%.12g", (*i)->value);
pointnode->add_property ("y", buf);
const XMLNodeList& elist = node.children();
XMLNodeConstIterator i;
XMLProperty* prop;
- jack_nframes_t x;
+ nframes_t x;
double y;
clear ();
cerr << "deletion done" << endl;
}
-jack_nframes_t
-CoreAudioSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
+nframes_t
+CoreAudioSource::read_unlocked (Sample *dst, nframes_t start, nframes_t cnt) const
{
try {
af.Seek (start);
}
int
-CoreAudioSource::update_header (jack_nframes_t when, struct tm&, time_t)
+CoreAudioSource::update_header (nframes_t when, struct tm&, time_t)
{
return 0;
}
using namespace ARDOUR;
using namespace PBD;
-jack_nframes_t Crossfade::_short_xfade_length = 0;
+nframes_t Crossfade::_short_xfade_length = 0;
Change Crossfade::ActiveChanged = new_change();
/* XXX if and when we ever implement parallel processing of the process()
Sample* Crossfade::crossfade_buffer_in = 0;
void
-Crossfade::set_buffer_size (jack_nframes_t sz)
+Crossfade::set_buffer_size (nframes_t sz)
{
if (crossfade_buffer_out) {
delete [] crossfade_buffer_out;
}
Crossfade::Crossfade (boost::shared_ptr<AudioRegion> in, boost::shared_ptr<AudioRegion> out,
- jack_nframes_t length,
- jack_nframes_t position,
+ nframes_t length,
+ nframes_t position,
AnchorPoint ap)
: _fade_in (0.0, 2.0, 1.0), // linear (gain coefficient) => -inf..+6dB
_fade_out (0.0, 2.0, 1.0) // linear (gain coefficient) => -inf..+6dB
{
boost::shared_ptr<AudioRegion> top;
boost::shared_ptr<AudioRegion> bottom;
- jack_nframes_t short_xfade_length;
+ nframes_t short_xfade_length;
short_xfade_length = _short_xfade_length;
return 0;
}
-jack_nframes_t
+nframes_t
Crossfade::read_at (Sample *buf, Sample *mixdown_buffer,
- 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)
+ float *gain_buffer, nframes_t start, nframes_t cnt, uint32_t chan_n,
+ nframes_t read_frames, nframes_t skip_frames)
{
- jack_nframes_t offset;
- jack_nframes_t to_write;
+ nframes_t offset;
+ nframes_t to_write;
if (!_active) {
return 0;
position and length, and so we know precisely how much data they could return.
*/
- for (jack_nframes_t n = 0; n < to_write; ++n) {
+ for (nframes_t n = 0; n < to_write; ++n) {
buf[n] = (crossfade_buffer_out[n] * fov[n]) + (crossfade_buffer_in[n] * fiv[n]);
}
}
OverlapType
-Crossfade::coverage (jack_nframes_t start, jack_nframes_t end) const
+Crossfade::coverage (nframes_t start, nframes_t end) const
{
- jack_nframes_t my_end = _position + _length;
+ nframes_t my_end = _position + _length;
if ((start >= _position) && (end <= my_end)) {
return OverlapInternal;
bool
Crossfade::update (bool force)
{
- jack_nframes_t newlen;
+ nframes_t newlen;
bool save = false;
if (_follow_overlap) {
pnode = new XMLNode ("point");
- snprintf (buf, sizeof (buf), "%" PRIu32, (jack_nframes_t) floor ((*ii)->when));
+ snprintf (buf, sizeof (buf), "%" PRIu32, (nframes_t) floor ((*ii)->when));
pnode->add_property ("x", buf);
snprintf (buf, sizeof (buf), "%.12g", (*ii)->value);
pnode->add_property ("y", buf);
pnode = new XMLNode ("point");
- snprintf (buf, sizeof (buf), "%" PRIu32, (jack_nframes_t) floor ((*ii)->when));
+ snprintf (buf, sizeof (buf), "%" PRIu32, (nframes_t) floor ((*ii)->when));
pnode->add_property ("x", buf);
snprintf (buf, sizeof (buf), "%.12g", (*ii)->value);
pnode->add_property ("y", buf);
for (i = children.begin(); i != children.end(); ++i) {
if ((*i)->name() == "point") {
- jack_nframes_t x;
+ nframes_t x;
float y;
prop = (*i)->property ("x");
for (i = children.begin(); i != children.end(); ++i) {
if ((*i)->name() == "point") {
- jack_nframes_t x;
+ nframes_t x;
float y;
XMLProperty* prop;
}
}
-jack_nframes_t
-Crossfade::set_length (jack_nframes_t len)
+nframes_t
+Crossfade::set_length (nframes_t len)
{
- jack_nframes_t limit;
+ nframes_t limit;
switch (_anchor_point) {
case StartOfIn:
return len;
}
-jack_nframes_t
+nframes_t
Crossfade::overlap_length () const
{
if (_fixed) {
}
void
-Crossfade::set_short_xfade_length (jack_nframes_t n)
+Crossfade::set_short_xfade_length (nframes_t n)
{
_short_xfade_length = n;
}
0, 0,
};
-const jack_nframes_t Session::default_click_emphasis_length = sizeof (default_click_emphasis) / sizeof (default_click_emphasis[0]);
+const nframes_t Session::default_click_emphasis_length = sizeof (default_click_emphasis) / sizeof (default_click_emphasis[0]);
const Sample Session::default_click[] = {
0, -0.014312744, -0.03338623, 0.019165039, 0.042541504,
0, 0, 0, 0, 0, 0, 0, 0,
};
-const jack_nframes_t Session::default_click_length = sizeof (default_click) / sizeof (default_click[0]);
+const nframes_t Session::default_click_length = sizeof (default_click) / sizeof (default_click[0]);
gain_t* DestructiveFileSource::out_coefficient = 0;
gain_t* DestructiveFileSource::in_coefficient = 0;
-jack_nframes_t DestructiveFileSource::xfade_frames = 64;
+nframes_t DestructiveFileSource::xfade_frames = 64;
-DestructiveFileSource::DestructiveFileSource (Session& s, string path, SampleFormat samp_format, HeaderFormat hdr_format, jack_nframes_t rate, Flag flags)
+DestructiveFileSource::DestructiveFileSource (Session& s, string path, SampleFormat samp_format, HeaderFormat hdr_format, nframes_t rate, Flag flags)
: SndFileSource (s, path, samp_format, hdr_format, rate, flags)
{
init ();
}
void
-DestructiveFileSource::setup_standard_crossfades (jack_nframes_t rate)
+DestructiveFileSource::setup_standard_crossfades (nframes_t rate)
{
/* This static method is assumed to have been called by the Session
before any DFS's are created.
*/
- xfade_frames = (jack_nframes_t) floor ((Config->get_destructive_xfade_msecs () / 1000.0) * rate);
+ xfade_frames = (nframes_t) floor ((Config->get_destructive_xfade_msecs () / 1000.0) * rate);
if (out_coefficient) {
delete [] out_coefficient;
}
void
-DestructiveFileSource::mark_capture_start (jack_nframes_t pos)
+DestructiveFileSource::mark_capture_start (nframes_t pos)
{
if (pos < timeline_position) {
_capture_start = false;
_capture_end = false;
}
-jack_nframes_t
-DestructiveFileSource::crossfade (Sample* data, jack_nframes_t cnt, int fade_in)
+nframes_t
+DestructiveFileSource::crossfade (Sample* data, nframes_t cnt, int fade_in)
{
- jack_nframes_t xfade = min (xfade_frames, cnt);
- jack_nframes_t nofade = cnt - xfade;
+ nframes_t xfade = min (xfade_frames, cnt);
+ nframes_t nofade = cnt - xfade;
Sample* fade_data = 0;
- jack_nframes_t fade_position = 0; // in frames
+ nframes_t fade_position = 0; // in frames
ssize_t retval;
- jack_nframes_t file_cnt;
+ nframes_t file_cnt;
if (fade_in) {
fade_position = file_pos;
}
if (file_cnt) {
+
if ((retval = read_unlocked (xfade_buf, fade_position, file_cnt)) != (ssize_t) file_cnt) {
if (retval >= 0 && errno == EAGAIN) {
/* XXX - can we really trust that errno is meaningful here? yes POSIX, i'm talking to you.
}
if (file_cnt != xfade) {
- jack_nframes_t delta = xfade - file_cnt;
+ nframes_t delta = xfade - file_cnt;
memset (xfade_buf+file_cnt, 0, sizeof (Sample) * delta);
}
if (nofade && !fade_in) {
- if (write_float (data, file_pos - timeline_position, nofade) != nofade) {
+ if (write_float (data, file_pos, nofade) != nofade) {
error << string_compose(_("DestructiveFileSource: \"%1\" bad write (%2)"), _path, strerror (errno)) << endmsg;
return 0;
}
if (xfade == xfade_frames) {
- jack_nframes_t n;
+ nframes_t n;
/* use the standard xfade curve */
compute_equal_power_fades (xfade, in, out);
- for (jack_nframes_t n = 0; n < xfade; ++n) {
+ for (nframes_t n = 0; n < xfade; ++n) {
xfade_buf[n] = (xfade_buf[n] * out[n]) + (fade_data[n] * in[n]);
}
}
if (xfade) {
- if (write_float (xfade_buf, fade_position - timeline_position, xfade) != xfade) {
+ if (write_float (xfade_buf, fade_position, xfade) != xfade) {
error << string_compose(_("DestructiveFileSource: \"%1\" bad write (%2)"), _path, strerror (errno)) << endmsg;
return 0;
}
}
if (fade_in && nofade) {
- if (write_float (data + xfade, file_pos + xfade - timeline_position, nofade) != nofade) {
+ if (write_float (data + xfade, file_pos + xfade, nofade) != nofade) {
error << string_compose(_("DestructiveFileSource: \"%1\" bad write (%2)"), _path, strerror (errno)) << endmsg;
return 0;
}
return cnt;
}
-jack_nframes_t
-DestructiveFileSource::write_unlocked (Sample* data, jack_nframes_t cnt)
+nframes_t
+DestructiveFileSource::write_unlocked (Sample* data, nframes_t cnt)
{
- jack_nframes_t old_file_pos;
+ nframes_t old_file_pos;
if (!writable()) {
return 0;
file_pos = capture_start_frame;
// split cnt in half
- jack_nframes_t subcnt = cnt / 2;
- jack_nframes_t ofilepos = file_pos;
+ nframes_t subcnt = cnt / 2;
+ nframes_t ofilepos = file_pos;
// fade in
if (crossfade (data, subcnt, 1) != subcnt) {
_capture_end = false;
/* move to the correct location place */
- file_pos = capture_start_frame;
-
+ file_pos = capture_start_frame - timeline_position;
+
if (crossfade (data, cnt, 1) != cnt) {
return 0;
}
/* in the middle of recording */
- if (write_float (data, file_pos - timeline_position, cnt) != cnt) {
+
+ if (write_float (data, file_pos, cnt) != cnt) {
return 0;
}
}
return cnt;
}
-jack_nframes_t
+nframes_t
DestructiveFileSource::last_capture_start_frame () const
{
return capture_start_frame;
}
void
-DestructiveFileSource::set_timeline_position (jack_nframes_t pos)
+DestructiveFileSource::set_timeline_position (nframes_t pos)
{
//destructive track timeline postion does not change except at instantion or when header_position_offset (session start) changes
}
* 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;
+nframes_t Diskstream::disk_io_chunk_frames = 1024 * 256;
sigc::signal<void,list<boost::shared_ptr<Source> >*> Diskstream::DeleteSources;
sigc::signal<void> Diskstream::DiskOverrun;
if (_seek_required) {
if (speed() != 1.0f || speed() != -1.0f) {
- seek ((jack_nframes_t) (_session.transport_frame() * (double) speed()), true);
+ seek ((nframes_t) (_session.transport_frame() * (double) speed()), true);
}
else {
seek (_session.transport_frame(), true);
if (new_speed != _actual_speed) {
- jack_nframes_t required_wrap_size = (jack_nframes_t) floor (_session.get_block_size() *
+ nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() *
fabs (new_speed)) + 1;
if (required_wrap_size > wrap_buffer_size) {
return 0;
}
-jack_nframes_t
+nframes_t
Diskstream::get_capture_start_frame (uint32_t n)
{
Glib::Mutex::Lock lm (capture_info_lock);
}
}
-jack_nframes_t
+nframes_t
Diskstream::get_captured_frames (uint32_t n)
{
Glib::Mutex::Lock lm (capture_info_lock);
}
void
-Diskstream::set_roll_delay (jack_nframes_t nframes)
+Diskstream::set_roll_delay (nframes_t nframes)
{
_roll_delay = nframes;
}
}
void
-Gain::fill_linear_volume_fade_in (Gain& gain, jack_nframes_t frames)
+Gain::fill_linear_volume_fade_in (Gain& gain, nframes_t frames)
{
}
void
-Gain::fill_linear_volume_fade_out (Gain& gain, jack_nframes_t frames)
+Gain::fill_linear_volume_fade_out (Gain& gain, nframes_t frames)
{
}
void
-Gain::fill_linear_fade_in (Gain& gain, jack_nframes_t frames)
+Gain::fill_linear_fade_in (Gain& gain, nframes_t frames)
{
}
void
-Gain::fill_linear_fade_out (Gain& gain, jack_nframes_t frames)
+Gain::fill_linear_fade_out (Gain& gain, nframes_t frames)
{
}
}
ARDOUR::OverlapType
-ARDOUR::coverage (jack_nframes_t sa, jack_nframes_t ea,
- jack_nframes_t sb, jack_nframes_t eb)
+ARDOUR::coverage (nframes_t sa, nframes_t ea,
+ nframes_t sb, nframes_t eb)
{
/* OverlapType returned reflects how the second (B)
range overlaps the first (A).
long n;
string basepath;
string sounds_dir;
- jack_nframes_t so_far;
+ nframes_t so_far;
char buf[PATH_MAX+1];
int ret = -1;
vector<string> new_paths;
}
void
-PluginInsert::set_block_size (jack_nframes_t nframes)
+PluginInsert::set_block_size (nframes_t nframes)
{
for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
(*i)->set_block_size (nframes);
}
void
-PluginInsert::connect_and_run (vector<Sample*>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset, bool with_auto, jack_nframes_t now)
+PluginInsert::connect_and_run (vector<Sample*>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset, bool with_auto, nframes_t now)
{
int32_t in_index = 0;
int32_t out_index = 0;
}
void
-PluginInsert::automation_snapshot (jack_nframes_t now)
+PluginInsert::automation_snapshot (nframes_t now)
{
map<uint32_t,AutomationList*>::iterator li;
}
void
-PluginInsert::transport_stopped (jack_nframes_t now)
+PluginInsert::transport_stopped (nframes_t now)
{
map<uint32_t,AutomationList*>::iterator li;
}
void
-PluginInsert::silence (jack_nframes_t nframes, jack_nframes_t offset)
+PluginInsert::silence (nframes_t nframes, nframes_t offset)
{
int32_t in_index = 0;
int32_t out_index = 0;
}
void
-PluginInsert::run (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset)
+PluginInsert::run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
{
if (active()) {
}
void
-PluginInsert::automation_run (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset)
+PluginInsert::automation_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
{
ControlEvent next_event (0, 0.0f);
- jack_nframes_t now = _session.transport_frame ();
- jack_nframes_t end = now + nframes;
+ nframes_t now = _session.transport_frame ();
+ nframes_t end = now + nframes;
Glib::Mutex::Lock lm (_automation_lock, Glib::TRY_LOCK);
while (nframes) {
- jack_nframes_t cnt = min (((jack_nframes_t) floor (next_event.when) - now), nframes);
+ nframes_t cnt = min (((nframes_t) floor (next_event.when) - now), nframes);
connect_and_run (bufs, nbufs, cnt, offset, true, now);
return _plugins[0]->describe_parameter (what);
}
-jack_nframes_t
+nframes_t
PluginInsert::latency()
{
return _plugins[0]->latency ();
}
void
-PortInsert::run (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset)
+PortInsert::run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
{
if (n_outputs() == 0) {
return;
return 0;
}
-jack_nframes_t
+nframes_t
PortInsert::latency()
{
/* because we deliver and collect within the same cycle,
static float current_automation_version_number = 1.0;
-jack_nframes_t IO::_automation_interval = 0;
+nframes_t IO::_automation_interval = 0;
const string IO::state_node_name = "IO";
bool IO::connecting_legal = false;
bool IO::ports_legal = false;
}
void
-IO::silence (jack_nframes_t nframes, jack_nframes_t offset)
+IO::silence (nframes_t nframes, nframes_t offset)
{
/* io_lock, not taken: function must be called from Session::process() calltree */
}
void
-IO::apply_declick (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, gain_t initial, gain_t target, bool invert_polarity)
+IO::apply_declick (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, gain_t initial, gain_t target, bool invert_polarity)
{
- jack_nframes_t declick = min ((jack_nframes_t)128, nframes);
+ nframes_t declick = min ((nframes_t)128, nframes);
gain_t delta;
Sample *buffer;
double fractional_shift;
buffer = bufs[n];
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;
}
if (this_target == 0.0) {
memset (&buffer[declick], 0, sizeof (Sample) * (nframes - declick));
} else if (this_target != 1.0) {
- for (jack_nframes_t nx = declick; nx < nframes; ++nx) {
+ for (nframes_t nx = declick; nx < nframes; ++nx) {
buffer[nx] *= this_target;
}
}
}
void
-IO::pan_automated (vector<Sample*>& bufs, uint32_t nbufs, jack_nframes_t start, jack_nframes_t end, jack_nframes_t nframes, jack_nframes_t offset)
+IO::pan_automated (vector<Sample*>& bufs, uint32_t nbufs, nframes_t start, nframes_t end, nframes_t nframes, nframes_t offset)
{
Sample* dst;
}
void
-IO::pan (vector<Sample*>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset, gain_t gain_coeff)
+IO::pan (vector<Sample*>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset, gain_t gain_coeff)
{
Sample* dst;
Sample* src;
for (n = 1; n < nbufs; ++n) {
src = bufs[n];
- for (jack_nframes_t n = 0; n < nframes; ++n) {
+ for (nframes_t n = 0; n < nframes; ++n) {
dst[n] += src[n];
}
}
src = bufs[0];
- for (jack_nframes_t n = 0; n < nframes; ++n) {
+ for (nframes_t n = 0; n < nframes; ++n) {
dst[n] = src[n] * gain_coeff;
}
for (n = 1; n < nbufs; ++n) {
src = bufs[n];
- for (jack_nframes_t n = 0; n < nframes; ++n) {
+ for (nframes_t n = 0; n < nframes; ++n) {
dst[n] += src[n] * gain_coeff;
}
}
}
void
-IO::deliver_output (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset)
+IO::deliver_output (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
{
/* io_lock, not taken: function must be called from Session::process() calltree */
}
void
-IO::deliver_output_no_pan (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset)
+IO::deliver_output_no_pan (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
{
/* io_lock, not taken: function must be called from Session::process() calltree */
} else if (actual_gain == 0.0f) {
memset (dst, 0, sizeof (Sample) * nframes);
} else {
- for (jack_nframes_t x = 0; x < nframes; ++x) {
+ for (nframes_t x = 0; x < nframes; ++x) {
dst[x] = src[x] * actual_gain;
}
}
}
void
-IO::collect_input (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset)
+IO::collect_input (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
{
/* io_lock, not taken: function must be called from Session::process() calltree */
}
void
-IO::just_meter_input (jack_nframes_t start_frame, jack_nframes_t end_frame,
- jack_nframes_t nframes, jack_nframes_t offset)
+IO::just_meter_input (nframes_t start_frame, nframes_t end_frame,
+ nframes_t nframes, nframes_t offset)
{
vector<Sample*>& bufs = _session.get_passthru_buffers ();
uint32_t nbufs = n_process_buffers ();
}
void
-IO::set_port_latency (jack_nframes_t nframes)
+IO::set_port_latency (nframes_t nframes)
{
Glib::Mutex::Lock lm (io_lock);
}
}
-jack_nframes_t
+nframes_t
IO::output_latency () const
{
- jack_nframes_t max_latency;
- jack_nframes_t latency;
+ nframes_t max_latency;
+ nframes_t latency;
max_latency = 0;
return max_latency;
}
-jack_nframes_t
+nframes_t
IO::input_latency () const
{
- jack_nframes_t max_latency;
- jack_nframes_t latency;
+ nframes_t max_latency;
+ nframes_t latency;
max_latency = 0;
/* XXX use apply_to_points to get thread safety */
for (AutomationList::iterator i = _gain_automation_curve.begin(); i != _gain_automation_curve.end(); ++i) {
- out << "g " << (jack_nframes_t) floor ((*i)->when) << ' ' << (*i)->value << endl;
+ out << "g " << (nframes_t) floor ((*i)->when) << ' ' << (*i)->value << endl;
}
_panner->save ();
while (in.getline (line, sizeof(line), '\n')) {
char type;
- jack_nframes_t when;
+ nframes_t when;
double value;
if (++linecnt == 1) {
}
void
-IO::automation_snapshot (jack_nframes_t now)
+IO::automation_snapshot (nframes_t now)
{
if (last_automation_snapshot > now || (now - last_automation_snapshot) > _automation_interval) {
}
void
-IO::transport_stopped (jack_nframes_t frame)
+IO::transport_stopped (nframes_t frame)
{
_gain_automation_curve.reposition_for_rt_add (frame);
: jack (j)
{
float x;
- jack_nframes_t p;
+ nframes_t p;
/* call this to initialize things */
speed_and_position (x, p);
}
}
bool
-JACK_Slave::speed_and_position (float& sp, jack_nframes_t& position)
+JACK_Slave::speed_and_position (float& sp, nframes_t& position)
{
jack_position_t pos;
jack_transport_state_t state;
using namespace ARDOUR;
using namespace PBD;
-LadspaPlugin::LadspaPlugin (void *mod, AudioEngine& e, Session& session, uint32_t index, jack_nframes_t rate)
+LadspaPlugin::LadspaPlugin (void *mod, AudioEngine& e, Session& session, uint32_t index, nframes_t rate)
: Plugin (e, session)
{
init (mod, index, rate);
}
void
-LadspaPlugin::init (void *mod, uint32_t index, jack_nframes_t rate)
+LadspaPlugin::init (void *mod, uint32_t index, nframes_t rate)
{
LADSPA_Descriptor_Function dfunc;
uint32_t i, port_cnt;
}
}
-jack_nframes_t
+nframes_t
LadspaPlugin::latency () const
{
if (latency_control_port) {
- return (jack_nframes_t) floor (*latency_control_port);
+ return (nframes_t) floor (*latency_control_port);
} else {
return 0;
}
}
int
-LadspaPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t nbufs, int32_t& in_index, int32_t& out_index, jack_nframes_t nframes, jack_nframes_t offset)
+LadspaPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t nbufs, int32_t& in_index, int32_t& out_index, nframes_t nframes, nframes_t offset)
{
uint32_t port_index;
cycles_t then, now;
}
void
-LadspaPlugin::run (jack_nframes_t nframes)
+LadspaPlugin::run (nframes_t nframes)
{
for (uint32_t i = 0; i < parameter_count(); ++i) {
if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) && LADSPA_IS_PORT_CONTROL(port_descriptor (i))) {
uint32_t port_index = 0;
uint32_t in_index = 0;
uint32_t out_index = 0;
- const jack_nframes_t bufsize = 1024;
+ const nframes_t bufsize = 1024;
LADSPA_Data buffer[bufsize];
memset(buffer,0,sizeof(LADSPA_Data)*bufsize);
}
int
-Location::set_start (jack_nframes_t s)
+Location::set_start (nframes_t s)
{
if (is_mark()) {
if (_start != s) {
}
int
-Location::set_end (jack_nframes_t e)
+Location::set_end (nframes_t e)
{
if (is_mark()) {
if (_start != e) {
}
int
-Location::set (jack_nframes_t start, jack_nframes_t end)
+Location::set (nframes_t start, nframes_t end)
{
if (is_mark() && start != end) {
return -1;
};
Location *
-Locations::first_location_before (jack_nframes_t frame)
+Locations::first_location_before (nframes_t frame)
{
LocationList locs;
}
Location *
-Locations::first_location_after (jack_nframes_t frame)
+Locations::first_location_after (nframes_t frame)
{
LocationList locs;
return 0;
}
-jack_nframes_t
-Locations::first_mark_before (jack_nframes_t frame)
+nframes_t
+Locations::first_mark_before (nframes_t frame)
{
LocationList locs;
return 0;
}
-jack_nframes_t
-Locations::first_mark_after (jack_nframes_t frame)
+nframes_t
+Locations::first_mark_after (nframes_t frame)
{
LocationList locs;
// Debug wrappers
float
-debug_compute_peak (ARDOUR::Sample *buf, jack_nframes_t nsamples, float current)
+debug_compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current)
{
if ( ((intptr_t)buf % 16) != 0) {
cerr << "compute_peak(): buffer unaligned!" << endl;
}
void
-debug_apply_gain_to_buffer (ARDOUR::Sample *buf, jack_nframes_t nframes, float gain)
+debug_apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain)
{
if ( ((intptr_t)buf % 16) != 0) {
cerr << "apply_gain_to_buffer(): buffer unaligned!" << endl;
}
void
-debug_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes, float gain)
+debug_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain)
{
if ( ((intptr_t)dst & 15) != 0) {
cerr << "mix_buffers_with_gain(): dst unaligned!" << endl;
}
void
-debug_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes)
+debug_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes)
{
if ( ((intptr_t)dst & 15) != 0) {
cerr << "mix_buffers_no_gain(): dst unaligned!" << endl;
float
-compute_peak (ARDOUR::Sample *buf, jack_nframes_t nsamples, float current)
+compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current)
{
- for (jack_nframes_t i = 0; i < nsamples; ++i) {
+ for (nframes_t i = 0; i < nsamples; ++i) {
current = f_max (current, fabsf (buf[i]));
}
}
void
-apply_gain_to_buffer (ARDOUR::Sample *buf, jack_nframes_t nframes, float gain)
+apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain)
{
- for (jack_nframes_t i=0; i<nframes; i++)
+ for (nframes_t i=0; i<nframes; i++)
buf[i] *= gain;
}
void
-mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes, float gain)
+mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain)
{
- for (jack_nframes_t i = 0; i < nframes; i++) {
+ for (nframes_t i = 0; i < nframes; i++) {
dst[i] += src[i] * gain;
}
}
void
-mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes)
+mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes)
{
- for (jack_nframes_t i=0; i < nframes; i++) {
+ for (nframes_t i=0; i < nframes; i++) {
dst[i] += src[i];
}
}
#include <Accelerate/Accelerate.h>
float
-veclib_compute_peak (ARDOUR::Sample *buf, jack_nframes_t nsamples, float current)
+veclib_compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current)
{
float tmpmax = 0.0f;
vDSP_maxmgv(buf, 1, &tmpmax, nsamples);
}
void
-veclib_apply_gain_to_buffer (ARDOUR::Sample *buf, jack_nframes_t nframes, float gain)
+veclib_apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain)
{
vDSP_vsmul(buf, 1, &gain, buf, 1, nframes);
}
void
-veclib_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes, float gain)
+veclib_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain)
{
vDSP_vsma(src, 1, &gain, dst, 1, dst, 1, nframes);
}
void
-veclib_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, jack_nframes_t nframes)
+veclib_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes)
{
// It seems that a vector mult only operation does not exist...
float gain = 1.0f;
MTC_Slave::update_mtc_qtr (Parser& p)
{
cycles_t cnow = get_cycles ();
- jack_nframes_t now = session.engine().frame_time();
- jack_nframes_t qtr;
+ nframes_t now = session.engine().frame_time();
+ nframes_t qtr;
static cycles_t last_qtr = 0;
qtr = (long) (session.frames_per_smpte_frame() / 4);
void
MTC_Slave::update_mtc_time (const byte *msg, bool was_full)
{
- jack_nframes_t now = session.engine().frame_time();
+ nframes_t now = session.engine().frame_time();
SMPTE::Time smpte;
smpte.hours = msg[3];
}
bool
-MTC_Slave::speed_and_position (float& speed, jack_nframes_t& pos)
+MTC_Slave::speed_and_position (float& speed, nframes_t& pos)
{
- jack_nframes_t now = session.engine().frame_time();
+ nframes_t now = session.engine().frame_time();
SafeTime last;
- jack_nframes_t frame_rate;
- jack_nframes_t elapsed;
+ nframes_t frame_rate;
+ nframes_t elapsed;
float speed_now;
read_current (&last);
/* scale elapsed time by the current MTC speed */
if (last.timestamp && (now > last.timestamp)) {
- elapsed = (jack_nframes_t) floor (mtc_speed * (now - last.timestamp));
+ elapsed = (nframes_t) floor (mtc_speed * (now - last.timestamp));
} else {
elapsed = 0; /* XXX is this right? */
}
return true;
}
-jack_nframes_t
+nframes_t
MTC_Slave::resolution() const
{
- return (jack_nframes_t) session.frames_per_smpte_frame();
+ return (nframes_t) session.frames_per_smpte_frame();
}
void
}
void
-BaseStereoPanner::snapshot (jack_nframes_t now)
+BaseStereoPanner::snapshot (nframes_t now)
{
if (_automation.automation_state() == Write || _automation.automation_state() == Touch) {
_automation.rt_add (now, x);
}
void
-BaseStereoPanner::transport_stopped (jack_nframes_t frame)
+BaseStereoPanner::transport_stopped (nframes_t frame)
{
_automation.reposition_for_rt_add (frame);
out << "begin" << endl;
for (AutomationList::const_iterator i = _automation.const_begin(); i != _automation.const_end(); ++i) {
- out << '\t' << (jack_nframes_t) floor ((*i)->when) << ' ' << (*i)->value << endl;
+ out << '\t' << (nframes_t) floor ((*i)->when) << ' ' << (*i)->value << endl;
if (!out) {
error << string_compose (_("error writing pan automation file (%s)"), strerror (errno)) << endmsg;
return -1;
_automation.clear ();
while (in.getline (line, sizeof (line), '\n')) {
- jack_nframes_t when;
+ nframes_t when;
double value;
++linecnt;
}
void
-BaseStereoPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, jack_nframes_t nframes)
+BaseStereoPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nframes_t nframes)
{
pan_t delta;
Sample* dst;
/* interpolate over 64 frames or nframes, whichever is smaller */
- jack_nframes_t limit = min ((jack_nframes_t)64, nframes);
- jack_nframes_t n;
+ nframes_t limit = min ((nframes_t)64, nframes);
+ nframes_t n;
delta = -(delta / (float) (limit));
/* interpolate over 64 frames or nframes, whichever is smaller */
- jack_nframes_t limit = min ((jack_nframes_t)64, nframes);
- jack_nframes_t n;
+ nframes_t limit = min ((nframes_t)64, nframes);
+ nframes_t n;
delta = -(delta / (float) (limit));
void
EqualPowerStereoPanner::distribute_automated (Sample* src, Sample** obufs,
- jack_nframes_t start, jack_nframes_t end, jack_nframes_t nframes,
+ nframes_t start, nframes_t end, nframes_t nframes,
pan_t** buffers)
{
Sample* dst;
const float pan_law_attenuation = -3.0f;
const float scale = 2.0f - 4.0f * powf (10.0f,pan_law_attenuation/20.0f);
- for (jack_nframes_t n = 0; n < nframes; ++n) {
+ for (nframes_t n = 0; n < nframes; ++n) {
float panR = buffers[0][n];
float panL = 1 - panR;
dst = obufs[0];
pbuf = buffers[0];
- for (jack_nframes_t n = 0; n < nframes; ++n) {
+ for (nframes_t n = 0; n < nframes; ++n) {
dst[n] += src[n] * pbuf[n];
}
dst = obufs[1];
pbuf = buffers[1];
- for (jack_nframes_t n = 0; n < nframes; ++n) {
+ for (nframes_t n = 0; n < nframes; ++n) {
dst[n] += src[n] * pbuf[n];
}
}
void
-Multi2dPanner::snapshot (jack_nframes_t now)
+Multi2dPanner::snapshot (nframes_t now)
{
// how?
}
void
-Multi2dPanner::transport_stopped (jack_nframes_t frame)
+Multi2dPanner::transport_stopped (nframes_t frame)
{
//what?
}
}
void
-Multi2dPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, jack_nframes_t nframes)
+Multi2dPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nframes_t nframes)
{
Sample* dst;
pan_t pan;
/* interpolate over 64 frames or nframes, whichever is smaller */
- jack_nframes_t limit = min ((jack_nframes_t)64, nframes);
- jack_nframes_t n;
+ nframes_t limit = min ((nframes_t)64, nframes);
+ nframes_t n;
delta = -(delta / (float) (limit));
if (pan != 0.0f) {
- for (jack_nframes_t n = 0; n < nframes; ++n) {
+ for (nframes_t n = 0; n < nframes; ++n) {
dst[n] += src[n] * pan;
}
} else {
- for (jack_nframes_t n = 0; n < nframes; ++n) {
+ for (nframes_t n = 0; n < nframes; ++n) {
dst[n] += src[n];
}
void
Multi2dPanner::distribute_automated (Sample* src, Sample** obufs,
- jack_nframes_t start, jack_nframes_t end, jack_nframes_t nframes,
+ nframes_t start, nframes_t end, nframes_t nframes,
pan_t** buffers)
{
if (_muted) {
}
void
-Panner::transport_stopped (jack_nframes_t frame)
+Panner::transport_stopped (nframes_t frame)
{
for (vector<StreamPanner*>::iterator i = begin(); i != end(); ++i) {
(*i)->transport_stopped (frame);
}
void
-Panner::snapshot (jack_nframes_t now)
+Panner::snapshot (nframes_t now)
{
for (vector<StreamPanner*>::iterator i = begin(); i != end(); ++i) {
(*i)->snapshot (now);
}
-Playlist::Playlist (const Playlist& other, jack_nframes_t start, jack_nframes_t cnt, string str, bool hide)
+Playlist::Playlist (const Playlist& other, nframes_t start, nframes_t cnt, string str, bool hide)
: _name (str), _session (other._session), _orig_diskstream_id(other._orig_diskstream_id)
{
RegionLock rlock2 (&((Playlist&)other));
- jack_nframes_t end = start + cnt - 1;
+ nframes_t end = start + cnt - 1;
init (hide);
boost::shared_ptr<Region> region;
boost::shared_ptr<Region> new_region;
- jack_nframes_t offset = 0;
- jack_nframes_t position = 0;
- jack_nframes_t len = 0;
+ nframes_t offset = 0;
+ nframes_t position = 0;
+ nframes_t len = 0;
string new_name;
OverlapType overlap;
*************************************************************/
void
-Playlist::add_region (boost::shared_ptr<Region> region, jack_nframes_t position, float times, bool with_save)
+Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times, bool with_save)
{
RegionLock rlock (this);
int itimes = (int) floor (times);
- jack_nframes_t pos = position;
+ nframes_t pos = position;
if (itimes >= 1) {
add_region_internal (region, pos, true);
}
if (floor (times) != times) {
- jack_nframes_t length = (jack_nframes_t) floor (region->length() * (times - floor (times)));
+ nframes_t length = (nframes_t) floor (region->length() * (times - floor (times)));
string name;
_session.region_name (name, region->name(), false);
boost::shared_ptr<Region> sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags());
}
void
-Playlist::add_region_internal (boost::shared_ptr<Region> region, jack_nframes_t position, bool delay_sort)
+Playlist::add_region_internal (boost::shared_ptr<Region> region, nframes_t position, bool delay_sort)
{
RegionSortByPosition cmp;
- jack_nframes_t old_length = 0;
+ nframes_t old_length = 0;
if (!holding_state()) {
old_length = _get_maximum_extent();
}
void
-Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, jack_nframes_t pos)
+Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, nframes_t pos)
{
RegionLock rlock (this);
Playlist::remove_region_internal (boost::shared_ptr<Region>region, bool delay_sort)
{
RegionList::iterator i;
- jack_nframes_t old_length = 0;
+ nframes_t old_length = 0;
// cerr << "removing region " << region->name() << endl;
}
void
-Playlist::partition (jack_nframes_t start, jack_nframes_t end, bool just_top_level)
+Playlist::partition (nframes_t start, nframes_t end, bool just_top_level)
{
RegionList thawlist;
}
void
-Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cutting, RegionList& thawlist)
+Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, RegionList& thawlist)
{
RegionLock rlock (this);
boost::shared_ptr<Region> region;
string new_name;
RegionList::iterator tmp;
OverlapType overlap;
- jack_nframes_t pos1, pos2, pos3, pos4;
+ nframes_t pos1, pos2, pos3, pos4;
RegionList new_regions;
in_partition = true;
}
Playlist*
-Playlist::cut_copy (Playlist* (Playlist::*pmf)(
jack_nframes_t, jack_nframes_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
+Playlist::cut_copy (Playlist* (Playlist::*pmf)(
nframes_t, nframes_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
{
Playlist* ret;
Playlist* pl;
- jack_nframes_t start;
+ nframes_t start;
if (ranges.empty()) {
return 0;
Playlist*
Playlist::cut (list<AudioRange>& ranges, bool result_is_hidden)
{
- Playlist* (Playlist::*pmf)(jack_nframes_t,jack_nframes_t,bool) = &Playlist::cut;
+ Playlist* (Playlist::*pmf)(nframes_t,nframes_t,bool) = &Playlist::cut;
return cut_copy (pmf, ranges, result_is_hidden);
}
Playlist*
Playlist::copy (list<AudioRange>& ranges, bool result_is_hidden)
{
- Playlist* (Playlist::*pmf)(jack_nframes_t,jack_nframes_t,bool) = &Playlist::copy;
+ Playlist* (Playlist::*pmf)(nframes_t,nframes_t,bool) = &Playlist::copy;
return cut_copy (pmf, ranges, result_is_hidden);
}
Playlist *
-Playlist::cut (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden)
+Playlist::cut (nframes_t start, nframes_t cnt, bool result_is_hidden)
{
Playlist *the_copy;
RegionList thawlist;
}
Playlist *
-Playlist::copy (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden)
+Playlist::copy (nframes_t start, nframes_t cnt, bool result_is_hidden)
{
char buf[32];
}
int
-Playlist::paste (Playlist& other, jack_nframes_t position, float times)
+Playlist::paste (Playlist& other, nframes_t position, float times)
{
times = fabs (times);
- jack_nframes_t old_length;
+ nframes_t old_length;
{
RegionLock rl1 (this);
old_length = _get_maximum_extent();
int itimes = (int) floor (times);
- jack_nframes_t pos = position;
- jack_nframes_t shift = other._get_maximum_extent();
+ nframes_t pos = position;
+ nframes_t shift = other._get_maximum_extent();
layer_t top_layer = regions.size();
while (itimes--) {
void
-Playlist::duplicate (boost::shared_ptr<Region> region, jack_nframes_t position, float times)
+Playlist::duplicate (boost::shared_ptr<Region> region, nframes_t position, float times)
{
times = fabs (times);
RegionLock rl (this);
int itimes = (int) floor (times);
- jack_nframes_t pos = position;
+ nframes_t pos = position;
while (itimes--) {
boost::shared_ptr<Region> copy = RegionFactory::create (region);
}
if (floor (times) != times) {
- jack_nframes_t length = (jack_nframes_t) floor (region->length() * (times - floor (times)));
+ nframes_t length = (nframes_t) floor (region->length() * (times - floor (times)));
string name;
_session.region_name (name, region->name(), false);
boost::shared_ptr<Region> sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags());
}
void
-Playlist::split_region (boost::shared_ptr<Region> region, jack_nframes_t playlist_position)
+Playlist::split_region (boost::shared_ptr<Region> region, nframes_t playlist_position)
{
RegionLock rl (this);
boost::shared_ptr<Region> left;
boost::shared_ptr<Region> right;
- jack_nframes_t before;
- jack_nframes_t after;
+ nframes_t before;
+ nframes_t after;
string before_name;
string after_name;
**********************************************************************/
Playlist::RegionList *
-Playlist::regions_at (jack_nframes_t frame)
+Playlist::regions_at (nframes_t frame)
{
RegionLock rlock (this);
}
boost::shared_ptr<Region>
-Playlist::top_region_at (jack_nframes_t frame)
+Playlist::top_region_at (nframes_t frame)
{
RegionLock rlock (this);
}
Playlist::RegionList *
-Playlist::find_regions_at (jack_nframes_t frame)
+Playlist::find_regions_at (nframes_t frame)
{
RegionList *rlist = new RegionList;
}
Playlist::RegionList *
-Playlist::regions_touched (jack_nframes_t start, jack_nframes_t end)
+Playlist::regions_touched (nframes_t start, nframes_t end)
{
RegionLock rlock (this);
RegionList *rlist = new RegionList;
boost::shared_ptr<Region>
-Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir)
+Playlist::find_next_region (nframes_t frame, RegionPoint point, int dir)
{
RegionLock rlock (this);
boost::shared_ptr<Region> ret;
- jack_nframes_t closest = max_frames;
+ nframes_t closest = max_frames;
for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
- jack_nframes_t distance;
+ nframes_t distance;
boost::shared_ptr<Region> r = (*i);
- jack_nframes_t pos = 0;
+ nframes_t pos = 0;
switch (point) {
case Start:
return regions.empty();
}
-jack_nframes_t
+nframes_t
Playlist::get_maximum_extent () const
{
RegionLock rlock (const_cast<Playlist *>(this));
return _get_maximum_extent ();
}
-jack_nframes_t
+nframes_t
Playlist::_get_maximum_extent () const
{
RegionList::const_iterator i;
- jack_nframes_t max_extent = 0;
- jack_nframes_t end = 0;
+ nframes_t max_extent = 0;
+ nframes_t end = 0;
for (i = regions.begin(); i != regions.end(); ++i) {
if ((end = (*i)->position() + (*i)->length()) > max_extent) {
}
void
-Playlist::nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwards)
+Playlist::nudge_after (nframes_t start, nframes_t distance, bool forwards)
{
RegionList::iterator i;
- jack_nframes_t new_pos;
+ nframes_t new_pos;
bool moved = false;
_nudging = true;
using namespace PBD;
Playlist*
-Playlist::copyPlaylist (const Playlist& playlist, jack_nframes_t start, jack_nframes_t length,
+Playlist::copyPlaylist (const Playlist& playlist, nframes_t start, nframes_t length,
string name, bool result_is_hidden)
{
const AudioPlaylist* apl;
}
bool
-Redirect::find_next_event (jack_nframes_t now, jack_nframes_t end, ControlEvent& next_event) const
+Redirect::find_next_event (nframes_t now, nframes_t end, ControlEvent& next_event) const
{
map<uint32_t,AutomationList*>::const_iterator li;
AutomationList::TimeComparator cmp;
Change Region::LayerChanged = ARDOUR::new_change ();
Change Region::HiddenChanged = ARDOUR::new_change ();
-Region::Region (jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Region::Flag flags)
+Region::Region (nframes_t start, nframes_t length, const string& name, layer_t layer, Region::Flag flags)
{
/* basic Region constructor */
_last_layer_op = 0;
}
-Region::Region (boost::shared_ptr<const Region> other, jack_nframes_t offset, jack_nframes_t length, const string& name, layer_t layer, Flag flags)
+Region::Region (boost::shared_ptr<const Region> other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags)
{
/* create a new Region from part of an existing one */
}
void
-Region::set_length (jack_nframes_t len, void *src)
+Region::set_length (nframes_t len, void *src)
{
if (_flags & Locked) {
return;
if (_length != len && len != 0) {
+ /* check that the current _position wouldn't make the new
+ length impossible.
+ */
+
+ if (max_frames - len < _position) {
+ return;
+ }
+
if (!verify_length (len)) {
return;
}
}
void
-Region::special_set_position (jack_nframes_t pos)
+Region::special_set_position (nframes_t pos)
{
/* this is used when creating a whole file region as
a way to store its "natural" or "captured" position.
}
void
-Region::set_position (jack_nframes_t pos, void *src)
+Region::set_position (nframes_t pos, void *src)
{
if (_flags & Locked) {
return;
if (_position != pos) {
_position = pos;
+ /* check that the new _position wouldn't make the current
+ length impossible - if so, change the length.
+
+ XXX is this the right thing to do?
+ */
+
+ if (max_frames - _length < _position) {
+ _length = max_frames - _position;
+ }
+
if (!_frozen) {
char buf[64];
snprintf (buf, sizeof (buf), "position set to %u", pos);
}
void
-Region::set_position_on_top (jack_nframes_t pos, void *src)
+Region::set_position_on_top (nframes_t pos, void *src)
{
if (_flags & Locked) {
return;
_position += n;
}
} else {
- if (_position < (jack_nframes_t) -n) {
+ if (_position < (nframes_t) -n) {
_position = 0;
} else {
_position += n;
}
void
-Region::set_start (jack_nframes_t pos, void *src)
+Region::set_start (nframes_t pos, void *src)
{
if (_flags & Locked) {
return;
}
void
-Region::trim_start (jack_nframes_t new_position, void *src)
+Region::trim_start (nframes_t new_position, void *src)
{
if (_flags & Locked) {
return;
}
- jack_nframes_t new_start;
+ nframes_t new_start;
int32_t start_shift;
if (new_position > _position) {
} else if (start_shift < 0) {
- if (_start < (jack_nframes_t) -start_shift) {
+ if (_start < (nframes_t) -start_shift) {
new_start = 0;
} else {
new_start = _start + start_shift;
}
void
-Region::trim_front (jack_nframes_t new_position, void *src)
+Region::trim_front (nframes_t new_position, void *src)
{
if (_flags & Locked) {
return;
}
- jack_nframes_t end = _position + _length - 1;
- jack_nframes_t source_zero;
+ nframes_t end = last_frame();
+ nframes_t source_zero;
if (_position > _start) {
source_zero = _position - _start;
if (new_position < end) { /* can't trim it zero or negative length */
- jack_nframes_t newlen;
+ nframes_t newlen;
/* can't trim it back passed where source position zero is located */
}
void
-Region::trim_end (jack_nframes_t new_endpoint, void *src)
+Region::trim_end (nframes_t new_endpoint, void *src)
{
if (_flags & Locked) {
return;
}
void
-Region::trim_to (jack_nframes_t position, jack_nframes_t length, void *src)
+Region::trim_to (nframes_t position, nframes_t length, void *src)
{
if (_flags & Locked) {
return;
}
void
-Region::trim_to_internal (jack_nframes_t position, jack_nframes_t length, void *src)
+Region::trim_to_internal (nframes_t position, nframes_t length, void *src)
{
int32_t start_shift;
- jack_nframes_t new_start;
+ nframes_t new_start;
if (_flags & Locked) {
return;
} else if (start_shift < 0) {
- if (_start < (jack_nframes_t) -start_shift) {
+ if (_start < (nframes_t) -start_shift) {
new_start = 0;
} else {
new_start = _start + start_shift;
}
void
-Region::set_sync_position (jack_nframes_t absolute_pos)
+Region::set_sync_position (nframes_t absolute_pos)
{
- jack_nframes_t file_pos;
+ nframes_t file_pos;
file_pos = _start + (absolute_pos - _position);
}
}
-jack_nframes_t
+nframes_t
Region::sync_offset (int& dir) const
{
/* returns the sync point relative the first frame of the region */
}
}
-jack_nframes_t
-Region::adjust_to_sync (jack_nframes_t pos)
+nframes_t
+Region::adjust_to_sync (nframes_t pos)
{
int sync_dir;
- jack_nframes_t offset = sync_offset (sync_dir);
+ nframes_t offset = sync_offset (sync_dir);
if (sync_dir > 0) {
if (max_frames - pos > offset) {
return pos;
}
-jack_nframes_t
+nframes_t
Region::sync_position() const
{
if (_flags & SyncMarked) {
_name = prop->value();
if ((prop = node.property ("start")) != 0) {
- _start = (jack_nframes_t) atoi (prop->value().c_str());
+ sscanf (prop->value().c_str(), "%" PRIu32, &_start);
}
if ((prop = node.property ("length")) != 0) {
- _length = (jack_nframes_t) atoi (prop->value().c_str());
+ sscanf (prop->value().c_str(), "%" PRIu32, &_length);
}
if ((prop = node.property ("position")) != 0) {
- _position = (jack_nframes_t) atoi (prop->value().c_str());
+ sscanf (prop->value().c_str(), "%" PRIu32, &_position);
}
if ((prop = node.property ("layer")) != 0) {
/* note: derived classes set flags */
if ((prop = node.property ("sync-position")) != 0) {
- _sync_position = (jack_nframes_t) atoi (prop->value().c_str());
+ sscanf (prop->value().c_str(), "%" PRIu32, &_sync_position);
} else {
_sync_position = _start;
}
sigc::signal<void,boost::shared_ptr<Region> > RegionFactory::CheckNewRegion;
boost::shared_ptr<Region>
-RegionFactory::create (boost::shared_ptr<Region> region, jack_nframes_t start,
- jack_nframes_t length, std::string name,
+RegionFactory::create (boost::shared_ptr<Region> region, nframes_t start,
+ nframes_t length, std::string name,
layer_t layer, Region::Flag flags, bool announce)
{
boost::shared_ptr<const AudioRegion> other;
}
boost::shared_ptr<Region>
-RegionFactory::create (boost::shared_ptr<AudioRegion> region, jack_nframes_t start,
- jack_nframes_t length, std::string name,
+RegionFactory::create (boost::shared_ptr<AudioRegion> region, nframes_t start,
+ nframes_t length, std::string name,
layer_t layer, Region::Flag flags, bool announce)
{
return create (boost::static_pointer_cast<Region> (region), start, length, name, layer, flags, announce);
}
boost::shared_ptr<Region>
-RegionFactory::create (SourceList& srcs, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Region::Flag flags, bool announce)
+RegionFactory::create (SourceList& srcs, nframes_t start, nframes_t length, const string& name, layer_t layer, Region::Flag flags, bool announce)
{
AudioRegion* ar = new AudioRegion (srcs, start, length, name, layer, flags);
boost::shared_ptr<AudioRegion> arp (ar);
}
boost::shared_ptr<Region>
-RegionFactory::create (boost::shared_ptr<Source> src, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t layer, Region::Flag flags, bool announce)
+RegionFactory::create (boost::shared_ptr<Source> src, nframes_t start, nframes_t length, const string& name, layer_t layer, Region::Flag flags, bool announce)
{
boost::shared_ptr<AudioSource> as;
{
SourceList nsrcs;
SourceList::iterator si;
- const jack_nframes_t blocksize = 256 * 1048;
+ const nframes_t blocksize = 256 * 1048;
Sample buf[blocksize];
- jack_nframes_t fpos;
- jack_nframes_t fend;
- jack_nframes_t fstart;
- jack_nframes_t to_read;
+ nframes_t fpos;
+ nframes_t fend;
+ nframes_t fstart;
+ nframes_t to_read;
int ret = -1;
/* create new sources */
/* swap memory order */
- for (jack_nframes_t i = 0; i < to_read/2; ++i) {
+ for (nframes_t i = 0; i < to_read/2; ++i) {
swap (buf[i],buf[to_read-1-i]);
}
void
Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
- 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)
{
uint32_t n;
for (n = 0; n < nbufs; ++n) {
Sample *sp = bufs[n];
- for (jack_nframes_t nx = 0; nx < nframes; ++nx) {
+ for (nframes_t nx = 0; nx < nframes; ++nx) {
sp[nx] *= -gab[nx];
}
}
for (n = 0; n < nbufs; ++n) {
Sample *sp = bufs[n];
- for (jack_nframes_t nx = 0; nx < nframes; ++nx) {
+ for (nframes_t nx = 0; nx < nframes; ++nx) {
sp[nx] *= gab[nx];
}
}
void
-Route::passthru (jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter_first)
+Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter_first)
{
vector<Sample*>& bufs = _session.get_passthru_buffers();
uint32_t limit = n_process_buffers ();
uint32_t i_cnt;
uint32_t s_cnt;
map<Placement,list<InsertCount> > insert_map;
- jack_nframes_t initial_streams;
+ nframes_t initial_streams;
redirect_max_outs = 0;
i_cnt = 0;
}
void
-Route::silence (jack_nframes_t nframes, jack_nframes_t offset)
+Route::silence (nframes_t nframes, nframes_t offset)
{
if (!_silent) {
void
Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_redirects)
{
- jack_nframes_t now = _session.transport_frame();
+ nframes_t now = _session.transport_frame();
{
Glib::RWLock::ReaderLock lm (redirect_lock);
}
int
-Route::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset,
+Route::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() == 0) {
return 0;
}
-jack_nframes_t
-Route::check_initial_delay (jack_nframes_t nframes, jack_nframes_t& offset, jack_nframes_t& transport_frame)
+nframes_t
+Route::check_initial_delay (nframes_t nframes, nframes_t& offset, nframes_t& transport_frame)
{
if (_roll_delay > nframes) {
}
int
-Route::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset, int declick,
+Route::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick,
bool can_record, bool rec_monitors_input)
{
{
return 0;
}
- jack_nframes_t unused = 0;
+ nframes_t unused = 0;
if ((nframes = check_initial_delay (nframes, offset, unused)) == 0) {
return 0;
if (am.locked() && _session.transport_rolling()) {
- jack_nframes_t start_frame = end_frame - nframes;
+ nframes_t start_frame = end_frame - nframes;
if (gain_automation_playback()) {
apply_gain_automation = _gain_automation_curve.rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes);
}
int
-Route::silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset,
+Route::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
bool can_record, bool rec_monitors_input)
{
silence (nframes, offset);
}
}
-jack_nframes_t
+nframes_t
Route::update_total_latency ()
{
_own_latency = 0;
}
void
-Route::set_latency_delay (jack_nframes_t longest_session_latency)
+Route::set_latency_delay (nframes_t longest_session_latency)
{
_initial_delay = longest_session_latency - _own_latency;
}
void
-Route::automation_snapshot (jack_nframes_t now)
+Route::automation_snapshot (nframes_t now)
{
IO::automation_snapshot (now);
}
void
-Route::set_block_size (jack_nframes_t nframes)
+Route::set_block_size (nframes_t nframes)
{
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
(*i)->set_block_size (nframes);
}
void
-Send::run (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset)
+Send::run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
{
if (active()) {
uint32_t master_out_channels,
uint32_t requested_physical_in,
uint32_t requested_physical_out,
- jack_nframes_t initial_length)
+ nframes_t initial_length)
: _engine (eng),
_mmc_port (default_mmc_port),
void
Session::auto_punch_end_changed (Location* location)
{
- jack_nframes_t when_to_stop = location->end();
+ nframes_t when_to_stop = location->end();
// when_to_stop += _worst_output_latency + _worst_input_latency;
replace_event (Event::PunchOut, when_to_stop);
}
void
Session::auto_punch_changed (Location* location)
{
- jack_nframes_t when_to_stop = location->end();
+ nframes_t when_to_stop = location->end();
replace_event (Event::PunchIn, location->start());
//when_to_stop += _worst_output_latency + _worst_input_latency;
set_dirty();
}
-jack_nframes_t
+nframes_t
Session::audible_frame () const
{
- jack_nframes_t ret;
- jack_nframes_t offset;
- jack_nframes_t tf;
+ nframes_t ret;
+ nframes_t offset;
+ nframes_t tf;
/* the first of these two possible settings for "offset"
mean that the audible frame is stationary until
}
void
-Session::set_frame_rate (jack_nframes_t frames_per_second)
+Session::set_frame_rate (nframes_t frames_per_second)
{
- /** \fn void Session::set_frame_size(jack_nframes_t)
+ /** \fn void Session::set_frame_size(nframes_t)
the AudioEngine object that calls this guarantees
that it will not be called while we are also in
::process(). Its fine to do things that block
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
// DestructiveFileSource::setup_standard_crossfades (frames_per_second);
}
void
-Session::set_block_size (jack_nframes_t nframes)
+Session::set_block_size (nframes_t nframes)
{
/* the AudioEngine guarantees
that it will not be called while we are also in
Session::set_default_fade (float steepness, float fade_msecs)
{
#if 0
- jack_nframes_t fade_frames;
+ nframes_t fade_frames;
/* Don't allow fade of less 1 frame */
} else {
- fade_frames = (jack_nframes_t) floor (fade_msecs * _current_frame_rate * 0.001);
+ fade_frames = (nframes_t) floor (fade_msecs * _current_frame_rate * 0.001);
}
return;
}
- jack_nframes_t max = get_maximum_extent ();
+ nframes_t max = get_maximum_extent ();
if (max > end_location->end()) {
end_location->set_end (max);
}
}
-jack_nframes_t
+nframes_t
Session::get_maximum_extent () const
{
- jack_nframes_t max = 0;
- jack_nframes_t me;
+ nframes_t max = 0;
+ nframes_t me;
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
set_dirty();
}
-jack_nframes_t
+nframes_t
Session::available_capture_duration ()
{
const double scale = 4096.0 / sizeof (Sample);
return max_frames;
}
- return (jack_nframes_t) floor (_total_free_4k_blocks * scale);
+ return (nframes_t) floor (_total_free_4k_blocks * scale);
}
void
}
void
-Session::allocate_pan_automation_buffers (jack_nframes_t nframes, uint32_t howmany, bool force)
+Session::allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force)
{
if (!force && howmany <= _npan_buffers) {
return;
}
int
-Session::write_one_audio_track (AudioTrack& track, jack_nframes_t start, jack_nframes_t len,
+Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t len,
bool overwrite, vector<boost::shared_ptr<AudioSource> >& srcs, InterThreadInfo& itt)
{
int ret = -1;
char buf[PATH_MAX+1];
string dir;
uint32_t nchans;
- jack_nframes_t position;
- jack_nframes_t this_chunk;
- jack_nframes_t to_do;
+ nframes_t position;
+ nframes_t this_chunk;
+ nframes_t to_do;
vector<Sample*> buffers;
// any bigger than this seems to cause stack overflows in called functions
- const jack_nframes_t chunk_size = (128 * 1024)/4;
+ const nframes_t chunk_size = (128 * 1024)/4;
g_atomic_int_set (&processing_prohibited, 1);
Pool Session::Click::pool ("click", sizeof (Click), 128);
void
-Session::click (jack_nframes_t start, jack_nframes_t nframes, jack_nframes_t offset)
+Session::click (nframes_t start, nframes_t nframes, nframes_t offset)
{
TempoMap::BBTPointList *points;
- jack_nframes_t end;
+ nframes_t end;
Sample *buf;
vector<Sample*> bufs;
for (list<Click*>::iterator i = clicks.begin(); i != clicks.end(); ) {
- jack_nframes_t copy;
- jack_nframes_t internal_offset;
+ nframes_t copy;
+ nframes_t internal_offset;
Click *clk;
list<Click*>::iterator next;
};
void
-Session::add_event (jack_nframes_t frame, Event::Type type, jack_nframes_t target_frame)
+Session::add_event (nframes_t frame, Event::Type type, nframes_t target_frame)
{
Event* ev = new Event (type, Event::Add, frame, target_frame, 0);
queue_event (ev);
}
void
-Session::remove_event (jack_nframes_t frame, Event::Type type)
+Session::remove_event (nframes_t frame, Event::Type type)
{
Event* ev = new Event (type, Event::Remove, frame, 0, 0);
queue_event (ev);
}
void
-Session::replace_event (Event::Type type, jack_nframes_t frame, jack_nframes_t target)
+Session::replace_event (Event::Type type, nframes_t frame, nframes_t target)
{
Event* ev = new Event (type, Event::Replace, frame, target, 0);
queue_event (ev);
}
int
-AudioExportSpecification::prepare (jack_nframes_t blocksize, jack_nframes_t frate)
+AudioExportSpecification::prepare (nframes_t blocksize, nframes_t frate)
{
char errbuf[256];
GDitherSize dither_size;
}
src_data.src_ratio = sample_rate / (double) frame_rate;
- out_samples_max = (jack_nframes_t) ceil (blocksize * src_data.src_ratio * channels);
+ out_samples_max = (nframes_t) ceil (blocksize * src_data.src_ratio * channels);
dataF2 = new float[out_samples_max];
max_leftover_frames = 4 * blocksize;
}
int
-AudioExportSpecification::process (jack_nframes_t nframes)
+AudioExportSpecification::process (nframes_t nframes)
{
float* float_buffer = 0;
uint32_t chn;
uint32_t i;
sf_count_t written;
char errbuf[256];
- jack_nframes_t to_write = 0;
+ nframes_t to_write = 0;
int cnt = 0;
do {
break;
}
- if ((jack_nframes_t) written != to_write) {
+ if ((nframes_t) written != to_write) {
sf_error_str (out, errbuf, sizeof (errbuf) - 1);
error << string_compose(_("Export: could not write data to output file (%1)"), errbuf) << endmsg;
return -1;
}
int
-Session::process_export (jack_nframes_t nframes, AudioExportSpecification* spec)
+Session::process_export (nframes_t nframes, AudioExportSpecification* spec)
{
uint32_t chn;
uint32_t x;
int ret = -1;
- jack_nframes_t this_nframes;
+ nframes_t this_nframes;
/* This is not required to be RT-safe because we are running while freewheeling */
return;
}
- jack_nframes_t target_frame;
+ nframes_t target_frame;
SMPTE::Time smpte;
smpte.hours = mmc_tc[0] & 0xf;
void
Session::send_time_code_in_another_thread (bool full)
{
- jack_nframes_t two_smpte_frames_duration;
- jack_nframes_t quarter_frame_duration;
+ nframes_t two_smpte_frames_duration;
+ nframes_t quarter_frame_duration;
/* Duration of two smpte frames */
two_smpte_frames_duration = ((long) _frames_per_smpte_frame) << 1;
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;
}
}
return 0;
}
- jack_nframes_t two_smpte_frames_duration;
- jack_nframes_t quarter_frame_duration;
+ nframes_t two_smpte_frames_duration;
+ nframes_t quarter_frame_duration;
/* Duration of two smpte frames */
two_smpte_frames_duration = ((long) _frames_per_smpte_frame) << 1;
**********************************************************************/
void
-Session::send_mmc_in_another_thread (MIDI::MachineControl::Command cmd, jack_nframes_t target_frame)
+Session::send_mmc_in_another_thread (MIDI::MachineControl::Command cmd, nframes_t target_frame)
{
MIDIRequest* request;
}
void
-Session::deliver_mmc (MIDI::MachineControl::Command cmd, jack_nframes_t where)
+Session::deliver_mmc (MIDI::MachineControl::Command cmd, nframes_t where)
{
using namespace MIDI;
int nbytes = 4;
using namespace std;
void
-Session::process (jack_nframes_t nframes)
+Session::process (nframes_t nframes)
{
if (synced_to_jack() && waiting_to_start) {
if ( _engine.transport_state() == AudioEngine::TransportRolling) {
}
int
-Session::no_roll (jack_nframes_t nframes, jack_nframes_t offset)
+Session::no_roll (nframes_t nframes, nframes_t offset)
{
- jack_nframes_t end_frame = _transport_frame + nframes;
+ nframes_t end_frame = _transport_frame + nframes;
int ret = 0;
bool declick = get_transport_declick_required();
boost::shared_ptr<RouteList> r = routes.reader ();
}
int
-Session::process_routes (jack_nframes_t nframes, jack_nframes_t offset)
+Session::process_routes (nframes_t nframes, nframes_t offset)
{
bool record_active;
int declick = get_transport_declick_required();
}
int
-Session::silent_process_routes (jack_nframes_t nframes, jack_nframes_t offset)
+Session::silent_process_routes (nframes_t nframes, nframes_t offset)
{
bool record_active = actively_recording();
int declick = get_transport_declick_required();
}
void
-Session::commit_diskstreams (jack_nframes_t nframes, bool &needs_butler)
+Session::commit_diskstreams (nframes_t nframes, bool &needs_butler)
{
int dret;
float pworst = 1.0f;
}
void
-Session::process_with_events (jack_nframes_t nframes)
+Session::process_with_events (nframes_t nframes)
{
Event* ev;
- jack_nframes_t this_nframes;
- jack_nframes_t end_frame;
- jack_nframes_t offset;
+ nframes_t this_nframes;
+ nframes_t end_frame;
+ nframes_t offset;
bool session_needs_butler = false;
- jack_nframes_t stop_limit;
+ nframes_t stop_limit;
long frames_moved;
/* make sure the auditioner is silent */
nframes -= this_nframes;
offset += this_nframes;
- frames_moved = (jack_nframes_t) floor (_transport_speed * this_nframes);
+ frames_moved = (nframes_t) floor (_transport_speed * this_nframes);
if (frames_moved < 0) {
decrement_transport_position (-frames_moved);
}
bool
-Session::follow_slave (jack_nframes_t nframes, jack_nframes_t offset)
+Session::follow_slave (nframes_t nframes, nframes_t offset)
{
float slave_speed;
- jack_nframes_t slave_transport_frame;
- jack_nframes_t this_delta;
+ nframes_t slave_transport_frame;
+ nframes_t this_delta;
int dir;
bool starting;
slave_state = Running;
bool ok = true;
- jack_nframes_t frame_delta = slave_transport_frame - _transport_frame;
+ nframes_t frame_delta = slave_transport_frame - _transport_frame;
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
/* XXX what? */
}
- memset (delta_accumulator, 0, sizeof (jack_nframes_t) * delta_accumulator_size);
+ memset (delta_accumulator, 0, sizeof (nframes_t) * delta_accumulator_size);
average_slave_delta = 0;
this_delta = 0;
}
request_transport_speed (adjusted_speed);
#if 1
- if ((jack_nframes_t) average_slave_delta > _slave->resolution()) {
+ if ((nframes_t) average_slave_delta > _slave->resolution()) {
// cerr << "not locked\n";
goto silent_motion;
}
increment_transport_position (frames_moved);
}
- jack_nframes_t stop_limit;
+ nframes_t stop_limit;
if (actively_recording()) {
stop_limit = max_frames;
}
void
-Session::process_without_events (jack_nframes_t nframes)
+Session::process_without_events (nframes_t nframes)
{
bool session_needs_butler = false;
- jack_nframes_t stop_limit;
+ nframes_t stop_limit;
long frames_moved;
- jack_nframes_t offset = 0;
+ nframes_t offset = 0;
{
if (post_transport_work & (PostTransportLocate|PostTransportStop)) {
}
void
-Session::process_audition (jack_nframes_t nframes)
+Session::process_audition (nframes_t nframes)
{
Event* ev;
boost::shared_ptr<RouteList> r = routes.reader ();
}
bool
-Session::maybe_sync_start (jack_nframes_t& nframes, jack_nframes_t& offset)
+Session::maybe_sync_start (nframes_t& nframes, nframes_t& offset)
{
- jack_nframes_t sync_offset;
+ nframes_t sync_offset;
if (!waiting_for_sync_offset) {
return false;
/* default short fade = 15ms */
- Crossfade::set_short_xfade_length ((jack_nframes_t) floor (Config->get_short_xfade_seconds() * frame_rate()));
+ Crossfade::set_short_xfade_length ((nframes_t) floor (Config->get_short_xfade_seconds() * frame_rate()));
DestructiveFileSource::setup_standard_crossfades (frame_rate());
last_mmc_step.tv_sec = 0;
}
int
-Session::create (bool& new_session, string* mix_template, jack_nframes_t initial_length)
+Session::create (bool& new_session, string* mix_template, nframes_t initial_length)
{
string dir;
/* BBT TIME*/
void
-Session::bbt_time (jack_nframes_t when, BBT_Time& bbt)
+Session::bbt_time (nframes_t when, BBT_Time& bbt)
{
_tempo_map->bbt_time (when, bbt);
}
void
Session::sync_time_vars ()
{
- _current_frame_rate = (jack_nframes_t) round (_base_frame_rate * (1.0 + (Config->get_video_pullup()/100.0)));
+ _current_frame_rate = (nframes_t) round (_base_frame_rate * (1.0 + (Config->get_video_pullup()/100.0)));
_frames_per_hour = _current_frame_rate * 3600;
_frames_per_smpte_frame = (double) _current_frame_rate / (double) Config->get_smpte_frames_per_second();
_smpte_frames_per_hour = (unsigned long) (Config->get_smpte_frames_per_second() * 3600.0);
}
void
-Session::set_smpte_offset (jack_nframes_t off)
+Session::set_smpte_offset (nframes_t off)
{
_smpte_offset = off;
last_smpte_valid = false;
}
void
-Session::smpte_to_sample( SMPTE::Time& smpte, jack_nframes_t& sample, bool use_offset, bool use_subframes ) const
+Session::smpte_to_sample( SMPTE::Time& smpte, nframes_t& sample, bool use_offset, bool use_subframes ) const
{
if (Config->get_smpte_drop_frames()) {
// The drop frame format was created to better approximate the 30000/1001 = 29.97002997002997....
// Per Sigmond <per@sigmond.no>
// Samples inside time dividable by 10 minutes (real time accurate)
- jack_nframes_t base_samples = ((smpte.hours * 60 * 60) + ((smpte.minutes / 10) * 10 * 60)) * frame_rate();
+ nframes_t base_samples = ((smpte.hours * 60 * 60) + ((smpte.minutes / 10) * 10 * 60)) * frame_rate();
// Samples inside time exceeding the nearest 10 minutes (always offset, see above)
long exceeding_df_minutes = smpte.minutes % 10;
long exceeding_df_seconds = (exceeding_df_minutes * 60) + smpte.seconds;
long exceeding_df_frames = (30 * exceeding_df_seconds) + smpte.frames - (2 * exceeding_df_minutes);
- jack_nframes_t exceeding_samples = (jack_nframes_t) rint(exceeding_df_frames * _frames_per_smpte_frame);
+ nframes_t exceeding_samples = (nframes_t) rint(exceeding_df_frames * _frames_per_smpte_frame);
sample = base_samples + exceeding_samples;
} else {
// Non drop is easy:
- sample = (((smpte.hours * 60 * 60) + (smpte.minutes * 60) + smpte.seconds) * frame_rate()) + (jack_nframes_t)rint(smpte.frames * _frames_per_smpte_frame);
+ sample = (((smpte.hours * 60 * 60) + (smpte.minutes * 60) + smpte.seconds) * frame_rate()) + (nframes_t)rint(smpte.frames * _frames_per_smpte_frame);
}
if (use_subframes) {
void
-Session::sample_to_smpte( jack_nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes ) const
+Session::sample_to_smpte( nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes ) const
{
- jack_nframes_t offset_sample;
+ nframes_t offset_sample;
if (!use_offset) {
offset_sample = sample;
}
void
-Session::smpte_time (jack_nframes_t when, SMPTE::Time& smpte)
+Session::smpte_time (nframes_t when, SMPTE::Time& smpte)
{
if (last_smpte_valid && when == last_smpte_when) {
smpte = last_smpte;
}
void
-Session::smpte_time_subframes (jack_nframes_t when, SMPTE::Time& smpte)
+Session::smpte_time_subframes (nframes_t when, SMPTE::Time& smpte)
{
if (last_smpte_valid && when == last_smpte_when) {
smpte = last_smpte;
}
void
-Session::smpte_duration (jack_nframes_t when, SMPTE::Time& smpte) const
+Session::smpte_duration (nframes_t when, SMPTE::Time& smpte) const
{
sample_to_smpte( when, smpte, false /* use_offset */, true /* use_subframes */ );
}
void
-Session::smpte_duration_string (char* buf, jack_nframes_t when) const
+Session::smpte_duration_string (char* buf, nframes_t when) const
{
SMPTE::Time smpte;
void
Session::jack_timebase_callback (jack_transport_state_t state,
- jack_nframes_t nframes,
+ nframes_t nframes,
jack_position_t* pos,
int new_position)
{
#endif
}
-jack_nframes_t
-Session::convert_to_frames_at (jack_nframes_t position, AnyTime& any)
+nframes_t
+Session::convert_to_frames_at (nframes_t position, AnyTime& any)
{
double secs;
secs += any.smpte.frames / Config->get_smpte_frames_per_second ();
if (_smpte_offset_negative)
{
- return (jack_nframes_t) floor (secs * frame_rate()) - _smpte_offset;
+ return (nframes_t) floor (secs * frame_rate()) - _smpte_offset;
}
else
{
- return (jack_nframes_t) floor (secs * frame_rate()) + _smpte_offset;
+ return (nframes_t) floor (secs * frame_rate()) + _smpte_offset;
}
break;
case AnyTime::Seconds:
- return (jack_nframes_t) floor (any.seconds * frame_rate());
+ return (nframes_t) floor (any.seconds * frame_rate());
break;
case AnyTime::Frames:
string region_name;
string ident = X_("-TIMEFX-");
float percentage;
- jack_nframes_t total_frames;
- jack_nframes_t done;
+ nframes_t total_frames;
+ nframes_t done;
/* the soundtouch code wants a *tempo* change percentage, which is
of opposite sign to the length change.
}
try {
- const jack_nframes_t bufsize = 16384;
+ const nframes_t bufsize = 16384;
for (uint32_t i = 0; i < sources.size(); ++i) {
gain_t gain_buffer[bufsize];
Sample buffer[bufsize];
- jack_nframes_t pos = 0;
- jack_nframes_t this_read = 0;
+ nframes_t pos = 0;
+ nframes_t this_read = 0;
st.clear();
while (tsr.running && pos < tsr.region->length()) {
- jack_nframes_t this_time;
+ nframes_t this_time;
this_time = min (bufsize, tsr.region->length() - pos);
}
void
-Session::request_locate (jack_nframes_t target_frame, bool with_roll)
+Session::request_locate (nframes_t target_frame, bool with_roll)
{
Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, false);
queue_event (ev);
}
void
-Session::force_locate (jack_nframes_t target_frame, bool with_roll)
+Session::force_locate (nframes_t target_frame, bool with_roll)
{
Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, true);
queue_event (ev);
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if (!(*i)->hidden()) {
if ((*i)->speed() != 1.0f || (*i)->speed() != -1.0f) {
- (*i)->seek ((jack_nframes_t) (_transport_frame * (double) (*i)->speed()));
+ (*i)->seek ((nframes_t) (_transport_frame * (double) (*i)->speed()));
}
else {
(*i)->seek (_transport_frame);
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if (!(*i)->hidden()) {
if ((*i)->speed() != 1.0f || (*i)->speed() != -1.0f) {
- (*i)->seek ((jack_nframes_t) (_transport_frame * (double) (*i)->speed()));
+ (*i)->seek ((nframes_t) (_transport_frame * (double) (*i)->speed()));
}
else {
(*i)->seek (_transport_frame);
}
void
-Session::start_locate (jack_nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
+Session::start_locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
{
if (synced_to_jack()) {
float sp;
- jack_nframes_t pos;
+ nframes_t pos;
_slave->speed_and_position (sp, pos);
}
void
-Session::locate (jack_nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
+Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
{
if (actively_recording()) {
return;
}
void
-Session::reset_rf_scale (jack_nframes_t motion)
+Session::reset_rf_scale (nframes_t motion)
{
cumulative_rf_motion += motion;
/* locating/stopping is subject to delays for declicking.
*/
- jack_nframes_t requested_frame = (*i).end;
+ nframes_t requested_frame = (*i).end;
if (requested_frame > current_block_size) {
requested_frame -= current_block_size;
}
void
-Session::request_bounded_roll (jack_nframes_t start, jack_nframes_t end)
+Session::request_bounded_roll (nframes_t start, nframes_t end)
{
request_stop ();
Event *ev = new Event (Event::StopOnce, Event::Replace, Event::Immediate, end, 0.0);
(!(post_transport_work & PostTransportLocate) || pending_locate_flush));
}
- jack_nframes_t old_latency = (*i)->signal_latency ();
- jack_nframes_t track_latency = (*i)->update_total_latency ();
+ nframes_t old_latency = (*i)->signal_latency ();
+ nframes_t track_latency = (*i)->update_total_latency ();
if (old_latency != track_latency) {
update_jack = true;
#include <pwd.h>
#include <sys/utsname.h>
+#include <sys/stat.h>
#include <glibmm/miscutils.h>
}
}
-SndFileSource::SndFileSource (Session& s, string idstr, SampleFormat sfmt, HeaderFormat hf, jack_nframes_t rate, Flag flags)
+SndFileSource::SndFileSource (Session& s, string idstr, SampleFormat sfmt, HeaderFormat hf, nframes_t rate, Flag flags)
: AudioFileSource (s, idstr, flags, sfmt, hf)
{
int fmt = 0;
if (sf) {
sf_close (sf);
sf = 0;
+
+ /* stupid libsndfile updated the headers on close,
+ so touch the peakfile if it exists and has data
+ to make sure its time is as new as the audio
+ file.
+ */
+
+ touch_peakfile ();
}
if (interleave_buf) {
return _info.samplerate;
}
-jack_nframes_t
-SndFileSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
+nframes_t
+SndFileSource::read_unlocked (Sample *dst, nframes_t start, nframes_t cnt) const
{
int32_t nread;
float *ptr;
uint32_t real_cnt;
- jack_nframes_t file_cnt;
-
- //destructive (tape) tracks need to offset reads and writes by the timeline position
- if (_flags && ARDOUR::Destructive == ARDOUR::Destructive) {
- start -= timeline_position;
- }
+ nframes_t file_cnt;
if (start > _length) {
}
if (_info.channels == 1) {
- jack_nframes_t ret = sf_read_float (sf, dst, file_cnt);
+ nframes_t ret = sf_read_float (sf, dst, file_cnt);
_read_data_count = cnt * sizeof(float);
return ret;
}
}
if (file_cnt != cnt) {
- jack_nframes_t delta = cnt - file_cnt;
+ nframes_t delta = cnt - file_cnt;
memset (dst+file_cnt, 0, sizeof (Sample) * delta);
}
return nread;
}
-jack_nframes_t
-SndFileSource::write_unlocked (Sample *data, jack_nframes_t cnt)
+nframes_t
+SndFileSource::write_unlocked (Sample *data, nframes_t cnt)
{
if (!writable()) {
return 0;
return 0;
}
- jack_nframes_t oldlen;
+ nframes_t oldlen;
int32_t frame_pos = _length;
if (write_float (data, frame_pos, cnt) != cnt) {
}
int
-SndFileSource::update_header (jack_nframes_t when, struct tm& now, time_t tnow)
+SndFileSource::update_header (nframes_t when, struct tm& now, time_t tnow)
{
set_timeline_position (when);
if (!writable() || (sf == 0)) {
return -1;
}
-
return (sf_command (sf, SFC_UPDATE_HEADER_NOW, 0, 0) != SF_TRUE);
}
int
-SndFileSource::setup_broadcast_info (jack_nframes_t when, struct tm& now, time_t tnow)
+SndFileSource::setup_broadcast_info (nframes_t when, struct tm& now, time_t tnow)
{
if (!writable()) {
return -1;
}
-jack_nframes_t
-SndFileSource::write_float (Sample* data, jack_nframes_t frame_pos, jack_nframes_t cnt)
+nframes_t
+SndFileSource::write_float (Sample* data, nframes_t frame_pos, nframes_t cnt)
{
if (sf_seek (sf, frame_pos, SEEK_SET|SFM_WRITE) != frame_pos) {
error << string_compose (_("%1: cannot seek to %2"), _path, frame_pos) << endmsg;
return cnt;
}
-jack_nframes_t
+nframes_t
SndFileSource::natural_position() const
{
return timeline_position;
#endif // HAVE_COREAUDIO
boost::shared_ptr<Source>
-SourceFactory::createWritable (Session& s, std::string path, bool destructive, jack_nframes_t rate, bool announce)
+SourceFactory::createWritable (Session& s, std::string path, bool destructive, nframes_t rate, bool announce)
{
/* this might throw failed_constructor(), which is OK */
/***********************************************************************/
double
-Meter::frames_per_bar (const Tempo& tempo, jack_nframes_t sr) const
+Meter::frames_per_bar (const Tempo& tempo, nframes_t sr) const
{
return ((60.0 * sr * _beats_per_bar) / tempo.beats_per_minute());
}
}
};
-TempoMap::TempoMap (jack_nframes_t fr)
+TempoMap::TempoMap (nframes_t fr)
{
metrics = new Metrics;
_frame_rate = fr;
const Tempo* tempo;
Meter *m;
Tempo *t;
- jack_nframes_t current;
- jack_nframes_t section_frames;
+ nframes_t current;
+ nframes_t section_frames;
BBT_Time start;
BBT_Time end;
}
TempoMap::Metric
-TempoMap::metric_at (jack_nframes_t frame) const
+TempoMap::metric_at (nframes_t frame) const
{
Metric m (first_meter(), first_tempo());
const Meter* meter;
}
void
-TempoMap::bbt_time (jack_nframes_t frame, BBT_Time& bbt) const
+TempoMap::bbt_time (nframes_t frame, BBT_Time& bbt) const
{
{
Glib::RWLock::ReaderLock lm (lock);
}
void
-TempoMap::bbt_time_unlocked (jack_nframes_t frame, BBT_Time& bbt) const
+TempoMap::bbt_time_unlocked (nframes_t frame, BBT_Time& bbt) const
{
bbt_time_with_metric (frame, bbt, metric_at (frame));
}
void
-TempoMap::bbt_time_with_metric (jack_nframes_t frame, BBT_Time& bbt, const Metric& metric) const
+TempoMap::bbt_time_with_metric (nframes_t frame, BBT_Time& bbt, const Metric& metric) const
{
- jack_nframes_t frame_diff;
+ nframes_t frame_diff;
uint32_t xtra_bars = 0;
double xtra_beats = 0;
}
-jack_nframes_t
+nframes_t
TempoMap::count_frames_between ( const BBT_Time& start, const BBT_Time& end) const
{
*/
- jack_nframes_t frames = 0;
- jack_nframes_t start_frame = 0;
- jack_nframes_t end_frame = 0;
+ nframes_t frames = 0;
+ nframes_t start_frame = 0;
+ nframes_t end_frame = 0;
Metric m = metric_at(start);
+ start.ticks/Meter::ticks_per_beat;
- start_frame = m.frame() + (jack_nframes_t) rint( beat_offset * m.tempo().frames_per_beat(_frame_rate));
+ start_frame = m.frame() + (nframes_t) rint( beat_offset * m.tempo().frames_per_beat(_frame_rate));
m = metric_at(end);
beat_offset = bar_offset * m.meter().beats_per_bar() - (m.start().beats -1) + (end.beats - 1)
+ end.ticks/Meter::ticks_per_beat;
- end_frame = m.frame() + (jack_nframes_t) rint(beat_offset * m.tempo().frames_per_beat(_frame_rate));
+ end_frame = m.frame() + (nframes_t) rint(beat_offset * m.tempo().frames_per_beat(_frame_rate));
frames = end_frame - start_frame;
}
-jack_nframes_t
+nframes_t
TempoMap::count_frames_between_metrics (const Meter& meter, const Tempo& tempo, const BBT_Time& start, const BBT_Time& end) const
{
/*this is used in timestamping the metrics by actually counting the beats */
- jack_nframes_t frames = 0;
+ nframes_t frames = 0;
uint32_t bar = start.bars;
double beat = (double) start.beats;
double beats_counted = 0;
}
}
- frames = (jack_nframes_t) floor (beats_counted * beat_frames);
+ frames = (nframes_t) floor (beats_counted * beat_frames);
return frames;
}
-jack_nframes_t
+nframes_t
TempoMap::frame_time (const BBT_Time& bbt) const
{
BBT_Time start ; /* 1|1|0 */
return count_frames_between ( start, bbt);
}
-jack_nframes_t
-TempoMap::bbt_duration_at (jack_nframes_t pos, const BBT_Time& bbt, int dir) const
+nframes_t
+TempoMap::bbt_duration_at (nframes_t pos, const BBT_Time& bbt, int dir) const
{
- jack_nframes_t frames = 0;
+ nframes_t frames = 0;
BBT_Time when;
bbt_time(pos,when);
return frames;
}
-jack_nframes_t
+nframes_t
TempoMap::bbt_duration_at_unlocked (const BBT_Time& when, const BBT_Time& bbt, int dir) const
{
- jack_nframes_t frames = 0;
+ nframes_t frames = 0;
double beats_per_bar;
BBT_Time result;
-jack_nframes_t
-TempoMap::round_to_bar (jack_nframes_t fr, int dir)
+nframes_t
+TempoMap::round_to_bar (nframes_t fr, int dir)
{
{
Glib::RWLock::ReaderLock lm (lock);
}
-jack_nframes_t
-TempoMap::round_to_beat (jack_nframes_t fr, int dir)
+nframes_t
+TempoMap::round_to_beat (nframes_t fr, int dir)
{
{
Glib::RWLock::ReaderLock lm (lock);
}
}
-jack_nframes_t
+nframes_t
-TempoMap::round_to_beat_subdivision (jack_nframes_t fr, int sub_num)
+TempoMap::round_to_beat_subdivision (nframes_t fr, int sub_num)
{
BBT_Time the_beat;
TempoMap::BBTPointList::iterator i;
TempoMap::BBTPointList *more_zoomed_bbt_points;
- jack_nframes_t frame_one_beats_worth;
- jack_nframes_t pos = 0;
- jack_nframes_t next_pos = 0 ;
+ nframes_t frame_one_beats_worth;
+ nframes_t pos = 0;
+ nframes_t next_pos = 0 ;
double tempo = 1;
double frames_one_subdivisions_worth;
bool fr_has_changed = false;
int n;
- frame_one_beats_worth = (jack_nframes_t) ::floor ((double) _frame_rate * 60 / 20 ); //one beat @ 20 bpm
+ frame_one_beats_worth = (nframes_t) ::floor ((double) _frame_rate * 60 / 20 ); //one beat @ 20 bpm
{
Glib::RWLock::ReaderLock lm (lock);
more_zoomed_bbt_points = get_points((fr >= frame_one_beats_worth) ?
for (n = sub_num; n > 0; n--) {
if (fr >= (pos + ((n - 0.5) * frames_one_subdivisions_worth))) {
- fr = (jack_nframes_t) round(pos + (n * frames_one_subdivisions_worth));
+ fr = (nframes_t) round(pos + (n * frames_one_subdivisions_worth));
if (fr > next_pos) {
fr = next_pos; //take care of fractional beats that don't match the subdivision asked
}
}
-jack_nframes_t
+nframes_t
-TempoMap::round_to_type (jack_nframes_t frame, int dir, BBTPointType type)
+TempoMap::round_to_type (nframes_t frame, int dir, BBTPointType type)
{
Metric metric = metric_at (frame);
BBT_Time bbt;
}
TempoMap::BBTPointList *
-TempoMap::get_points (jack_nframes_t lower, jack_nframes_t upper) const
+TempoMap::get_points (nframes_t lower, nframes_t upper) const
{
Metrics::const_iterator i;
double beat_frame;
double beat_frames;
double frames_per_bar;
- jack_nframes_t limit;
+ nframes_t limit;
meter = &first_meter ();
tempo = &first_tempo ();
if (beat == 1) {
if (current >= lower) {
- points->push_back (BBTPoint (*meter, *tempo,(jack_nframes_t)rint(current), Bar, bar, 1));
+ points->push_back (BBTPoint (*meter, *tempo,(nframes_t)rint(current), Bar, bar, 1));
}
}
while (beat <= ceil( beats_per_bar) && beat_frame < limit) {
if (beat_frame >= lower) {
- points->push_back (BBTPoint (*meter, *tempo, (jack_nframes_t) rint(beat_frame), Beat, bar, beat));
+ points->push_back (BBTPoint (*meter, *tempo, (nframes_t) rint(beat_frame), Beat, bar, beat));
}
beat_frame += beat_frames;
current+= beat_frames;
}
const Tempo&
-TempoMap::tempo_at (jack_nframes_t frame)
+TempoMap::tempo_at (nframes_t frame)
{
Metric m (metric_at (frame));
return m.tempo();
const Meter&
-TempoMap::meter_at (jack_nframes_t frame)
+TempoMap::meter_at (nframes_t frame)
{
Metric m (metric_at (frame));
return m.meter();
}
}
-jack_nframes_t
+nframes_t
Track::update_total_latency ()
{
_own_latency = 0;
}
void
-Track::set_latency_delay (jack_nframes_t longest_session_latency)
+Track::set_latency_delay (nframes_t longest_session_latency)
{
Route::set_latency_delay (longest_session_latency);
_diskstream->set_roll_delay (_roll_delay);
#endif // HAVE_COREAUDIO
void
-compute_equal_power_fades (jack_nframes_t nframes, float* in, float* out)
+compute_equal_power_fades (nframes_t nframes, float* in, float* out)
{
double step;
in[0] = 0.0f;
- for (jack_nframes_t i = 1; i < nframes - 1; ++i) {
+ for (nframes_t i = 1; i < nframes - 1; ++i) {
in[i] = in[i-1] + step;
}
}
void
-VSTPlugin::set_block_size (jack_nframes_t nframes)
+VSTPlugin::set_block_size (nframes_t nframes)
{
deactivate ();
_plugin->dispatcher (_plugin, effSetBlockSize, 0, nframes, NULL, 0.0f);
return name;
}
-jack_nframes_t
+nframes_t
VSTPlugin::latency () const
{
return _plugin->initialDelay;
}
int
-VSTPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in_index, int32_t& out_index, jack_nframes_t nframes, jack_nframes_t offset)
+VSTPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in_index, int32_t& out_index, nframes_t nframes, nframes_t offset)
{
float *ins[_plugin->numInputs];
float *outs[_plugin->numOutputs];
void
BasicUI::add_marker ()
{
- jack_nframes_t when = session->audible_frame();
+ nframes_t when = session->audible_frame();
session->locations()->add (new Location (when, when, _("unnamed"), Location::IsMark));
}
}
}
-jack_nframes_t
+nframes_t
BasicUI::transport_frame ()
{
return session->transport_frame();
}
void
-BasicUI::locate (jack_nframes_t where, bool roll_after_locate)
+BasicUI::locate (nframes_t where, bool roll_after_locate)
{
session->request_locate (where, roll_after_locate);
}
return session->transport_locked ();
}
-jack_nframes_t
+nframes_t
BasicUI::smpte_frames_per_hour ()
{
return session->smpte_frames_per_hour ();
}
void
-BasicUI::smpte_time (jack_nframes_t where, SMPTE::Time& smpte)
+BasicUI::smpte_time (nframes_t where, SMPTE::Time& smpte)
{
session->smpte_time (where, *((SMPTE::Time *) &smpte));
}
void
-BasicUI::smpte_to_sample (SMPTE::Time& smpte, jack_nframes_t& sample, bool use_offset, bool use_subframes) const
+BasicUI::smpte_to_sample (SMPTE::Time& smpte, nframes_t& sample, bool use_offset, bool use_subframes) const
{
session->smpte_to_sample (*((SMPTE::Time*)&smpte), sample, use_offset, use_subframes);
}
void
-BasicUI::sample_to_smpte (jack_nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes) const
+BasicUI::sample_to_smpte (nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes) const
{
session->sample_to_smpte (sample, *((SMPTE::Time*)&smpte), use_offset, use_subframes);
}
void
TranzportControlProtocol::show_transport_time ()
{
- jack_nframes_t where = session->transport_frame();
+ nframes_t where = session->transport_frame();
if (where != last_where) {
uint32_t last_mins;
uint32_t last_secs;
uint32_t last_frames;
- jack_nframes_t last_where;
+ nframes_t last_where;
ARDOUR::gain_t last_track_gain;
uint32_t last_meter_fill;
struct timeval last_wheel_motion;
env.Alias('install', env.Install(os.path.join(install_prefix, 'bin'), wine_executable))
# the win32 executable - into the lib dir since the wine script will look for it there
env.Alias('install', env.Install(os.path.join(install_prefix, 'lib/ardour2'), 'ardour_vst.exe.so'))
+
+env.Alias ('tarball', env.Distribute (env['DISTTREE'],
+ [ 'SConscript',
+ 'winmain.c',
+ 'ardourvst.in',
+ 'ardevst'
+ ]))
+
projects / ardour.git / commitdiff