unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-06 11:46:41 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor: reuse horizontal::draw

Browse source
This commit is contained in:
🪞👃🪞 2024-07-01 22:12:25 +03:00
parent 91832e0072
commit 939ffe3630
6 changed files with 130 additions and 117 deletions
Download patch file Download diff file Expand all files Collapse all files

34
src/core/time.rs
View file

@ -27,7 +27,7 @@ impl Timebase {
self.bpm.load(Ordering::Relaxed)
}
#[inline] fn beat_usec (&self) -> f64 {
60_000_000_000_000f64 / self.bpm() as f64
60_000_000f64 / self.bpm() as f64
}
#[inline] pub fn ppq (&self) -> f64 {
@ -36,7 +36,7 @@ impl Timebase {
#[inline] fn pulse_usec (&self) -> f64 {
self.beat_usec() / self.ppq() as f64
}
#[inline] fn pulse_frame (&self) -> f64 {
#[inline] pub fn pulse_frame (&self) -> f64 {
self.pulse_usec() / self.frame_usec() as f64
}
#[inline] pub fn pulses_frames (&self, pulses: f64) -> f64 {
@ -130,3 +130,33 @@ impl Timebase {
}
}
#[cfg(test)] mod test {
use super::*;
#[test]
fn test_timebase () -> Usually<()> {
let timebase = Timebase::new(48000.0, 240.0, 24.0);
println!("F/S = {:.03}", s.rate());
println!("B/S = {:.03}", s.beats_per_secon());
println!("F/B = {:.03}", s.frames_per_beat());
println!("T/B = {:.03}", s.ticks_per_beat());
println!("F/T = {:.03}", s.frames_per_tick());
println!("F/L = {:.03}", s.frames_per_loop());
println!("T/L = {:.03}", s.ticks_per_loop());
let fpt = s.fpt();
let frames_per_chunk = 240;
let chunk = |chunk: usize| s.frames_to_ticks(
chunk * frames_per_chunk,
(chunk + 1) * frames_per_chunk
);
//for i in 0..2000 {
//println!("{i} {:?}", chunk(i));
//}
assert_eq!(chunk(0), vec![(0, 0), (125, 1)]);
assert_eq!(chunk(1), vec![(10, 2), (135, 3)]);
assert_eq!(chunk(12), vec![(120, 24)]);
assert_eq!(chunk(412), vec![(120, 24)]);
assert_eq!(chunk(413), vec![(5, 25), (130, 26)]);
Ok(())
}
}

34
src/device/launcher/mod.rs
View file

