#include "seqplay.h" #include #include #include #include "api_util.h" #include "beat.h" #include "engine.h" #include "espnow_tx.h" #include "bench.h" #include "esp_heap_caps.h" #include "esp_log.h" #include "esp_timer.h" #include "freertos/FreeRTOS.h" #include "freertos/queue.h" #include "freertos/task.h" #include "store.h" static const char *TAG = "seqplay"; #define LANES_MAX 8 #define STEPS_MAX 64 #define ID_MAX 24 #define BPM_MIN 60 #define BPM_MAX 200 #define BEATS_PER_BAR 4 typedef struct { char preset[ID_MAX]; int beats; int ms; // time mode: how long the step plays char group_ids[4][GROUP_ID_MAX]; // a single lane's step may carry its own groups int ngroups; } step_t; typedef struct { step_t step[STEPS_MAX]; int n, idx, count; int64_t t0; // time mode: when the step started (us) bool done; char last[ID_MAX]; // preset last uploaded for this lane } lane_t; // Everything below is guarded by the store lock (the beat task and the HTTP handlers both take it). // The lanes (about 57 KB) live in PSRAM, allocated by seqplay_init. static struct { bool active; char seq[ID_MAX], zone[ID_MAX], profile[ID_MAX]; lane_t *lane; int nlanes; bool loop; bool timed; // steps last seconds, not beats int loop_beat; bool anchor_on_pass_start; bool pending_switch; // a queued start takes over on the next beat; stop advancing meanwhile } s_run; static struct { bool set; char seq[ID_MAX], zone[ID_MAX], profile[ID_MAX]; } s_pend; static char s_done_readout[24]; // "6/6" kept after a sequence ran to its end static bool s_audio = true; static uint32_t s_sim_beats; // simulated clock beats, for its bar phase static int64_t s_last_beat_us; /* ------------------------------------------------------------- settings */ static int simulated_bpm(void) { const cJSON *v = cJSON_GetObjectItem(store_settings(), "audio_simulated_bpm"); int bpm = cJSON_IsNumber(v) ? (int)v->valuedouble : 120; return bpm < BPM_MIN ? BPM_MIN : (bpm > BPM_MAX ? BPM_MAX : bpm); } static bool audio_drives(void) { beat_info_t bi; beat_get_info(&bi); return s_audio && bi.locked; } // "downbeat" only while the mic is timing (the clock's bar is a guess); otherwise "beat" static bool wait_for_downbeat(void) { const cJSON *v = cJSON_GetObjectItem(store_settings(), "sequence_switch_wait"); return audio_drives() && cJSON_IsString(v) && !strcasecmp(v->valuestring, "downbeat"); } /* ---------------------------------------------------------------- targets */ static void add_id(cJSON *arr, const char *id) { const cJSON *it; cJSON_ArrayForEach(it, arr) { if (!strcmp(it->valuestring, id)) { return; } } cJSON_AddItemToArray(arr, cJSON_CreateString(id)); } static void add_list(cJSON *arr, const cJSON *list) { const cJSON *it; cJSON_ArrayForEach(it, list) { char id[GROUP_ID_MAX]; if (api_id(it, id, sizeof(id))) { add_id(arr, id); } } } // Groups a lane's step plays to (main's _group_ids_for_lane_step), falling back to the zone's groups static cJSON *lane_groups(int lane, const step_t *st) { cJSON *out = cJSON_CreateArray(); const cJSON *seq = cJSON_GetObjectItem(store_coll("sequence"), s_run.seq); const cJSON *lgs = cJSON_GetObjectItem(seq, "lanes_group_ids"); if (cJSON_IsArray(lgs) && lane < cJSON_GetArraySize(lgs)) { add_list(out, cJSON_GetArrayItem(lgs, lane)); } else if (!(s_run.nlanes > 1 && cJSON_IsArray(lgs))) { add_list(out, cJSON_GetObjectItem(seq, "group_ids")); for (int i = 0; !out->child && s_run.nlanes == 1 && i < st->ngroups; i++) { add_id(out, st->group_ids[i]); } } if (!out->child) { char t[ZONE_TARGETS_MAX][GROUP_ID_MAX]; int n = engine_zone_targets(s_run.zone, t, ZONE_TARGETS_MAX); for (int i = 0; i < n; i++) { add_id(out, t[i]); } } return out; } static void send(cJSON *msg) { cJSON *messages = cJSON_CreateArray(); cJSON_AddItemToArray(messages, msg); engine_push(messages, NULL); cJSON_Delete(messages); } static cJSON *message(cJSON *groups) { cJSON *m = cJSON_CreateObject(); cJSON_AddStringToObject(m, "v", "1"); if (groups && groups->child) { cJSON_AddItemToObject(m, "groups", groups); } else { cJSON_Delete(groups); } return m; } // Upload presets [from, to) of a lane (each once) to the lane's groups static void send_presets(int lane, int from, int to) { lane_t *l = &s_run.lane[lane]; cJSON *presets = cJSON_CreateObject(); for (int i = from; i < to && i < l->n; i++) { const char *id = l->step[i].preset; cJSON *p = cJSON_GetObjectItem(presets, id) ? NULL : engine_preset_payload(id); if (p) { cJSON_AddItemToObject(presets, id, p); } } if (!presets->child) { cJSON_Delete(presets); return; } cJSON *m = message(lane_groups(lane, &l->step[from])); cJSON_AddItemToObject(m, "presets", presets); send(m); } static void send_select(int lane) { lane_t *l = &s_run.lane[lane]; const step_t *st = &l->step[l->idx]; cJSON *m = message(lane_groups(lane, st)); cJSON *sel = cJSON_AddArrayToObject(m, "select"); cJSON_AddItemToArray(sel, cJSON_CreateString(st->preset)); send(m); } // Step change: upload the new step's preset unless it is already there, then select it static void send_lane(int lane) { lane_t *l = &s_run.lane[lane]; if (l->done || l->idx >= l->n || !l->step[l->idx].preset[0]) { return; } if (strcmp(l->last, l->step[l->idx].preset)) { send_presets(lane, l->idx, l->idx + 1); memcpy(l->last, l->step[l->idx].preset, ID_MAX); } send_select(lane); } // Every driver the zone reaches gets its combined brightness with the zone's slider value static void zone_brightness(void) { const cJSON *zone = cJSON_GetObjectItem(store_coll("zone"), s_run.zone); const cJSON *zb = cJSON_GetObjectItem(zone, "brightness"); int zone_b = cJSON_IsNumber(zb) ? (int)zb->valuedouble : 255; zone_b = zone_b < 0 ? 0 : (zone_b > 255 ? 255 : zone_b); cJSON *macs = cJSON_CreateArray(); char t[ZONE_TARGETS_MAX][GROUP_ID_MAX]; int n = engine_zone_targets(s_run.zone, t, ZONE_TARGETS_MAX); for (int i = 0; i < n; i++) { const cJSON *it; if (t[i][0] == 'z') { // drivers named by the zone const cJSON *d; cJSON_ArrayForEach(d, store_coll("device")) { const cJSON *name = cJSON_GetObjectItem(d, "name"); cJSON_ArrayForEach(it, cJSON_GetObjectItem(zone, "names")) { if (cJSON_IsString(name) && cJSON_IsString(it) && !strcmp(name->valuestring, it->valuestring)) { add_id(macs, d->string); } } } continue; } cJSON_ArrayForEach(it, cJSON_GetObjectItem(cJSON_GetObjectItem(store_coll("group"), t[i]), "devices")) { char mac[13]; if (api_mac(it, mac)) { add_id(macs, mac); } } } const cJSON *mac; cJSON_ArrayForEach(mac, macs) { cJSON *m = message(NULL); cJSON_AddNumberToObject(m, "b", api_effective_brightness(mac->valuestring, zone_b)); cJSON_AddTrueToObject(m, "save"); cJSON *messages = cJSON_CreateArray(), *targets = cJSON_CreateArray(); cJSON_AddItemToArray(messages, m); cJSON_AddItemToArray(targets, cJSON_CreateString(mac->valuestring)); engine_push(messages, targets); cJSON_Delete(messages); cJSON_Delete(targets); } cJSON_Delete(macs); } /* --------------------------------------------------------------- playback */ // The sequence's lanes as steps (main's _normalize_sequence_lanes); empty lanes are dropped static int load_lanes(const cJSON *seq) { const cJSON *lanes = cJSON_GetObjectItem(seq, "lanes"); bool any = false; const cJSON *l; cJSON_ArrayForEach(l, lanes) { any = any || cJSON_GetArraySize(l) > 0; } cJSON *one = NULL; if (!any && cJSON_GetArraySize(cJSON_GetObjectItem(seq, "steps"))) { one = cJSON_CreateArray(); cJSON_AddItemReferenceToArray(one, cJSON_GetObjectItem(seq, "steps")); lanes = one; } int n = 0; cJSON_ArrayForEach(l, lanes) { if (n == LANES_MAX || !cJSON_IsArray(l) || !cJSON_GetArraySize(l)) { continue; } lane_t *lane = &s_run.lane[n]; memset(lane, 0, sizeof(*lane)); const cJSON *s; cJSON_ArrayForEach(s, l) { if (lane->n == STEPS_MAX || !cJSON_IsObject(s)) { continue; } step_t *st = &lane->step[lane->n++]; const cJSON *pid = cJSON_GetObjectItem(s, "preset_id"); api_id(pid ? pid : cJSON_GetObjectItem(s, "presetId"), st->preset, sizeof(st->preset)); const cJSON *b = cJSON_GetObjectItem(s, "beats"); st->beats = cJSON_IsNumber(b) && b->valuedouble >= 1 ? (int)b->valuedouble : 1; const cJSON *sec = cJSON_GetObjectItem(s, "seconds"); double secs = cJSON_IsNumber(sec) ? sec->valuedouble : 3.0; st->ms = secs < 0.1 ? 100 : (secs > 3600 ? 3600000 : (int)(secs * 1000)); const cJSON *g; cJSON_ArrayForEach(g, cJSON_GetObjectItem(s, "group_ids")) { if (st->ngroups < 4 && api_id(g, st->group_ids[st->ngroups], GROUP_ID_MAX)) { st->ngroups++; } } } n += lane->n > 0; } cJSON_Delete(one); return n; } static void anchor_bar(void) { s_sim_beats = 0; // the next clock beat is a downbeat if (audio_drives()) { beat_tap(); // the beat just counted is beat 1 of the bar } } static void clear_drivers(void) { cJSON *groups = cJSON_CreateArray(); char t[ZONE_TARGETS_MAX][GROUP_ID_MAX]; int n = engine_zone_targets(s_run.zone, t, ZONE_TARGETS_MAX); for (int i = 0; i < n; i++) { add_id(groups, t[i]); } if (!groups->child) { // never clear every driver in range cJSON_Delete(groups); return; } cJSON *m = message(groups); cJSON_AddTrueToObject(m, "clear_presets"); cJSON_AddTrueToObject(m, "save"); send(m); } static esp_err_t start_now(const char *seq_id, const char *zone_id, const char *profile_id, bool handoff, bool downbeat, const char **msg) { const cJSON *seq = cJSON_GetObjectItem(store_coll("sequence"), seq_id); if (!seq) { return ESP_ERR_NOT_FOUND; } if (!cJSON_GetObjectItem(store_coll("zone"), zone_id)) { *msg = "zone not found"; return ESP_ERR_INVALID_ARG; } s_pend.set = false; s_run.active = false; s_done_readout[0] = 0; snprintf(s_run.seq, sizeof(s_run.seq), "%s", seq_id); snprintf(s_run.zone, sizeof(s_run.zone), "%s", zone_id); snprintf(s_run.profile, sizeof(s_run.profile), "%s", profile_id); s_run.nlanes = load_lanes(seq); if (!s_run.nlanes) { *msg = "sequence has no steps"; return ESP_ERR_INVALID_SIZE; } const cJSON *loop = cJSON_GetObjectItem(seq, "loop"); s_run.loop = !loop || cJSON_IsTrue(loop) || (cJSON_IsNumber(loop) && loop->valuedouble != 0); const cJSON *mode = cJSON_GetObjectItem(seq, "advance_mode"); s_run.timed = cJSON_IsString(mode) && !strcmp(mode->valuestring, "time"); int64_t t_start = esp_timer_get_time(); for (int i = 0; i < s_run.nlanes; i++) { s_run.lane[i].t0 = t_start; } s_run.loop_beat = 0; s_run.pending_switch = false; s_run.anchor_on_pass_start = handoff ? downbeat : true; // Step-0 presets, the selects, then the rest of each lane's presets (main's _prime_all_lanes) for (int i = 0; i < s_run.nlanes; i++) { send_presets(i, 0, 1); memcpy(s_run.lane[i].last, s_run.lane[i].step[0].preset, ID_MAX); } for (int i = 0; i < s_run.nlanes; i++) { send_select(i); } for (int i = 0; i < s_run.nlanes; i++) { send_presets(i, 1, s_run.lane[i].n); } zone_brightness(); s_run.active = true; ESP_LOGI(TAG, "sequence %s in zone %s: %d lane(s)", seq_id, zone_id, s_run.nlanes); return ESP_OK; } static bool pass_start(void) { const lane_t *l = &s_run.lane[0]; return !l->done && l->idx == 0 && l->count == 0; } static int readout(char *buf, size_t len); // forward // Move a lane on once its step is over. Sets *looped when lane 0 wrapped round. static void step_lane(int i, int64_t now, bool *looped) { lane_t *l = &s_run.lane[i]; if (l->idx + 1 >= l->n) { if (s_run.loop) { *looped = *looped || i == 0; l->count = 0; l->idx = 0; l->t0 = now; l->last[0] = 0; // step 0 goes up again on each wrap send_lane(i); } else { l->count = l->step[l->idx].beats; l->done = true; } } else { l->count = 0; l->idx++; l->t0 = now; send_lane(i); } } static void finish_if_done(void) { for (int i = 0; i < s_run.nlanes; i++) { if (!s_run.lane[i].done) { return; } } readout(s_done_readout, sizeof(s_done_readout)); clear_drivers(); s_run.active = false; ESP_LOGI(TAG, "sequence %s finished", s_run.seq); } // Time mode: called often; lanes move on when their step's seconds are up static void advance_time(void) { if (!s_run.active || !s_run.timed || s_run.pending_switch) { return; } int64_t now = esp_timer_get_time(); bool looped = false; for (int i = 0; i < s_run.nlanes; i++) { lane_t *l = &s_run.lane[i]; if (!l->done && l->n && now - l->t0 >= (int64_t)l->step[l->idx].ms * 1000) { step_lane(i, now, &looped); } } finish_if_done(); } static void advance(void) { if (!s_run.active || s_run.pending_switch || s_run.timed) { return; } if (pass_start() && s_run.anchor_on_pass_start) { anchor_bar(); } s_run.anchor_on_pass_start = true; bool lane0_looped = false; for (int i = 0; i < s_run.nlanes; i++) { lane_t *l = &s_run.lane[i]; if (l->done || !l->n) { continue; } if (++l->count >= l->step[l->idx].beats) { step_lane(i, 0, &lane0_looped); } } s_run.loop_beat = lane0_looped ? 1 : s_run.loop_beat + 1; finish_if_done(); } static void on_beat(bool downbeat) { int64_t now = esp_timer_get_time(); if (now - s_last_beat_us < 60LL * 1000000 / BPM_MAX) { // never faster than BPM_MAX return; } s_last_beat_us = now; store_lock(); if (s_pend.set && (downbeat || !wait_for_downbeat())) { const char *msg = NULL; char seq[ID_MAX], zone[ID_MAX], profile[ID_MAX]; snprintf(seq, sizeof(seq), "%s", s_pend.seq); snprintf(zone, sizeof(zone), "%s", s_pend.zone); snprintf(profile, sizeof(profile), "%s", s_pend.profile); if (start_now(seq, zone, profile, true, downbeat, &msg) != ESP_OK) { ESP_LOGW(TAG, "queued sequence %s did not start: %s", seq, msg ? msg : "not found"); } } else { advance(); } store_unlock(); } static void beat_task(void *arg) { QueueHandle_t q = xQueueCreate(8, sizeof(beat_event_t)); if (!q || beat_subscribe(q) != ESP_OK) { ESP_LOGE(TAG, "no beat subscription; the clock alone times sequences"); } int64_t next = esp_timer_get_time(); for (;;) { store_lock(); advance_time(); int64_t interval = 60LL * 1000000 / simulated_bpm(); store_unlock(); int64_t now = esp_timer_get_time(); if (next <= now) { // clock beat, counted only while the mic is not timing next = (next + interval > now) ? next + interval : now + interval; if (!audio_drives()) { bool down = s_sim_beats % BEATS_PER_BAR == 0; s_sim_beats++; // Drivers get the clock's beats too, so manual (beat-stepped) presets keep moving if (!bench_running()) { espnow_tx_beat(60e6f / interval, down, (int)((s_sim_beats - 1) % BEATS_PER_BAR) + 1); } on_beat(down); } continue; } beat_event_t ev; int64_t wait_ms = (next - now) / 1000; if (wait_ms > 40) { // wake often enough to time steps in seconds wait_ms = 40; } if (q && xQueueReceive(q, &ev, pdMS_TO_TICKS(wait_ms) + 1) == pdTRUE && ev == BEAT_EVENT_BEAT && audio_drives()) { beat_info_t bi; beat_get_info(&bi); on_beat(bi.bar_beat == 1); } } } /* --------------------------------------------------------------------- API */ esp_err_t seqplay_init(void) { s_run.lane = heap_caps_calloc(LANES_MAX, sizeof(lane_t), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT); if (!s_run.lane) { return ESP_ERR_NO_MEM; } store_lock(); const cJSON *a = cJSON_GetObjectItem(store_settings(), "audio_timing"); s_audio = !cJSON_IsFalse(a); store_unlock(); espnow_tx_set_mic_beats(s_audio); return xTaskCreate(beat_task, "seqplay", 6144, NULL, 4, NULL) == pdPASS ? ESP_OK : ESP_ERR_NO_MEM; } esp_err_t seqplay_start(const char *seq_id, const char *zone_id, const char *profile_id, const char **msg) { *msg = NULL; const cJSON *seq = cJSON_GetObjectItem(store_coll("sequence"), seq_id); char owner[ID_MAX]; if (!seq || !api_id(cJSON_GetObjectItem(seq, "profile_id"), owner, sizeof(owner)) || strcmp(owner, profile_id)) { *msg = "sequence not found"; return ESP_ERR_NOT_FOUND; } if (!s_run.active) { return start_now(seq_id, zone_id, profile_id, false, false, msg); } // Another sequence plays: switch on the next beat (or downbeat) s_pend.set = true; snprintf(s_pend.seq, sizeof(s_pend.seq), "%s", seq_id); snprintf(s_pend.zone, sizeof(s_pend.zone), "%s", zone_id); snprintf(s_pend.profile, sizeof(s_pend.profile), "%s", profile_id); s_run.pending_switch = true; return ESP_OK; } void seqplay_stop(bool clear) { store_lock(); bool was = s_run.active; s_pend.set = false; s_run.active = false; bool finished = true; for (int i = 0; i < s_run.nlanes; i++) { finished = finished && s_run.lane[i].done; } if (!finished) { s_done_readout[0] = 0; } if (was && clear) { clear_drivers(); } store_unlock(); } void seqplay_stop_if(const char *seq_id) { store_lock(); bool playing = s_run.active && !strcmp(s_run.seq, seq_id); store_unlock(); if (playing) { seqplay_stop(true); } } bool seqplay_sync(const char *mode) { store_lock(); bool ok = s_run.active; if (ok && (!strcasecmp(mode, "pass") || !strcasecmp(mode, "sequence") || !strcasecmp(mode, "restart"))) { for (int i = 0; i < s_run.nlanes; i++) { s_run.lane[i].idx = s_run.lane[i].count = 0; s_run.lane[i].done = false; } s_run.loop_beat = 0; for (int i = 0; i < s_run.nlanes; i++) { send_lane(i); } } else if (ok) { for (int i = 0; i < s_run.nlanes; i++) { if (!s_run.lane[i].done) { s_run.lane[i].count = 0; } } } if (ok) { anchor_bar(); } store_unlock(); return ok; } // Lane 0's position in the pass: beats so far and per pass static void pass_position(int *at, int *per_pass) { const lane_t *l = &s_run.lane[0]; *at = *per_pass = 0; for (int i = 0; i < l->n; i++) { *per_pass += l->step[i].beats; } if (l->done) { *at = *per_pass; return; } for (int i = 0; i < l->idx && i < l->n; i++) { *at += l->step[i].beats; } int bt = l->idx < l->n ? l->step[l->idx].beats : 1; *at += l->count < 0 ? 0 : (l->count > bt ? bt : l->count); } static int readout(char *buf, size_t len) { int at, tot; buf[0] = 0; if (s_run.timed) { // seconds, not beats: no n/n readout return 0; } pass_position(&at, &tot); if (tot > 0 && s_run.lane[0].done) { return snprintf(buf, len, "%d/%d", tot, tot); } if (tot > 0 && at > 0) { // on the last beat of the pass show n/n return snprintf(buf, len, "%d/%d", at == tot - 1 ? tot : (at < tot ? at : tot), tot); } return 0; } cJSON *seqplay_status(void) { cJSON *o = cJSON_CreateObject(); store_lock(); if (!s_run.active) { cJSON_AddFalseToObject(o, "active"); cJSON_AddStringToObject(o, "beat_readout", ""); store_unlock(); return o; } const lane_t *l = &s_run.lane[0]; int total = 0; for (int i = 0; i < s_run.nlanes; i++) { total += s_run.lane[i].n; } int at, per_pass; pass_position(&at, &per_pass); int bps = !l->done && l->idx < l->n ? l->step[l->idx].beats : 1; int beat_in = l->done ? 0 : (l->count > bps ? bps : l->count); const char *pid = !l->done && l->idx < l->n ? l->step[l->idx].preset : ""; const cJSON *pdoc = pid[0] ? cJSON_GetObjectItem(store_coll("preset"), pid) : NULL; const cJSON *pname = cJSON_GetObjectItem(pdoc, "name"); char ro[24]; readout(ro, sizeof(ro)); cJSON_AddTrueToObject(o, "active"); cJSON_AddStringToObject(o, "advance_mode", s_run.timed ? "time" : "beats"); if (s_run.timed && !l->done && l->idx < l->n) { cJSON_AddNumberToObject(o, "lane0_step_elapsed_ms", (double)((esp_timer_get_time() - l->t0) / 1000)); cJSON_AddNumberToObject(o, "lane0_step_duration_ms", l->step[l->idx].ms); } cJSON_AddStringToObject(o, "sequence_id", s_run.seq); cJSON_AddStringToObject(o, "zone_id", s_run.zone); cJSON_AddNumberToObject(o, "num_lanes", s_run.nlanes); cJSON_AddNumberToObject(o, "total_sequence_steps", total); cJSON_AddNumberToObject(o, "lane0_current_step", l->done ? l->n : l->idx + 1); cJSON_AddNumberToObject(o, "lane0_lane_length", l->n); cJSON_AddNumberToObject(o, "lane0_beat_in_step", beat_in); cJSON_AddNumberToObject(o, "lane0_beats_per_step", bps); cJSON_AddStringToObject(o, "lane0_preset_id", pid); cJSON_AddStringToObject(o, "lane0_preset_name", cJSON_IsString(pname) && pname->valuestring[0] ? pname->valuestring : pid); cJSON_AddNumberToObject(o, "sequence_beat_at", at); cJSON_AddNumberToObject(o, "sequence_beats_per_pass", per_pass); cJSON_AddNumberToObject(o, "sequence_loop_beat", s_run.loop_beat); cJSON_AddStringToObject(o, "beat_readout", ro); store_unlock(); return o; } cJSON *seqplay_pending(void) { cJSON *o = cJSON_CreateObject(); store_lock(); cJSON_AddBoolToObject(o, "pending", s_pend.set); if (s_pend.set) { cJSON_AddStringToObject(o, "wait_for", wait_for_downbeat() ? "downbeat" : "beat"); cJSON_AddStringToObject(o, "sequence_id", s_pend.seq); cJSON_AddStringToObject(o, "zone_id", s_pend.zone); } store_unlock(); return o; } const char *seqplay_done_readout(void) { return s_done_readout; } void seqplay_set_audio(bool on) { store_lock(); s_audio = on; espnow_tx_set_mic_beats(on); api_set(store_settings(), "audio_timing", cJSON_CreateBool(on)); store_save("settings"); store_unlock(); } bool seqplay_audio(void) { return s_audio; } const char *seqplay_switch_wait(void) { store_lock(); bool down = wait_for_downbeat(); store_unlock(); return down ? "downbeat" : "beat"; } void seqplay_clock(int *bar_beat, uint32_t *tick) { *tick = s_sim_beats; *bar_beat = s_sim_beats ? (int)((s_sim_beats - 1) % BEATS_PER_BAR) + 1 : 1; }