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

triggerbox: barcnt -> beatcnt (libardour part)

Browse source
This commit is contained in:
Ben Loftis 2022-01-26 10:17:30 -06:00
parent 925a3b3ccd
commit efb44fc640
2 changed files with 44 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

18
libs/ardour/ardour/triggerbox.h
View file

@ -352,7 +352,16 @@ class LIBARDOUR_API Trigger : public PBD::Stateful {
double _estimated_tempo; //TODO: this should come from the MIDI file double _estimated_tempo; //TODO: this should come from the MIDI file
double _segment_tempo; //TODO: this will likely get stored in the SegmentDescriptor for audio triggers double _segment_tempo; //TODO: this will likely get stored in the SegmentDescriptor for audio triggers
double _barcnt; /* our estimate of the number of bars in the region */ /* basic process is :
1) when a file is loaded, we infer its bpm either by minibpm's estimate, a flag in the filename, metadata (TBD) or other means
2) we assume the clip must have an integer number of beats in it (simplest case is a one-bar loop with 4 beats in it)
3) ...so we round to the nearest beat length, and set the tempo to *exactly* fit the sample-length into the assumed beat-length
4) the user may recognize a problem: "this was a 3/4 beat, which was rounded to 4 beats but it should have been 3"
5) if the user changes the beat-length, then the tempo is recalculated for use during stretching
6) someday, we will also allow the sample start and length to be adjusted in a trimmer, and that will also adjust the tempo
7) in all cases the user should be in final control; but our "internal" value for stretching are just sample-start and BPM, end of story
*/
double _beatcnt;
Temporal::Meter _meter; Temporal::Meter _meter;
samplepos_t expected_end_sample; samplepos_t expected_end_sample;
@ -382,11 +391,8 @@ class LIBARDOUR_API AudioTrigger : public Trigger {
double segment_tempo() const { return _segment_tempo; } double segment_tempo() const { return _segment_tempo; }
void set_segment_tempo (double t); void set_segment_tempo (double t);
Temporal::Meter segment_meter() const { return _meter; } //TODO: might be different? double segment_beatcnt () { return _beatcnt; }
void set_segment_meter(Temporal::Meter const &); //TODO: disambiguated from a future midi::metrum void set_segment_beatcnt (double count);
double segment_barcnt () { return _barcnt; }
void set_segment_barcnt (double count);
void set_start (timepos_t const &); void set_start (timepos_t const &);
void set_end (timepos_t const &); void set_end (timepos_t const &);

84
libs/ardour/triggerbox.cc
View file

@ -132,7 +132,7 @@ Trigger::Trigger (uint32_t n, TriggerBox& b)
, cue_launched (false) , cue_launched (false)
, _estimated_tempo (0.) , _estimated_tempo (0.)
, _segment_tempo (0.) , _segment_tempo (0.)
, _barcnt (0.) , _beatcnt (0.)
, _meter (4, 4) , _meter (4, 4)
, expected_end_sample (0) , expected_end_sample (0)
, _pending ((Trigger*) 0) , _pending ((Trigger*) 0)
@ -371,7 +371,7 @@ Trigger::get_state (void)
node->set_property (X_("index"), _index); node->set_property (X_("index"), _index);
node->set_property (X_("estimated-tempo"), _estimated_tempo); node->set_property (X_("estimated-tempo"), _estimated_tempo);
node->set_property (X_("segment-tempo"), _segment_tempo); node->set_property (X_("segment-tempo"), _segment_tempo);
node->set_property (X_("barcnt"), _barcnt); node->set_property (X_("beatcnt"), _beatcnt);
if (_region) { if (_region) {
node->set_property (X_("region"), _region->id()); node->set_property (X_("region"), _region->id());
@ -399,7 +399,7 @@ Trigger::set_state (const XMLNode& node, int version)
node.get_property (X_("estimated-tempo"), _estimated_tempo); //TODO: for now: if we know the bpm, overwrite the value that estimate_tempo() found node.get_property (X_("estimated-tempo"), _estimated_tempo); //TODO: for now: if we know the bpm, overwrite the value that estimate_tempo() found
node.get_property (X_("segment-tempo"), _segment_tempo); node.get_property (X_("segment-tempo"), _segment_tempo);
node.get_property (X_("barcnt"), _barcnt); node.get_property (X_("beatcnt"), _beatcnt);
node.get_property (X_("index"), _index); node.get_property (X_("index"), _index);
set_values (node); set_values (node);
@ -860,33 +860,17 @@ AudioTrigger::set_segment_tempo (double t)
} }
void void
AudioTrigger::set_segment_meter (Temporal::Meter const &m) AudioTrigger::set_segment_beatcnt (double count)
{ {
if (_meter != m) { if (_beatcnt != count) {
_meter = m; _beatcnt = count;
//given a meter from the user, tempo is assumed constant and we re-calc barcnt internally //given a beatcnt from the user, we use the data length to re-calc tempo internally
// ... TODO: provide a graphical trimmer to give the user control of data.length by dragging the start and end of the sample.
const double seconds = (double) data.length / _box.session().sample_rate(); const double seconds = (double) data.length / _box.session().sample_rate();
const double quarters = (seconds / 60.) * _segment_tempo; double tempo = _beatcnt / (seconds/60.0);
_barcnt = quarters / _meter.divisions_per_bar();
PropertyChanged (ARDOUR::Properties::tempo_meter); set_segment_tempo(tempo);
_box.session().set_dirty();
}
}
void
AudioTrigger::set_segment_barcnt (double count)
{
if (_barcnt != count) {
_barcnt = count;
//given a barcnt from the user, meter is assumed constant and we re-calc tempo internally
const double seconds = (double) data.length / _box.session().sample_rate();
const double quarters = _barcnt * _meter.divisions_per_bar(); //TODO: this assumes note_value=quarter
_estimated_tempo = quarters / (seconds/60.0);
set_segment_tempo(_estimated_tempo);
} }
} }
@ -1006,23 +990,22 @@ AudioTrigger::set_expected_end_sample (Temporal::TempoMap::SharedPtr const & tma
data.length : how many samples there are in the data (AudioTime / samples) data.length : how many samples there are in the data (AudioTime / samples)
_follow_length : the (user specified) time after the start of the trigger when the follow action should take effect _follow_length : the (user specified) time after the start of the trigger when the follow action should take effect
_use_follow_length : whether to use the follow_length value, or the clip's natural length _use_follow_length : whether to use the follow_length value, or the clip's natural length
_barcnt : the expected duration of the trigger, based on analysis of its tempo, or user-set _beatcnt : the expected duration of the trigger, based on analysis of its tempo .. can be overridden by the user later
*/ */
samplepos_t end_by_follow_length = tmap->sample_at (tmap->bbt_walk(transition_bbt, _follow_length)); samplepos_t end_by_follow_length = tmap->sample_at (tmap->bbt_walk(transition_bbt, _follow_length));
samplepos_t end_by_barcnt = tmap->sample_at (tmap->bbt_walk(transition_bbt, Temporal::BBT_Offset (round (_barcnt), 0, 0))); samplepos_t end_by_beatcnt = tmap->sample_at (tmap->bbt_walk(transition_bbt, Temporal::BBT_Offset (0, round (_beatcnt), 0))); //OK?
samplepos_t end_by_data_length = transition_sample + data.length; samplepos_t end_by_data_length = transition_sample + data.length;
DEBUG_TRACE (DEBUG::Triggers, string_compose ("%1 @ %2 / %3 / %4 ends: FL %5 (from %6) BC %7 DL %8\n", DEBUG_TRACE (DEBUG::Triggers, string_compose ("%1 @ %2 / %3 / %4 ends: FL %5 (from %6) BC %7 DL %8\n",
index(), transition_sample, transition_beats, transition_bbt, index(), transition_sample, transition_beats, transition_bbt,
end_by_follow_length, _follow_length, end_by_barcnt, end_by_data_length)); end_by_follow_length, _follow_length, end_by_beatcnt, end_by_data_length));
if (stretching()) { if (stretching()) {
if (internal_use_follow_length()) { if (internal_use_follow_length()) {
expected_end_sample = std::min (end_by_follow_length, end_by_barcnt); expected_end_sample = std::min (end_by_follow_length, end_by_beatcnt);
} else { } else {
expected_end_sample = end_by_barcnt; expected_end_sample = end_by_beatcnt;
} }
} else { } else {
if (internal_use_follow_length()) { if (internal_use_follow_length()) {
@ -1253,35 +1236,32 @@ AudioTrigger::estimate_tempo ()
} }
const double seconds = (double) data.length / _box.session().sample_rate(); const double seconds = (double) data.length / _box.session().sample_rate();
const double quarters = (seconds / 60.) * _estimated_tempo;
/* initialize bar count to match the file length ... user can later change this value */
_barcnt = quarters / _meter.divisions_per_bar();
/* initialize our follow_length to match the barcnt ... user can later change this value */
_follow_length = (Temporal::BBT_Offset( rint(_barcnt), 0, 0));
/* now check the determined tempo and force it to a value that gives us /* now check the determined tempo and force it to a value that gives us
an integer bar/quarter count. This is a heuristic that tries to an integer beat/quarter count. This is a heuristic that tries to
avoid clips that slightly over- or underrun a quantization point, avoid clips that slightly over- or underrun a quantization point,
resulting in small or larger gaps in output if they are repeating. resulting in small or larger gaps in output if they are repeating.
*/ */
if ((_estimated_tempo != 0.) && (rint (_barcnt) != _barcnt)) { if ((_estimated_tempo != 0.)) {
/* fractional barcnt */ /* fractional beatcnt */
int intquarters = round (quarters); double maybe_beats = (seconds / 60.) * _estimated_tempo;
double at = _estimated_tempo; _beatcnt = round (maybe_beats);
_estimated_tempo = intquarters / (seconds/60.); double est = _estimated_tempo;
DEBUG_TRACE (DEBUG::Triggers, string_compose ("adjusted barcnt of %1 and q = %2 to %3, old %4 new at = %5 seconds was %6\n", _barcnt, quarters, intquarters, at, _estimated_tempo, seconds)); _estimated_tempo = _beatcnt / (seconds/60.);
DEBUG_TRACE (DEBUG::Triggers, string_compose ("given original estimated tempo %1, rounded beatcnt is %2 : resulting in working bpm = %3\n", est, _beatcnt, _estimated_tempo));
} }
/* initialize our follow_length to match the beatcnt ... user can later change this value to have the clip end sooner or later than its data length */
_follow_length = (Temporal::BBT_Offset( 0, rint(_beatcnt), 0)); //OK ?
/* use initial tempo in map (assumed for now to be the only one */ /* use initial tempo in map (assumed for now to be the only one */
const samplecnt_t one_bar = tm->bbt_duration_at (timepos_t (AudioTime), BBT_Offset (1, 0, 0)).samples(); const samplecnt_t one_beat = tm->bbt_duration_at (timepos_t (AudioTime), BBT_Offset (0, 1, 0)).samples();
cerr << "estimated tempo: " << _estimated_tempo << endl; cerr << "estimated tempo: " << _estimated_tempo << endl;
cerr << "one bar in samples: " << one_bar << endl; cerr << "one beat in samples: " << one_beat << endl;
cerr << "barcnt = " << round (_barcnt) << endl; cerr << "beatcnt = " << round (_beatcnt) << endl;
} }
bool bool
@ -1289,9 +1269,9 @@ AudioTrigger::probably_oneshot () const
{ {
assert (_segment_tempo != 0.); assert (_segment_tempo != 0.);
if ((data.length < (_box.session().sample_rate()/2)) || if ((data.length < (_box.session().sample_rate()/2)) || //less than 1/2 second
/* XXX use Meter here, not 4.0 */ (_segment_tempo > 140) || //minibpm thinks this is really fast
((_barcnt < 1) && (data.length < (4.0 * ((_box.session().sample_rate() * 60) / _segment_tempo))))) { (_segment_tempo < 60)) { //minibpm thinks this is really slow
std::cerr << "looks like a one-shot\n"; std::cerr << "looks like a one-shot\n";
return true; return true;
} }