#undef check
#endif
-#include "timecode/time.h"
+#include "temporal/time.h"
typedef uint64_t microseconds_t;
int test_channel = (*_events.begin())->note()->channel ();
int test_pitch = (*_events.begin())->note()->note ();
int test_velocity = (*_events.begin())->note()->velocity ();
- Evoral::Beats test_time = (*_events.begin())->note()->time ();
- Evoral::Beats test_length = (*_events.begin())->note()->length ();
+ Temporal::Beats test_time = (*_events.begin())->note()->time ();
+ Temporal::Beats test_length = (*_events.begin())->note()->length ();
for (set<NoteBase*>::iterator i = _events.begin(); i != _events.end(); ++i) {
if ((*i)->note()->channel() != test_channel) {
}
samplecnt_t const region_samples = _time_clock.current_time() - (_region_view->region()->position() - _region_view->region()->start());
- Evoral::Beats const t = _region_view->source_relative_time_converter().from (region_samples);
+ Temporal::Beats const t = _region_view->source_relative_time_converter().from (region_samples);
if (!_time_all.get_sensitive() || _time_all.get_active ()) {
for (set<NoteBase*>::iterator i = _events.begin(); i != _events.end(); ++i) {
if (!_length_all.get_sensitive() || _length_all.get_active ()) {
for (set<NoteBase*>::iterator i = _events.begin(); i != _events.end(); ++i) {
samplepos_t const note_end_sample = region_samples + _length_clock.current_duration (_time_clock.current_time());
- Evoral::Beats const d = _region_view->source_relative_time_converter().from (note_end_sample) - (*i)->note()->time();
+ Temporal::Beats const d = _region_view->source_relative_time_converter().from (note_end_sample) - (*i)->note()->time();
if (d != (*i)->note()->length()) {
_region_view->change_note_length (*i, d);
had_change = true;
return 0;
}
-Evoral::Beats
+Temporal::Beats
Editor::get_grid_type_as_beats (bool& success, samplepos_t position)
{
success = true;
const unsigned divisions = get_grid_beat_divisions(position);
if (divisions) {
- return Evoral::Beats(1.0 / (double)get_grid_beat_divisions(position));
+ return Temporal::Beats(1.0 / (double)get_grid_beat_divisions(position));
}
switch (_snap_type) {
case SnapToBeat:
- return Evoral::Beats(4.0 / _session->tempo_map().meter_at_sample (position).note_divisor());
+ return Temporal::Beats(4.0 / _session->tempo_map().meter_at_sample (position).note_divisor());
case SnapToBar:
if (_session) {
const Meter& m = _session->tempo_map().meter_at_sample (position);
- return Evoral::Beats((4.0 * m.divisions_per_bar()) / m.note_divisor());
+ return Temporal::Beats((4.0 * m.divisions_per_bar()) / m.note_divisor());
}
break;
default:
break;
}
- return Evoral::Beats();
+ return Temporal::Beats();
}
samplecnt_t
}
void
-Editor::get_per_region_note_selection (list<pair<PBD::ID, set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > > &selection) const
+Editor::get_per_region_note_selection (list<pair<PBD::ID, set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > > > &selection) const
{
for (TrackViewList::const_iterator i = track_views.begin(); i != track_views.end(); ++i) {
samplecnt_t get_nudge_distance (samplepos_t pos, samplecnt_t& next);
samplecnt_t get_paste_offset (samplepos_t pos, unsigned paste_count, samplecnt_t duration);
unsigned get_grid_beat_divisions(samplepos_t position);
- Evoral::Beats get_grid_type_as_beats (bool& success, samplepos_t position);
+ Temporal::Beats get_grid_type_as_beats (bool& success, samplepos_t position);
int32_t get_grid_music_divisions (uint32_t event_state);
void get_regions_corresponding_to (boost::shared_ptr<ARDOUR::Region> region, std::vector<RegionView*>& regions, bool src_comparison);
void get_regionviews_by_id (PBD::ID const id, RegionSelection & regions) const;
- void get_per_region_note_selection (std::list<std::pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > >&) const;
+ void get_per_region_note_selection (std::list<std::pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > > >&) const;
void center_screen (samplepos_t);
void cut_copy (Editing::CutCopyOp);
bool can_cut_copy () const;
- void cut_copy_points (Editing::CutCopyOp, Evoral::Beats earliest=Evoral::Beats(), bool midi=false);
+ void cut_copy_points (Editing::CutCopyOp, Temporal::Beats earliest=Temporal::Beats(), bool midi=false);
void cut_copy_regions (Editing::CutCopyOp, RegionSelection&);
void cut_copy_ranges (Editing::CutCopyOp);
void cut_copy_midi (Editing::CutCopyOp);
NoteCreateDrag::grid_samples (samplepos_t t) const
{
- const Evoral::Beats grid_beats = _region_view->get_grid_beats (t);
- const Evoral::Beats t_beats = _region_view->region_samples_to_region_beats (t);
+ const Temporal::Beats grid_beats = _region_view->get_grid_beats (t);
+ const Temporal::Beats t_beats = _region_view->region_samples_to_region_beats (t);
return _region_view->region_beats_to_region_samples (t_beats + grid_beats)
- _region_view->region_beats_to_region_samples (t_beats);
const samplepos_t pf = _drags->current_pointer_sample ();
const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
- const Evoral::Beats grid_beats = _region_view->get_grid_beats (pf);
+ const Temporal::Beats grid_beats = _region_view->get_grid_beats (pf);
double eqaf = map.exact_qn_at_sample (pf, divisions);
if (divisions != 0) {
- const Evoral::Beats grid_beats = _region_view->get_grid_beats (pf);
+ const Temporal::Beats grid_beats = _region_view->get_grid_beats (pf);
const double qaf = map.quarter_note_at_sample (pf);
/* Hack so that we always snap to the note that we are over, instead of snapping
TempoMap& map (_editor->session()->tempo_map());
const double qn_length = map.quarter_notes_between_samples (start_sess_rel, start_sess_rel + length);
- Evoral::Beats qn_length_beats = max (Evoral::Beats::ticks(1), Evoral::Beats (qn_length));
+ Temporal::Beats qn_length_beats = max (Temporal::Beats::ticks(1), Temporal::Beats (qn_length));
_editor->begin_reversible_command (_("Create Note"));
_region_view->clear_editor_note_selection();
}
const samplepos_t start = map.sample_at_quarter_note (eqaf) - _region_view->region()->position();
- Evoral::Beats length = _region_view->get_grid_beats (pf);
+ Temporal::Beats length = _region_view->get_grid_beats (pf);
_editor->begin_reversible_command (_("Create Hit"));
_region_view->clear_editor_note_selection();
return;
}
- Evoral::Beats length = _region_view->get_grid_beats (pf);
+ Temporal::Beats length = _region_view->get_grid_beats (pf);
boost::shared_ptr<MidiRegion> mr = _region_view->midi_region();
* @param op Operation (Cut, Copy or Clear)
*/
void
-Editor::cut_copy_points (Editing::CutCopyOp op, Evoral::Beats earliest, bool midi)
+Editor::cut_copy_points (Editing::CutCopyOp op, Temporal::Beats earliest, bool midi)
{
if (selection->points.empty ()) {
return;
lists[al].copy->fast_simple_add ((*ctrl_evt)->when, (*ctrl_evt)->value);
if (midi) {
/* Update earliest MIDI start time in beats */
- earliest = std::min(earliest, Evoral::Beats((*ctrl_evt)->when));
+ earliest = std::min(earliest, Temporal::Beats((*ctrl_evt)->when));
} else {
/* Update earliest session start time in samples */
start.sample = std::min(start.sample, (*sel_point)->line().session_position(ctrl_evt));
/* Snap start time backwards, so copy/paste is snap aligned. */
if (midi) {
- if (earliest == std::numeric_limits<Evoral::Beats>::max()) {
- earliest = Evoral::Beats(); // Weird... don't offset
+ if (earliest == std::numeric_limits<Temporal::Beats>::max()) {
+ earliest = Temporal::Beats(); // Weird... don't offset
}
earliest.round_down_to_beat();
} else {
void
Editor::cut_copy_midi (CutCopyOp op)
{
- Evoral::Beats earliest = std::numeric_limits<Evoral::Beats>::max();
+ Temporal::Beats earliest = std::numeric_limits<Temporal::Beats>::max();
for (MidiRegionSelection::iterator i = selection->midi_regions.begin(); i != selection->midi_regions.end(); ++i) {
MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*i);
if (mrv) {
Command*
Editor::apply_midi_note_edit_op_to_region (MidiOperator& op, MidiRegionView& mrv)
{
- Evoral::Sequence<Evoral::Beats>::Notes selected;
+ Evoral::Sequence<Temporal::Beats>::Notes selected;
mrv.selection_as_notelist (selected, true);
- vector<Evoral::Sequence<Evoral::Beats>::Notes> v;
+ vector<Evoral::Sequence<Temporal::Beats>::Notes> v;
v.push_back (selected);
- Evoral::Beats pos_beats = Evoral::Beats (mrv.midi_region()->beat()) - mrv.midi_region()->start_beats();
+ Temporal::Beats pos_beats = Temporal::Beats (mrv.midi_region()->beat()) - mrv.midi_region()->start_beats();
return op (mrv.midi_region()->model(), pos_beats, v);
}
*/
MidiRegionView* first = dynamic_cast<MidiRegionView*> (rs.front ());
- Evoral::PatchChange<Evoral::Beats> empty (Evoral::Beats(), 0, 0, 0);
+ Evoral::PatchChange<Temporal::Beats> empty (Temporal::Beats(), 0, 0, 0);
PatchChangeDialog d (0, _session, empty, first->instrument_info(), Gtk::Stock::ADD);
if (d.run() == RESPONSE_CANCEL) {
for (vector<PTFFormat::midi_ev_t>::iterator
j = a->midi.begin();
j != a->midi.end(); ++j) {
- Evoral::Beats start = (Evoral::Beats)(j->pos/960000.);
- Evoral::Beats len = (Evoral::Beats)(j->length/960000.);
+ Temporal::Beats start = (Temporal::Beats)(j->pos/960000.);
+ Temporal::Beats len = (Temporal::Beats)(j->length/960000.);
// PT C-2 = 0, Ardour C-1 = 0, subtract twelve to convert...
- midicmd->add(boost::shared_ptr<Evoral::Note<Evoral::Beats> >
- (new Evoral::Note<Evoral::Beats>( (uint8_t)1, start, len, j->note - 12, j->velocity )));
+ midicmd->add(boost::shared_ptr<Evoral::Note<Temporal::Beats> >
+ (new Evoral::Note<Temporal::Beats>( (uint8_t)1, start, len, j->note - 12, j->velocity )));
}
mm->apply_command (_session, midicmd);
boost::shared_ptr<Region> copy (RegionFactory::create (mr, true));
ArdourCanvas::Polygon* _tmp_poly;
MidiRegionView& parent_mrv;
- typedef Evoral::Note<Evoral::Beats> NoteType;
+ typedef Evoral::Note<Temporal::Beats> NoteType;
MidiGhostRegion::GhostEvent* find_event (boost::shared_ptr<NoteType>);
typedef boost::unordered_map<boost::shared_ptr<NoteType>, MidiGhostRegion::GhostEvent* > EventList;
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "evoral/Note.hpp"
#include "canvas/polygon.h"
class Hit : public NoteBase
{
public:
- typedef Evoral::Note<Evoral::Beats> NoteType;
+ typedef Evoral::Note<Temporal::Beats> NoteType;
Hit (MidiRegionView& region,
ArdourCanvas::Item* parent,
#include <pbd/windows_timer_utils.h>
#endif
-#include "timecode/time.h"
+#include "temporal/time.h"
#include "idleometer.h"
#include "pbd/i18n.h"
using namespace ARDOUR;
MidiCutBuffer::MidiCutBuffer (Session* s)
- : AutomatableSequence<Evoral::Beats> (*s)
+ : AutomatableSequence<Temporal::Beats> (*s)
, _origin (0)
{
#ifndef __gtk_ardour_midi_cut_buffer_h__
#define __gtk_ardour_midi_cut_buffer_h__
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "ardour/automatable_sequence.h"
class Session;
}
-class MidiCutBuffer : public ARDOUR::AutomatableSequence<Evoral::Beats>
+class MidiCutBuffer : public ARDOUR::AutomatableSequence<Temporal::Beats>
{
public:
- typedef Evoral::Beats TimeType;
+ typedef Temporal::Beats TimeType;
MidiCutBuffer (ARDOUR::Session*);
~MidiCutBuffer();
if (note->time() + fdelta >= 0) {
cmd->change (note, prop, note->time() + fdelta);
} else {
- cmd->change (note, prop, Evoral::Beats());
+ cmd->change (note, prop, Temporal::Beats());
}
break;
case MidiModel::NoteDiffCommand::Velocity:
break;
case MidiModel::NoteDiffCommand::Length:
if (note->length().to_double() + fdelta >=
- Evoral::Beats::tick().to_double()) {
+ Temporal::Beats::tick().to_double()) {
cmd->change (note, prop, note->length() + fdelta);
} else {
- cmd->change (note, prop, Evoral::Beats::tick());
+ cmd->change (note, prop, Temporal::Beats::tick());
}
break;
case MidiModel::NoteDiffCommand::Channel:
if (note->time() + fdelta >= 0) {
cmd->change (note, prop, note->time() + fdelta);
} else {
- cmd->change (note, prop, Evoral::Beats());
+ cmd->change (note, prop, Temporal::Beats());
}
break;
case MidiModel::NoteDiffCommand::Velocity:
break;
case MidiModel::NoteDiffCommand::Length:
if (note->length() + fdelta >=
- Evoral::Beats::tick().to_double()) {
+ Temporal::Beats::tick().to_double()) {
cmd->change (note, prop, note->length() + fdelta);
} else {
- cmd->change (note, prop, Evoral::Beats::tick());
+ cmd->change (note, prop, Temporal::Beats::tick());
}
break;
case MidiModel::NoteDiffCommand::Channel:
row[columns.start] = ss.str();
bbt.bars = 0;
- const Evoral::Beats dur = (*i)->end_time() - (*i)->time();
+ const Temporal::Beats dur = (*i)->end_time() - (*i)->time();
bbt.beats = dur.get_beats ();
bbt.ticks = dur.get_ticks ();
class MidiListEditor : public ArdourWindow
{
public:
- typedef Evoral::Note<Evoral::Beats> NoteType;
+ typedef Evoral::Note<Temporal::Beats> NoteType;
MidiListEditor(ARDOUR::Session*, boost::shared_ptr<ARDOUR::MidiRegion>,
boost::shared_ptr<ARDOUR::MidiTrack>);
bool shorter = Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier);
bool fine = Keyboard::modifier_state_contains (ev->state, Keyboard::SecondaryModifier);
- change_note_lengths (fine, shorter, Evoral::Beats(), start, end);
+ change_note_lengths (fine, shorter, Temporal::Beats(), start, end);
return true;
* \param snap_t true to snap t to the grid, otherwise false.
*/
void
-MidiRegionView::create_note_at (samplepos_t t, double y, Evoral::Beats length, uint32_t state, bool shift_snap)
+MidiRegionView::create_note_at (samplepos_t t, double y, Temporal::Beats length, uint32_t state, bool shift_snap)
{
if (length < 2 * DBL_EPSILON) {
return;
// Start of note in samples relative to region start
const int32_t divisions = trackview.editor().get_grid_music_divisions (state);
- Evoral::Beats beat_time = snap_sample_to_grid_underneath (t, divisions, shift_snap);
+ Temporal::Beats beat_time = snap_sample_to_grid_underneath (t, divisions, shift_snap);
const double note = view->y_to_note(y);
const uint8_t chan = mtv->get_channel_for_add();
void
MidiRegionView::note_diff_add_change (NoteBase* ev,
MidiModel::NoteDiffCommand::Property property,
- Evoral::Beats val)
+ Temporal::Beats val)
{
if (_note_diff_command) {
_note_diff_command->change (ev->note(), property, val);
}
void
-MidiRegionView::get_events (Events& e, Evoral::Sequence<Evoral::Beats>::NoteOperator op, uint8_t val, int chan_mask)
+MidiRegionView::get_events (Events& e, Evoral::Sequence<Temporal::Beats>::NoteOperator op, uint8_t val, int chan_mask)
{
MidiModel::Notes notes;
_model->get_notes (notes, op, val, chan_mask);
for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
MidiModel::SysExPtr sysex_ptr = *i;
- Evoral::Beats time = sysex_ptr->time();
+ Temporal::Beats time = sysex_ptr->time();
if ((*i)->is_spp() || (*i)->is_mtc_quarter() || (*i)->is_mtc_full()) {
if (!display_periodic_messages) {
}
// Show unless message is beyond the region bounds
-// XXX REQUIRES APPROPRIATE OPERATORS FOR Evoral::Beats and samplepos? say what?
+// XXX REQUIRES APPROPRIATE OPERATORS FOR Temporal::Beats and samplepos? say what?
#warning paul fix this
// if (time - _region->start() >= _region->length() || time < _region->start()) {
// sysex->hide();
/** Resolve an active MIDI note (while recording).
*/
void
-MidiRegionView::resolve_note(uint8_t note, Evoral::Beats end_time)
+MidiRegionView::resolve_note(uint8_t note, Temporal::Beats end_time)
{
if (midi_view()->note_mode() != Sustained) {
return;
void
MidiRegionView::step_add_note (uint8_t channel, uint8_t number, uint8_t velocity,
- Evoral::Beats pos, Evoral::Beats len)
+ Temporal::Beats pos, Temporal::Beats len)
{
boost::shared_ptr<NoteType> new_note (new NoteType (channel, pos, len, number, velocity));
}
void
-MidiRegionView::step_sustain (Evoral::Beats beats)
+MidiRegionView::step_sustain (Temporal::Beats beats)
{
change_note_lengths (false, false, beats, false, true);
}
/// Return true iff @p pc applies to the given time on the given channel.
static bool
-patch_applies (const ARDOUR::MidiModel::constPatchChangePtr pc, Evoral::Beats time, uint8_t channel)
+patch_applies (const ARDOUR::MidiModel::constPatchChangePtr pc, Temporal::Beats time, uint8_t channel)
{
return pc->time() <= time && pc->channel() == channel;
}
void
-MidiRegionView::get_patch_key_at (Evoral::Beats time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key) const
+MidiRegionView::get_patch_key_at (Temporal::Beats time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key) const
{
// The earliest event not before time
MidiModel::PatchChanges::iterator i = _model->patch_change_lower_bound (time);
}
void
-MidiRegionView::change_patch_change (MidiModel::PatchChangePtr old_change, const Evoral::PatchChange<Evoral::Beats> & new_change)
+MidiRegionView::change_patch_change (MidiModel::PatchChangePtr old_change, const Evoral::PatchChange<Temporal::Beats> & new_change)
{
string name = _("alter patch change");
trackview.editor().begin_reversible_command (name);
* MidiTimeAxisView::get_channel_for_add())
*/
void
-MidiRegionView::add_patch_change (samplecnt_t t, Evoral::PatchChange<Evoral::Beats> const & patch)
+MidiRegionView::add_patch_change (samplecnt_t t, Evoral::PatchChange<Temporal::Beats> const & patch)
{
string name = _("add patch change");
trackview.editor().begin_reversible_command (name);
MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (name);
c->add (MidiModel::PatchChangePtr (
- new Evoral::PatchChange<Evoral::Beats> (
+ new Evoral::PatchChange<Temporal::Beats> (
absolute_samples_to_source_beats (_region->position() + t),
patch.channel(), patch.program(), patch.bank()
)
}
void
-MidiRegionView::move_patch_change (PatchChange& pc, Evoral::Beats t)
+MidiRegionView::move_patch_change (PatchChange& pc, Temporal::Beats t)
{
trackview.editor().begin_reversible_command (_("move patch change"));
MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("move patch change"));
} else {
/* find end of latest note selected, select all between that and the start of "ev" */
- Evoral::Beats earliest = std::numeric_limits<Evoral::Beats>::max();
- Evoral::Beats latest = Evoral::Beats();
+ Temporal::Beats earliest = std::numeric_limits<Temporal::Beats>::max();
+ Temporal::Beats latest = Temporal::Beats();
for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
if ((*i)->note()->end_time() > latest) {
}
}
-Evoral::Beats
+Temporal::Beats
MidiRegionView::earliest_in_selection ()
{
- Evoral::Beats earliest = std::numeric_limits<Evoral::Beats>::max();
+ Temporal::Beats earliest = std::numeric_limits<Temporal::Beats>::max();
for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
if ((*i)->note()->time() < earliest) {
Editor* editor = dynamic_cast<Editor*> (&trackview.editor());
TempoMap& tmap (editor->session()->tempo_map());
PossibleChord to_play;
- Evoral::Beats earliest = earliest_in_selection();
+ Temporal::Beats earliest = earliest_in_selection();
for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
NoteBase* n = *i;
Editor* editor = dynamic_cast<Editor*> (&trackview.editor());
TempoMap& tmap (editor->session()->tempo_map());
PossibleChord to_play;
- Evoral::Beats earliest = earliest_in_selection();
+ Temporal::Beats earliest = earliest_in_selection();
for (CopyDragEvents::iterator i = _copy_drag_events.begin(); i != _copy_drag_events.end(); ++i) {
NoteBase* n = *i;
for (Selection::iterator i = _selection.begin(); i != _selection.end() ; ++i) {
- Evoral::Beats new_time = Evoral::Beats ((*i)->note()->time().to_double() + d_qn);
+ Temporal::Beats new_time = Temporal::Beats ((*i)->note()->time().to_double() + d_qn);
if (new_time < 0) {
continue;
for (CopyDragEvents::iterator i = _copy_drag_events.begin(); i != _copy_drag_events.end() ; ++i) {
/* update time */
- Evoral::Beats new_time = Evoral::Beats ((*i)->note()->time().to_double() + d_qn);
+ Temporal::Beats new_time = Temporal::Beats ((*i)->note()->time().to_double() + d_qn);
if (new_time < 0) {
continue;
}
samplepos_t
-MidiRegionView::source_beats_to_absolute_samples(Evoral::Beats beats) const
+MidiRegionView::source_beats_to_absolute_samples(Temporal::Beats beats) const
{
/* the time converter will return the sample corresponding to `beats'
relative to the start of the source. The start of the source
return source_start + _source_relative_time_converter.to (beats);
}
-Evoral::Beats
+Temporal::Beats
MidiRegionView::absolute_samples_to_source_beats(samplepos_t samples) const
{
/* the `samples' argument needs to be converted into a sample count
}
samplepos_t
-MidiRegionView::region_beats_to_region_samples(Evoral::Beats beats) const
+MidiRegionView::region_beats_to_region_samples(Temporal::Beats beats) const
{
return _region_relative_time_converter.to(beats);
}
-Evoral::Beats
+Temporal::Beats
MidiRegionView::region_samples_to_region_beats(samplepos_t samples) const
{
return _region_relative_time_converter.from(samples);
} else {
snapped_x = trackview.editor ().pixel_to_sample (current_x);
}
- const Evoral::Beats beats = Evoral::Beats (tmap.exact_beat_at_sample (snapped_x + midi_region()->position(), divisions)
+ const Temporal::Beats beats = Temporal::Beats (tmap.exact_beat_at_sample (snapped_x + midi_region()->position(), divisions)
- midi_region()->beat()) + midi_region()->start_beats();
- Evoral::Beats len = Evoral::Beats();
+ Temporal::Beats len = Temporal::Beats();
if (at_front) {
if (beats < canvas_note->note()->end_time()) {
}
}
- len = std::max(Evoral::Beats(1 / 512.0), len);
+ len = std::max(Temporal::Beats(1 / 512.0), len);
char buf[16];
snprintf (buf, sizeof (buf), "%.3g beats", len.to_double());
/* and then to beats */
const double e_qaf = tmap.exact_qn_at_sample (current_fr + midi_region()->position(), divisions);
const double quarter_note_start = _region->quarter_note() - midi_region()->start_beats();
- const Evoral::Beats x_beats = Evoral::Beats (e_qaf - quarter_note_start);
+ const Temporal::Beats x_beats = Temporal::Beats (e_qaf - quarter_note_start);
if (at_front && x_beats < canvas_note->note()->end_time()) {
note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::StartTime, x_beats - (sign * snap_delta_beats));
- Evoral::Beats len = canvas_note->note()->time() - x_beats + (sign * snap_delta_beats);
+ Temporal::Beats len = canvas_note->note()->time() - x_beats + (sign * snap_delta_beats);
len += canvas_note->note()->length();
if (!!len) {
}
if (!at_front) {
- Evoral::Beats len = std::max(Evoral::Beats(1 / 512.0),
+ Temporal::Beats len = std::max(Temporal::Beats(1 / 512.0),
x_beats - canvas_note->note()->time() - (sign * snap_delta_beats));
note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::Length, len);
}
}
void
-MidiRegionView::trim_note (NoteBase* event, Evoral::Beats front_delta, Evoral::Beats end_delta)
+MidiRegionView::trim_note (NoteBase* event, Temporal::Beats front_delta, Temporal::Beats end_delta)
{
bool change_start = false;
bool change_length = false;
- Evoral::Beats new_start;
- Evoral::Beats new_length;
+ Temporal::Beats new_start;
+ Temporal::Beats new_length;
/* NOTE: the semantics of the two delta arguments are slightly subtle:
if (front_delta < 0) {
if (event->note()->time() < -front_delta) {
- new_start = Evoral::Beats();
+ new_start = Temporal::Beats();
} else {
new_start = event->note()->time() + front_delta; // moves earlier
}
} else {
- Evoral::Beats new_pos = event->note()->time() + front_delta;
+ Temporal::Beats new_pos = event->note()->time() + front_delta;
if (new_pos < event->note()->end_time()) {
new_start = event->note()->time() + front_delta;
}
void
-MidiRegionView::change_note_time (NoteBase* event, Evoral::Beats delta, bool relative)
+MidiRegionView::change_note_time (NoteBase* event, Temporal::Beats delta, bool relative)
{
- Evoral::Beats new_time;
+ Temporal::Beats new_time;
if (relative) {
if (delta < 0.0) {
if (event->note()->time() < -delta) {
- new_time = Evoral::Beats();
+ new_time = Temporal::Beats();
} else {
new_time = event->note()->time() + delta;
}
}
void
-MidiRegionView::change_note_length (NoteBase* event, Evoral::Beats t)
+MidiRegionView::change_note_length (NoteBase* event, Temporal::Beats t)
{
note_diff_add_change (event, MidiModel::NoteDiffCommand::Length, t);
}
}
void
-MidiRegionView::change_note_lengths (bool fine, bool shorter, Evoral::Beats delta, bool start, bool end)
+MidiRegionView::change_note_lengths (bool fine, bool shorter, Temporal::Beats delta, bool start, bool end)
{
if (!delta) {
if (fine) {
- delta = Evoral::Beats(1.0/128.0);
+ delta = Temporal::Beats(1.0/128.0);
} else {
/* grab the current grid distance */
delta = get_grid_beats(_region->position());
/* note the negation of the delta for start */
trim_note (*i,
- (start ? -delta : Evoral::Beats()),
- (end ? delta : Evoral::Beats()));
+ (start ? -delta : Temporal::Beats()),
+ (end ? delta : Temporal::Beats()));
i = next;
}
*/
const samplepos_t ref_point = source_beats_to_absolute_samples ((*(_selection.begin()))->note()->time());
- Evoral::Beats delta;
+ Temporal::Beats delta;
if (!fine) {
/* non-fine, move by 1 bar regardless of snap */
- delta = Evoral::Beats(trackview.session()->tempo_map().meter_at_sample (ref_point).divisions_per_bar());
+ delta = Temporal::Beats(trackview.session()->tempo_map().meter_at_sample (ref_point).divisions_per_bar());
} else if (trackview.editor().snap_mode() == Editing::SnapOff) {
start_note_diff_command (_("paste"));
- const Evoral::Beats snap_beats = get_grid_beats(pos);
- const Evoral::Beats first_time = (*mcb.notes().begin())->time();
- const Evoral::Beats last_time = (*mcb.notes().rbegin())->end_time();
- const Evoral::Beats duration = last_time - first_time;
- const Evoral::Beats snap_duration = duration.snap_to(snap_beats);
- const Evoral::Beats paste_offset = snap_duration * paste_count;
- const Evoral::Beats quarter_note = absolute_samples_to_source_beats(pos) + paste_offset;
- Evoral::Beats end_point = Evoral::Beats();
+ const Temporal::Beats snap_beats = get_grid_beats(pos);
+ const Temporal::Beats first_time = (*mcb.notes().begin())->time();
+ const Temporal::Beats last_time = (*mcb.notes().rbegin())->end_time();
+ const Temporal::Beats duration = last_time - first_time;
+ const Temporal::Beats snap_duration = duration.snap_to(snap_beats);
+ const Temporal::Beats paste_offset = snap_duration * paste_count;
+ const Temporal::Beats quarter_note = absolute_samples_to_source_beats(pos) + paste_offset;
+ Temporal::Beats end_point = Temporal::Beats();
DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("Paste data spans from %1 to %2 (%3) ; paste pos beats = %4 (based on %5 - %6)\n",
first_time,
const int32_t divisions = editor.get_grid_music_divisions (state);
const bool shift_snap = midi_view()->note_mode() != Percussive;
- const Evoral::Beats snapped_beats = snap_sample_to_grid_underneath (unsnapped_sample, divisions, shift_snap);
+ const Temporal::Beats snapped_beats = snap_sample_to_grid_underneath (unsnapped_sample, divisions, shift_snap);
/* prevent Percussive mode from displaying a ghost hit at region end */
if (!shift_snap && snapped_beats >= midi_region()->start_beats() + midi_region()->length_beats()) {
}
/* calculate time in beats relative to start of source */
- const Evoral::Beats length = get_grid_beats(unsnapped_sample + _region->position());
+ const Temporal::Beats length = get_grid_beats(unsnapped_sample + _region->position());
_ghost_note->note()->set_time (snapped_beats);
_ghost_note->note()->set_length (length);
uint16_t chn_mask = mtv->midi_track()->get_playback_channel_mask();
if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
- get_events (e, Evoral::Sequence<Evoral::Beats>::PitchGreaterThanOrEqual, (uint8_t) floor (note), chn_mask);
+ get_events (e, Evoral::Sequence<Temporal::Beats>::PitchGreaterThanOrEqual, (uint8_t) floor (note), chn_mask);
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- get_events (e, Evoral::Sequence<Evoral::Beats>::PitchLessThanOrEqual, (uint8_t) floor (note), chn_mask);
+ get_events (e, Evoral::Sequence<Temporal::Beats>::PitchLessThanOrEqual, (uint8_t) floor (note), chn_mask);
} else {
return;
}
}
void
-MidiRegionView::show_step_edit_cursor (Evoral::Beats pos)
+MidiRegionView::show_step_edit_cursor (Temporal::Beats pos)
{
if (_step_edit_cursor == 0) {
ArdourCanvas::Item* const group = get_canvas_group();
}
void
-MidiRegionView::move_step_edit_cursor (Evoral::Beats pos)
+MidiRegionView::move_step_edit_cursor (Temporal::Beats pos)
{
_step_edit_cursor_position = pos;
}
void
-MidiRegionView::set_step_edit_cursor_width (Evoral::Beats beats)
+MidiRegionView::set_step_edit_cursor_width (Temporal::Beats beats)
{
_step_edit_cursor_width = beats;
}
/* convert from session samples to source beats */
- Evoral::Beats const time_beats = _source_relative_time_converter.from(
+ Temporal::Beats const time_beats = _source_relative_time_converter.from(
ev.time() - src->timeline_position() + _region->start());
if (ev.type() == MIDI_CMD_NOTE_ON) {
boost::shared_ptr<NoteType> note (
- new NoteType (ev.channel(), time_beats, Evoral::Beats(), ev.note(), ev.velocity()));
+ new NoteType (ev.channel(), time_beats, Temporal::Beats(), ev.note(), ev.velocity()));
add_note (note, true);
* bar is -1, 0 is audio samples and a positive integer is beat subdivisions.
* @return beat duration of p snapped to the grid subdivision underneath it.
*/
-Evoral::Beats
+Temporal::Beats
MidiRegionView::snap_sample_to_grid_underneath (samplepos_t p, int32_t divisions, bool shift_snap) const
{
TempoMap& map (trackview.session()->tempo_map());
/* Hack so that we always snap to the note that we are over, instead of snapping
to the next one if we're more than halfway through the one we're over.
*/
- const Evoral::Beats grid_beats = get_grid_beats (p + _region->position());
+ const Temporal::Beats grid_beats = get_grid_beats (p + _region->position());
const double rem = eqaf - qaf;
if (rem >= 0.0) {
eqaf -= grid_beats.to_double();
}
const double session_start_off = _region->quarter_note() - midi_region()->start_beats();
- return Evoral::Beats (eqaf - session_start_off);
+ return Temporal::Beats (eqaf - session_start_off);
}
ChannelMode
}
-Evoral::Beats
+Temporal::Beats
MidiRegionView::get_grid_beats(samplepos_t pos) const
{
PublicEditor& editor = trackview.editor();
bool success = false;
- Evoral::Beats beats = editor.get_grid_type_as_beats (success, pos);
+ Temporal::Beats beats = editor.get_grid_type_as_beats (success, pos);
if (!success) {
- beats = Evoral::Beats(1);
+ beats = Temporal::Beats(1);
}
return beats;
}
class MidiRegionView : public RegionView
{
public:
- typedef Evoral::Note<Evoral::Beats> NoteType;
- typedef Evoral::Sequence<Evoral::Beats>::Notes Notes;
+ typedef Evoral::Note<Temporal::Beats> NoteType;
+ typedef Evoral::Sequence<Temporal::Beats>::Notes Notes;
MidiRegionView (ArdourCanvas::Container* parent,
RouteTimeAxisView& tv,
{ return midi_view()->midi_view(); }
void step_add_note (uint8_t channel, uint8_t number, uint8_t velocity,
- Evoral::Beats pos, Evoral::Beats len);
- void step_sustain (Evoral::Beats beats);
+ Temporal::Beats pos, Temporal::Beats len);
+ void step_sustain (Temporal::Beats beats);
void set_height (double);
void apply_note_range(uint8_t lowest, uint8_t highest, bool force=false);
uint32_t get_fill_color() const;
void color_handler ();
- void show_step_edit_cursor (Evoral::Beats pos);
- void move_step_edit_cursor (Evoral::Beats pos);
+ void show_step_edit_cursor (Temporal::Beats pos);
+ void move_step_edit_cursor (Temporal::Beats pos);
void hide_step_edit_cursor ();
- void set_step_edit_cursor_width (Evoral::Beats beats);
+ void set_step_edit_cursor_width (Temporal::Beats beats);
void redisplay_model();
GhostRegion* add_ghost (TimeAxisView&);
NoteBase* add_note(const boost::shared_ptr<NoteType> note, bool visible);
- void resolve_note(uint8_t note_num, Evoral::Beats end_time);
+ void resolve_note(uint8_t note_num, Temporal::Beats end_time);
void cut_copy_clear (Editing::CutCopyOp);
bool paste (samplepos_t pos, const ::Selection& selection, PasteContext& ctx, const int32_t sub_num);
* @key a reference to an instance of MIDI::Name::PatchPrimaryKey whose fields will
* will be set according to the result of the lookup
*/
- void get_patch_key_at (Evoral::Beats time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key) const;
+ void get_patch_key_at (Temporal::Beats time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key) const;
/** Convert a given PatchChange into a PatchPrimaryKey
*/
* @param new_patch new patch
*/
void change_patch_change (PatchChange& old_patch, const MIDI::Name::PatchPrimaryKey& new_patch);
- void change_patch_change (ARDOUR::MidiModel::PatchChangePtr, Evoral::PatchChange<Evoral::Beats> const &);
+ void change_patch_change (ARDOUR::MidiModel::PatchChangePtr, Evoral::PatchChange<Temporal::Beats> const &);
- void add_patch_change (samplecnt_t, Evoral::PatchChange<Evoral::Beats> const &);
- void move_patch_change (PatchChange &, Evoral::Beats);
+ void add_patch_change (samplecnt_t, Evoral::PatchChange<Temporal::Beats> const &);
+ void move_patch_change (PatchChange &, Temporal::Beats);
void delete_patch_change (PatchChange *);
void edit_patch_change (PatchChange *);
void start_note_diff_command (std::string name = "midi edit");
void note_diff_add_change (NoteBase* ev, ARDOUR::MidiModel::NoteDiffCommand::Property, uint8_t val);
- void note_diff_add_change (NoteBase* ev, ARDOUR::MidiModel::NoteDiffCommand::Property, Evoral::Beats val);
+ void note_diff_add_change (NoteBase* ev, ARDOUR::MidiModel::NoteDiffCommand::Property, Temporal::Beats val);
void note_diff_add_note (const boost::shared_ptr<NoteType> note, bool selected, bool show_velocity = false);
void note_diff_remove_note (NoteBase* ev);
void select_range(samplepos_t start, samplepos_t end);
void invert_selection ();
- Evoral::Beats earliest_in_selection ();
+ Temporal::Beats earliest_in_selection ();
void move_selection(double dx, double dy, double cumulative_dy);
void note_dropped (NoteBase* ev, double d_qn, int8_t d_note, bool copy);
NoteBase* copy_selection (NoteBase* primary);
samplepos_t snap_pixel_to_sample(double x, bool ensure_snap = false);
/** Convert a timestamp in beats into samples (both relative to region position) */
- samplepos_t region_beats_to_region_samples(Evoral::Beats beats) const;
+ samplepos_t region_beats_to_region_samples(Temporal::Beats beats) const;
/** Convert a timestamp in beats into absolute samples */
- samplepos_t region_beats_to_absolute_samples(Evoral::Beats beats) const {
+ samplepos_t region_beats_to_absolute_samples(Temporal::Beats beats) const {
return _region->position() + region_beats_to_region_samples (beats);
}
/** Convert a timestamp in samples to beats (both relative to region position) */
- Evoral::Beats region_samples_to_region_beats(samplepos_t) const;
+ Temporal::Beats region_samples_to_region_beats(samplepos_t) const;
double region_samples_to_region_beats_double(samplepos_t) const;
/** Convert a timestamp in beats measured from source start into absolute samples */
- samplepos_t source_beats_to_absolute_samples(Evoral::Beats beats) const;
+ samplepos_t source_beats_to_absolute_samples(Temporal::Beats beats) const;
/** Convert a timestamp in beats measured from source start into region-relative samples */
- samplepos_t source_beats_to_region_samples(Evoral::Beats beats) const {
+ samplepos_t source_beats_to_region_samples(Temporal::Beats beats) const {
return source_beats_to_absolute_samples (beats) - _region->position();
}
/** Convert a timestamp in absolute samples to beats measured from source start*/
- Evoral::Beats absolute_samples_to_source_beats(samplepos_t) const;
+ Temporal::Beats absolute_samples_to_source_beats(samplepos_t) const;
ARDOUR::BeatsSamplesConverter const & region_relative_time_converter () const {
return _region_relative_time_converter;
void goto_previous_note (bool add_to_selection);
void goto_next_note (bool add_to_selection);
- void change_note_lengths (bool, bool, Evoral::Beats beats, bool start, bool end);
+ void change_note_lengths (bool, bool, Temporal::Beats beats, bool start, bool end);
void change_velocities (bool up, bool fine, bool allow_smush, bool all_together);
void transpose (bool up, bool fine, bool allow_smush);
void nudge_notes (bool forward, bool fine);
* \param state the keyboard modifier mask for the canvas event (click).
* \param shift_snap true alters snap behavior to round down always (false if the gui has already done that).
*/
- void create_note_at (samplepos_t t, double y, Evoral::Beats length, uint32_t state, bool shift_snap);
+ void create_note_at (samplepos_t t, double y, Temporal::Beats length, uint32_t state, bool shift_snap);
/** An external request to clear the note selection, remove MRV from editor
* selection.
double _last_ghost_x;
double _last_ghost_y;
ArdourCanvas::Rectangle* _step_edit_cursor;
- Evoral::Beats _step_edit_cursor_width;
- Evoral::Beats _step_edit_cursor_position;
+ Temporal::Beats _step_edit_cursor_width;
+ Temporal::Beats _step_edit_cursor_position;
NoteBase* _channel_selection_scoped_note;
MouseState _mouse_state;
void drop_down_keys ();
void maybe_select_by_position (GdkEventButton* ev, double x, double y);
- void get_events (Events& e, Evoral::Sequence<Evoral::Beats>::NoteOperator op, uint8_t val, int chan_mask = 0);
+ void get_events (Events& e, Evoral::Sequence<Temporal::Beats>::NoteOperator op, uint8_t val, int chan_mask = 0);
void display_patch_changes_on_channel (uint8_t, bool);
void data_recorded (boost::weak_ptr<ARDOUR::MidiSource>);
/** Get grid type as beats, or default to 1 if not snapped to beats. */
- Evoral::Beats get_grid_beats(samplepos_t pos) const;
+ Temporal::Beats get_grid_beats(samplepos_t pos) const;
void remove_ghost_note ();
void mouse_mode_changed ();
Gtkmm2ext::Color _patch_change_outline;
Gtkmm2ext::Color _patch_change_fill;
- Evoral::Beats snap_sample_to_grid_underneath (samplepos_t p, int32_t divisions, bool shift_snap) const;
+ Temporal::Beats snap_sample_to_grid_underneath (samplepos_t p, int32_t divisions, bool shift_snap) const;
PBD::ScopedConnection _mouse_mode_connection;
}
void
-MidiTimeAxisView::get_per_region_note_selection (list<pair<PBD::ID, set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > >& selection)
+MidiTimeAxisView::get_per_region_note_selection (list<pair<PBD::ID, set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > > >& selection)
{
_view->foreach_regionview (
sigc::bind (sigc::mem_fun (*this, &MidiTimeAxisView::get_per_region_note_selection_region_view), sigc::ref(selection)));
}
void
-MidiTimeAxisView::get_per_region_note_selection_region_view (RegionView* rv, list<pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > > &selection)
+MidiTimeAxisView::get_per_region_note_selection_region_view (RegionView* rv, list<pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > > > &selection)
{
- Evoral::Sequence<Evoral::Beats>::Notes selected;
+ Evoral::Sequence<Temporal::Beats>::Notes selected;
dynamic_cast<MidiRegionView*>(rv)->selection_as_notelist (selected, false);
- std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > notes;
+ std::set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > notes;
- Evoral::Sequence<Evoral::Beats>::Notes::iterator sel_it;
+ Evoral::Sequence<Temporal::Beats>::Notes::iterator sel_it;
for (sel_it = selected.begin(); sel_it != selected.end(); ++sel_it) {
notes.insert (*sel_it);
}
uint8_t get_channel_for_add () const;
- void get_per_region_note_selection (std::list<std::pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > >&);
+ void get_per_region_note_selection (std::list<std::pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > > >&);
protected:
void start_step_editing ();
void add_note_selection_region_view (RegionView* rv, uint8_t note, uint16_t chn_mask);
void extend_note_selection_region_view (RegionView*, uint8_t note, uint16_t chn_mask);
void toggle_note_selection_region_view (RegionView*, uint8_t note, uint16_t chn_mask);
- void get_per_region_note_selection_region_view (RegionView*, std::list<std::pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > >&);
+ void get_per_region_note_selection_region_view (RegionView*, std::list<std::pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > > >&);
void ensure_step_editor ();
class Note : public NoteBase
{
public:
- typedef Evoral::Note<Evoral::Beats> NoteType;
+ typedef Evoral::Note<Temporal::Beats> NoteType;
Note (MidiRegionView& region,
ArdourCanvas::Item* parent,
#include <boost/shared_ptr.hpp>
+#include "temporal/beats.h"
#include "canvas/types.h"
#include "rgb_macros.h"
class NoteBase : public sigc::trackable
{
public:
- typedef Evoral::Note<Evoral::Beats> NoteType;
+ typedef Evoral::Note<Temporal::Beats> NoteType;
NoteBase (MidiRegionView& region, bool, const boost::shared_ptr<NoteType> note = boost::shared_ptr<NoteType>());
virtual ~NoteBase ();
class NotePlayer : public sigc::trackable {
public:
- typedef Evoral::Note<Evoral::Beats> NoteType;
+ typedef Evoral::Note<Temporal::Beats> NoteType;
NotePlayer (boost::shared_ptr<ARDOUR::MidiTrack>);
~NotePlayer ();
PatchChangeDialog::PatchChangeDialog (
const ARDOUR::BeatsSamplesConverter* tc,
ARDOUR::Session* session,
- Evoral::PatchChange<Evoral::Beats> const & patch,
+ Evoral::PatchChange<Temporal::Beats> const & patch,
ARDOUR::InstrumentInfo& info,
const Gtk::BuiltinStockID& ok,
bool allow_delete,
fill_patch_combo ();
}
-Evoral::PatchChange<Evoral::Beats>
+Evoral::PatchChange<Temporal::Beats>
PatchChangeDialog::patch () const
{
- Evoral::Beats t = Evoral::Beats();
+ Temporal::Beats t = Temporal::Beats();
if (_time_converter) {
t = _time_converter->from (_time.current_time ());
}
- return Evoral::PatchChange<Evoral::Beats> (
+ return Evoral::PatchChange<Temporal::Beats> (
t,
_channel.get_value_as_int() - 1,
_program.get_value_as_int() - 1,
PatchChangeDialog (
const ARDOUR::BeatsSamplesConverter *,
ARDOUR::Session *,
- Evoral::PatchChange<Evoral::Beats> const &,
+ Evoral::PatchChange<Temporal::Beats> const &,
ARDOUR::InstrumentInfo&,
const Gtk::BuiltinStockID &,
bool allow_delete = false,
bool modal = true
);
- Evoral::PatchChange<Evoral::Beats> patch () const;
+ Evoral::PatchChange<Temporal::Beats> patch () const;
protected:
void on_response (int);
#include <gtkmm/notebook.h>
#include <sigc++/signal.h>
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "evoral/Note.hpp"
#include "pbd/statefuldestructible.h"
virtual samplecnt_t get_nudge_distance (samplepos_t pos, samplecnt_t& next) = 0;
virtual samplecnt_t get_paste_offset (samplepos_t pos, unsigned paste_count, samplecnt_t duration) = 0;
virtual unsigned get_grid_beat_divisions(samplepos_t position) = 0;
- virtual Evoral::Beats get_grid_type_as_beats (bool& success, samplepos_t position) = 0;
+ virtual Temporal::Beats get_grid_type_as_beats (bool& success, samplepos_t position) = 0;
virtual int32_t get_grid_music_divisions (uint32_t event_state) = 0;
virtual void edit_notes (MidiRegionView*) = 0;
virtual void get_regions_after (RegionSelection&, samplepos_t where, const TrackViewList& ts) const = 0;
virtual RegionSelection get_regions_from_selection_and_mouse (samplepos_t) = 0;
virtual void get_regionviews_by_id (PBD::ID const id, RegionSelection & regions) const = 0;
- virtual void get_per_region_note_selection (std::list<std::pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > >&) const = 0;
+ virtual void get_per_region_note_selection (std::list<std::pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > > >&) const = 0;
virtual void mouse_add_new_tempo_event (samplepos_t where) = 0;
virtual void mouse_add_new_meter_event (samplepos_t where) = 0;
if (txt == _("main grid")) {
bool success;
- Evoral::Beats b = editor.get_grid_type_as_beats (success, 0);
+ Temporal::Beats b = editor.get_grid_type_as_beats (success, 0);
if (!success) {
return 1.0;
}
}
/* midi region views have thir own internal selection. */
- list<pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > > rid_notes;
+ list<pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > > > rid_notes;
editor->get_per_region_note_selection (rid_notes);
- list<pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > > > >::iterator rn_it;
+ list<pair<PBD::ID, std::set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > > > >::iterator rn_it;
for (rn_it = rid_notes.begin(); rn_it != rid_notes.end(); ++rn_it) {
XMLNode* n = node->add_child (X_("MIDINotes"));
n->set_property (X_("region-id"), (*rn_it).first);
- for (std::set<boost::shared_ptr<Evoral::Note<Evoral::Beats> > >::iterator i = (*rn_it).second.begin(); i != (*rn_it).second.end(); ++i) {
+ for (std::set<boost::shared_ptr<Evoral::Note<Temporal::Beats> > >::iterator i = (*rn_it).second.begin(); i != (*rn_it).second.end(); ++i) {
XMLNode* nc = n->add_child(X_("note"));
nc->set_property(X_("note-id"), (*i)->id());
}
step_edit_insert_position = 0;
_step_edit_triplet_countdown = 0;
_step_edit_within_chord = 0;
- _step_edit_chord_duration = Evoral::Beats();
+ _step_edit_chord_duration = Temporal::Beats();
step_edit_region_view = 0;
_track->PlaylistChanged.connect (*this, invalidator (*this),
{
_step_edit_triplet_countdown = 0;
_step_edit_within_chord = 0;
- _step_edit_chord_duration = Evoral::Beats();
+ _step_edit_chord_duration = Temporal::Beats();
step_edit_region.reset ();
step_edit_region_view = 0;
last_added_pitch = -1;
- last_added_end = Evoral::Beats();
+ last_added_end = Temporal::Beats();
resync_step_edit_position ();
prepare_step_edit_region ();
incoming.read_contents (size, buf);
if ((buf[0] & 0xf0) == MIDI_CMD_NOTE_ON) {
- step_add_note (buf[0] & 0xf, buf[1], buf[2], Evoral::Beats());
+ step_add_note (buf[0] & 0xf, buf[1], buf[2], Temporal::Beats());
}
}
}
}
void
-StepEditor::step_edit_sustain (Evoral::Beats beats)
+StepEditor::step_edit_sustain (Temporal::Beats beats)
{
if (step_edit_region_view) {
step_edit_region_view->step_sustain (beats);
}
void
-StepEditor::move_step_edit_beat_pos (Evoral::Beats beats)
+StepEditor::move_step_edit_beat_pos (Temporal::Beats beats)
{
if (!step_edit_region_view) {
return;
if (-beats < step_edit_beat_pos) {
step_edit_beat_pos += beats; // its negative, remember
} else {
- step_edit_beat_pos = Evoral::Beats();
+ step_edit_beat_pos = Temporal::Beats();
}
}
step_edit_region_view->move_step_edit_cursor (step_edit_beat_pos);
}
int
-StepEditor::step_add_note (uint8_t channel, uint8_t pitch, uint8_t velocity, Evoral::Beats beat_duration)
+StepEditor::step_add_note (uint8_t channel, uint8_t pitch, uint8_t velocity, Temporal::Beats beat_duration)
{
/* do these things in case undo removed the step edit region
*/
_editor.reset_x_origin (fpos - (_editor.current_page_samples()/4));
}
- Evoral::Beats at = step_edit_beat_pos;
- Evoral::Beats len = beat_duration;
+ Temporal::Beats at = step_edit_beat_pos;
+ Temporal::Beats len = beat_duration;
if ((last_added_pitch >= 0) && (pitch == last_added_pitch) && (last_added_end == step_edit_beat_pos)) {
up by 1 tick from where the last note ended
*/
- at += Evoral::Beats::ticks(1);
- len -= Evoral::Beats::ticks(1);
+ at += Temporal::Beats::ticks(1);
+ len -= Temporal::Beats::ticks(1);
}
step_edit_region_view->step_add_note (channel, pitch, velocity, at, len);
step_edit_beat_pos += beat_duration;
step_edit_region_view->move_step_edit_cursor (step_edit_beat_pos);
} else {
- step_edit_beat_pos += Evoral::Beats::ticks(1); // tiny, but no longer overlapping
+ step_edit_beat_pos += Temporal::Beats::ticks(1); // tiny, but no longer overlapping
_step_edit_chord_duration = max (_step_edit_chord_duration, beat_duration);
}
}
void
-StepEditor::set_step_edit_cursor_width (Evoral::Beats beats)
+StepEditor::set_step_edit_cursor_width (Temporal::Beats beats)
{
if (step_edit_region_view) {
step_edit_region_view->set_step_edit_cursor_width (beats);
}
void
-StepEditor::step_edit_rest (Evoral::Beats beats)
+StepEditor::step_edit_rest (Temporal::Beats beats)
{
bool success;
step_edit_region.reset();
step_edit_region_view = 0;
// force a recompute of the insert position
- step_edit_beat_pos = Evoral::Beats(-1);
+ step_edit_beat_pos = Temporal::Beats(-1);
}
}
#include <sigc++/trackable.h>
#include "pbd/signals.h"
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
namespace ARDOUR {
class MidiTrack;
virtual ~StepEditor ();
void check_step_edit ();
- void step_edit_rest (Evoral::Beats beats);
+ void step_edit_rest (Temporal::Beats beats);
void step_edit_beat_sync ();
void step_edit_bar_sync ();
int step_add_bank_change (uint8_t channel, uint8_t bank);
int step_add_program_change (uint8_t channel, uint8_t program);
int step_add_note (uint8_t channel, uint8_t pitch, uint8_t velocity,
- Evoral::Beats beat_duration);
- void step_edit_sustain (Evoral::Beats beats);
+ Temporal::Beats beat_duration);
+ void step_edit_sustain (Temporal::Beats beats);
bool step_edit_within_triplet () const;
void step_edit_toggle_triplet ();
bool step_edit_within_chord () const;
void step_edit_toggle_chord ();
void reset_step_edit_beat_pos ();
void resync_step_edit_to_edit_point ();
- void move_step_edit_beat_pos (Evoral::Beats beats);
- void set_step_edit_cursor_width (Evoral::Beats beats);
+ void move_step_edit_beat_pos (Temporal::Beats beats);
+ void set_step_edit_cursor_width (Temporal::Beats beats);
std::string name() const;
private:
ARDOUR::samplepos_t step_edit_insert_position;
- Evoral::Beats step_edit_beat_pos;
+ Temporal::Beats step_edit_beat_pos;
boost::shared_ptr<ARDOUR::MidiRegion> step_edit_region;
MidiRegionView* step_edit_region_view;
uint8_t _step_edit_triplet_countdown;
bool _step_edit_within_chord;
- Evoral::Beats _step_edit_chord_duration;
+ Temporal::Beats _step_edit_chord_duration;
PBD::ScopedConnection step_edit_region_connection;
PublicEditor& _editor;
boost::shared_ptr<ARDOUR::MidiTrack> _track;
StepEntry* step_editor;
MidiTimeAxisView& _mtv;
int8_t last_added_pitch;
- Evoral::Beats last_added_end;
+ Temporal::Beats last_added_end;
void region_removed (boost::weak_ptr<ARDOUR::Region>);
void playlist_changed ();
void
StepEntry::rest_event_handler ()
{
- se->step_edit_rest (Evoral::Beats());
+ se->step_edit_rest (Temporal::Beats());
}
-Evoral::Beats
+Temporal::Beats
StepEntry::note_length ()
{
double base_time = 4.0 / (double) length_divisor_adjustment.get_value();
base_time *= 1 + ((dots - 1.0)/dots);
}
- return Evoral::Beats(base_time);
+ return Temporal::Beats(base_time);
}
uint8_t
void
StepEntry::insert_grid_rest ()
{
- se->step_edit_rest (Evoral::Beats());
+ se->step_edit_rest (Temporal::Beats());
}
void
void note_off_event_handler (int note);
void rest_event_handler ();
- Evoral::Beats note_length();
+ Temporal::Beats note_length();
uint8_t note_velocity() const;
uint8_t note_channel() const;
int current_octave () const { return (int) floor (octave_adjustment.get_value()); }
private:
- Evoral::Beats _current_note_length;
+ Temporal::Beats _current_note_length;
uint8_t _current_note_velocity;
Gtk::VBox packer;
/* draw line with alpha corresponding to coarsest level */
const uint8_t a = max(8, (int)rint(UINT_RGBA_A(base) / (0.8 * log2(level))));
const uint32_t c = UINT_RGBA_CHANGE_A(base, a);
- const samplepos_t f = _bfc->to (Evoral::Beats (grid.begin()->qn + (l / (double) divisions))) + _bfc->origin_b();
+ const samplepos_t f = _bfc->to (Temporal::Beats (grid.begin()->qn + (l / (double) divisions))) + _bfc->origin_b();
if (f > leftmost_sample) {
lines.add (PublicEditor::instance().sample_to_pixel_unrounded (f), 1.0, c);
item_duration = duration;
name_connected = false;
position_locked = false;
- max_item_duration = ARDOUR::max_samplepos;
+ max_item_duration = Temporal::max_samplepos;
min_item_duration = 0;
visibility = vis;
_sensitive = true;
return (xjadeo_settings[k]);
}
-#define NO_OFFSET (ARDOUR::max_samplepos) //< skip setting or modifying offset
+#define NO_OFFSET (Temporal::max_samplepos) //< skip setting or modifying offset
void
VideoMonitor::srsupdate ()
{
'libpbd',
'libardour',
'libardour_cp',
- 'libtimecode',
+ 'libtemporal',
'libmidipp',
'libgtkmm2ext',
'libcanvas',
# 'libpbd',
# 'libardour',
# 'libardour_cp',
-# 'libtimecode',
+# 'libtemporal',
# 'libmidipp',
# 'libgtkmm2ext',
# 'libcanvas',
'libmidipp',
'libardour',
'libardour_cp',
- 'libtimecode',
+ 'libtemporal',
'libmidipp',
'libgtk2_ardour',
'libgtkmm2ext',
obj.use = [ 'libpbd',
'libardour',
'libardour_cp',
- 'libtimecode',
+ 'libtemporal',
'libmidipp',
'libgtkmm2ext',
'libcanvas',
obj.use = [ 'libpbd',
'libardour',
'libardour_cp',
- 'libtimecode',
+ 'libtemporal',
'libmidipp',
]
#include "ardour/route.h"
#include "ardour/session.h"
-#include "timecode/time.h"
+#include "temporal/time.h"
#include "audiographer/process_context.h"
#include "audiographer/general/chunker.h"
$Id: midiregion.h 733 2006-08-01 17:19:38Z drobilla $
*/
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "evoral/TimeConverter.hpp"
#include "ardour/libardour_visibility.h"
* them to the opposite unit, taking tempo changes into account.
*/
class LIBARDOUR_API BeatsSamplesConverter
- : public Evoral::TimeConverter<Evoral::Beats,samplepos_t> {
+ : public Evoral::TimeConverter<Temporal::Beats,samplepos_t> {
public:
BeatsSamplesConverter (const TempoMap& tempo_map, samplepos_t origin)
- : Evoral::TimeConverter<Evoral::Beats, samplepos_t> (origin)
+ : Evoral::TimeConverter<Temporal::Beats, samplepos_t> (origin)
, _tempo_map(tempo_map)
{}
- samplepos_t to (Evoral::Beats beats) const;
- Evoral::Beats from (samplepos_t samples) const;
+ samplepos_t to (Temporal::Beats beats) const;
+ Temporal::Beats from (samplepos_t samples) const;
private:
const TempoMap& _tempo_map;
#include "pbd/enum_convert.h"
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "evoral/ControlList.hpp"
namespace PBD {
DEFINE_ENUM_CONVERT(Evoral::ControlList::InterpolationStyle)
template <>
-inline bool to_string (Evoral::Beats beats, std::string& str)
+inline bool to_string (Temporal::Beats beats, std::string& str)
{
return double_to_string (beats.to_double (), str);
}
template <>
-inline bool string_to (const std::string& str, Evoral::Beats& beats)
+inline bool string_to (const std::string& str, Temporal::Beats& beats)
{
double tmp;
if (!string_to_double (str, tmp)) {
return false;
}
- beats = Evoral::Beats(tmp);
+ beats = Temporal::Beats(tmp);
return true;
}
template <>
-inline std::string to_string (Evoral::Beats beats)
+inline std::string to_string (Temporal::Beats beats)
{
std::string tmp;
double_to_string (beats.to_double (), tmp);
}
template <>
-inline Evoral::Beats string_to (const std::string& str)
+inline Temporal::Beats string_to (const std::string& str)
{
double tmp;
string_to_double (str, tmp);
- return Evoral::Beats (tmp);
+ return Temporal::Beats (tmp);
}
} // namespace PBD
Legatize(bool shrink_only);
~Legatize();
- typedef Evoral::Sequence<Evoral::Beats>::Notes Notes;
+ typedef Evoral::Sequence<Temporal::Beats>::Notes Notes;
Command* operator()(boost::shared_ptr<ARDOUR::MidiModel> model,
- Evoral::Beats position,
+ Temporal::Beats position,
std::vector<Notes>& seqs);
std::string name () const { return (_shrink_only ? std::string ("remove overlap") : std::string ("legatize")); }
};
- boost::shared_ptr<Evoral::Note<Evoral::Beats> >
- new_noteptr (uint8_t, Evoral::Beats, Evoral::Beats, uint8_t, uint8_t);
+ boost::shared_ptr<Evoral::Note<Temporal::Beats> >
+ new_noteptr (uint8_t, Temporal::Beats, Temporal::Beats, uint8_t, uint8_t);
- std::list<boost::shared_ptr< Evoral::Note<Evoral::Beats> > >
+ std::list<boost::shared_ptr< Evoral::Note<Temporal::Beats> > >
note_list (boost::shared_ptr<ARDOUR::MidiModel>);
} } /* namespace */
#include <boost/utility.hpp>
#include "ardour/types.h"
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "evoral/Sequence.hpp"
#include "pbd/signals.h"
last_read_end = 0;
}
- Evoral::Sequence<Evoral::Beats>::const_iterator iter;
- std::set<Evoral::Sequence<Evoral::Beats>::WeakNotePtr> active_notes;
+ Evoral::Sequence<Temporal::Beats>::const_iterator iter;
+ std::set<Evoral::Sequence<Temporal::Beats>::WeakNotePtr> active_notes;
samplepos_t last_read_end;
PBD::ScopedConnectionList connections;
};
* Because of this MIDI controllers and automatable controllers/widgets/etc
* are easily interchangeable.
*/
-class LIBARDOUR_API MidiModel : public AutomatableSequence<Evoral::Beats> {
+class LIBARDOUR_API MidiModel : public AutomatableSequence<Temporal::Beats> {
public:
- typedef Evoral::Beats TimeType;
+ typedef Temporal::Beats TimeType;
MidiModel (boost::shared_ptr<MidiSource>);
bool write_section_to(boost::shared_ptr<MidiSource> source,
const Glib::Threads::Mutex::Lock& source_lock,
- Evoral::Beats begin = Evoral::Beats(),
- Evoral::Beats end = std::numeric_limits<Evoral::Beats>::max(),
+ Temporal::Beats begin = Temporal::Beats(),
+ Temporal::Beats end = std::numeric_limits<Temporal::Beats>::max(),
bool offset_events = false);
// MidiModel doesn't use the normal AutomationList serialisation code
#include <vector>
#include <string>
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "evoral/Sequence.hpp"
class Command;
virtual ~MidiOperator() {}
virtual Command* operator() (boost::shared_ptr<ARDOUR::MidiModel>,
- Evoral::Beats,
- std::vector<Evoral::Sequence<Evoral::Beats>::Notes>&) = 0;
+ Temporal::Beats,
+ std::vector<Evoral::Sequence<Temporal::Beats>::Notes>&) = 0;
virtual std::string name() const = 0;
};
void region_going_away (boost::weak_ptr<Region> region);
private:
- typedef Evoral::Note<Evoral::Beats> Note;
+ typedef Evoral::Note<Temporal::Beats> Note;
typedef Evoral::Event<samplepos_t> Event;
struct RegionTracker : public boost::noncopyable {
XMLNode& get_state ();
int set_state (const XMLNode&, int version);
- void append_event_beats(const Glib::Threads::Mutex::Lock& lock, const Evoral::Event<Evoral::Beats>& ev);
+ void append_event_beats(const Glib::Threads::Mutex::Lock& lock, const Evoral::Event<Temporal::Beats>& ev);
void append_event_samples(const Glib::Threads::Mutex::Lock& lock, const Evoral::Event<samplepos_t>& ev, samplepos_t source_start);
void load_model(const Glib::Threads::Mutex::Lock& lock, bool force_reload=false);
void destroy_model(const Glib::Threads::Mutex::Lock& lock);
#include <vector>
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "evoral/Range.hpp"
#include "pbd/string_convert.h"
class LIBARDOUR_API MidiSource : virtual public Source, public boost::enable_shared_from_this<MidiSource>
{
public:
- typedef Evoral::Beats TimeType;
+ typedef Temporal::Beats TimeType;
MidiSource (Session& session, std::string name, Source::Flag flags = Source::Flag(0));
MidiSource (Session& session, const XMLNode&);
*/
int write_to (const Lock& lock,
boost::shared_ptr<MidiSource> newsrc,
- Evoral::Beats begin = Evoral::Beats(),
- Evoral::Beats end = std::numeric_limits<Evoral::Beats>::max());
+ Temporal::Beats begin = Temporal::Beats(),
+ Temporal::Beats end = std::numeric_limits<Temporal::Beats>::max());
/** Export the midi data in the given time range to another MidiSource
* \param newsrc MidiSource to which data will be written. Should be a
*/
int export_write_to (const Lock& lock,
boost::shared_ptr<MidiSource> newsrc,
- Evoral::Beats begin,
- Evoral::Beats end);
+ Temporal::Beats begin,
+ Temporal::Beats end);
/** Read the data in a given time range from the MIDI source.
* All time stamps in parameters are in audio samples (even if the source has tempo time).
* Caller must ensure that the event is later than the last written event.
*/
virtual void append_event_beats(const Lock& lock,
- const Evoral::Event<Evoral::Beats>& ev) = 0;
+ const Evoral::Event<Temporal::Beats>& ev) = 0;
/** Append a single event with a timestamp in samples.
*
*/
virtual void mark_midi_streaming_write_completed (
const Lock& lock,
- Evoral::Sequence<Evoral::Beats>::StuckNoteOption stuck_option,
- Evoral::Beats when = Evoral::Beats());
+ Evoral::Sequence<Temporal::Beats>::StuckNoteOption stuck_option,
+ Temporal::Beats when = Temporal::Beats());
virtual void session_saved();
boost::shared_ptr<MidiModel> _model;
bool _writing;
- Evoral::Beats _length_beats;
+ Temporal::Beats _length_beats;
/** The total duration of the current capture. */
samplepos_t _capture_length;
#include <glibmm/threads.h>
+#include "temporal/beats.h"
#include "ardour/midi_buffer.h"
namespace Evoral {
void remove (uint8_t note, uint8_t chn);
void resolve_notes (MidiBuffer& buffer, samplepos_t time);
void resolve_notes (Evoral::EventSink<samplepos_t>& buffer, samplepos_t time);
- void resolve_notes (MidiSource& src, const Glib::Threads::Mutex::Lock& lock, Evoral::Beats time);
+ void resolve_notes (MidiSource& src, const Glib::Threads::Mutex::Lock& lock, Temporal::Beats time);
void dump (std::ostream&);
void reset ();
bool empty() const { return _on == 0; }
#include "ardour/midi_model.h"
#include "ardour/types.h"
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "evoral/Note.hpp"
namespace Evoral { template<typename Time> class EventSink; }
class NoteFixer : public boost::noncopyable
{
public:
- typedef Evoral::Note<Evoral::Beats> Note;
+ typedef Evoral::Note<Temporal::Beats> Note;
~NoteFixer();
typedef std::list<Event*> Events;
/** Copy a beats event to a samples event with the given time stamp. */
- Event* copy_event(samplepos_t time, const Evoral::Event<Evoral::Beats>& ev);
+ Event* copy_event(samplepos_t time, const Evoral::Event<Temporal::Beats>& ev);
/** Return true iff `note` is active at `pos`. */
bool note_is_active(const BeatsSamplesConverter& converter,
~Quantize ();
Command* operator() (boost::shared_ptr<ARDOUR::MidiModel>,
- Evoral::Beats position,
- std::vector<Evoral::Sequence<Evoral::Beats>::Notes>&);
+ Temporal::Beats position,
+ std::vector<Evoral::Sequence<Temporal::Beats>::Notes>&);
std::string name() const { return std::string ("quantize"); }
private:
#include "midi++/types.h"
#include "midi++/mmc.h"
-#include "timecode/time.h"
+#include "temporal/time.h"
#include "ardour/ardour.h"
#include "ardour/chan_count.h"
#include "pbd/signals.h"
-#include "timecode/time.h"
+#include "temporal/time.h"
#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
return safe_midi_file_extension(path);
}
- void append_event_beats (const Lock& lock, const Evoral::Event<Evoral::Beats>& ev);
+ void append_event_beats (const Lock& lock, const Evoral::Event<Temporal::Beats>& ev);
void append_event_samples (const Lock& lock, const Evoral::Event<samplepos_t>& ev, samplepos_t source_start);
void mark_streaming_midi_write_started (const Lock& lock, NoteMode mode);
void mark_streaming_write_completed (const Lock& lock);
void mark_midi_streaming_write_completed (const Lock& lock,
- Evoral::Sequence<Evoral::Beats>::StuckNoteOption,
- Evoral::Beats when = Evoral::Beats());
+ Evoral::Sequence<Temporal::Beats>::StuckNoteOption,
+ Temporal::Beats when = Temporal::Beats());
XMLNode& get_state ();
int set_state (const XMLNode&, int version);
private:
bool _open;
- Evoral::Beats _last_ev_time_beats;
+ Temporal::Beats _last_ev_time_beats;
samplepos_t _last_ev_time_samples;
/** end time (start + duration) of last call to read_unlocked */
mutable samplepos_t _smf_last_read_end;
#include "pbd/stateful.h"
#include "pbd/statefuldestructible.h"
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "ardour/ardour.h"
that align with the grid formed by tempo and meter sections.
They SHOULD NOT be used to determine the position of events
- whose location is canonically defined in Evoral::Beats.
+ whose location is canonically defined in Temporal::Beats.
*/
double beat_at_sample (const samplecnt_t sample) const;
when tempo matters but meter does not.
They SHOULD be used to determine the position of events
- whose location is canonically defined in Evoral::Beats.
+ whose location is canonically defined in Temporal::Beats.
*/
- samplepos_t samplepos_plus_qn (samplepos_t, Evoral::Beats) const;
- Evoral::Beats framewalk_to_qn (samplepos_t pos, samplecnt_t distance) const;
+ samplepos_t samplepos_plus_qn (samplepos_t, Temporal::Beats) const;
+ Temporal::Beats framewalk_to_qn (samplepos_t pos, samplecnt_t distance) const;
/* quarter note related functions are also tempo-sensitive and ignore meter.
- quarter notes may be compared with and assigned to Evoral::Beats.
+ quarter notes may be compared with and assigned to Temporal::Beats.
*/
double quarter_note_at_sample (const samplepos_t sample) const;
double quarter_note_at_sample_rt (const samplepos_t sample) const;
#ifndef __libardour_timecode_h__
#define __libardour_timecode_h__
-#include "timecode/time.h"
+#include "temporal/time.h"
#endif // __libardour_timecode_h__
*/
class LIBARDOUR_API Transform : public MidiOperator {
public:
- typedef Evoral::Sequence<Evoral::Beats>::NotePtr NotePtr;
- typedef Evoral::Sequence<Evoral::Beats>::Notes Notes;
+ typedef Evoral::Sequence<Temporal::Beats>::NotePtr NotePtr;
+ typedef Evoral::Sequence<Temporal::Beats>::Notes Notes;
typedef ARDOUR::MidiModel::NoteDiffCommand::Property Property;
/** Context while iterating over notes during transformation. */
Transform(const Program& prog);
Command* operator()(boost::shared_ptr<ARDOUR::MidiModel> model,
- Evoral::Beats position,
+ Temporal::Beats position,
std::vector<Notes>& seqs);
std::string name() const { return std::string ("transform"); }
class LIBARDOUR_API Transpose : public MidiOperator {
public:
- typedef Evoral::Sequence<Evoral::Beats>::NotePtr NotePtr;
- typedef Evoral::Sequence<Evoral::Beats>::Notes Notes;
+ typedef Evoral::Sequence<Temporal::Beats>::NotePtr NotePtr;
+ typedef Evoral::Sequence<Temporal::Beats>::Notes Notes;
Transpose (int semitones);
Command* operator() (boost::shared_ptr<ARDOUR::MidiModel> model,
- Evoral::Beats position,
+ Temporal::Beats position,
std::vector<Notes>& seqs);
std::string name () const { return std::string ("transpose"); }
#include <inttypes.h>
-#include "timecode/bbt_time.h"
-#include "timecode/time.h"
+#include "temporal/bbt_time.h"
+#include "temporal/time.h"
+#include "temporal/types.h"
#include "pbd/id.h"
#include <map>
+using Temporal::max_samplepos;
+using Temporal::max_samplecnt;
+
#if __GNUC__ < 3
typedef int intptr_t;
#endif
typedef uint64_t microseconds_t;
typedef uint32_t pframes_t;
- /* Any position measured in audio samples.
- Assumed to be non-negative but not enforced.
- */
- typedef int64_t samplepos_t;
-
- /* Any distance from a given samplepos_t.
- Maybe positive or negative.
- */
- typedef int64_t sampleoffset_t;
-
- /* Any count of audio samples.
- Assumed to be positive but not enforced.
- */
- typedef int64_t samplecnt_t;
+ /* rebind Temporal position types into ARDOUR namespace */
+ typedef Temporal::samplecnt_t samplecnt_t;
+ typedef Temporal::samplepos_t samplepos_t;
+ typedef Temporal::sampleoffset_t sampleoffset_t;
- static const samplepos_t max_samplepos = INT64_MAX;
- static const samplecnt_t max_samplecnt = INT64_MAX;
static const layer_t max_layer = UINT32_MAX;
// a set of (time) intervals: first of pair is the offset of the start within the region, second is the offset of the end
} // namespace ARDOUR
-static inline ARDOUR::samplepos_t
-session_sample_to_track_sample (ARDOUR::samplepos_t session_sample, double speed)
-{
- long double result = (long double) session_sample * (long double) speed;
-
- if (result >= (long double) ARDOUR::max_samplepos) {
- return ARDOUR::max_samplepos;
- } else if (result <= (long double) (ARDOUR::max_samplepos) * (ARDOUR::samplepos_t)(-1)) {
- return (ARDOUR::max_samplepos * (ARDOUR::samplepos_t)(-1));
- } else {
- return result;
- }
-}
-
-static inline ARDOUR::samplepos_t
-track_sample_to_session_sample (ARDOUR::samplepos_t track_sample, double speed)
-{
- /* NB - do we need a check for speed == 0 ??? */
- long double result = (long double) track_sample / (long double) speed;
-
- if (result >= (long double) ARDOUR::max_samplepos) {
- return ARDOUR::max_samplepos;
- } else if (result <= (long double) (ARDOUR::max_samplepos) * (ARDOUR::samplepos_t)(-1)) {
- return (ARDOUR::max_samplepos * (ARDOUR::samplepos_t)(-1));
- } else {
- return result;
- }
-}
-
/* for now, break the rules and use "using" to make this "global" */
using ARDOUR::samplepos_t;
-
#endif /* __ardour_types_h__ */
#include <stdexcept>
#include "ardour/libardour_visibility.h"
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "pbd/compose.h"
namespace ARDOUR {
explicit Variant(int32_t value) : _type(INT) { _int = value; }
explicit Variant(int64_t value) : _type(LONG) { _long = value; }
- explicit Variant(const Evoral::Beats& beats)
+ explicit Variant(const Temporal::Beats& beats)
: _type(BEATS)
, _beats(beats)
{}
std::min(value, (double)INT64_MAX)));
break;
case BEATS:
- _beats = Evoral::Beats(value);
+ _beats = Temporal::Beats(value);
break;
default:
_type = NOTHING;
return false;
}
- bool operator==(const Evoral::Beats& v) const {
+ bool operator==(const Temporal::Beats& v) const {
return _type == BEATS && _beats == v;
}
bool operator!() const { return _type == NOTHING; }
- Variant& operator=(Evoral::Beats v) {
+ Variant& operator=(Temporal::Beats v) {
_type = BEATS;
_beats = v;
return *this;
}
- const Evoral::Beats& get_beats() const {
+ const Temporal::Beats& get_beats() const {
ensure_type(BEATS); return _beats;
}
Type _type; ///< Type tag
std::string _string; ///< PATH, STRING, URI
- Evoral::Beats _beats; ///< BEATS
+ Temporal::Beats _beats; ///< BEATS
// Union of all primitive numeric types
union {
* taking tempo changes into account.
*/
samplepos_t
-BeatsSamplesConverter::to (Evoral::Beats beats) const
+BeatsSamplesConverter::to (Temporal::Beats beats) const
{
- if (beats < Evoral::Beats()) {
+ if (beats < Temporal::Beats()) {
std::cerr << "negative beats passed to BFC: " << beats << std::endl;
PBD::stacktrace (std::cerr, 30);
return 0;
* supplied to the constructor. Returns the equivalent number of quarter-note beats,
* taking tempo changes into account.
*/
-Evoral::Beats
+Temporal::Beats
BeatsSamplesConverter::from (samplepos_t samples) const
{
return _tempo_map.framewalk_to_qn (_origin_b, samples);
PBD::stacktrace (std::cerr, 30);
return 0;
}
- return _tempo_map.samplepos_plus_qn (_origin_b, Evoral::Beats(beats)) - _origin_b;
+ return _tempo_map.samplepos_plus_qn (_origin_b, Temporal::Beats(beats)) - _origin_b;
}
/** As above, but with quarter-note beats in double instead (for GUI). */
/* set length in beats to entire capture length */
BeatsSamplesConverter converter (_session.tempo_map(), capture_info.front()->start);
- const Evoral::Beats total_capture_beats = converter.from (total_capture);
+ const Temporal::Beats total_capture_beats = converter.from (total_capture);
_midi_write_source->set_length_beats (total_capture_beats);
/* flush to disk: this step differs from the audio path,
where all the data is already on disk.
*/
- _midi_write_source->mark_midi_streaming_write_completed (source_lock, Evoral::Sequence<Evoral::Beats>::ResolveStuckNotes, total_capture_beats);
+ _midi_write_source->mark_midi_streaming_write_completed (source_lock, Evoral::Sequence<Temporal::Beats>::ResolveStuckNotes, total_capture_beats);
}
_last_capture_sources.insert (_last_capture_sources.end(), audio_srcs.begin(), audio_srcs.end());
smfs->append_event_beats(
source_lock,
- Evoral::Event<Evoral::Beats>(
+ Evoral::Event<Temporal::Beats>(
Evoral::MIDI_EVENT,
- Evoral::Beats::ticks_at_rate(t, source->ppqn()),
+ Temporal::Beats::ticks_at_rate(t, source->ppqn()),
size,
buf));
/* we wrote something */
const samplepos_t pos = 0;
- const Evoral::Beats length_beats = Evoral::Beats::ticks_at_rate(t, source->ppqn());
+ const Temporal::Beats length_beats = Temporal::Beats::ticks_at_rate(t, source->ppqn());
BeatsSamplesConverter converter(smfs->session().tempo_map(), pos);
smfs->update_length(pos + converter.to(length_beats.round_up_to_beat()));
smfs->mark_streaming_write_completed (source_lock);
Command*
Legatize::operator()(boost::shared_ptr<ARDOUR::MidiModel> model,
- Evoral::Beats position,
+ Temporal::Beats position,
std::vector<Legatize::Notes>& seqs)
{
MidiModel::NoteDiffCommand* cmd = new MidiModel::NoteDiffCommand(model, name ());
break;
}
- const Evoral::Beats new_end = (*next)->time() - Evoral::Beats::tick();
+ const Temporal::Beats new_end = (*next)->time() - Temporal::Beats::tick();
if ((*i)->end_time() > new_end ||
(!_shrink_only && (*i)->end_time() < new_end)) {
- const Evoral::Beats new_length(new_end - (*i)->time());
+ const Temporal::Beats new_length(new_end - (*i)->time());
cmd->change((*i), MidiModel::NoteDiffCommand::Length, new_length);
}
#include "pbd/error.h"
#include "pbd/failed_constructor.h"
-#include "timecode/time.h"
+#include "temporal/time.h"
#include "ardour/ltc_file_reader.h"
#include "pbd/i18n.h"
return _plugin->process (bufs, rt);
}
-boost::shared_ptr<Evoral::Note<Evoral::Beats> >
-LuaAPI::new_noteptr (uint8_t chan, Evoral::Beats beat_time, Evoral::Beats length, uint8_t note, uint8_t velocity)
+boost::shared_ptr<Evoral::Note<Temporal::Beats> >
+LuaAPI::new_noteptr (uint8_t chan, Temporal::Beats beat_time, Temporal::Beats length, uint8_t note, uint8_t velocity)
{
- return boost::shared_ptr<Evoral::Note<Evoral::Beats> > (new Evoral::Note<Evoral::Beats>(chan, beat_time, length, note, velocity));
+ return boost::shared_ptr<Evoral::Note<Temporal::Beats> > (new Evoral::Note<Temporal::Beats>(chan, beat_time, length, note, velocity));
}
-std::list<boost::shared_ptr<Evoral::Note<Evoral::Beats> > >
+std::list<boost::shared_ptr<Evoral::Note<Temporal::Beats> > >
LuaAPI::note_list (boost::shared_ptr<MidiModel> mm)
{
- typedef boost::shared_ptr<Evoral::Note<Evoral::Beats> > NotePtr;
+ typedef boost::shared_ptr<Evoral::Note<Temporal::Beats> > NotePtr;
std::list<NotePtr> note_ptr_list;
#include <glibmm.h>
-#include "timecode/bbt_time.h"
+#include "temporal/bbt_time.h"
#include "pbd/stateful_diff_command.h"
#include "pbd/openuri.h"
#include "evoral/Control.hpp"
CLASSKEYS(PBD::PropertyChange);
CLASSKEYS(PBD::StatefulDestructible);
-CLASSKEYS(Evoral::Beats);
+CLASSKEYS(Temporal::Beats);
CLASSKEYS(Evoral::Event<samplepos_t>);
CLASSKEYS(Evoral::ControlEvent);
CLASSKEYS(boost::shared_ptr<ARDOUR::AudioRegion>);
CLASSKEYS(boost::shared_ptr<ARDOUR::AudioSource>);
CLASSKEYS(boost::shared_ptr<ARDOUR::Automatable>);
-CLASSKEYS(boost::shared_ptr<ARDOUR::AutomatableSequence<Evoral::Beats> >);
+CLASSKEYS(boost::shared_ptr<ARDOUR::AutomatableSequence<Temporal::Beats> >);
CLASSKEYS(boost::shared_ptr<ARDOUR::AutomationList>);
CLASSKEYS(boost::shared_ptr<ARDOUR::FileSource>);
CLASSKEYS(boost::shared_ptr<ARDOUR::MidiModel>);
CLASSKEYS(boost::shared_ptr<ARDOUR::Readable>);
CLASSKEYS(boost::shared_ptr<ARDOUR::Region>);
CLASSKEYS(boost::shared_ptr<Evoral::ControlList>);
-CLASSKEYS(boost::shared_ptr<Evoral::Note<Evoral::Beats> >);
-CLASSKEYS(boost::shared_ptr<Evoral::Sequence<Evoral::Beats> >);
+CLASSKEYS(boost::shared_ptr<Evoral::Note<Temporal::Beats> >);
+CLASSKEYS(boost::shared_ptr<Evoral::Sequence<Temporal::Beats> >);
CLASSKEYS(boost::shared_ptr<ARDOUR::Playlist>);
CLASSKEYS(boost::shared_ptr<ARDOUR::Route>);
.addFunction ("time", (samplepos_t (Evoral::Event<samplepos_t>::*)())&Evoral::Event<samplepos_t>::time)
.endClass ()
- .beginClass <Evoral::Beats> ("Beats")
+ .beginClass <Temporal::Beats> ("Beats")
.addConstructor <void (*) (double)> ()
- .addFunction ("to_double", &Evoral::Beats::to_double)
+ .addFunction ("to_double", &Temporal::Beats::to_double)
.endClass ()
.beginClass <Evoral::Parameter> ("Parameter")
.addData ("to", &Evoral::Range<samplepos_t>::to)
.endClass ()
- .deriveWSPtrClass <Evoral::Sequence<Evoral::Beats>, Evoral::ControlSet> ("Sequence")
+ .deriveWSPtrClass <Evoral::Sequence<Temporal::Beats>, Evoral::ControlSet> ("Sequence")
.endClass ()
- .beginWSPtrClass <Evoral::Note<Evoral::Beats> > ("NotePtr")
- .addFunction ("time", &Evoral::Note<Evoral::Beats>::time)
- .addFunction ("note", &Evoral::Note<Evoral::Beats>::note)
- .addFunction ("velocity", &Evoral::Note<Evoral::Beats>::velocity)
- .addFunction ("off_velocity", &Evoral::Note<Evoral::Beats>::off_velocity)
- .addFunction ("length", &Evoral::Note<Evoral::Beats>::length)
- .addFunction ("channel", &Evoral::Note<Evoral::Beats>::channel)
+ .beginWSPtrClass <Evoral::Note<Temporal::Beats> > ("NotePtr")
+ .addFunction ("time", &Evoral::Note<Temporal::Beats>::time)
+ .addFunction ("note", &Evoral::Note<Temporal::Beats>::note)
+ .addFunction ("velocity", &Evoral::Note<Temporal::Beats>::velocity)
+ .addFunction ("off_velocity", &Evoral::Note<Temporal::Beats>::off_velocity)
+ .addFunction ("length", &Evoral::Note<Temporal::Beats>::length)
+ .addFunction ("channel", &Evoral::Note<Temporal::Beats>::channel)
.endClass ()
/* libevoral enums */
//.addFunction ("what_can_be_automated", &Automatable::what_can_be_automated)
.endClass ()
- .deriveWSPtrClass <AutomatableSequence<Evoral::Beats>, Automatable> ("AutomatableSequence")
- .addCast<Evoral::Sequence<Evoral::Beats> > ("to_sequence")
+ .deriveWSPtrClass <AutomatableSequence<Temporal::Beats>, Automatable> ("AutomatableSequence")
+ .addCast<Evoral::Sequence<Temporal::Beats> > ("to_sequence")
.endClass ()
- .deriveWSPtrClass <MidiModel, AutomatableSequence<Evoral::Beats> > ("MidiModel")
+ .deriveWSPtrClass <MidiModel, AutomatableSequence<Temporal::Beats> > ("MidiModel")
.addFunction ("apply_command", (void (MidiModel::*)(Session*, Command*))&MidiModel::apply_command)
.addFunction ("new_note_diff_command", &MidiModel::new_note_diff_command)
.endClass ()
.addVoidPtrConstructor<std::list<boost::shared_ptr <AutomationControl> > > ()
.endClass ()
- .beginStdList <boost::shared_ptr<Evoral::Note<Evoral::Beats> > > ("NotePtrList")
+ .beginStdList <boost::shared_ptr<Evoral::Note<Temporal::Beats> > > ("NotePtrList")
.endClass ()
.beginConstStdList <Evoral::ControlEvent*> ("EventList")
.endClass ()
#if 0 // depends on Evoal:: Note, Beats see note_fixer.h
- // typedef Evoral::Note<Evoral::Beats> Note;
+ // typedef Evoral::Note<Temporal::Beats> Note;
// std::set< boost::weak_ptr<Note> >
.beginStdSet <boost::weak_ptr<Note> > ("WeakNoteSet")
.endClass ()
}
int old_val;
- Evoral::Beats old_time;
+ Temporal::Beats old_time;
if ((change.property == StartTime || change.property == Length) &&
xml_change->get_property ("old", old_time)) {
change.old_value = old_time;
}
int new_val;
- Evoral::Beats new_time;
+ Temporal::Beats new_time;
if ((change.property == StartTime || change.property == Length) &&
xml_change->get_property ("new", new_time)) {
change.new_value = new_time;
assert(false);
}
- Evoral::Beats time = Evoral::Beats();
+ Temporal::Beats time = Temporal::Beats();
if (!n->get_property ("time", time)) {
// warning??
}
void
MidiModel::control_list_marked_dirty ()
{
- AutomatableSequence<Evoral::Beats>::control_list_marked_dirty ();
+ AutomatableSequence<Temporal::Beats>::control_list_marked_dirty ();
ContentsChanged (); /* EMIT SIGNAL */
}
}
void
-MidiPlaylistSource::append_event_beats(const Glib::Threads::Mutex::Lock& /*lock*/, const Evoral::Event<Evoral::Beats>& /*ev*/)
+MidiPlaylistSource::append_event_beats(const Glib::Threads::Mutex::Lock& /*lock*/, const Evoral::Event<Temporal::Beats>& /*ev*/)
{
fatal << string_compose (_("programming error: %1"), "MidiPlaylistSource::append_event_beats() called - should be impossible") << endmsg;
abort(); /*NOTREACHED*/
#include <glibmm/fileutils.h>
#include <glibmm/miscutils.h>
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "pbd/xml++.h"
#include "pbd/basename.h"
path, false, _session.sample_rate()));
BeatsSamplesConverter bfc (_session.tempo_map(), _position);
- Evoral::Beats const bbegin = bfc.from (_start);
- Evoral::Beats const bend = bfc.from (_start + _length);
+ Temporal::Beats const bbegin = bfc.from (_start);
+ Temporal::Beats const bend = bfc.from (_start + _length);
{
/* Lock our source since we'll be reading from it. write_to() will
MidiRegion::clone (boost::shared_ptr<MidiSource> newsrc) const
{
BeatsSamplesConverter bfc (_session.tempo_map(), _position);
- Evoral::Beats const bbegin = bfc.from (_start);
- Evoral::Beats const bend = bfc.from (_start + _length);
+ Temporal::Beats const bbegin = bfc.from (_start);
+ Temporal::Beats const bend = bfc.from (_start + _length);
{
boost::shared_ptr<MidiSource> ms = midi_source(0);
_ignore_shift = true;
- model()->insert_silence_at_start (Evoral::Beats (- _start_beats));
+ model()->insert_silence_at_start (Temporal::Beats (- _start_beats));
_start = 0;
_start_beats = 0.0;
}
// Find appropriate model iterator
- Evoral::Sequence<Evoral::Beats>::const_iterator& i = cursor.iter;
+ Evoral::Sequence<Temporal::Beats>::const_iterator& i = cursor.iter;
const bool linear_read = cursor.last_read_end != 0 && start == cursor.last_read_end;
if (!linear_read || !i.valid()) {
/* Cached iterator is invalid, search for the first event past start.
sure if this is necessary here (channels are mapped later in
buffers anyway), but it preserves existing behaviour without
destroying events in the model during read. */
- Evoral::Event<Evoral::Beats> ev(*i, true);
+ Evoral::Event<Temporal::Beats> ev(*i, true);
if (!filter->filter(ev.buffer(), ev.size())) {
dst.write(time_samples, ev.event_type(), ev.size(), ev.buffer());
} else {
void
MidiSource::mark_midi_streaming_write_completed (const Lock& lock,
- Evoral::Sequence<Evoral::Beats>::StuckNoteOption option,
- Evoral::Beats end)
+ Evoral::Sequence<Temporal::Beats>::StuckNoteOption option,
+ Temporal::Beats end)
{
if (_model) {
_model->end_write (option, end);
void
MidiSource::mark_streaming_write_completed (const Lock& lock)
{
- mark_midi_streaming_write_completed (lock, Evoral::Sequence<Evoral::Beats>::DeleteStuckNotes);
+ mark_midi_streaming_write_completed (lock, Evoral::Sequence<Temporal::Beats>::DeleteStuckNotes);
}
int
-MidiSource::export_write_to (const Lock& lock, boost::shared_ptr<MidiSource> newsrc, Evoral::Beats begin, Evoral::Beats end)
+MidiSource::export_write_to (const Lock& lock, boost::shared_ptr<MidiSource> newsrc, Temporal::Beats begin, Temporal::Beats end)
{
Lock newsrc_lock (newsrc->mutex ());
}
int
-MidiSource::write_to (const Lock& lock, boost::shared_ptr<MidiSource> newsrc, Evoral::Beats begin, Evoral::Beats end)
+MidiSource::write_to (const Lock& lock, boost::shared_ptr<MidiSource> newsrc, Temporal::Beats begin, Temporal::Beats end)
{
Lock newsrc_lock (newsrc->mutex ());
newsrc->copy_automation_state_from (this);
if (_model) {
- if (begin == Evoral::Beats() && end == std::numeric_limits<Evoral::Beats>::max()) {
+ if (begin == Temporal::Beats() && end == std::numeric_limits<Temporal::Beats>::max()) {
_model->write_to (newsrc, newsrc_lock);
} else {
_model->write_section_to (newsrc, newsrc_lock, begin, end);
/* force a reload of the model if the range is partial */
- if (begin != Evoral::Beats() || end != std::numeric_limits<Evoral::Beats>::max()) {
+ if (begin != Temporal::Beats() || end != std::numeric_limits<Temporal::Beats>::max()) {
newsrc->load_model (newsrc_lock, true);
} else {
newsrc->set_model (newsrc_lock, _model);
}
void
-MidiStateTracker::resolve_notes (MidiSource& src, const MidiSource::Lock& lock, Evoral::Beats time)
+MidiStateTracker::resolve_notes (MidiSource& src, const MidiSource::Lock& lock, Temporal::Beats time)
{
DEBUG_TRACE (PBD::DEBUG::MidiTrackers, string_compose ("%1 MS-resolve notes @ %2 on = %3\n", this, time, _on));
for (int channel = 0; channel < 16; ++channel) {
for (int note = 0; note < 128; ++note) {
while (_active_notes[note + 128 * channel]) {
- Evoral::Event<Evoral::Beats> ev (Evoral::MIDI_EVENT, time, 3, 0, true);
+ Evoral::Event<Temporal::Beats> ev (Evoral::MIDI_EVENT, time, 3, 0, true);
ev.set_type (MIDI_CMD_NOTE_OFF);
ev.set_channel (channel);
ev.set_note (note);
this, (int) note, (int) channel, time));
_active_notes[note + 128 * channel]--;
/* don't stack events up at the same time */
- time += Evoral::Beats::tick();
+ time += Temporal::Beats::tick();
}
}
}
new_model->append(ev, Evoral::next_event_id());
}
- new_model->end_write (Evoral::Sequence<Evoral::Beats>::DeleteStuckNotes);
+ new_model->end_write (Evoral::Sequence<Temporal::Beats>::DeleteStuckNotes);
new_model->set_edited (true);
new_src->copy_interpolation_from (src);
boost::shared_ptr<Evoral::Control> rcontrol;
if ((tcontrol = boost::dynamic_pointer_cast<MidiTrack::MidiControl>(c->second)) &&
(rcontrol = region->control(tcontrol->parameter()))) {
- const Evoral::Beats pos_beats = bfc.from(pos - origin);
+ const Temporal::Beats pos_beats = bfc.from(pos - origin);
if (rcontrol->list()->size() > 0) {
tcontrol->set_value(rcontrol->list()->eval(pos_beats.to_double()), Controllable::NoGroup);
}
}
NoteFixer::Event*
-NoteFixer::copy_event(samplepos_t time, const Evoral::Event<Evoral::Beats>& ev)
+NoteFixer::copy_event(samplepos_t time, const Evoral::Event<Temporal::Beats>& ev)
{
return new Event(ev.event_type(), time, ev.size(), ev.buffer());
}
Command*
Quantize::operator () (boost::shared_ptr<MidiModel> model,
- Evoral::Beats position,
- std::vector<Evoral::Sequence<Evoral::Beats>::Notes>& seqs)
+ Temporal::Beats position,
+ std::vector<Evoral::Sequence<Temporal::Beats>::Notes>& seqs)
{
/* TODO: Rewrite this to be precise with fixed point? */
MidiModel::NoteDiffCommand* cmd = new MidiModel::NoteDiffCommand (model, "quantize");
- for (std::vector<Evoral::Sequence<Evoral::Beats>::Notes>::iterator s = seqs.begin(); s != seqs.end(); ++s) {
+ for (std::vector<Evoral::Sequence<Temporal::Beats>::Notes>::iterator s = seqs.begin(); s != seqs.end(); ++s) {
for (Evoral::Sequence<MidiModel::TimeType>::Notes::iterator i = (*s).begin(); i != (*s).end(); ++i) {
delta = new_end - (*i)->end_time().to_double();
if (fabs (delta) >= _threshold) {
- Evoral::Beats new_dur(new_end - new_start);
+ Temporal::Beats new_dur(new_end - new_start);
if (!new_dur) {
- new_dur = Evoral::Beats(_end_grid);
+ new_dur = Temporal::Beats(_end_grid);
}
cmd->change ((*i), MidiModel::NoteDiffCommand::Length, new_dur);
*/
-#include "timecode/time.h"
+#include "temporal/time.h"
#include "ardour/audioengine.h"
#include "ardour/audio_port.h"
#include "pbd/timersub.h"
#include "pbd/stacktrace.h"
-#include "timecode/time.h"
+#include "temporal/time.h"
#include "ardour/audio_track.h"
#include "ardour/audioengine.h"
if (!ms->model()) {
ms->load_model (lm);
}
- if (ms->write_to (lm, newsrc, Evoral::Beats(), std::numeric_limits<Evoral::Beats>::max())) {
+ if (ms->write_to (lm, newsrc, Temporal::Beats(), std::numeric_limits<Temporal::Beats>::max())) {
error << string_compose (_("Session-Save: Failed to copy MIDI Source '%1' for snapshot"), ancestor_name) << endmsg;
} else {
if (snapshot_type == SnapshotKeep) {
/* Note that we add on the source start time (in session samples) here so that ev_sample_time
is in session samples.
*/
- const samplepos_t ev_sample_time = converter.to(Evoral::Beats::ticks_at_rate(time, ppqn())) + source_start;
+ const samplepos_t ev_sample_time = converter.to(Temporal::Beats::ticks_at_rate(time, ppqn())) + source_start;
if (loop_range) {
loop_range->squish (ev_sample_time);
/** Append an event with a timestamp in beats */
void
SMFSource::append_event_beats (const Glib::Threads::Mutex::Lock& lock,
- const Evoral::Event<Evoral::Beats>& ev)
+ const Evoral::Event<Temporal::Beats>& ev)
{
if (!_writing || ev.size() == 0) {
return;
for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");
#endif
- Evoral::Beats time = ev.time();
+ Temporal::Beats time = ev.time();
if (time < _last_ev_time_beats) {
- const Evoral::Beats difference = _last_ev_time_beats - time;
+ const Temporal::Beats difference = _last_ev_time_beats - time;
if (difference.to_double() / (double)ppqn() < 1.0) {
/* Close enough. This problem occurs because Sequence is not
actually ordered due to fuzzy time comparison. I'm pretty sure
_length_beats = max(_length_beats, time);
- const Evoral::Beats delta_time_beats = time - _last_ev_time_beats;
+ const Temporal::Beats delta_time_beats = time - _last_ev_time_beats;
const uint32_t delta_time_ticks = delta_time_beats.to_ticks(ppqn());
Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
}
BeatsSamplesConverter converter(_session.tempo_map(), position);
- const Evoral::Beats ev_time_beats = converter.from(ev.time());
+ const Temporal::Beats ev_time_beats = converter.from(ev.time());
Evoral::event_id_t event_id;
if (ev.id() < 0) {
}
if (_model) {
- const Evoral::Event<Evoral::Beats> beat_ev (ev.event_type(),
+ const Evoral::Event<Temporal::Beats> beat_ev (ev.event_type(),
ev_time_beats,
ev.size(),
const_cast<uint8_t*>(ev.buffer()));
_length_beats = max(_length_beats, ev_time_beats);
- const Evoral::Beats last_time_beats = converter.from (_last_ev_time_samples);
- const Evoral::Beats delta_time_beats = ev_time_beats - last_time_beats;
+ const Temporal::Beats last_time_beats = converter.from (_last_ev_time_samples);
+ const Temporal::Beats delta_time_beats = ev_time_beats - last_time_beats;
const uint32_t delta_time_ticks = delta_time_beats.to_ticks(ppqn());
Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer(), event_id);
MidiSource::mark_streaming_midi_write_started (lock, mode);
Evoral::SMF::begin_write ();
- _last_ev_time_beats = Evoral::Beats();
+ _last_ev_time_beats = Temporal::Beats();
_last_ev_time_samples = 0;
}
void
SMFSource::mark_streaming_write_completed (const Lock& lock)
{
- mark_midi_streaming_write_completed (lock, Evoral::Sequence<Evoral::Beats>::DeleteStuckNotes);
+ mark_midi_streaming_write_completed (lock, Evoral::Sequence<Temporal::Beats>::DeleteStuckNotes);
}
void
-SMFSource::mark_midi_streaming_write_completed (const Lock& lm, Evoral::Sequence<Evoral::Beats>::StuckNoteOption stuck_notes_option, Evoral::Beats when)
+SMFSource::mark_midi_streaming_write_completed (const Lock& lm, Evoral::Sequence<Temporal::Beats>::StuckNoteOption stuck_notes_option, Temporal::Beats when)
{
MidiSource::mark_midi_streaming_write_completed (lm, stuck_notes_option, when);
}
static bool compare_eventlist (
- const std::pair< const Evoral::Event<Evoral::Beats>*, gint >& a,
- const std::pair< const Evoral::Event<Evoral::Beats>*, gint >& b) {
+ const std::pair< const Evoral::Event<Temporal::Beats>*, gint >& a,
+ const std::pair< const Evoral::Event<Temporal::Beats>*, gint >& b) {
return ( a.first->time() < b.first->time() );
}
Evoral::SMF::seek_to_start();
uint64_t time = 0; /* in SMF ticks */
- Evoral::Event<Evoral::Beats> ev;
+ Evoral::Event<Temporal::Beats> ev;
uint32_t scratch_size = 0; // keep track of scratch and minimize reallocs
bool have_event_id;
// TODO simplify event allocation
- std::list< std::pair< Evoral::Event<Evoral::Beats>*, gint > > eventlist;
+ std::list< std::pair< Evoral::Event<Temporal::Beats>*, gint > > eventlist;
for (unsigned i = 1; i <= num_tracks(); ++i) {
if (seek_to_track(i)) continue;
if (!have_event_id) {
event_id = Evoral::next_event_id();
}
- const Evoral::Beats event_time = Evoral::Beats::ticks_at_rate(time, ppqn());
+ const Temporal::Beats event_time = Temporal::Beats::ticks_at_rate(time, ppqn());
#ifndef NDEBUG
std::string ss;
#endif
eventlist.push_back(make_pair (
- new Evoral::Event<Evoral::Beats> (
+ new Evoral::Event<Temporal::Beats> (
Evoral::MIDI_EVENT, event_time,
size, buf, true)
, event_id));
eventlist.sort(compare_eventlist);
- std::list< std::pair< Evoral::Event<Evoral::Beats>*, gint > >::iterator it;
+ std::list< std::pair< Evoral::Event<Temporal::Beats>*, gint > >::iterator it;
for (it=eventlist.begin(); it!=eventlist.end(); ++it) {
_model->append (*it->first, it->second);
delete it->first;
// _playback_buf->dump (cerr);
// cerr << "----------------\n";
- _model->end_write (Evoral::Sequence<Evoral::Beats>::ResolveStuckNotes, _length_beats);
+ _model->end_write (Evoral::Sequence<Temporal::Beats>::ResolveStuckNotes, _length_beats);
_model->set_edited (false);
invalidate(lock);
#include "pbd/enumwriter.h"
#include "pbd/xml++.h"
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "ardour/debug.h"
#include "ardour/lmath.h"
* @param beat The BBT (meter-based) beat.
* @return The quarter-note position of the supplied BBT (meter-based) beat.
*
- * a quarter-note may be compared with and assigned to Evoral::Beats.
+ * a quarter-note may be compared with and assigned to Temporal::Beats.
*
*/
double
* @param quarter_note The position in quarter-note beats.
* @return the BBT (meter-based) beat position of the supplied quarter-note beats.
*
- * a quarter-note is the musical unit of Evoral::Beats.
+ * a quarter-note is the musical unit of Temporal::Beats.
*
*/
double
* pos can be -ve, if required.
*/
samplepos_t
-TempoMap::samplepos_plus_qn (samplepos_t sample, Evoral::Beats beats) const
+TempoMap::samplepos_plus_qn (samplepos_t sample, Temporal::Beats beats) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
const double sample_qn = pulse_at_minute_locked (_metrics, minute_at_sample (sample)) * 4.0;
/** Count the number of beats that are equivalent to distance when going forward,
starting at pos.
*/
-Evoral::Beats
+Temporal::Beats
TempoMap::framewalk_to_qn (samplepos_t pos, samplecnt_t distance) const
{
Glib::Threads::RWLock::ReaderLock lm (lock);
- return Evoral::Beats (quarter_notes_between_samples_locked (_metrics, pos, pos + distance));
+ return Temporal::Beats (quarter_notes_between_samples_locked (_metrics, pos, pos + distance));
}
struct bbtcmp {
#include <sigc++/sigc++.h>
#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
-#include "timecode/bbt_time.h"
+#include "temporal/bbt_time.h"
class BBTTest : public CppUnit::TestFixture
{
#include "samplepos_minus_beats_test.h"
#include "ardour/tempo.h"
-#include "timecode/bbt_time.h"
+#include "temporal/bbt_time.h"
CPPUNIT_TEST_SUITE_REGISTRATION (FrameposMinusBeatsTest);
#include "samplepos_plus_beats_test.h"
#include "ardour/tempo.h"
-#include "timecode/bbt_time.h"
+#include "temporal/bbt_time.h"
CPPUNIT_TEST_SUITE_REGISTRATION (FrameposPlusBeatsTest);
map.replace_tempo (map.first_tempo(), tempo, 0.0, 0, AudioTime);
/* Add 1 beat to beat 3 of the first bar */
- samplepos_t r = map.samplepos_plus_qn (samples_per_beat * 2, Evoral::Beats(1));
+ samplepos_t r = map.samplepos_plus_qn (samples_per_beat * 2, Temporal::Beats(1));
CPPUNIT_ASSERT_EQUAL (samplepos_t (samples_per_beat * 3), r);
/* Add 4 beats to a -ve sample of 1 beat before zero */
- r = map.samplepos_plus_qn (-samples_per_beat * 1, Evoral::Beats(4));
+ r = map.samplepos_plus_qn (-samples_per_beat * 1, Temporal::Beats(4));
CPPUNIT_ASSERT_EQUAL (samplepos_t (samples_per_beat * 3), r);
}
/* Now some tests */
/* Add 1 beat to 1|2 */
- samplepos_t r = map.samplepos_plus_qn (24e3, Evoral::Beats(1));
+ samplepos_t r = map.samplepos_plus_qn (24e3, Temporal::Beats(1));
CPPUNIT_ASSERT_EQUAL (samplepos_t (48e3), r);
/* Add 2 beats to 3|4 (over the tempo change) */
- r = map.samplepos_plus_qn (264e3, Evoral::Beats(2));
+ r = map.samplepos_plus_qn (264e3, Temporal::Beats(2));
CPPUNIT_ASSERT_EQUAL (samplepos_t (264e3 + 24e3 + 12e3), r);
/* Add 2.5 beats to 3|3|960 (over the tempo change) */
- r = map.samplepos_plus_qn (264e3 - 12e3, Evoral::Beats(2.5));
+ r = map.samplepos_plus_qn (264e3 - 12e3, Temporal::Beats(2.5));
CPPUNIT_ASSERT_EQUAL (samplepos_t (264e3 + 24e3 + 12e3), r);
}
/* Now some tests */
/* Add 1 beat to 1|2 */
- samplepos_t r = map.samplepos_plus_qn (24e3, Evoral::Beats(1));
+ samplepos_t r = map.samplepos_plus_qn (24e3, Temporal::Beats(1));
CPPUNIT_ASSERT_EQUAL (samplepos_t (48e3), r);
/* Add 2 beats to 3|4 (over the tempo change) */
- r = map.samplepos_plus_qn (264e3, Evoral::Beats(2));
+ r = map.samplepos_plus_qn (264e3, Temporal::Beats(2));
CPPUNIT_ASSERT_EQUAL (samplepos_t (264e3 + 24e3 + 12e3), r);
/* Add 2.5 beats to 3|3|960 (over the tempo change) */
- r = map.samplepos_plus_qn (264e3 - 12e3, Evoral::Beats(2.5));
+ r = map.samplepos_plus_qn (264e3 - 12e3, Temporal::Beats(2.5));
CPPUNIT_ASSERT_EQUAL (samplepos_t (264e3 + 24e3 + 12e3), r);
}
/* Now some tests */
/* Add 1 beat to 1|2 */
- samplepos_t r = map.samplepos_plus_qn (24e3, Evoral::Beats(1));
+ samplepos_t r = map.samplepos_plus_qn (24e3, Temporal::Beats(1));
CPPUNIT_ASSERT_EQUAL (samplepos_t (48e3), r);
/* Add 2 beats to 5|1 (over the tempo change) */
- r = map.samplepos_plus_qn (264e3, Evoral::Beats(2));
+ r = map.samplepos_plus_qn (264e3, Temporal::Beats(2));
CPPUNIT_ASSERT_EQUAL (samplepos_t (264e3 + 24e3 + 12e3), r);
/* Add 2.5 beats to 4|5 (over the tempo change) */
- r = map.samplepos_plus_qn (264e3 - 12e3, Evoral::Beats(2.5));
+ r = map.samplepos_plus_qn (264e3 - 12e3, Temporal::Beats(2.5));
CPPUNIT_ASSERT_EQUAL (samplepos_t (264e3 + 24e3 + 12e3), r);
}
#include "samplewalk_to_beats_test.h"
#include "ardour/tempo.h"
-#include "timecode/bbt_time.h"
+#include "temporal/bbt_time.h"
CPPUNIT_TEST_SUITE_REGISTRATION (FramewalkToBeatsTest);
Command*
Transform::operator()(boost::shared_ptr<MidiModel> model,
- Evoral::Beats position,
+ Temporal::Beats position,
std::vector<Notes>& seqs)
{
typedef MidiModel::NoteDiffCommand Command;
Command*
Transpose::operator()(boost::shared_ptr<MidiModel> model,
- Evoral::Beats position,
+ Temporal::Beats position,
std::vector<Notes>& seqs)
{
typedef MidiModel::NoteDiffCommand Command;
'OSX','BOOST','CURL','TAGLIB','VAMPSDK','VAMPHOSTSDK','RUBBERBAND']
obj.use = ['libpbd','libmidipp','libevoral',
'libaudiographer',
- 'libtimecode',
+ 'libtemporal',
'liblua',
]
if bld.env['build_target'] != 'mingw':
source = avx_sources,
cxxflags = avx_cxxflags,
includes = [ '.' ],
- use = [ 'libtimecode', 'libpbd', 'libevoral', 'liblua' ],
+ use = [ 'libtemporal', 'libpbd', 'libevoral', 'liblua' ],
uselib = [ 'GLIBMM', 'XML' ],
target = 'sse_avx_functions')
audiographer.name = 'libaudiographer'
audiographer.target = 'audiographer'
audiographer.export_includes = ['.', './src']
- audiographer.includes = ['.', './src','../ardour','../timecode','../evoral']
+ audiographer.includes = ['.', './src','../ardour','../temporal','../evoral']
audiographer.uselib = 'GLIB GLIBMM GTHREAD SAMPLERATE SNDFILE FFTW3F VAMPSDK VAMPHOSTSDK XML'
audiographer.use = 'libpbd'
audiographer.vnum = AUDIOGRAPHER_LIB_VERSION
#include <glib.h>
+#include "temporal/beats.h"
#include "evoral/Event.hpp"
-#include "evoral/Beats.hpp"
namespace Evoral {
#endif // EVORAL_EVENT_ALLOC
-template class Event<Evoral::Beats>;
+template class Event<Temporal::Beats>;
template class Event<double>;
template class Event<int64_t>;
#include "evoral/Note.hpp"
#endif
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
namespace Evoral {
_off_event.set_id (id);
}
-template class Note<Evoral::Beats>;
+template class Note<Temporal::Beats>;
} // namespace Evoral
return ret;
}
-template class SMF<Evoral::Beats>;
+template class SMF<Temporal::Beats>;
} // namespace Evoral
#include "pbd/compose.h"
#include "pbd/error.h"
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
+
#include "evoral/Control.hpp"
#include "evoral/ControlList.hpp"
#include "evoral/ControlSet.hpp"
str << "--- dump\n";
}
-template class Sequence<Evoral::Beats>;
+template class Sequence<Temporal::Beats>;
} // namespace Evoral
-/* This file is part of Evoral.
+/*
* Copyright (C) 2008 David Robillard <http://drobilla.net>
* Copyright (C) 2000-2008 Paul Davis
*
#include <stdint.h>
+#include "temporal/beats.h"
+#include "temporal/types.h"
+
#include "evoral/TimeConverter.hpp"
#include "evoral/types.hpp"
return static_cast<A>(b);
}
-template class IdentityConverter<double, framepos_t>;
-template class TimeConverter<double, framepos_t>;
-template class TimeConverter<Evoral::Beats, framepos_t>;
+template class IdentityConverter<double, Temporal::samplepos_t>;
+template class TimeConverter<double, Temporal::samplepos_t>;
+template class TimeConverter<Temporal::Beats, Temporal::samplepos_t>;
} // namespace Evoral
libsmf.name = 'libsmf'
libsmf.target = 'smf'
libsmf.uselib = 'GLIB'
+ libsmf.use = [ 'libtemporal' ]
libsmf.install_path = None
if bld.env['build_target'] != 'mingw':
libsmf.cxxflags = [ '-fPIC' ]
#ifndef __midipp_mmc_h_h__
#define __midipp_mmc_h_h__
-#include "timecode/time.h"
+#include "temporal/time.h"
#include "pbd/signals.h"
#include "pbd/ringbuffer.h"
node->set_property("Name", _name);
/*
- typedef std::list< boost::shared_ptr< Evoral::Event<Evoral::Beats> > > PatchMidiCommands;
+ typedef std::list< boost::shared_ptr< Evoral::Event<Temporal::Beats> > > PatchMidiCommands;
XMLNode* commands = node->add_child("PatchMIDICommands");
for (PatchMidiCommands::const_iterator event = _patch_midi_commands.begin();
event != _patch_midi_commands.end();
#include <fcntl.h>
#include <map>
-#include "timecode/time.h"
-#include "timecode/bbt_time.h"
+#include "temporal/time.h"
+#include "temporal/bbt_time.h"
#include "pbd/error.h"
obj.name = 'libmidipp'
obj.target = 'midipp'
obj.uselib = 'GLIBMM SIGCPP XML OSX'
- obj.use = 'libpbd libevoral libtimecode'
+ obj.use = 'libpbd libevoral libtemporal'
obj.vnum = LIBMIDIPP_LIB_VERSION
obj.install_path = bld.env['LIBDIR']
#include "ardour/types.h"
#include "ardour/presentation_info.h"
-#include "timecode/time.h"
+#include "temporal/time.h"
#include "control_protocol/visibility.h"
#include "pbd/enumwriter.h"
#include "midi++/parser.h"
-#include "timecode/time.h"
-#include "timecode/bbt_time.h"
+#include "temporal/time.h"
+#include "temporal/bbt_time.h"
#include "ardour/async_midi_port.h"
#include "ardour/audioengine.h"
#include "pbd/enumwriter.h"
#include "midi++/parser.h"
-#include "timecode/time.h"
-#include "timecode/bbt_time.h"
+#include "temporal/time.h"
+#include "temporal/bbt_time.h"
#include "ardour/amp.h"
#include "ardour/async_midi_port.h"
#include "pbd/enumwriter.h"
#include "midi++/parser.h"
-#include "timecode/time.h"
-#include "timecode/bbt_time.h"
+#include "temporal/time.h"
+#include "temporal/bbt_time.h"
#include "ardour/async_midi_port.h"
#include "ardour/audioengine.h"
obj.name = 'libardour_push2'
obj.target = 'ardour_push2'
obj.uselib = 'CAIROMM PANGOMM USB GTKMM SIGCPP'
- obj.use = 'libardour libardour_cp libgtkmm2ext libpbd libevoral libcanvas libtimecode'
+ obj.use = 'libardour libardour_cp libgtkmm2ext libpbd libevoral libcanvas libtemporal'
obj.install_path = os.path.join(bld.env['LIBDIR'], 'surfaces')
def shutdown():
#include <cmath>
#include <cassert>
-#include "timecode/bbt_time.h"
+#include "temporal/bbt_time.h"
using namespace Timecode;
1920 has many factors, though going up to 3840 gets a couple more.
- This needs to match Evoral::Beats::PPQN
+ This needs to match Temporal::Beats::PPQN
*/
const double BBT_Time::ticks_per_beat = 1920.0;
#include <iomanip>
#include <exception>
-#include "timecode/visibility.h"
+#include "temporal/visibility.h"
namespace Timecode {
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#ifndef EVORAL_BEATS_HPP
-#define EVORAL_BEATS_HPP
+#ifndef TEMPORAL_BEATS_HPP
+#define TEMPORAL_BEATS_HPP
#include <float.h>
#include <math.h>
#include <iostream>
#include <limits>
-#include "evoral/visibility.h"
+#include "temporal/visibility.h"
-namespace Evoral {
+namespace Temporal {
/** Musical time in beats. */
-class /*LIBEVORAL_API*/ Beats {
+class /*LIBTEMPORAL_API*/ Beats {
public:
- LIBEVORAL_API static const int32_t PPQN = 1920;
+ LIBTEMPORAL_API static const int32_t PPQN = 1920;
Beats() : _beats(0), _ticks(0) {}
return Beats(_beats, 0);
}
- Beats snap_to(const Evoral::Beats& snap) const {
+ Beats snap_to(const Temporal::Beats& snap) const {
const double snap_time = snap.to_double();
return Beats(ceil(to_double() / snap_time) * snap_time);
}
/*
TIL, several horrible hours later, that sometimes the compiler looks in the
- namespace of a type (Evoral::Beats in this case) for an operator, and
+ namespace of a type (Temporal::Beats in this case) for an operator, and
does *NOT* look in the global namespace.
C++ is proof that hell exists and we are living in it. In any case, move
namespace PBD {
namespace DEBUG {
- LIBEVORAL_API extern uint64_t Beats;
+ LIBTEMPORAL_API extern uint64_t Beats;
}
}
namespace std {
template<>
- struct numeric_limits<Evoral::Beats> {
- static Evoral::Beats lowest() {
- return Evoral::Beats(std::numeric_limits<int32_t>::min(),
+ struct numeric_limits<Temporal::Beats> {
+ static Temporal::Beats lowest() {
+ return Temporal::Beats(std::numeric_limits<int32_t>::min(),
std::numeric_limits<int32_t>::min());
}
but Beats is used as both. Better to avoid providing a min at all
than a confusing one. */
- static Evoral::Beats max() {
- return Evoral::Beats(std::numeric_limits<int32_t>::max(),
+ static Temporal::Beats max() {
+ return Temporal::Beats(std::numeric_limits<int32_t>::max(),
std::numeric_limits<int32_t>::max());
}
};
}
-#endif // EVORAL_BEATS_HPP
+#endif // TEMPORAL_BEATS_HPP
#include <ostream>
#include <inttypes.h>
-#include "timecode/visibility.h"
+#include "temporal/visibility.h"
namespace Timecode {
#include <stdio.h>
#include <stdlib.h>
-#include "timecode/time.h"
+#include "temporal/time.h"
namespace Timecode {
using std::endl;
/* overloaded operator* that avoids floating point math when multiplying a superclock position by a number of quarter notes */
-superclock_t operator*(superclock_t sc, Evoral::Beats const & b) { return (sc * ((b.get_beats() * Evoral::Beats::PPQN) + b.get_ticks())) / Evoral::Beats::PPQN; }
+superclock_t operator*(superclock_t sc, Temporal::Beats const & b) { return (sc * ((b.get_beats() * Temporal::Beats::PPQN) + b.get_ticks())) / Temporal::Beats::PPQN; }
Timecode::BBT_Time
Meter::bbt_add (Timecode::BBT_Time const & bbt, Timecode::BBT_Offset const & add) const
Timecode::BBT_Offset r (bars + add.bars, beats + add.beats, ticks + add.ticks);
- if (r.ticks >= Evoral::Beats::PPQN) {
- r.beats += r.ticks / Evoral::Beats::PPQN;
- r.ticks %= Evoral::Beats::PPQN;
+ if (r.ticks >= Temporal::Beats::PPQN) {
+ r.beats += r.ticks / Temporal::Beats::PPQN;
+ r.ticks %= Temporal::Beats::PPQN;
}
if (r.beats > _divisions_per_bar) {
Timecode::BBT_Offset r (bars - sub.bars, beats - sub.beats, ticks - sub.ticks);
if (r.ticks < 0) {
- r.beats -= 1 - (r.ticks / Evoral::Beats::PPQN);
- r.ticks = Evoral::Beats::PPQN + (r.ticks % Evoral::Beats::PPQN);
+ r.beats -= 1 - (r.ticks / Temporal::Beats::PPQN);
+ r.ticks = Temporal::Beats::PPQN + (r.ticks % Temporal::Beats::PPQN);
}
if (r.beats <= 0) {
return b;
}
-Evoral::Beats
+Temporal::Beats
Meter::to_quarters (Timecode::BBT_Offset const & offset) const
{
- Evoral::Beats b;
+ Temporal::Beats b;
b += (offset.bars * _divisions_per_bar * 4) / _note_value;
b += (offset.beats * 4) / _note_value;
- b += Evoral::Beats::ticks (offset.ticks);
+ b += Temporal::Beats::ticks (offset.ticks);
return b;
}
_c_per_superclock = log ((double) superclocks_per_quarter_note () / end_scpqn) / superclock_duration;
}
void
-TempoMetric::compute_c_quarters (samplecnt_t sr, superclock_t end_scpqn, Evoral::Beats const & quarter_duration)
+TempoMetric::compute_c_quarters (samplecnt_t sr, superclock_t end_scpqn, Temporal::Beats const & quarter_duration)
{
if ((superclocks_per_quarter_note () == end_scpqn) || !ramped()) {
_c_per_quarter = 0.0;
}
superclock_t
-TempoMetric::superclock_at_qn (Evoral::Beats const & qn) const
+TempoMetric::superclock_at_qn (Temporal::Beats const & qn) const
{
if (_c_per_quarter == 0.0) {
/* not ramped, use linear */
}
}
-Evoral::Beats
+Temporal::Beats
TempoMapPoint::quarters_at (superclock_t sc) const
{
/* This TempoMapPoint must already have a fully computed metric and position */
if (!ramped()) {
- return _quarters + Evoral::Beats ((sc - _sclock) / (double) (metric().superclocks_per_quarter_note ()));
+ return _quarters + Temporal::Beats ((sc - _sclock) / (double) (metric().superclocks_per_quarter_note ()));
}
- return _quarters + Evoral::Beats (expm1 (metric().c_per_superclock() * (sc - _sclock)) / (metric().c_per_superclock() * metric().superclocks_per_quarter_note ()));
+ return _quarters + Temporal::Beats (expm1 (metric().c_per_superclock() * (sc - _sclock)) / (metric().c_per_superclock() * metric().superclocks_per_quarter_note ()));
}
-Evoral::Beats
+Temporal::Beats
TempoMapPoint::quarters_at (Timecode::BBT_Time const & bbt) const
{
/* This TempoMapPoint must already have a fully computed metric and position */
}
Timecode::BBT_Time
-TempoMapPoint::bbt_at (Evoral::Beats const & qn) const
+TempoMapPoint::bbt_at (Temporal::Beats const & qn) const
{
/* This TempoMapPoint must already have a fully computed metric and position */
- Evoral::Beats quarters_delta = qn - _quarters;
- int32_t ticks_delta = quarters_delta.to_ticks (Evoral::Beats::PPQN);
+ Temporal::Beats quarters_delta = qn - _quarters;
+ int32_t ticks_delta = quarters_delta.to_ticks (Temporal::Beats::PPQN);
return metric().bbt_add (_bbt, Timecode::BBT_Offset (0, 0, ticks_delta));
}
: _sample_rate (sr)
, _dirty (false)
{
- TempoMapPoint tmp (TempoMapPoint::Flag (TempoMapPoint::ExplicitMeter|TempoMapPoint::ExplicitTempo), initial_tempo, initial_meter, 0, Evoral::Beats(), Timecode::BBT_Time(), AudioTime);
+ TempoMapPoint tmp (TempoMapPoint::Flag (TempoMapPoint::ExplicitMeter|TempoMapPoint::ExplicitTempo), initial_tempo, initial_meter, 0, Temporal::Beats(), Timecode::BBT_Time(), AudioTime);
_points.push_back (tmp);
}
}
Meter const &
-TempoMap::meter_at (Evoral::Beats const & b) const
+TempoMap::meter_at (Temporal::Beats const & b) const
{
Glib::Threads::RWLock::ReaderLock lm (_lock);
return meter_at_locked (b);
}
Tempo const &
-TempoMap::tempo_at (Evoral::Beats const &b) const
+TempoMap::tempo_at (Temporal::Beats const &b) const
{
Glib::Threads::RWLock::ReaderLock lm (_lock);
return tempo_at_locked (b);
if ((tmp->lock_style() == MusicTime)) {
/* determine superclock and quarter note time for this (music-time) locked point */
- Evoral::Beats qn = prev->quarters_at (tmp->bbt());
+ Temporal::Beats qn = prev->quarters_at (tmp->bbt());
superclock_t sc = prev->sclock() + prev->metric().superclock_at_qn (qn - prev->quarters());
if (qn != tmp->quarters() || tmp->sclock() != sc) {
}
superclock_t sc = tmp->sclock();
- Evoral::Beats qn (tmp->quarters ());
+ Temporal::Beats qn (tmp->quarters ());
Timecode::BBT_Time bbt (tmp->bbt());
const bool ramped = tmp->ramped () && next != _points.end();
- /* Evoral::Beats are really quarter notes. This counts how many quarter notes
+ /* Temporal::Beats are really quarter notes. This counts how many quarter notes
there are between grid points in this section of the tempo map.
*/
- const Evoral::Beats qn_step = (Evoral::Beats (1) * 4) / tmp->metric().note_value();
+ const Temporal::Beats qn_step = (Temporal::Beats (1) * 4) / tmp->metric().note_value();
/* compute implicit points as far as the next explicit point, or limit,
whichever comes first.
fractional.
*/
- Evoral::Beats b = _points.front().quarters_at (sc).round_to_beat();
+ Temporal::Beats b = _points.front().quarters_at (sc).round_to_beat();
Timecode::BBT_Time bbt = _points.front().bbt_at (b).round_to_beat ();
_points.insert (_points.begin(), TempoMapPoint (TempoMapPoint::ExplicitTempo, tempo, meter, sc, b, bbt, AudioTime, ramp));
fractional.
*/
- Evoral::Beats qn = i->quarters_at (sc).round_to_beat();
+ Temporal::Beats qn = i->quarters_at (sc).round_to_beat();
/* rule: all Tempo changes must be on-beat. So determine the nearest later beat to "sc"
*/
fractional.
*/
- Evoral::Beats b = _points.front().quarters_at (sc).round_to_beat();
+ Temporal::Beats b = _points.front().quarters_at (sc).round_to_beat();
Timecode::BBT_Time bbt = _points.front().bbt_at (b).round_to_beat ();
_points.insert (_points.begin(), TempoMapPoint (TempoMapPoint::ExplicitTempo, t, _points.front().metric(), sc, b, bbt, AudioTime, ramp));
fractional.
*/
- Evoral::Beats qn = i->quarters_at (sc).round_to_beat();
+ Temporal::Beats qn = i->quarters_at (sc).round_to_beat();
/* rule: all Tempo changes must be on-beat. So determine the nearest later beat to "sc"
*/
++i;
/* stick a prototype music-locked point up front and let ::rebuild figure out the superclock and quarter time */
- _points.insert (i, TempoMapPoint (TempoMapPoint::ExplicitTempo, t, meter, 0, Evoral::Beats(), on_beat, MusicTime, ramp));
+ _points.insert (i, TempoMapPoint (TempoMapPoint::ExplicitTempo, t, meter, 0, Temporal::Beats(), on_beat, MusicTime, ramp));
return true;
}
return true;
}
- Evoral::Beats qn = i->quarters_at (measure_start);
+ Temporal::Beats qn = i->quarters_at (measure_start);
superclock_t sc = i->sclock() + i->metric().superclock_at_qn (qn);
Tempo const & tempo (i->metric());
fractional.
*/
- Evoral::Beats b = _points.front().quarters_at (sc).round_to_beat();
+ Temporal::Beats b = _points.front().quarters_at (sc).round_to_beat();
Timecode::BBT_Time bbt = _points.front().bbt_at (b).round_to_beat ();
_points.insert (_points.begin(), TempoMapPoint (TempoMapPoint::ExplicitMeter, _points.front().metric(), m, sc, b, bbt, AudioTime));
fractional.
*/
- Evoral::Beats b = i->quarters_at (sc).round_to_beat();
+ Temporal::Beats b = i->quarters_at (sc).round_to_beat();
/* rule: all Meter changes must start a new measure. So determine the nearest, lower beat to "sc". If this is not
the first division of the measure, move to the next measure.
*/
TempoMetric const & metric (_points.front().metric());
- const TempoMapPoint tp (TempoMapPoint::Flag (0), metric, metric, sc, Evoral::Beats(), Timecode::BBT_Time(), AudioTime);
+ const TempoMapPoint tp (TempoMapPoint::Flag (0), metric, metric, sc, Temporal::Beats(), Timecode::BBT_Time(), AudioTime);
TempoMapPoint::SuperClockComparator scmp;
TempoMapPoints::iterator tmp = upper_bound (_points.begin(), _points.end(), tp, scmp);
}
TempoMapPoints::iterator
-TempoMap::iterator_at (Evoral::Beats const & qn)
+TempoMap::iterator_at (Temporal::Beats const & qn)
{
/* CALLER MUST HOLD LOCK */
*/
TempoMetric const & metric (_points.front().metric());
- const TempoMapPoint tp (TempoMapPoint::Flag(0), metric, metric, 0, Evoral::Beats(), bbt, MusicTime);
+ const TempoMapPoint tp (TempoMapPoint::Flag(0), metric, metric, 0, Temporal::Beats(), bbt, MusicTime);
TempoMapPoint::BBTComparator bcmp;
TempoMapPoints::iterator tmp = upper_bound (_points.begin(), _points.end(), tp, bcmp);
TempoMap::bbt_at_locked (superclock_t sc) const
{
TempoMapPoint point (const_point_at (sc));
- Evoral::Beats b ((sc - point.sclock()) / (double) point.metric().superclocks_per_quarter_note());
+ Temporal::Beats b ((sc - point.sclock()) / (double) point.metric().superclocks_per_quarter_note());
return point.metric().bbt_add (point.bbt(), Timecode::BBT_Offset (0, b.get_beats(), b.get_ticks()));
}
Timecode::BBT_Time
-TempoMap::bbt_at (Evoral::Beats const & qn) const
+TempoMap::bbt_at (Temporal::Beats const & qn) const
{
Glib::Threads::RWLock::ReaderLock lm (_lock);
return bbt_at_locked (qn);
}
Timecode::BBT_Time
-TempoMap::bbt_at_locked (Evoral::Beats const & qn) const
+TempoMap::bbt_at_locked (Temporal::Beats const & qn) const
{
//Glib::Threads::RWLock::ReaderLock lm (_lock);
TempoMapPoint const & point (const_point_at (qn));
- Evoral::Beats delta (qn - point.quarters());
+ Temporal::Beats delta (qn - point.quarters());
return point.metric().bbt_add (point.bbt(), Timecode::BBT_Offset (0, delta.get_beats(), delta.get_ticks()));
}
superclock_t
-TempoMap::superclock_at (Evoral::Beats const & qn) const
+TempoMap::superclock_at (Temporal::Beats const & qn) const
{
Glib::Threads::RWLock::ReaderLock lm (_lock);
return superclock_at_locked (qn);
}
superclock_t
-TempoMap::superclock_at_locked (Evoral::Beats const & qn) const
+TempoMap::superclock_at_locked (Temporal::Beats const & qn) const
{
assert (!_points.empty());
--i;
}
- /* compute distance from reference point to b. Remember that Evoral::Beats is always interpreted as quarter notes */
+ /* compute distance from reference point to b. Remember that Temporal::Beats is always interpreted as quarter notes */
- const Evoral::Beats q_delta = qn - i->quarters();
+ const Temporal::Beats q_delta = qn - i->quarters();
superclock_t sclock_delta = i->metric().superclock_at_qn (q_delta);
return i->sclock() + sclock_delta;
}
assert (!_points.empty());
/* only the bbt property matters, since we're just using it to compare */
- const TempoMapPoint tmp (TempoMapPoint::Flag (0), Tempo (120), Meter (4, 4), 0, Evoral::Beats(), bbt, MusicTime);
+ const TempoMapPoint tmp (TempoMapPoint::Flag (0), Tempo (120), Meter (4, 4), 0, Temporal::Beats(), bbt, MusicTime);
TempoMapPoint::BBTComparator bcmp;
TempoMapPoints::const_iterator i = upper_bound (_points.begin(), _points.end(), tmp, bcmp);
const Timecode::BBT_Offset delta = i->metric().bbt_delta (bbt, i->bbt());
/* convert to quarter notes */
- const int32_t ticks = delta.ticks + (Evoral::Beats::PPQN * delta.beats * 4) / i->metric().note_value();
+ const int32_t ticks = delta.ticks + (Temporal::Beats::PPQN * delta.beats * 4) / i->metric().note_value();
/* get distance in superclocks */
- return i->sclock() + i->metric().superclock_at_qn (Evoral::Beats::ticks (ticks));
+ return i->sclock() + i->metric().superclock_at_qn (Temporal::Beats::ticks (ticks));
}
void
}
void
-TempoMap::get_grid (TempoMapPoints& ret, superclock_t start, superclock_t end, Evoral::Beats const & resolution)
+TempoMap::get_grid (TempoMapPoints& ret, superclock_t start, superclock_t end, Temporal::Beats const & resolution)
{
Glib::Threads::RWLock::ReaderLock lm (_lock);
TempoMapPoints::iterator p = iterator_at (start);
++p;
}
- if (resolution == Evoral::Beats()) {
+ if (resolution == Temporal::Beats()) {
/* just hand over the points as-is */
while (p != _points.end() && p->sclock() < end) {
ret.push_back (*p);
}
superclock_t pos = p->sclock();
- Evoral::Beats qpos;
+ Temporal::Beats qpos;
TempoMapPoints::iterator nxt = p;
++nxt;
for (int b = 1; b < 13; ++b) {
PRINT_RESULT((*m), "+", bbt_add, a, B, b, 0);
PRINT_RESULT((*m), "+", bbt_add, a, B, b, 1);
- PRINT_RESULT((*m), "+", bbt_add, a, B, b, Evoral::Beats::PPQN/2);
- PRINT_RESULT((*m), "+", bbt_add, a, B, b, Evoral::Beats::PPQN);
- PRINT_RESULT((*m), "+", bbt_add, a, B, b, Evoral::Beats::PPQN - 1);
- PRINT_RESULT((*m), "+", bbt_add, a, B, b, Evoral::Beats::PPQN - 2);
+ PRINT_RESULT((*m), "+", bbt_add, a, B, b, Temporal::Beats::PPQN/2);
+ PRINT_RESULT((*m), "+", bbt_add, a, B, b, Temporal::Beats::PPQN);
+ PRINT_RESULT((*m), "+", bbt_add, a, B, b, Temporal::Beats::PPQN - 1);
+ PRINT_RESULT((*m), "+", bbt_add, a, B, b, Temporal::Beats::PPQN - 2);
PRINT_RESULT((*m), "+", bbt_add, b1, B, b, 0);
PRINT_RESULT((*m), "+", bbt_add, b1, B, b, 1);
- PRINT_RESULT((*m), "+", bbt_add, b1, B, b, Evoral::Beats::PPQN/2);
- PRINT_RESULT((*m), "+", bbt_add, b1, B, b, Evoral::Beats::PPQN);
- PRINT_RESULT((*m), "+", bbt_add, b1, B, b, Evoral::Beats::PPQN - 1);
- PRINT_RESULT((*m), "+", bbt_add, b1, B, b, Evoral::Beats::PPQN - 2);
+ PRINT_RESULT((*m), "+", bbt_add, b1, B, b, Temporal::Beats::PPQN/2);
+ PRINT_RESULT((*m), "+", bbt_add, b1, B, b, Temporal::Beats::PPQN);
+ PRINT_RESULT((*m), "+", bbt_add, b1, B, b, Temporal::Beats::PPQN - 1);
+ PRINT_RESULT((*m), "+", bbt_add, b1, B, b, Temporal::Beats::PPQN - 2);
PRINT_RESULT((*m), "+", bbt_add, n1, B, b, 0);
PRINT_RESULT((*m), "+", bbt_add, n1, B, b, 1);
- PRINT_RESULT((*m), "+", bbt_add, n1, B, b, Evoral::Beats::PPQN/2);
- PRINT_RESULT((*m), "+", bbt_add, n1, B, b, Evoral::Beats::PPQN);
- PRINT_RESULT((*m), "+", bbt_add, n1, B, b, Evoral::Beats::PPQN - 1);
- PRINT_RESULT((*m), "+", bbt_add, n1, B, b, Evoral::Beats::PPQN - 2);
+ PRINT_RESULT((*m), "+", bbt_add, n1, B, b, Temporal::Beats::PPQN/2);
+ PRINT_RESULT((*m), "+", bbt_add, n1, B, b, Temporal::Beats::PPQN);
+ PRINT_RESULT((*m), "+", bbt_add, n1, B, b, Temporal::Beats::PPQN - 1);
+ PRINT_RESULT((*m), "+", bbt_add, n1, B, b, Temporal::Beats::PPQN - 2);
}
}
for (int b = 1; b < 13; ++b) {
PRINT_RESULT ((*m), "-", bbt_subtract, a, B, b, 0);
PRINT_RESULT ((*m), "-", bbt_subtract, a, B, b, 1);
- PRINT_RESULT ((*m), "-", bbt_subtract, a, B, b, Evoral::Beats::PPQN/2);
- PRINT_RESULT ((*m), "-", bbt_subtract, a, B, b, Evoral::Beats::PPQN);
- PRINT_RESULT ((*m), "-", bbt_subtract, a, B, b, Evoral::Beats::PPQN - 1);
- PRINT_RESULT ((*m), "-", bbt_subtract, a, B, b, Evoral::Beats::PPQN - 2);
+ PRINT_RESULT ((*m), "-", bbt_subtract, a, B, b, Temporal::Beats::PPQN/2);
+ PRINT_RESULT ((*m), "-", bbt_subtract, a, B, b, Temporal::Beats::PPQN);
+ PRINT_RESULT ((*m), "-", bbt_subtract, a, B, b, Temporal::Beats::PPQN - 1);
+ PRINT_RESULT ((*m), "-", bbt_subtract, a, B, b, Temporal::Beats::PPQN - 2);
}
}
}
}
TempoMapPoints grid;
- tmap.get_grid (grid, SECONDS_TO_SUPERCLOCK (12.3), SECONDS_TO_SUPERCLOCK (44), Evoral::Beats::ticks ((Evoral::Beats::PPQN * 4) / 12));
+ tmap.get_grid (grid, SECONDS_TO_SUPERCLOCK (12.3), SECONDS_TO_SUPERCLOCK (44), Temporal::Beats::ticks ((Temporal::Beats::PPQN * 4) / 12));
cout << "grid contains " << grid.size() << endl;
for (TempoMapPoints::iterator p = grid.begin(); p != grid.end(); ++p) {
cout << *p << endl;
#include "pbd/signals.h"
-#include "evoral/Beats.hpp"
+#include "temporal/beats.h"
#include "ardour/ardour.h"
#include "ardour/superclock.h"
-#include "timecode/bbt_time.h"
+#include "temporal/bbt_time.h"
namespace ARDOUR {
Timecode::BBT_Time round_down_to_bar (Timecode::BBT_Time const &) const;
Timecode::BBT_Time round_to_bar (Timecode::BBT_Time const &) const;
- Evoral::Beats to_quarters (Timecode::BBT_Offset const &) const;
+ Temporal::Beats to_quarters (Timecode::BBT_Offset const &) const;
protected:
/** The type of "note" that a division represents. For example, 4 is
double c_per_quarter () const { return _c_per_quarter; }
void compute_c_superclock (samplecnt_t sr, superclock_t end_superclocks_per_note_type, superclock_t duration);
- void compute_c_quarters (samplecnt_t sr, superclock_t end_superclocks_per_note_type, Evoral::Beats const & duration);
+ void compute_c_quarters (samplecnt_t sr, superclock_t end_superclocks_per_note_type, Temporal::Beats const & duration);
superclock_t superclocks_per_bar (samplecnt_t sr) const;
superclock_t superclocks_per_grid (samplecnt_t sr) const;
- superclock_t superclock_at_qn (Evoral::Beats const & qn) const;
+ superclock_t superclock_at_qn (Temporal::Beats const & qn) const;
superclock_t superclock_per_note_type_at_superclock (superclock_t) const;
bool ramped () const { return _ramped; }
ExplicitMeter = 0x2,
};
- TempoMapPoint (Flag f, Tempo const& t, Meter const& m, superclock_t sc, Evoral::Beats const & q, Timecode::BBT_Time const & bbt, PositionLockStyle psl, bool ramp = false)
+ TempoMapPoint (Flag f, Tempo const& t, Meter const& m, superclock_t sc, Temporal::Beats const & q, Timecode::BBT_Time const & bbt, PositionLockStyle psl, bool ramp = false)
: _flags (f), _explicit (t, m, psl, ramp), _sclock (sc), _quarters (q), _bbt (bbt), _dirty (true), _map (0) {}
- TempoMapPoint (TempoMapPoint const & tmp, superclock_t sc, Evoral::Beats const & q, Timecode::BBT_Time const & bbt)
+ TempoMapPoint (TempoMapPoint const & tmp, superclock_t sc, Temporal::Beats const & q, Timecode::BBT_Time const & bbt)
: _flags (Flag (0)), _reference (&tmp), _sclock (sc), _quarters (q), _bbt (bbt), _dirty (true), _map (0) {}
~TempoMapPoint () {}
bool dirty() const { return _dirty; }
superclock_t sclock() const { return _sclock; }
- Evoral::Beats const & quarters() const { return _quarters; }
+ Temporal::Beats const & quarters() const { return _quarters; }
Timecode::BBT_Time const & bbt() const { return _bbt; }
bool ramped() const { return metric().ramped(); }
TempoMetric const & metric() const { return is_explicit() ? _explicit.metric : _reference->metric(); }
PositionLockStyle lock_style() const { return is_explicit() ? _explicit.lock_style : _reference->lock_style(); }
void compute_c_superclock (samplecnt_t sr, superclock_t end_superclocks_per_note_type, superclock_t duration) { if (is_explicit()) { _explicit.metric.compute_c_superclock (sr, end_superclocks_per_note_type, duration); } }
- void compute_c_quarters (samplecnt_t sr, superclock_t end_superclocks_per_note_type, Evoral::Beats const & duration) { if (is_explicit()) { _explicit.metric.compute_c_quarters (sr, end_superclocks_per_note_type, duration); } }
+ void compute_c_quarters (samplecnt_t sr, superclock_t end_superclocks_per_note_type, Temporal::Beats const & duration) { if (is_explicit()) { _explicit.metric.compute_c_quarters (sr, end_superclocks_per_note_type, duration); } }
/* None of these properties can be set for an Implicit point, because
* they are determined by the TempoMapPoint pointed to by _reference.
*/
void set_sclock (superclock_t sc) { if (is_explicit()) { _sclock = sc; _dirty = true; } }
- void set_quarters (Evoral::Beats const & q) { if (is_explicit()) { _quarters = q; _dirty = true; } }
+ void set_quarters (Temporal::Beats const & q) { if (is_explicit()) { _quarters = q; _dirty = true; } }
void set_bbt (Timecode::BBT_Time const & bbt) { if (is_explicit()) { _bbt = bbt; _dirty = true; } }
void set_dirty (bool yn);
void set_lock_style (PositionLockStyle psl) { if (is_explicit()) { _explicit.lock_style = psl; _dirty = true; } }
void make_implicit (TempoMapPoint & tmp) { _flags = Flag (0); _reference = &tmp; }
- Evoral::Beats quarters_at (superclock_t sc) const;
- Evoral::Beats quarters_at (Timecode::BBT_Time const &) const;
+ Temporal::Beats quarters_at (superclock_t sc) const;
+ Temporal::Beats quarters_at (Timecode::BBT_Time const &) const;
- Timecode::BBT_Time bbt_at (Evoral::Beats const &) const;
+ Timecode::BBT_Time bbt_at (Temporal::Beats const &) const;
#if 0
XMLNode& get_state() const;
ExplicitInfo _explicit;
};
superclock_t _sclock;
- Evoral::Beats _quarters;
+ Temporal::Beats _quarters;
Timecode::BBT_Time _bbt;
bool _dirty;
TempoMap* _map;
bool set_meter (Meter const &, superclock_t);
Meter const & meter_at (superclock_t sc) const;
- Meter const & meter_at (Evoral::Beats const & b) const;
+ Meter const & meter_at (Temporal::Beats const & b) const;
Meter const & meter_at (Timecode::BBT_Time const & bbt) const;
Tempo const & tempo_at (superclock_t sc) const;
- Tempo const & tempo_at (Evoral::Beats const &b) const;
+ Tempo const & tempo_at (Temporal::Beats const &b) const;
Tempo const & tempo_at (Timecode::BBT_Time const & bbt) const;
Timecode::BBT_Time bbt_at (superclock_t sc) const;
- Timecode::BBT_Time bbt_at (Evoral::Beats const &) const;
- Evoral::Beats quarter_note_at (superclock_t sc) const;
- Evoral::Beats quarter_note_at (Timecode::BBT_Time const &) const;
- superclock_t superclock_at (Evoral::Beats const &) const;
+ Timecode::BBT_Time bbt_at (Temporal::Beats const &) const;
+ Temporal::Beats quarter_note_at (superclock_t sc) const;
+ Temporal::Beats quarter_note_at (Timecode::BBT_Time const &) const;
+ superclock_t superclock_at (Temporal::Beats const &) const;
superclock_t superclock_at (Timecode::BBT_Time const &) const;
TempoMapPoint const & const_point_at (superclock_t sc) const { return *const_iterator_at (sc); }
- TempoMapPoint const & const_point_at (Evoral::Beats const & b) const { return *const_iterator_at (b); }
+ TempoMapPoint const & const_point_at (Temporal::Beats const & b) const { return *const_iterator_at (b); }
TempoMapPoint const & const_point_at (Timecode::BBT_Time const & bbt) const { return *const_iterator_at (bbt); }
TempoMapPoint const & const_point_after (superclock_t sc) const;
- TempoMapPoint const & const_point_after (Evoral::Beats const & b) const;
+ TempoMapPoint const & const_point_after (Temporal::Beats const & b) const;
TempoMapPoint const & const_point_after (Timecode::BBT_Time const & bbt) const;
- /* If resolution == Evoral::Beats() (i.e. zero), then the grid that is
+ /* If resolution == Temporal::Beats() (i.e. zero), then the grid that is
returned will contain a mixture of implicit and explicit points,
and will only be valid as long as this map remains unchanged
(because the implicit points may reference explicit points in the
map.
- If resolution != Evoral::Beats() (i.e. non-zero), then the in-out @param
+ If resolution != Temporal::Beats() (i.e. non-zero), then the in-out @param
grid will contain only explicit points that do not reference this
map in anyway.
*/
- void get_grid (TempoMapPoints& points, superclock_t start, superclock_t end, Evoral::Beats const & resolution);
+ void get_grid (TempoMapPoints& points, superclock_t start, superclock_t end, Temporal::Beats const & resolution);
void get_bar_grid (TempoMapPoints& points, superclock_t start, superclock_t end, int32_t bar_gap);
*/
TempoMapPoints::iterator iterator_at (superclock_t sc);
- TempoMapPoints::iterator iterator_at (Evoral::Beats const &);
+ TempoMapPoints::iterator iterator_at (Temporal::Beats const &);
TempoMapPoints::iterator iterator_at (Timecode::BBT_Time const &);
TempoMapPoints::const_iterator const_iterator_at (superclock_t sc) const { return const_cast<TempoMap*>(this)->iterator_at (sc); }
- TempoMapPoints::const_iterator const_iterator_at (Evoral::Beats const & b) const { return const_cast<TempoMap*>(this)->iterator_at (b); }
+ TempoMapPoints::const_iterator const_iterator_at (Temporal::Beats const & b) const { return const_cast<TempoMap*>(this)->iterator_at (b); }
TempoMapPoints::const_iterator const_iterator_at (Timecode::BBT_Time const & bbt) const { return const_cast<TempoMap*>(this)->iterator_at (bbt); }
/* Returns the TempoMapPoint at or most immediately preceding the given time. If the given time is
*/
TempoMapPoint & point_at (superclock_t sc) { return *iterator_at (sc); }
- TempoMapPoint & point_at (Evoral::Beats const & b) { return *iterator_at (b); }
+ TempoMapPoint & point_at (Temporal::Beats const & b) { return *iterator_at (b); }
TempoMapPoint & point_at (Timecode::BBT_Time const & bbt) { return *iterator_at (bbt); }
Meter const & meter_at_locked (superclock_t sc) const { return const_point_at (sc).metric(); }
- Meter const & meter_at_locked (Evoral::Beats const & b) const { return const_point_at (b).metric(); }
+ Meter const & meter_at_locked (Temporal::Beats const & b) const { return const_point_at (b).metric(); }
Meter const & meter_at_locked (Timecode::BBT_Time const & bbt) const { return const_point_at (bbt).metric(); }
Tempo const & tempo_at_locked (superclock_t sc) const { return const_point_at (sc).metric(); }
- Tempo const & tempo_at_locked (Evoral::Beats const &b) const { return const_point_at (b).metric(); }
+ Tempo const & tempo_at_locked (Temporal::Beats const &b) const { return const_point_at (b).metric(); }
Tempo const & tempo_at_locked (Timecode::BBT_Time const & bbt) const { return const_point_at (bbt).metric(); }
Timecode::BBT_Time bbt_at_locked (superclock_t sc) const;
- Timecode::BBT_Time bbt_at_locked (Evoral::Beats const &) const;
- Evoral::Beats quarter_note_at_locked (superclock_t sc) const;
- Evoral::Beats quarter_note_at_locked (Timecode::BBT_Time const &) const;
- superclock_t superclock_at_locked (Evoral::Beats const &) const;
+ Timecode::BBT_Time bbt_at_locked (Temporal::Beats const &) const;
+ Temporal::Beats quarter_note_at_locked (superclock_t sc) const;
+ Temporal::Beats quarter_note_at_locked (Timecode::BBT_Time const &) const;
+ superclock_t superclock_at_locked (Temporal::Beats const &) const;
superclock_t superclock_at_locked (Timecode::BBT_Time const &) const;
void rebuild_locked (superclock_t limit);
for (Evoral::Sequence<MidiModel::TimeType>::const_iterator i = bbt_source->model()->begin(MidiModel::TimeType(), true); i != bbt_source->model()->end(); ++i) {
const double new_time = map.quarter_note_at_beat ((*i).time().to_double() + map.beat_at_quarter_note (session_offset * 4.0)) - (session_offset * 4.0);
- Evoral::Event<Evoral::Beats> new_ev (*i, true);
- new_ev.set_time (Evoral::Beats (new_time));
+ Evoral::Event<Temporal::Beats> new_ev (*i, true);
+ new_ev.set_time (Temporal::Beats (new_time));
source->append_event_beats (source_lock, new_ev);
}
obj.use = [ 'libpbd',
'libardour',
'libardour_cp',
- 'libtimecode',
+ 'libtemporal',
'libmidipp',
]
obj.defines = [
'libpbd',
'libardour',
'libardour_cp',
- 'libtimecode',
+ 'libtemporal',
'libmidipp',
]
obj.defines = [
projects / ardour.git / commitdiff