@ -221,26 +221,24 @@ fn draw_section_sequencer (state: &Launcher, buf: &mut Buffer, area: Rect) -> Us
}
let track = track.unwrap().1;
let sequencer = track.sequencer.state();
{
use crate::device::sequencer::horizontal::*;
timer(buf, x+5, y, sequencer.time_start, sequencer.time_start + area.width as usize, 0);
keys(buf, Rect { x, y: y + 1, width, height }, sequencer.note_start)?;
if let Some(Some(phrase)) = state.phrase_id().map(|id|sequencer.phrases.get(id)) {
let ppq = sequencer.timebase.ppq() as usize;
let zoom = sequencer.time_zoom;
let t0 = sequencer.time_start;
let t1 = t0 + area.width as usize;
let n0 = sequencer.note_start;
let n1 = n0 + area.height as usize;
lanes(buf, x, y + 1, &phrase, ppq, zoom, t0, t1, n0, n1);
}
let cursor_style = match view {
crate::device::sequencer::horizontal::draw(
buf,
area,
match state.phrase_id().map(|id|sequencer.phrases.get(id)) {
Some(Some(phrase)) => Some(phrase),
_ => None
},
state.timebase.ppq() as usize,
sequencer.time_cursor,
sequencer.time_start,
sequencer.time_zoom,
sequencer.note_cursor,
sequencer.note_start,
Some(match view {
LauncherView::Sequencer => Style::default().green().not_dim(),
_ => Style::default().green().dim(),
};
cursor(buf, x, y + 1, cursor_style, sequencer.time_cursor, sequencer.note_cursor);
}
Ok(area)
})
)
}
fn draw_section_chains (state: &Launcher, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
let style = Some(Style::default().green().dim());

116
src/device/sequencer/horizontal.rs
View file

@ -2,47 +2,39 @@ use crate::core::*;
use super::*;
pub fn draw (
s: &Sequencer,
buf: &mut Buffer,
mut area: Rect,
buf: &mut Buffer,
area: Rect,
phrase: Option<&Phrase>,
ppq: usize,
time: usize,
time0: usize,
timeZ: usize,
note: usize,
note0: usize,
style: Option<Style>,
) -> Usually<Rect> {
area.x = area.x + 13;
let Rect { x, y, width, height } = area;
keys(buf, area, s.note_start)?;
timer(buf, x+6, y-1, s.time_start, s.time_start + area.width as usize, 0);
if let Some(phrase) = s.phrase() {
lanes(buf, x, y,
phrase,
s.timebase.ppq() as usize,
s.time_zoom,
s.time_start,
s.time_start + area.width as usize,
s.note_start,
s.note_start + area.height as usize,
);
let now = 0;
let notes = &[];
keys(buf, area, note0, notes)?;
timer(buf, area, time0, now);
if let Some(phrase) = phrase {
lanes(buf, area, phrase, ppq, timeZ, time0, note0);
}
cursor(
buf,
x,
y,
Style::default().green().not_dim(),
s.time_cursor,
s.note_cursor
);
footer(s, buf, x, y, width, height);
Ok(Rect { x: x - 13, y, width, height })
let style = style.unwrap_or_else(||{Style::default().green().not_dim()});
cursor(buf, area, style, time, note);
//footer(buf, area, note0, note, time0, time, timeZ);
Ok(area)
}
pub fn timer (
buf: &mut Buffer,
x: u16,
y: u16,
area: Rect,
time0: usize,
time1: usize,
now: usize
) {
for step in time0..time1 {
buf.set_string(x + step as u16, y, &"-", if step == now {
let x = area.x + 5;
for step in time0..(time0+area.width as usize).saturating_sub(5) {
buf.set_string(x + step as u16, area.y, &"-", if step == now {
Style::default().yellow().bold().not_dim()
} else {
Style::default()
@ -51,20 +43,23 @@ pub fn timer (
}
pub fn keys (
buf: &mut Buffer, area: Rect, note_start: usize
buf: &mut Buffer,
area: Rect,
note0: usize,
notes: &[bool],
) -> Usually<Rect> {
let bw = Style::default().dim();
let Rect { x, y, width, height } = area;
let h = height.saturating_sub(2);
for i in 0..h {
let y = y + i;
let y = y + i + 1;
let key = KEYS_VERTICAL[(i % 6) as usize];
key.blit(buf, x + 1, y, Some(bw));
"█".blit(buf, x + 2, y, Some(bw));
"·".repeat(width.saturating_sub(6) as usize).blit(buf, x + 5, y, Some(bw.black()));
"|---".repeat(width.saturating_sub(6) as usize).blit(buf, x + 5, y, Some(bw.black()));
//buf.set_string(x + 3, y, &format!("{i}"), Style::default());
if i % 6 == 0 {
let octave = format!("C{}", ((note_start - i as usize) / 6) as i8 - 4);
let octave = format!("C{}", ((note0 - i as usize) / 6) as i8 - 4);
buf.set_string(x + 3, y, &octave, Style::default());
}
}
@ -73,27 +68,27 @@ pub fn keys (
pub fn lanes (
buf: &mut Buffer,
x: u16,
y: u16,
area: Rect,
phrase: &Phrase,
ppq: usize,
time_zoom: usize,
time0: usize,
time1: usize,
note0: usize,
note1: usize,
) {
let bg = Style::default();
let Rect { x, y, width, height } = area;
let time1 = time0 + width as usize;
let note1 = note0 + height as usize;
let bg = Style::default();
let (bw, wh) = (bg.dim(), bg.white());
for step in time0..time1 {
let x = x as usize + 5 + step;
let (a, b) = ((step + 0) * ppq / time_zoom, (step + 1) * ppq / time_zoom,);
if step % 4 == 0 {
"|".blit(buf, x as u16, y - 1, Some(Style::default().dim()));
"|".blit(buf, x as u16, y, Some(Style::default().dim()));
}
if step % (time_zoom * 4) == 0 {
format!("{}", step / time_zoom / 4 + 1)
.blit(buf, x as u16, y - 1, Some(Style::default().bold().not_dim()));
.blit(buf, x as u16, y, Some(Style::default().bold().not_dim()));
}
let h = ((note1-note0)/2).saturating_sub(y as usize);
for k in 0..h {
@ -112,14 +107,29 @@ pub fn lanes (
}
}
pub fn cursor (buf: &mut Buffer, x: u16, y: u16, style: Style, time: usize, note: usize) {
let x = x + 5 + time as u16;
let y = y + note as u16 / 2;
pub fn cursor (
buf: &mut Buffer,
area: Rect,
style: Style,
time: usize,
note: usize
) {
let x = area.x + 5 + time as u16;
let y = area.y + 1 + note as u16 / 2;
let c = if note % 2 == 0 { "▀" } else { "▄" };
c.blit(buf, x, y, Some(style));
}
pub fn footer (s: &Sequencer, buf: &mut Buffer, mut x: u16, y: u16, width: u16, height: u16) {
pub fn footer (
buf: &mut Buffer,
area: Rect,
note0: usize,
note: usize,
time0: usize,
time: usize,
timeZ: usize,
) {
let Rect { mut x, y, width, height } = area;
buf.set_string(x, y + height, format!("├{}┤", "-".repeat((width - 2).into())),
Style::default().dim());
buf.set_string(x, y + height + 2, format!("├{}┤", "-".repeat((width - 2).into())),
@ -128,15 +138,9 @@ pub fn footer (s: &Sequencer, buf: &mut Buffer, mut x: u16, y: u16, width: u16,
{
for (_, [letter, title, value]) in [
["S", &format!("ync"), &format!("<4/4>")],
["Q", &format!("uant"), &format!("<1/{}>", 4 * s.time_zoom)],
["N", &format!("ote"), &format!("{} ({}-{})",
s.note_start + s.note_cursor,
s.note_start,
"X")],
["T", &format!("ime"), &format!("{} ({}-{})",
s.time_start + s.time_cursor + 1,
s.time_start + 1,
"X")],
["Q", &format!("uant"), &format!("<1/{}>", 4 * timeZ)],
["N", &format!("ote"), &format!("{} ({}-{})", note0 + note, note0, "X")],
["T", &format!("ime"), &format!("{} ({}-{})", time0 + time, time0 + 1, "X")],
].iter().enumerate() {
buf.set_string(x, y + height + 1, letter, Style::default().bold().yellow().dim());
x = x + 1;

49
src/device/sequencer/mod.rs
View file

@ -102,9 +102,18 @@ fn render (s: &Sequencer, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
SequencerView::Vertical => self::vertical::draw(s, buf, Rect {
x, y: y + header.height, width, height,
})?,
SequencerView::Horizontal => self::horizontal::draw(s, buf, Rect {
x, y: y + header.height, width, height,
})?,
SequencerView::Horizontal => self::horizontal::draw(
buf,
Rect { x, y: y + header.height, width, height, },
s.phrase(),
s.timebase.ppq() as usize,
s.time_cursor,
s.time_start,
s.time_zoom,
s.note_cursor,
s.note_start,
None
)?,
};
Ok(draw_box(buf, Rect {
x, y,
@ -159,37 +168,3 @@ pub fn contains_note_on (sequence: &Phrase, k: u7, start: usize, end: usize) ->
}
return false
}
#[cfg(test)] mod test {
use super::*;
#[test]
fn test_sequencer_output () -> Usually<()> {
let sequencer = Sequencer::new("test")?;
let mut s = sequencer.state.lock().unwrap();
s.rate = Hz(48000);
s.tempo = Tempo(240_000);
println!("F/S = {:.03}", s.rate());
println!("B/S = {:.03}", s.beats_per_secon());
println!("F/B = {:.03}", s.frames_per_beat());
println!("T/B = {:.03}", s.ticks_per_beat());
println!("F/T = {:.03}", s.frames_per_tick());
println!("F/L = {:.03}", s.frames_per_loop());
println!("T/L = {:.03}", s.ticks_per_loop());
let fpt = s.fpt();
let frames_per_chunk = 240;
let chunk = |chunk: usize| s.frames_to_ticks(
chunk * frames_per_chunk,
(chunk + 1) * frames_per_chunk
);
//for i in 0..2000 {
//println!("{i} {:?}", chunk(i));
//}
assert_eq!(chunk(0), vec![(0, 0), (125, 1)]);
assert_eq!(chunk(1), vec![(10, 2), (135, 3)]);
assert_eq!(chunk(12), vec![(120, 24)]);
assert_eq!(chunk(412), vec![(120, 24)]);
assert_eq!(chunk(413), vec![(5, 25), (130, 26)]);
Ok(())
}
}

12
src/device/transport.rs
View file

@ -3,13 +3,19 @@ use crate::layout::*;
pub fn draw_timer (buf: &mut Buffer, x: u16, y: u16, timebase: &Arc<Timebase>, frame: usize) {
let ppq = timebase.ppq() as usize;
let pulse = timebase.frames_pulses(frame as f64) as usize;
let (beats, pulses) = (pulse / ppq, pulse % ppq);
let (bars, beats) = (beats / 4, beats % 4);
let (bars, beats) = (beats / 4, beats % 4);
let usecs = timebase.frames_usecs(frame as f64) as usize;
let (seconds, msecs) = (usecs / 1000000, usecs / 1000 % 1000);
let (seconds, msecs) = (usecs / 1000000, usecs / 1000 % 1000);
let (minutes, seconds) = (seconds / 60, seconds % 60);
let timer = format!("{minutes}:{seconds:02}:{msecs:03} {}.{}.{pulses:02}", bars as usize + 1, beats as usize + 1);
let timer = format!("{minutes}:{seconds:02}:{msecs:03} {}.{}.{pulses:02}",
bars as usize + 1,
beats as usize + 1
);
timer.blit(buf, x - timer.len() as u16, y, Some(Style::default().not_dim()));
}
pub fn draw_play_stop (buf: &mut Buffer, x: u16, y: u16, state: &TransportState) {

2
src/main.rs
View file

@ -43,7 +43,7 @@ fn main () -> Result<(), Box<dyn Error>> {
let input = ".*nanoKEY.*";
let output = ["Komplete.*:playback_FL", "Komplete.*:playback_FR"];
let (client, _) = Client::new("init", ClientOptions::NO_START_SERVER)?;
let timebase = Arc::new(Timebase::new(client.sample_rate() as f64, 125000.0, 96.0));
let timebase = Arc::new(Timebase::new(client.sample_rate() as f64, 60.0, 96.0));
let ppq = timebase.ppq() as usize;
macro_rules! play {
($t1:expr => [ $($msg:expr),* $(,)? ]) => {