return;
}
- nframes_t frames = _session->available_capture_duration();
+ framecnt_t frames = _session->available_capture_duration();
char buf[64];
nframes_t fr = _session->frame_rate();
- if (frames == max_frames) {
+ if (frames == max_framecnt) {
strcpy (buf, _("Disk: 24hrs+"));
} else {
rec_enabled_streams = 0;
}
Timecode::Time timecode;
- nframes_t sample;
+ framepos_t sample;
timecode.hours = atoi (hours_label.get_text());
timecode.minutes = atoi (minutes_label.get_text());
// Testcode for timecode<->sample conversions (P.S.)
Timecode::Time timecode1;
- nframes_t sample1;
- nframes_t oldsample = 0;
+ framepos_t sample1;
+ framepos_t oldsample = 0;
Timecode::Time timecode2;
- nframes_t sample_increment;
+ framecnt_t sample_increment;
- sample_increment = (long)rint(_session->frame_rate() / _session->timecode_frames_per_second);
+ sample_increment = (framecnt_t)rint(_session->frame_rate() / _session->timecode_frames_per_second);
#ifdef Timecode_SAMPLE_TEST_1
// Test 1: use_offset = false, use_subframes = false
, alist (al)
, _parent_group (parent)
, _time_converter (converter ? (*converter) : default_converter)
- , _maximum_time (max_frames)
+ , _maximum_time (max_framepos)
{
points_visible = false;
update_pending = false;
bool
AutomationLine::invalid_point (ALPoints& p, uint32_t index)
{
- return p[index].x == max_frames && p[index].y == DBL_MAX;
+ return p[index].x == max_framepos && p[index].y == DBL_MAX;
}
void
AutomationLine::invalidate_point (ALPoints& p, uint32_t index)
{
- p[index].x = max_frames;
+ p[index].x = max_framepos;
p[index].y = DBL_MAX;
}
pair<framepos_t, framepos_t>
AutomationLine::get_point_x_range () const
{
- pair<framepos_t, framepos_t> r (max_frames, 0);
+ pair<framepos_t, framepos_t> r (max_framepos, 0);
for (AutomationList::const_iterator i = the_list()->begin(); i != the_list()->end(); ++i) {
r.first = min (r.first, _time_converter.to ((*i)->when) + _time_converter.origin_b ());
if ((fraction < 0.0f) && (*_control_scroll_target < (nframes64_t) fabs(step))) {
*_control_scroll_target = 0;
- } else if ((fraction > 0.0f) && (max_frames - *_control_scroll_target < step)) {
- *_control_scroll_target = max_frames - (current_page_frames()*2); // allow room for slop in where the PH is on the screen
+ } else if ((fraction > 0.0f) && (max_framepos - *_control_scroll_target < step)) {
+ *_control_scroll_target = max_framepos - (current_page_frames()*2); // allow room for slop in where the PH is on the screen
} else {
*_control_scroll_target += (nframes64_t) floor (step);
}
_session->locations()->marks_either_side (start, before, after);
- if (before == max_frames) {
+ if (before == max_framepos) {
start = after;
- } else if (after == max_frames) {
+ } else if (after == max_framepos) {
start = before;
- } else if (before != max_frames && after != max_frames) {
+ } else if (before != max_framepos && after != max_framepos) {
/* have before and after */
if ((start - before) < (after - start)) {
start = before;
of frames into an 800 pixel wide space.
*/
- if (max_frames / fpu < 800.0) {
+ if (max_framepos / fpu < 800.0) {
return;
}
if ((tr = rtv->track()) && ((pl = tr->playlist()))) {
Playlist::RegionList* regions = pl->regions_touched (
- (nframes64_t) floor ( (double)where * tr->speed()), max_frames);
+ (framepos_t) floor ( (double)where * tr->speed()), max_framepos);
for (Playlist::RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
}
if (_drags->current_pointer_frame() > rightmost_frame && allow_horiz) {
- if (rightmost_frame < max_frames) {
+ if (rightmost_frame < max_framepos) {
autoscroll_x = 1;
startit = true;
}
bool
Editor::autoscroll_canvas ()
{
- nframes64_t new_frame;
- nframes64_t limit = max_frames - current_page_frames();
+ framepos_t new_frame;
+ framepos_t limit = max_framepos - current_page_frames();
GdkEventMotion ev;
double new_pixel;
double target_pixel;
case GDK_SCROLL_RIGHT:
xdelta = (current_page_frames() / 8);
- if (max_frames - xdelta > leftmost_frame) {
+ if (max_framepos - xdelta > leftmost_frame) {
reset_x_origin (leftmost_frame + xdelta);
} else {
- reset_x_origin (max_frames - current_page_frames());
+ reset_x_origin (max_framepos - current_page_frames());
}
break;
*pending_region_position = _last_frame_position;
}
- if (*pending_region_position > max_frames - _primary->region()->length()) {
+ if (*pending_region_position > max_framepos - _primary->region()->length()) {
*pending_region_position = _last_frame_position;
}
e = max (_marker->position(), e);
s = min (s, e);
e = max (s, e);
- if (e < max_frames) {
+ if (e < max_framepos) {
++e;
}
_editor->session()->locations()->find_all_between (s, e, ll, Location::Flags (0));
_editor->session()->locations()->marks_either_side (grab_frame(), start, end);
- if (end == max_frames) {
+ if (end == max_framepos) {
end = _editor->session()->current_end_frame ();
}
- if (start == max_frames) {
+ if (start == max_framepos) {
start = _editor->session()->current_start_frame ();
}
nframes64_t end;
_session->locations()->marks_either_side (marker->position(), start, end);
- if (end != max_frames) {
+ if (end != max_framepos) {
string range_name = l->name();
range_name += "-range";
if (next) {
distance = next_distance;
}
- if (max_frames - distance > loc->start() + loc->length()) {
+ if (max_framepos - distance > loc->start() + loc->length()) {
loc->set_start (loc->start() + distance);
} else {
- loc->set_start (max_frames - loc->length());
+ loc->set_start (max_framepos - loc->length());
}
} else {
distance = get_nudge_distance (loc->end(), next_distance);
if (next) {
distance = next_distance;
}
- if (max_frames - distance > loc->end()) {
+ if (max_framepos - distance > loc->end()) {
loc->set_end (loc->end() + distance);
} else {
- loc->set_end (max_frames);
+ loc->set_end (max_framepos);
}
}
XMLNode& after (loc->get_state());
while (pos < _session->current_end_frame() && !at_end) {
framepos_t rpos;
- framepos_t lpos = max_frames;
+ framepos_t lpos = max_framepos;
for (vector<RegionPoint>::iterator p = interesting_points.begin(); p != interesting_points.end(); ++p) {
Editor::find_next_region (framepos_t frame, RegionPoint point, int32_t dir, TrackViewList& tracks, TimeAxisView **ontrack)
{
TrackViewList::iterator i;
- nframes64_t closest = max_frames;
+ framepos_t closest = max_framepos;
boost::shared_ptr<Region> ret;
framepos_t rpos = 0;
framepos_t
Editor::find_next_region_boundary (framepos_t pos, int32_t dir, const TrackViewList& tracks)
{
- framecnt_t distance = max_frames;
+ framecnt_t distance = max_framepos;
framepos_t current_nearest = -1;
for (TrackViewList::const_iterator i = tracks.begin(); i != tracks.end(); ++i) {
void
Editor::scroll_playhead (bool forward)
{
- nframes64_t pos = playhead_cursor->current_frame;
- nframes64_t delta = (nframes64_t) floor (current_page_frames() / 0.8);
+ framepos_t pos = playhead_cursor->current_frame;
+ framecnt_t delta = (framecnt_t) floor (current_page_frames() / 0.8);
if (forward) {
- if (pos == max_frames) {
+ if (pos == max_framepos) {
return;
}
- if (pos < max_frames - delta) {
+ if (pos < max_framepos - delta) {
pos += delta ;
} else {
- pos = max_frames;
+ pos = max_framepos;
}
} else {
}
}
- if (max_frames - cnt < leftmost_frame) {
- frame = max_frames - cnt;
+ if (max_framepos - cnt < leftmost_frame) {
+ frame = max_framepos - cnt;
} else {
frame = leftmost_frame + cnt;
}
if (l < 0) {
leftmost_after_zoom = 0;
- } else if (l > max_frames) {
- leftmost_after_zoom = max_frames - new_page_size;
+ } else if (l > max_framepos) {
+ leftmost_after_zoom = max_framepos - new_page_size;
} else {
leftmost_after_zoom = (nframes64_t) l;
}
if (l < 0) {
leftmost_after_zoom = 0;
- } else if (l > max_frames) {
- leftmost_after_zoom = max_frames - new_page_size;
+ } else if (l > max_framepos) {
+ leftmost_after_zoom = max_framepos - new_page_size;
} else {
leftmost_after_zoom = (nframes64_t) l;
}
if (l < 0) {
leftmost_after_zoom = 0;
- } else if (l > max_frames) {
- leftmost_after_zoom = max_frames - new_page_size;
+ } else if (l > max_framepos) {
+ leftmost_after_zoom = max_framepos - new_page_size;
} else {
leftmost_after_zoom = (nframes64_t) l;
}
void
Editor::temporal_zoom_region (bool both_axes)
{
-
- nframes64_t start = max_frames;
- nframes64_t end = 0;
+ framepos_t start = max_framepos;
+ framepos_t end = 0;
RegionSelection rs;
set<TimeAxisView*> tracks;
start = 0;
}
- if (max_frames - extra_samples > end) {
+ if (max_framepos - extra_samples > end) {
end += extra_samples;
} else {
- end = max_frames;
+ end = max_framepos;
}
if (both_axes) {
void
Editor::play_selected_region ()
{
- nframes64_t start = max_frames;
- nframes64_t end = 0;
+ framepos_t start = max_framepos;
+ framepos_t end = 0;
RegionSelection rs;
get_regions_for_action (rs);
*/
the_start = max (the_start, (nframes64_t) region->position());
- if (max_frames - the_start < region->length()) {
+ if (max_framepos - the_start < region->length()) {
the_end = the_start + region->length() - 1;
} else {
- the_end = max_frames;
+ the_end = max_framepos;
}
the_end = min (end, the_end);
cnt = the_end - the_start + 1;
vector<PlaylistMapping> pmap;
- nframes64_t first_position = max_frames;
+ framepos_t first_position = max_framepos;
typedef set<boost::shared_ptr<Playlist> > FreezeList;
FreezeList freezelist;
}
}
- if (position == max_frames) {
+ if (position == max_framepos) {
position = get_preferred_edit_position();
}
void
Editor::set_loop_from_region (bool play)
{
- nframes64_t start = max_frames;
- nframes64_t end = 0;
+ framepos_t start = max_framepos;
+ framepos_t end = 0;
RegionSelection rs;
void
Editor::set_punch_from_region ()
{
- nframes64_t start = max_frames;
- nframes64_t end = 0;
+ framepos_t start = max_framepos;
+ framepos_t end = 0;
RegionSelection rs;
Editor::playhead_forward_to_grid ()
{
if (!_session) return;
- nframes64_t pos = playhead_cursor->current_frame;
- if (pos < max_frames - 1) {
+ framepos_t pos = playhead_cursor->current_frame;
+ if (pos < max_framepos - 1) {
pos += 2;
snap_to_internal (pos, 1, false);
_session->request_locate (pos);
case GDK_SCROLL_RIGHT:
xdelta = (current_page_frames() / 2);
- if (max_frames - xdelta > leftmost_frame) {
+ if (max_framepos - xdelta > leftmost_frame) {
reset_x_origin (leftmost_frame + xdelta);
} else {
- reset_x_origin (max_frames - current_page_frames());
+ reset_x_origin (max_framepos - current_page_frames());
}
handled = true;
break;
gint
Editor::metric_get_timecode (GtkCustomRulerMark **marks, gdouble lower, gdouble /*upper*/, gint /*maxchars*/)
{
- nframes_t pos;
- nframes64_t spacer;
+ framepos_t pos;
+ framecnt_t spacer;
Timecode::Time timecode;
gchar buf[16];
gint n;
return 0;
}
- if (lower > (spacer = (nframes64_t)(128 * Editor::get_current_zoom ()))) {
+ if (lower > (spacer = (framecnt_t)(128 * Editor::get_current_zoom ()))) {
lower = lower - spacer;
} else {
lower = 0;
} else if (op == Selection::Extend) {
list<Selectable*> results;
- nframes64_t last_frame;
- nframes64_t first_frame;
+ framepos_t last_frame;
+ framepos_t first_frame;
bool same_track = false;
/* 1. find the last selected regionview in the track that was clicked in */
last_frame = 0;
- first_frame = max_frames;
+ first_frame = max_framepos;
for (RegionSelection::iterator x = selection->regions.begin(); x != selection->regions.end(); ++x) {
if (&(*x)->get_time_axis_view() == &clicked_regionview->get_time_axis_view()) {
return;
}
- clicked_routeview->get_selectables (0, max_frames, 0, DBL_MAX, touched);
+ clicked_routeview->get_selectables (0, max_framepos, 0, DBL_MAX, touched);
switch (op) {
case Selection::Toggle:
if ((*iter)->hidden()) {
continue;
}
- (*iter)->get_selectables (0, max_frames, 0, DBL_MAX, touched);
+ (*iter)->get_selectables (0, max_framepos, 0, DBL_MAX, touched);
}
begin_reversible_command (_("select all"));
switch (op) {
struct MarkerSelection : public std::list<Marker*>
{
- void range (nframes64_t& start, nframes64_t& end);
+ void range (ARDOUR::framepos_t& start, ARDOUR::framepos_t& end);
};
#endif /* __ardour_gtk_marker_selection_h__ */
canvas_rect = new ArdourCanvas::SimpleRect (*canvas_group);
canvas_rect->property_x1() = 0.0;
canvas_rect->property_y1() = 0.0;
- canvas_rect->property_x2() = max_frames;
+ canvas_rect->property_x2() = max_framepos;
canvas_rect->property_y2() = (double)20;
canvas_rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_MarkerTrack.get();
canvas_rect->property_fill_color_rgba() = stream_base_color;
/* use grid */
- nframes64_t next_pos = ref_point;
+ framepos_t next_pos = ref_point;
if (forward) {
- /* XXX need check on max_frames, but that needs max_frames64 or something */
- next_pos += 1;
+ if (max_framepos - 1 < next_pos) {
+ next_pos += 1;
+ }
} else {
if (next_pos == 0) {
return;
_note_lines->property_x1() = 0;
_note_lines->property_y1() = 0;
- _note_lines->property_x2() = trackview().editor().frame_to_pixel (max_frames);
+ _note_lines->property_x2() = trackview().editor().frame_to_pixel (max_framepos);
_note_lines->property_y2() = 0;
_note_lines->signal_event().connect(sigc::bind(
/* reset current start */
- nframes_t ref = max_frames;
+ framepos_t ref = max_framepos;
for (RegionSelection::iterator i = begin (); i != end(); ++i) {
if (region->first_frame() < ref) {
*/
#include <algorithm>
-#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#include <glibmm/thread.h>
}
void
-MarkerSelection::range (nframes64_t& s, nframes64_t& e)
+MarkerSelection::range (framepos_t& s, framepos_t& e)
{
- s = max_frames;
+ s = max_framepos;
e = 0;
for (MarkerSelection::iterator i = begin(); i != end(); ++i) {
}
max_silence = 0;
- min_silence = max_frames;
+ min_silence = max_framepos;
max_audible = 0;
- min_audible = max_frames;
+ min_audible = max_framepos;
SilenceResult::const_iterator cur;
name_connected = false;
fill_opacity = 60;
position_locked = false;
- max_item_duration = ARDOUR::max_frames;
+ max_item_duration = ARDOUR::max_framepos;
min_item_duration = 0;
show_vestigial = true;
visibility = vis;
return changed;
}
-nframes_t
+framepos_t
TimeSelection::start ()
{
if (empty()) {
return 0;
}
- nframes_t first = max_frames;
+ framepos_t first = max_framepos;
for (std::list<AudioRange>::iterator i = begin(); i != end(); ++i) {
if ((*i).start < first) {
return first;
}
-nframes_t
+framepos_t
TimeSelection::end_frame ()
{
- nframes_t last = 0;
+ framepos_t last = 0;
/* XXX make this work like RegionSelection: no linear search needed */
return last;
}
-nframes_t
+framecnt_t
TimeSelection::length()
{
return end_frame() - start() + 1;
public:
ARDOUR::AudioRange& operator[](uint32_t);
- nframes_t start();
- nframes_t end_frame();
- nframes_t length();
+ ARDOUR::framepos_t start();
+ ARDOUR::framepos_t end_frame();
+ ARDOUR::framepos_t length();
bool consolidate ();
};
class AudioEngine;
- static const nframes_t max_frames = JACK_MAX_FRAMES;
extern PBD::Signal1<void,std::string> BootMessage;
int init (bool with_vst, bool try_optimization);
void set_pending_overwrite(bool);
int overwrite_existing_buffers ();
void set_block_size (nframes_t);
- int internal_playback_seek (nframes_t distance);
- int can_internal_playback_seek (nframes_t distance);
+ int internal_playback_seek (framecnt_t distance);
+ int can_internal_playback_seek (framecnt_t distance);
int rename_write_sources ();
std::list<boost::shared_ptr<Source> > steal_write_sources();
void reset_write_sources (bool, bool force = false);
void non_realtime_input_change ();
- void non_realtime_locate (nframes_t location);
+ void non_realtime_locate (framepos_t location);
protected:
friend class Auditioner;
- int seek (nframes_t which_sample, bool complete_refill = false);
+ int seek (framepos_t which_sample, bool complete_refill = false);
protected:
friend class AudioTrack;
- int process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler);
+ int process (framepos_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler);
bool commit (nframes_t nframes);
private:
int do_refill_with_alloc ();
int read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
- nframes_t& start, nframes_t cnt,
- ChannelInfo* channel_info, int channel, bool reversed);
+ framepos_t& start, nframes_t cnt,
+ ChannelInfo* channel_info, int channel, bool reversed);
void finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList>);
void transport_stopped_wallclock (struct tm&, time_t, bool abort);
- void transport_looped (nframes_t transport_frame);
+ void transport_looped (framepos_t transport_frame);
void init ();
int use_pending_capture_data (XMLNode& node);
void get_input_sources ();
- void prepare_record_status(nframes_t capture_start_frame);
+ void prepare_record_status(framepos_t capture_start_frame);
void set_align_style_from_io();
void setup_destructive_playlist ();
void use_destructive_playlist ();
virtual void clear_capture_marks() {}
virtual bool one_of_several_channels () const { return false; }
- virtual int update_header (sframes_t when, struct tm&, time_t) = 0;
+ virtual int update_header (framepos_t when, struct tm&, time_t) = 0;
virtual int flush_header () = 0;
void mark_streaming_write_completed ();
void set_path (const std::string& p);
float sample_rate() const;
- int update_header (sframes_t when, struct tm&, time_t);
+ int update_header (framepos_t when, struct tm&, time_t);
int flush_header () {return 0;};
void set_header_timeline_position () {};
virtual void punch_out() {}
void non_realtime_set_speed ();
- virtual void non_realtime_locate (nframes_t /*location*/) {};
+ virtual void non_realtime_locate (framepos_t /*location*/) {};
virtual void playlist_modified ();
boost::shared_ptr<Playlist> playlist () { return _playlist; }
virtual int use_new_playlist () = 0;
virtual int use_copy_playlist () = 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);
+ framepos_t current_capture_start() const { return capture_start_frame; }
+ framepos_t current_capture_end() const { return capture_start_frame + capture_captured; }
+ framepos_t get_capture_start_frame (uint32_t n=0);
+ framecnt_t get_captured_frames (uint32_t n=0);
ChanCount n_channels() { return _n_channels; }
virtual void set_pending_overwrite (bool) = 0;
virtual int overwrite_existing_buffers () = 0;
- virtual int internal_playback_seek (nframes_t distance) = 0;
- virtual int can_internal_playback_seek (nframes_t distance) = 0;
+ virtual int internal_playback_seek (framecnt_t distance) = 0;
+ virtual int can_internal_playback_seek (framecnt_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 (nframes_t which_sample, bool complete_refill = false) = 0;
+ virtual int seek (framepos_t which_sample, bool complete_refill = false) = 0;
protected:
friend class Track;
- virtual int process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler) = 0;
+ virtual int process (framepos_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler) = 0;
virtual bool commit (nframes_t nframes) = 0;
//private:
struct CaptureTransition {
TransitionType type;
- nframes_t capture_val; ///< The start or end file frame position
+ framepos_t capture_val; ///< The start or end file frame position
};
/* The two central butler operations */
virtual void playlist_ranges_moved (std::list< Evoral::RangeMove<framepos_t> > const &, bool);
virtual void transport_stopped_wallclock (struct tm&, time_t, bool abort) = 0;
- virtual void transport_looped (nframes_t transport_frame) = 0;
+ virtual void transport_looped (framepos_t transport_frame) = 0;
struct CaptureInfo {
- uint32_t start;
- uint32_t frames;
+ framepos_t start;
+ framecnt_t frames;
};
virtual int use_new_write_source (uint32_t n=0) = 0;
virtual int use_pending_capture_data (XMLNode& node) = 0;
- virtual void check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record);
- virtual void prepare_record_status (nframes_t /*capture_start_frame*/) {}
+ virtual void check_record_status (framepos_t transport_frame, nframes_t nframes, bool can_record);
+ virtual void prepare_record_status (framepos_t /*capture_start_frame*/) {}
virtual void set_align_style_from_io() {}
virtual void setup_destructive_playlist () {}
virtual void use_destructive_playlist () {}
virtual void prepare_to_stop (framepos_t pos);
- void calculate_record_range(OverlapType ot, sframes_t transport_frame, nframes_t nframes,
+ void calculate_record_range(OverlapType ot, framepos_t transport_frame, framecnt_t nframes,
nframes_t& rec_nframes, nframes_t& rec_offset);
static nframes_t disk_io_chunk_frames;
bool _seek_required;
bool force_refill;
- nframes_t capture_start_frame;
- nframes_t capture_captured;
+ framepos_t capture_start_frame;
+ framecnt_t capture_captured;
bool was_recording;
nframes_t adjust_capture_position;
nframes_t _capture_offset;
nframes_t _roll_delay;
- nframes_t first_recordable_frame;
- nframes_t last_recordable_frame;
+ framepos_t first_recordable_frame;
+ framepos_t last_recordable_frame;
int last_possibly_recording;
AlignStyle _alignment_style;
bool _scrubbing;
bool _slaved;
Location* loop_location;
- nframes_t overwrite_frame;
+ framepos_t overwrite_frame;
off_t overwrite_offset;
bool _pending_overwrite;
bool overwrite_queued;
double _speed;
double _target_speed;
- nframes_t file_frame;
- nframes_t playback_sample;
- nframes_t playback_distance;
+ framepos_t file_frame;
+ framepos_t playback_sample;
+ framecnt_t playback_distance;
uint32_t _read_data_count;
uint32_t _write_data_count;
Glib::Mutex state_lock;
- nframes_t scrub_start;
- nframes_t scrub_buffer_size;
- nframes_t scrub_offset;
+ framepos_t scrub_start;
+ nframes_t scrub_buffer_size;
+ nframes_t scrub_offset;
PBD::ScopedConnectionList playlist_connections;
float playback_buffer_load() const;
float capture_buffer_load() const;
- void get_playback(MidiBuffer& dst, nframes_t start, nframes_t end);
+ void get_playback(MidiBuffer& dst, framepos_t start, framepos_t end);
void set_record_enabled (bool yn);
void set_pending_overwrite(bool);
int overwrite_existing_buffers ();
void set_block_size (nframes_t);
- int internal_playback_seek (nframes_t distance);
- int can_internal_playback_seek (nframes_t distance);
+ int internal_playback_seek (framecnt_t distance);
+ int can_internal_playback_seek (framecnt_t distance);
int rename_write_sources ();
std::list<boost::shared_ptr<Source> > steal_write_sources();
void reset_write_sources (bool, bool force = false);
void non_realtime_input_change ();
- void non_realtime_locate (nframes_t location);
+ void non_realtime_locate (framepos_t location);
static void set_readahead_frames(nframes_t frames_ahead) { midi_readahead = frames_ahead; }
protected:
- int seek (nframes_t which_sample, bool complete_refill = false);
+ int seek (framepos_t which_sample, bool complete_refill = false);
protected:
friend class MidiTrack;
- int process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler);
+ int process (framepos_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler);
bool commit (nframes_t nframes);
static nframes_t midi_readahead;
int do_refill_with_alloc();
- int read (nframes_t& start, nframes_t cnt, bool reversed);
+ int read (framepos_t& start, nframes_t cnt, bool reversed);
void finish_capture (bool rec_monitors_input);
void transport_stopped_wallclock (struct tm&, time_t, bool abort);
- void transport_looped (nframes_t transport_frame);
+ void transport_looped (framepos_t transport_frame);
void init ();
class XMLNode;
+namespace ARDOUR {
+ namespace Properties {
+ /* this is pseudo-property: nothing has this as an actual
+ property, but it allows us to signal changes to the
+ MidiModel used by the MidiRegion
+ */
+ extern PBD::PropertyDescriptor<void*> midi_data;
+ }
+}
+
namespace ARDOUR {
class Route;
class MidiRegion : public Region
{
public:
+ static void make_property_quarks ();
+
~MidiRegion();
boost::shared_ptr<MidiRegion> clone ();
NoteMode mode = Sustained,
MidiStateTracker* tracker = 0) const;
+ void register_properties ();
+
void recompute_at_start ();
void recompute_at_end ();
void switch_source(boost::shared_ptr<Source> source);
void model_changed ();
void model_automation_state_changed (Evoral::Parameter const &);
+ void model_contents_changed ();
std::set<Evoral::Parameter> _filtered_parameters; ///< parameters that we ask our source not to return when reading
PBD::ScopedConnection _model_connection;
PBD::ScopedConnection _source_connection;
+ PBD::ScopedConnection _model_contents_connection;
};
} /* namespace ARDOUR */
virtual uint32_t read_data_count() const = 0;
virtual uint32_t write_data_count() const = 0;
virtual void set_pending_overwrite (bool) = 0;
- virtual int seek (nframes_t, bool complete_refill = false) = 0;
+ virtual int seek (framepos_t, bool complete_refill = false) = 0;
virtual bool hidden () const = 0;
- virtual int can_internal_playback_seek (nframes_t) = 0;
- virtual int internal_playback_seek (nframes_t) = 0;
+ virtual int can_internal_playback_seek (framepos_t) = 0;
+ virtual int internal_playback_seek (framepos_t) = 0;
virtual void non_realtime_input_change () = 0;
- virtual void non_realtime_locate (nframes_t) = 0;
+ virtual void non_realtime_locate (framepos_t) = 0;
virtual void non_realtime_set_speed () = 0;
virtual int overwrite_existing_buffers () = 0;
- virtual nframes_t get_captured_frames (uint32_t n = 0) = 0;
+ virtual framecnt_t get_captured_frames (uint32_t n = 0) = 0;
virtual int set_loop (Location *) = 0;
- virtual void transport_looped (nframes_t) = 0;
+ virtual void transport_looped (framepos_t) = 0;
virtual bool realtime_set_speed (double, bool) = 0;
virtual void transport_stopped_wallclock (struct tm &, time_t, bool) = 0;
virtual bool pending_overwrite () const = 0;
virtual void prepare_to_stop (framepos_t) = 0;
virtual void set_slaved (bool) = 0;
virtual ChanCount n_channels () = 0;
- virtual nframes_t get_capture_start_frame (uint32_t n = 0) = 0;
+ virtual framepos_t get_capture_start_frame (uint32_t n = 0) = 0;
virtual AlignStyle alignment_style () const = 0;
- virtual nframes_t current_capture_start () const = 0;
- virtual nframes_t current_capture_end () const = 0;
+ virtual framepos_t current_capture_start () const = 0;
+ virtual framepos_t current_capture_end () const = 0;
virtual void playlist_modified () = 0;
virtual int use_playlist (boost::shared_ptr<Playlist>) = 0;
virtual void set_align_style (AlignStyle) = 0;
int wipe ();
- std::pair<nframes_t, nframes_t> get_extent () const;
- nframes_t current_end_frame () const;
- nframes_t current_start_frame () const;
+ std::pair<framepos_t, framepos_t> get_extent () const;
+ framepos_t current_end_frame () const;
+ framepos_t current_start_frame () const;
/// "actual" sample rate of session, set by current audioengine rate, pullup/down etc.
nframes_t frame_rate() const { return _current_frame_rate; }
/// "native" sample rate of session, regardless of current audioengine rate, pullup/down etc
void sync_time_vars();
void bbt_time (nframes_t when, BBT_Time&);
- void timecode_to_sample(Timecode::Time& timecode, nframes_t& sample, bool use_offset, bool use_subframes) const;
- void sample_to_timecode(nframes_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const;
+ void timecode_to_sample(Timecode::Time& timecode, framepos_t& sample, bool use_offset, bool use_subframes) const;
+ void sample_to_timecode(framepos_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const;
void timecode_time (Timecode::Time &);
void timecode_time (nframes_t when, Timecode::Time&);
void timecode_time_subframes (nframes_t when, Timecode::Time&);
void timecode_duration (nframes_t, Timecode::Time&) const;
- void timecode_duration_string (char *, nframes_t) const;
+ void timecode_duration_string (char *, framecnt_t) const;
void set_timecode_offset (nframes_t);
nframes_t timecode_offset () const { return _timecode_offset; }
/* s/w "RAID" management */
- nframes_t available_capture_duration();
+ framecnt_t available_capture_duration();
/* I/O bundles */
void enable_record ();
- void increment_transport_position (uint32_t val) {
- if (max_frames - val < _transport_frame) {
- _transport_frame = max_frames;
+ void increment_transport_position (framecnt_t val) {
+ if (max_framepos - val < _transport_frame) {
+ _transport_frame = max_framepos;
} else {
_transport_frame += val;
}
}
- void decrement_transport_position (uint32_t val) {
+ void decrement_transport_position (framecnt_t val) {
if (val < _transport_frame) {
_transport_frame -= val;
} else {
class SilentFileSource : public AudioFileSource {
public:
- int update_header (sframes_t /*when*/, struct tm&, time_t) { return 0; }
+ int update_header (framepos_t /*when*/, struct tm&, time_t) { return 0; }
int flush_header () { return 0; }
float sample_rate () const { return _sample_rate; }
static const int frame_tolerance;
SafeTime current;
- nframes_t mtc_frame; /* current time */
- nframes_t last_inbound_frame; /* when we got it; audio clocked */
+ framepos_t mtc_frame; /* current time */
+ framepos_t last_inbound_frame; /* when we got it; audio clocked */
MIDI::byte last_mtc_fps_byte;
- nframes64_t window_begin;
- nframes64_t window_end;
- nframes64_t last_mtc_timestamp;
- nframes64_t last_mtc_frame;
+ framepos_t window_begin;
+ framepos_t window_end;
+ framepos_t last_mtc_timestamp;
+ framepos_t last_mtc_frame;
bool did_reset_tc_format;
TimecodeFormat saved_tc_format;
size_t speed_accumulator_size;
~SndFileSource ();
float sample_rate () const;
- int update_header (sframes_t when, struct tm&, time_t);
+ int update_header (framepos_t when, struct tm&, time_t);
int flush_header ();
nframes64_t natural_position () const;
static boost::shared_ptr<Source> create (Session&, const XMLNode& node, bool async = false);
static boost::shared_ptr<Source> createSilent (Session&, const XMLNode& node,
- nframes_t nframes, float sample_rate);
+ framecnt_t nframes, float sample_rate);
static boost::shared_ptr<Source> createReadable (DataType type, Session&,
const std::string& path,
uint32_t read_data_count() const;
uint32_t write_data_count() const;
void set_pending_overwrite (bool);
- int seek (nframes_t, bool complete_refill = false);
+ int seek (framepos_t, bool complete_refill = false);
bool hidden () const;
- int can_internal_playback_seek (nframes_t);
- int internal_playback_seek (nframes_t);
+ int can_internal_playback_seek (framepos_t);
+ int internal_playback_seek (framepos_t);
void non_realtime_input_change ();
- void non_realtime_locate (nframes_t);
+ void non_realtime_locate (framepos_t);
void non_realtime_set_speed ();
int overwrite_existing_buffers ();
- nframes_t get_captured_frames (uint32_t n = 0);
+ framecnt_t get_captured_frames (uint32_t n = 0);
int set_loop (Location *);
- void transport_looped (nframes_t);
+ void transport_looped (framepos_t);
bool realtime_set_speed (double, bool);
void transport_stopped_wallclock (struct tm &, time_t, bool);
bool pending_overwrite () const;
void prepare_to_stop (framepos_t);
void set_slaved (bool);
ChanCount n_channels ();
- nframes_t get_capture_start_frame (uint32_t n = 0);
+ framepos_t get_capture_start_frame (uint32_t n = 0);
AlignStyle alignment_style () const;
- nframes_t current_capture_start () const;
- nframes_t current_capture_end () const;
+ framepos_t current_capture_start () const;
+ framepos_t current_capture_end () const;
void playlist_modified ();
int use_playlist (boost::shared_ptr<Playlist>);
void set_align_style (AlignStyle);
#ifndef __ardour_types_h__
#define __ardour_types_h__
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS /* PRI<foo>; C++ requires explicit requesting of these */
-#endif
-
#include <istream>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <sys/types.h>
+#include <stdint.h>
#include <inttypes.h>
#include <jack/types.h>
typedef uint32_t nframes_t;
typedef int64_t nframes64_t;
-
- /** "Session frames", frames relative to the session timeline.
- * Everything related to transport position etc. should be of this type.
- * We might want to make this a compile time option for 32-bitters who
- * don't want to pay for extremely long session times they don't need...
- */
typedef int64_t sframes_t;
typedef int64_t framepos_t;
/* any offset from a framepos_t, measured in audio frames */
/* any count of audio frames */
typedef int64_t framecnt_t;
+ static const framepos_t max_framepos = INT64_MAX;
+ static const framecnt_t max_framecnt = INT64_MAX;
+
struct IOChange {
enum Type {
/* now refill channel buffers */
if (speed() != 1.0f || speed() != -1.0f) {
- seek ((nframes_t) (_session.transport_frame() * (double) speed()));
+ seek ((framepos_t) (_session.transport_frame() * (double) speed()));
} else {
seek (_session.transport_frame());
}
}
void
-AudioDiskstream::non_realtime_locate (nframes_t location)
+AudioDiskstream::non_realtime_locate (framepos_t location)
{
/* now refill channel buffers */
if (speed() != 1.0f || speed() != -1.0f) {
- seek ((nframes_t) (location * (double) speed()));
+ seek ((framepos_t) (location * (double) speed()));
} else {
seek (location);
}
PropertyList plist;
plist.add (Properties::name, _name.val());
plist.add (Properties::start, 0);
- plist.add (Properties::length, max_frames - max_frames - srcs.front()->natural_position());
+ plist.add (Properties::length, max_framepos - (max_framepos - srcs.front()->natural_position()));
boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist));
_playlist->add_region (region, srcs.front()->natural_position());
/* be sure to stretch the region out to the maximum length */
- region->set_length (max_frames - region->position(), this);
+ region->set_length (max_framepos - region->position(), this);
uint32_t n;
ChannelList::iterator chan;
}
void
-AudioDiskstream::prepare_record_status(nframes_t capture_start_frame)
+AudioDiskstream::prepare_record_status(framepos_t capture_start_frame)
{
if (recordable() && destructive()) {
boost::shared_ptr<ChannelList> c = channels.reader();
}
int
-AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
+AudioDiskstream::process (framepos_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
{
uint32_t n;
boost::shared_ptr<ChannelList> c = channels.reader();
// and last_recordable_frame < first_recordable_frame
if (last_recordable_frame < first_recordable_frame) {
- last_recordable_frame = max_frames;
+ last_recordable_frame = max_framepos;
}
OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
size--;
uint32_t n=0;
- nframes_t start;
+ framepos_t start;
for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
}
int
-AudioDiskstream::seek (nframes_t frame, bool complete_refill)
+AudioDiskstream::seek (framepos_t frame, bool complete_refill)
{
uint32_t n;
int ret = -1;
}
int
-AudioDiskstream::can_internal_playback_seek (nframes_t distance)
+AudioDiskstream::can_internal_playback_seek (framecnt_t distance)
{
ChannelList::iterator chan;
boost::shared_ptr<ChannelList> c = channels.reader();
for (chan = c->begin(); chan != c->end(); ++chan) {
- if ((*chan)->playback_buf->read_space() < distance) {
+ if ((*chan)->playback_buf->read_space() < (size_t) distance) {
return false;
}
}
}
int
-AudioDiskstream::internal_playback_seek (nframes_t distance)
+AudioDiskstream::internal_playback_seek (framecnt_t distance)
{
ChannelList::iterator chan;
boost::shared_ptr<ChannelList> c = channels.reader();
}
int
-AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
+AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
+ framepos_t& start, nframes_t cnt,
ChannelInfo* /*channel_info*/, int channel, bool reversed)
{
nframes_t this_read = 0;
bool reloop = false;
- nframes_t loop_end = 0;
- nframes_t loop_start = 0;
+ framepos_t loop_end = 0;
+ framepos_t loop_start = 0;
nframes_t offset = 0;
Location *loc = 0;
if (!reversed) {
- nframes_t loop_length = 0;
+ framecnt_t loop_length = 0;
/* Make the use of a Location atomic for this read operation.
} else {
- if (file_frame == max_frames) {
+ if (file_frame == max_framepos) {
/* at end: nothing to do but fill with silence */
return 0;
}
- if (file_frame > max_frames - total_space) {
+ if (file_frame > max_framepos - total_space) {
/* to close to the end: read what we can, and zero fill the rest */
- zero_fill = total_space - (max_frames - file_frame);
- total_space = max_frames - file_frame;
+ zero_fill = total_space - (max_framepos - file_frame);
+ total_space = max_framepos - file_frame;
} else {
zero_fill = 0;
}
}
- nframes_t file_frame_tmp = 0;
+ framepos_t file_frame_tmp = 0;
for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
}
void
-AudioDiskstream::transport_looped (nframes_t transport_frame)
+AudioDiskstream::transport_looped (framepos_t transport_frame)
{
if (was_recording) {
// all we need to do is finish this capture, with modified capture length
// no latency adjustment or capture offset needs to be made, as that already happened the first time
capture_start_frame = transport_frame;
first_recordable_frame = transport_frame; // mild lie
- last_recordable_frame = max_frames;
+ last_recordable_frame = max_framepos;
was_recording = true;
if (recordable() && destructive()) {
AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
{
was_recording = false;
- first_recordable_frame = max_frames;
- last_recordable_frame = max_frames;
+ first_recordable_frame = max_framepos;
+ last_recordable_frame = max_framepos;
if (capture_captured == 0) {
return;
capture_captured = 0;
/* now we've finished a capture, reset first_recordable_frame for next time */
- first_recordable_frame = max_frames;
+ first_recordable_frame = max_framepos;
}
void
boost::shared_ptr<AudioFileSource> fs;
boost::shared_ptr<AudioFileSource> first_fs;
SourceList pending_sources;
- nframes_t position;
+ framepos_t position;
if ((prop = node.property (X_("at"))) == 0) {
return -1;
}
- if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
+ if (sscanf (prop->value().c_str(), "%" PRIu64, &position) != 1) {
return -1;
}
_running = false;
_has_run = false;
last_monitor_check = 0;
- monitor_check_interval = max_frames;
+ monitor_check_interval = INT32_MAX;
_processed_frames = 0;
_usecs_per_cycle = 0;
_jack = 0;
/* handle wrap around of total frames counter */
- if (max_frames - _processed_frames < nframes) {
- next_processed_frames = nframes - (max_frames - _processed_frames);
+ if (max_framepos - _processed_frames < nframes) {
+ next_processed_frames = nframes - (max_framepos - _processed_frames);
} else {
next_processed_frames = _processed_frames + nframes;
}
}
int
-CoreAudioSource::update_header (sframes_t when, struct tm&, time_t)
+CoreAudioSource::update_header (framepos_t when, struct tm&, time_t)
{
return 0;
}
, adjust_capture_position (0)
, _capture_offset (0)
, _roll_delay (0)
- , first_recordable_frame (max_frames)
- , last_recordable_frame (max_frames)
+ , first_recordable_frame (max_framepos)
+ , last_recordable_frame (max_framepos)
, last_possibly_recording (0)
, _alignment_style (ExistingMaterial)
, _scrubbing (false)
, adjust_capture_position (0)
, _capture_offset (0)
, _roll_delay (0)
- , first_recordable_frame (max_frames)
- , last_recordable_frame (max_frames)
+ , first_recordable_frame (max_framepos)
+ , last_recordable_frame (max_framepos)
, last_possibly_recording (0)
, _alignment_style (ExistingMaterial)
, _scrubbing (false)
if (_seek_required) {
if (speed() != 1.0f || speed() != -1.0f) {
- seek ((nframes_t) (_session.transport_frame() * (double) speed()), true);
+ seek ((framepos_t) (_session.transport_frame() * (double) speed()), true);
}
else {
seek (_session.transport_frame(), true);
if (new_speed != _actual_speed) {
nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() *
- fabs (new_speed)) + 1;
+ fabs (new_speed)) + 1;
if (required_wrap_size > wrap_buffer_size) {
_buffer_reallocation_required = true;
return 0;
}
-ARDOUR::nframes_t
+ARDOUR::framepos_t
Diskstream::get_capture_start_frame (uint32_t n)
{
Glib::Mutex::Lock lm (capture_info_lock);
}
}
-ARDOUR::nframes_t
+ARDOUR::framecnt_t
Diskstream::get_captured_frames (uint32_t n)
{
Glib::Mutex::Lock lm (capture_info_lock);
}
void
-Diskstream::check_record_status (nframes_t transport_frame, nframes_t /*nframes*/, bool can_record)
+Diskstream::check_record_status (framepos_t transport_frame, nframes_t /*nframes*/, bool can_record)
{
int possibly_recording;
int rolling;
/* we transitioned to recording. lets see if its transport based or a punch */
first_recordable_frame = transport_frame + _capture_offset;
- last_recordable_frame = max_frames;
+ last_recordable_frame = max_framepos;
capture_start_frame = transport_frame;
if (change & transport_rolling) {
}
void
-Diskstream::calculate_record_range(OverlapType ot, sframes_t transport_frame, nframes_t nframes,
+Diskstream::calculate_record_range(OverlapType ot, framepos_t transport_frame, framecnt_t nframes,
nframes_t& rec_nframes, nframes_t& rec_offset)
{
switch (ot) {
* side of a frame. Note that if frame is exactly on a `mark', that mark will not be considered for returning
* as before/after.
* @param frame Frame to look for.
- * @param before Filled in with the position of the last `mark' before `frame' (or max_frames if none exists)
- * @param after Filled in with the position of the next `mark' after `frame' (or max_frames if none exists)
+ * @param before Filled in with the position of the last `mark' before `frame' (or max_framepos if none exists)
+ * @param after Filled in with the position of the next `mark' after `frame' (or max_framepos if none exists)
*/
void
Locations::marks_either_side (nframes64_t const frame, nframes64_t& before, nframes64_t& after) const
{
- before = after = max_frames;
+ before = after = max_framepos;
LocationList locs;
void
-MidiDiskstream::non_realtime_locate (nframes_t position)
+MidiDiskstream::non_realtime_locate (framepos_t position)
{
if (_write_source) {
_write_source->set_timeline_position (position);
/* now refill channel buffers */
if (speed() != 1.0f || speed() != -1.0f) {
- seek ((nframes_t) (_session.transport_frame() * (double) speed()));
+ seek ((framepos_t) (_session.transport_frame() * (double) speed()));
}
else {
seek (_session.transport_frame());
#endif
int
-MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
+MidiDiskstream::process (framepos_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
{
int ret = -1;
nframes_t rec_offset = 0;
int
MidiDiskstream::overwrite_existing_buffers ()
{
- //read(overwrite_frame, disk_io_chunk_frames, false);
+ read (overwrite_frame, disk_io_chunk_frames, false);
overwrite_queued = false;
_pending_overwrite = false;
}
int
-MidiDiskstream::seek (nframes_t frame, bool complete_refill)
+MidiDiskstream::seek (framepos_t frame, bool complete_refill)
{
Glib::Mutex::Lock lm (state_lock);
int ret = -1;
}
int
-MidiDiskstream::can_internal_playback_seek (nframes_t distance)
+MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
{
uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
}
int
-MidiDiskstream::internal_playback_seek (nframes_t distance)
+MidiDiskstream::internal_playback_seek (framecnt_t distance)
{
first_recordable_frame += distance;
playback_sample += distance;
/** @a start is set to the new frame position (TIME) read up to */
int
-MidiDiskstream::read (nframes_t& start, nframes_t dur, bool reversed)
+MidiDiskstream::read (framepos_t& start, nframes_t dur, bool reversed)
{
nframes_t this_read = 0;
bool reloop = false;
- nframes_t loop_end = 0;
- nframes_t loop_start = 0;
+ framepos_t loop_end = 0;
+ framepos_t loop_start = 0;
Location *loc = 0;
if (!reversed) {
- nframes_t loop_length = 0;
+ framecnt_t loop_length = 0;
/* Make the use of a Location atomic for this read operation.
if (reloop) {
// Synthesize LoopEvent here, because the next events
// written will have non-monotonic timestamps.
- _playback_buf->write(loop_end - 1, LoopEventType, sizeof (nframes_t), (uint8_t *) &loop_start);
+ _playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start);
cout << "Pushing LoopEvent ts=" << loop_end-1
<< " start+this_read " << start+this_read << endl;
}
/* at end: nothing to do */
- if (file_frame == max_frames) {
+ if (file_frame == max_framepos) {
return 0;
}
// At this point we...
assert(_playback_buf->write_space() > 0); // ... have something to write to, and
- assert(file_frame <= max_frames); // ... something to write
+ assert(file_frame <= max_framepos); // ... something to write
// now calculate how much time is in the ringbuffer.
// and lets write as much as we need to get this to be midi_readahead;
//cout << "MDS read for midi_readahead " << to_read << " rb_contains: "
// << frames_written - frames_read << endl;
- to_read = min(to_read, (max_frames - file_frame));
+ to_read = (nframes_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
if (read (file_frame, to_read, reversed)) {
ret = -1;
}
void
-MidiDiskstream::transport_looped (nframes_t transport_frame)
+MidiDiskstream::transport_looped (framepos_t transport_frame)
{
if (was_recording) {
// no latency adjustment or capture offset needs to be made, as that already happened the first time
capture_start_frame = transport_frame;
first_recordable_frame = transport_frame; // mild lie
- last_recordable_frame = max_frames;
+ last_recordable_frame = max_framepos;
was_recording = true;
}
}
* so that an event at \a start has time = 0
*/
void
-MidiDiskstream::get_playback (MidiBuffer& dst, nframes_t start, nframes_t end)
+MidiDiskstream::get_playback (MidiBuffer& dst, framepos_t start, framepos_t end)
{
dst.clear();
assert(dst.size() == 0);
{
XMLNode* xml_note = new XMLNode("note");
- cerr << "Marshalling note: " << *note << endl;
-
{
ostringstream id_str(ios::ate);
id_str << int(note->id());
return false;
}
- // Feeling rather uninterested today, but thanks for the heads up anyway!
-
PBD::PropertyChange our_interests;
+ our_interests.add (Properties::midi_data);
- bool parent_wants_notify;
-
- parent_wants_notify = Playlist::region_changed (what_changed, region);
+ bool parent_wants_notify = Playlist::region_changed (what_changed, region);
if (parent_wants_notify || what_changed.contains (our_interests)) {
notify_contents_changed ();
using namespace ARDOUR;
using namespace PBD;
+namespace ARDOUR {
+ namespace Properties {
+ PBD::PropertyDescriptor<void*> midi_data;
+ }
+}
+
+void
+MidiRegion::make_property_quarks ()
+{
+ Properties::midi_data.property_id = g_quark_from_static_string (X_("midi-data"));
+ DEBUG_TRACE (DEBUG::Properties, string_compose ("quark for midi-data = %1\n", Properties::midi_data.property_id));
+}
+
+void
+MidiRegion::register_properties ()
+{
+ /* none yet, but its only a matter of time */
+}
+
/* Basic MidiRegion constructor (many channels) */
MidiRegion::MidiRegion (const SourceList& srcs)
: Region (srcs)
{
+ register_properties ();
+
// midi_source(0)->Switched.connect_same_thread (*this, boost::bind (&MidiRegion::switch_source, this, _1));
midi_source(0)->ModelChanged.connect_same_thread (_source_connection, boost::bind (&MidiRegion::model_changed, this));
model_changed ();
MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other, frameoffset_t offset, bool offset_relative)
: Region (other, offset, offset_relative)
{
+ register_properties ();
+
assert(_name.val().find("/") == string::npos);
// midi_source(0)->Switched.connect_same_thread (*this, boost::bind (&MidiRegion::switch_source, this, _1));
midi_source(0)->ModelChanged.connect_same_thread (_source_connection, boost::bind (&MidiRegion::model_changed, this));
boost::shared_ptr<MidiSource> src = midi_source(chan_n);
src->set_note_mode(mode);
-
- /*cerr << "MR read @ " << position << " * " << to_read
- << " _position = " << _position
- << " _start = " << _start
- << " offset = " << output_buffer_position
- << " intoffset = " << internal_offset
- << endl;*/
+
+ /*
+ cerr << "MR read @ " << position << " * " << to_read
+ << " _position = " << _position
+ << " _start = " << _start
+ << " intoffset = " << internal_offset
+ << endl;
+ */
/* This call reads events from a source and writes them to `dst' timed in session frames */
midi_source()->AutomationStateChanged.connect_same_thread (
_model_connection, boost::bind (&MidiRegion::model_automation_state_changed, this, _1)
);
+
+ model()->ContentsChanged.connect_same_thread (
+ _model_contents_connection, boost::bind (&MidiRegion::model_contents_changed, this));
+}
+
+void
+MidiRegion::model_contents_changed ()
+{
+ send_change (PropertyChange (Properties::midi_data));
}
void
Timecode::Time timecode;
TimecodeFormat tc_format;
bool reset_tc = true;
- nframes64_t window_root = -1;
+ framepos_t window_root = -1;
DEBUG_TRACE (DEBUG::MTC, string_compose ("full mtc time known at %1, full ? %2\n", now, was_full));
*/
-#define __STDC_LIMIT_MACROS
#include <stdint.h>
-
#include <set>
#include <fstream>
#include <algorithm>
framepos_t new_pos = (*i)->position() + distance;
if (new_pos < 0) {
new_pos = 0;
- } else if (new_pos >= max_frames - (*i)->length()) {
- new_pos = max_frames - (*i)->length();
+ } else if (new_pos >= max_framepos - (*i)->length()) {
+ new_pos = max_framepos - (*i)->length();
}
(*i)->set_position (new_pos, this);
{
RegionLock rlock (this);
boost::shared_ptr<Region> ret;
- framepos_t closest = max_frames;
+ framepos_t closest = max_framepos;
bool end_iter = false;
{
RegionLock rlock (this);
- framepos_t closest = max_frames;
+ framepos_t closest = max_framepos;
framepos_t ret = -1;
if (dir > 0) {
pair<framecnt_t, framecnt_t>
Playlist::_get_extent () const
{
- pair<framecnt_t, framecnt_t> ext (max_frames, 0);
+ pair<framecnt_t, framecnt_t> ext (max_framepos, 0);
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
pair<framecnt_t, framecnt_t> const e ((*i)->position(), (*i)->position() + (*i)->length());
if (forwards) {
- if ((*i)->last_frame() > max_frames - distance) {
- new_pos = max_frames - (*i)->length();
+ if ((*i)->last_frame() > max_framepos - distance) {
+ new_pos = max_framepos - (*i)->length();
} else {
new_pos = (*i)->position() + distance;
}
length impossible.
*/
- if (max_frames - len < _position) {
+ if (max_framepos - len < _position) {
return;
}
XXX is this the right thing to do?
*/
- if (max_frames - _length < _position) {
+ if (max_framepos - _length < _position) {
_last_length = _length;
- _length = max_frames - _position;
+ _length = max_framepos - _position;
}
if (allow_bbt_recompute) {
_last_position = _position;
if (n > 0) {
- if (_position > max_frames - n) {
- _position = max_frames;
+ if (_position > max_framepos - n) {
+ _position = max_framepos;
} else {
_position += n;
}
if (start_shift > 0) {
- if (_start > max_frames - start_shift) {
- new_start = max_frames;
+ if (_start > max_framepos - start_shift) {
+ new_start = max_framepos;
} else {
new_start = _start + start_shift;
}
if (start_shift > 0) {
- if (_start > max_frames - start_shift) {
- new_start = max_frames;
+ if (_start > max_framepos - start_shift) {
+ new_start = max_framepos;
} else {
new_start = _start + start_shift;
}
pos = 0;
}
} else {
- if (max_frames - pos > offset) {
+ if (max_framepos - pos > offset) {
pos += offset;
}
}
*/
-#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#include "pbd/error.h"
*/
-#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#include <algorithm>
*/
-#define __STDC_LIMIT_MACROS
#include <stdint.h>
#include <algorithm>
return;
}
- pair<nframes_t, nframes_t> const ext = get_extent ();
+ pair<framepos_t, framepos_t> const ext = get_extent ();
if (_session_range_location == 0) {
/* we don't have a session range yet; use this one (provided it is valid) */
- if (ext.first != max_frames) {
+ if (ext.first != max_framepos) {
add_session_range_location (ext.first, ext.second);
}
} else {
}
/** @return Extent of the session's contents; if the session is empty, the first value of
- * the pair will equal max_frames.
+ * the pair will equal max_framepos.
*/
-pair<nframes_t, nframes_t>
+pair<framepos_t, framepos_t>
Session::get_extent () const
{
- pair<nframes_t, nframes_t> ext (max_frames, 0);
+ pair<framepos_t, framepos_t> ext (max_framepos, 0);
boost::shared_ptr<RouteList> rl = routes.reader ();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
}
}
-nframes_t
+framecnt_t
Session::available_capture_duration ()
{
float sample_bytes_on_disk = 4.0; // keep gcc happy
double scale = 4096.0 / sample_bytes_on_disk;
- if (_total_free_4k_blocks * scale > (double) max_frames) {
- return max_frames;
+ if (_total_free_4k_blocks * scale > (double) max_framecnt) {
+ return max_framecnt;
}
-
- return (nframes_t) floor (_total_free_4k_blocks * scale);
+
+ return (framecnt_t) floor (_total_free_4k_blocks * scale);
}
void
}
}
-nframes_t
+framepos_t
Session::current_start_frame () const
{
return _session_range_location ? _session_range_location->start() : 0;
}
-nframes_t
+framepos_t
Session::current_end_frame () const
{
return _session_range_location ? _session_range_location->end() : 0;
return;
}
- nframes_t target_frame;
+ framepos_t target_frame;
Timecode::Time timecode;
timecode.hours = mmc_tc[0] & 0xf;
// Also takes timecode offset into account:
timecode_to_sample( timecode, target_frame, true /* use_offset */, false /* use_subframes */ );
- if (target_frame > max_frames) {
- target_frame = max_frames;
+ if (target_frame > max_framepos) {
+ target_frame = max_framepos;
}
/* Some (all?) MTC/MMC devices do not send a full MTC frame
void
Session::process_with_events (nframes_t nframes)
{
- SessionEvent* ev;
+ SessionEvent* ev;
nframes_t this_nframes;
- nframes_t end_frame;
+ framepos_t end_frame;
bool session_needs_butler = false;
- nframes_t stop_limit;
+ framepos_t stop_limit;
framecnt_t frames_moved;
/* make sure the auditioner is silent */
}
if (actively_recording()) {
- stop_limit = max_frames;
+ stop_limit = max_framepos;
} else {
if (Config->get_stop_at_session_end()) {
stop_limit = current_end_frame();
} else {
- stop_limit = max_frames;
+ stop_limit = max_framepos;
}
}
} else {
increment_transport_position (frames_moved);
}
-
- nframes_t stop_limit;
+
+ framepos_t stop_limit;
if (actively_recording()) {
- stop_limit = max_frames;
+ stop_limit = max_framepos;
} else {
if (Config->get_stop_at_session_end()) {
stop_limit = current_end_frame();
} else {
- stop_limit = max_frames;
+ stop_limit = max_framepos;
}
}
Session::process_without_events (nframes_t nframes)
{
bool session_needs_butler = false;
- nframes_t stop_limit;
+ framepos_t stop_limit;
framecnt_t frames_moved;
if (!process_can_proceed()) {
}
if (actively_recording()) {
- stop_limit = max_frames;
+ stop_limit = max_framepos;
} else {
if (Config->get_stop_at_session_end()) {
stop_limit = current_end_frame();
} else {
- stop_limit = max_frames;
+ stop_limit = max_framepos;
}
}
// with the default start and end, and get the state for that.
Locations loc (*this);
Location* range = new Location (*this, 0, 0, _("session"), Location::IsSessionRange);
- range->set (max_frames, 0);
+ range->set (max_framepos, 0);
loc.add (range);
node->add_child_nocopy (loc.get_state());
}
}
} catch (MissingSource& err) {
warning << _("A sound file is missing. It will be replaced by silence.") << endmsg;
- source = SourceFactory::createSilent (*this, **niter, max_frames, _current_frame_rate);
+ source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate);
}
}
}
void
-Session::timecode_to_sample( Timecode::Time& timecode, nframes_t& sample, bool use_offset, bool use_subframes ) const
+Session::timecode_to_sample( Timecode::Time& timecode, framepos_t& sample, bool use_offset, bool use_subframes ) const
{
if (timecode.drop) {
void
-Session::sample_to_timecode( nframes_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes ) const
+Session::sample_to_timecode (framepos_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes ) const
{
- nframes_t offset_sample;
+ framepos_t offset_sample;
if (!use_offset) {
offset_sample = sample;
}
void
-Session::timecode_duration_string (char* buf, nframes_t when) const
+Session::timecode_duration_string (char* buf, framepos_t when) const
{
Timecode::Time timecode;
}
int
-SndFileSource::update_header (sframes_t when, struct tm& now, time_t tnow)
+SndFileSource::update_header (framepos_t when, struct tm& now, time_t tnow)
{
set_timeline_position (when);
}
void
-SndFileSource::set_timeline_position (int64_t pos)
+SndFileSource::set_timeline_position (framepos_t pos)
{
// destructive track timeline postion does not change
// except at instantion or when header_position_offset
}
boost::shared_ptr<Source>
-SourceFactory::createSilent (Session& s, const XMLNode& node, nframes_t nframes, float sr)
+SourceFactory::createSilent (Session& s, const XMLNode& node, framecnt_t nframes, float sr)
{
Source* src = new SilentFileSource (s, node, nframes, sr);
// boost_debug_shared_ptr_mark_interesting (src, "Source");
}
int
-Track::seek (nframes_t s, bool complete_refill)
+Track::seek (framepos_t p, bool complete_refill)
{
- return _diskstream->seek (s, complete_refill);
+ return _diskstream->seek (p, complete_refill);
}
bool
}
int
-Track::can_internal_playback_seek (nframes_t d)
+Track::can_internal_playback_seek (framepos_t p)
{
- return _diskstream->can_internal_playback_seek (d);
+ return _diskstream->can_internal_playback_seek (p);
}
int
-Track::internal_playback_seek (nframes_t d)
+Track::internal_playback_seek (framepos_t p)
{
- return _diskstream->internal_playback_seek (d);
+ return _diskstream->internal_playback_seek (p);
}
void
}
void
-Track::non_realtime_locate (nframes_t p)
+Track::non_realtime_locate (framepos_t p)
{
_diskstream->non_realtime_locate (p);
}
return _diskstream->overwrite_existing_buffers ();
}
-nframes_t
+framecnt_t
Track::get_captured_frames (uint32_t n)
{
return _diskstream->get_captured_frames (n);
}
void
-Track::transport_looped (nframes_t f)
+Track::transport_looped (framepos_t p)
{
- _diskstream->transport_looped (f);
+ _diskstream->transport_looped (p);
}
bool
return _diskstream->n_channels ();
}
-nframes_t
+framepos_t
Track::get_capture_start_frame (uint32_t n)
{
return _diskstream->get_capture_start_frame (n);
return _diskstream->alignment_style ();
}
-nframes_t
+framepos_t
Track::current_capture_start () const
{
return _diskstream->current_capture_start ();
}
-nframes_t
+framepos_t
Track::current_capture_end () const
{
return _diskstream->current_capture_end ();
}
void
-BasicUI::timecode_to_sample (Timecode::Time& timecode, nframes_t& sample, bool use_offset, bool use_subframes) const
+BasicUI::timecode_to_sample (Timecode::Time& timecode, int64_t& sample, bool use_offset, bool use_subframes) const
{
session->timecode_to_sample (*((Timecode::Time*)&timecode), sample, use_offset, use_subframes);
}
void
-BasicUI::sample_to_timecode (nframes_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const
+BasicUI::sample_to_timecode (int64_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const
{
session->sample_to_timecode (sample, *((Timecode::Time*)&timecode), use_offset, use_subframes);
}
#define __ardour_basic_ui_h__
#include <string>
+#include <stdint.h>
+
#include "pbd/signals.h"
#include <jack/types.h>
jack_nframes_t timecode_frames_per_hour ();
void timecode_time (jack_nframes_t where, Timecode::Time&);
- void timecode_to_sample (Timecode::Time& timecode, jack_nframes_t& sample, bool use_offset, bool use_subframes) const;
- void sample_to_timecode (jack_nframes_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const;
+ void timecode_to_sample (Timecode::Time& timecode, int64_t& sample, bool use_offset, bool use_subframes) const;
+ void sample_to_timecode (int64_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const;
protected:
BasicUI ();
#include <vector>
#include <iomanip>
-#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#include <float.h>
#include <sys/time.h>
conf.env.append_value('CCFLAGS', [ '-D_FILE_OFFSET_BITS=64', '-D_FILE_OFFSET_BITS=64' ])
conf.env.append_value('CXXFLAGS', [ '-D_LARGEFILE64_SOURCE', '-D_LARGEFILE_SOURCE' ])
conf.env.append_value('CXXFLAGS', [ '-D_FILE_OFFSET_BITS=64', '-D_FILE_OFFSET_BITS=64' ])
+
+ conf.env.append_value('CXXFLAGS', [ '-D__STDC_LIMIT_MACROS', '-D__STDC_LIMIT_MACROS' ])
+ conf.env.append_value('CXXFLAGS', [ '-D__STDC_FORMAT_MACROS', '-D__STDC_FORMAT_MACROS' ])
+
if opt.nls:
conf.env.append_value('CXXFLAGS', '-DENABLE_NLS')
conf.env.append_value('CCFLAGS', '-DENABLE_NLS')
projects / ardour.git / commitdiff