soundkit 0.12.2

Audio format optimised for low-latency audio.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135


function ringbuffer_from_data(data, dataType, frame_size) {
  const data_offset = 6 * 4;
  const el_bytes = dataType.BYTES_PER_ELEMENT;
  const sab = new SharedArrayBuffer(data.byteLength + data_offset);
  const sabView = new Uint8Array(sab);
  sabView.set(data, data_offset);
  const n = (data.byteLength / el_bytes) / frame_size;
  const w_ptr_b = new Uint32Array(sab, 12, 1);
  const in_b = new Uint32Array(sab, 0, 1);
  Atomics.store(w_ptr_b, 0, n);
  Atomics.store(in_b, 0, n);
  return ringbuffer(sab, frame_size, n, dataType)
}

function sharedbuffer_growable(frame_size, max_frames, dataType) {
  const data_offset = 6 * 4; // Assuming 4 bytes per Uint32Array element
  const el_bytes = dataType.BYTES_PER_ELEMENT;
  const initialLength = (frame_size * el_bytes) + data_offset;
  const maxByteLength = (frame_size * el_bytes * max_frames) + data_offset;
  const sab = new SharedArrayBuffer(
    initialLength,
    { maxByteLength },
  );

  return sab;
}

function sharedbuffer(frame_size, max_frames, dataType) {
  const data_offset = 6 * 4; // Assuming 4 bytes per Uint32Array element
  const el_bytes = dataType.BYTES_PER_ELEMENT;

  const sab = new SharedArrayBuffer((frame_size * el_bytes * max_frames) + data_offset);

  return sab;
}

function ringbuffer(sab, frame_size, max_frames, dataType) {
  const data_offset = 6 * 4; // Assuming 4 bytes per Uint32Array element
  const in_b = new Uint32Array(sab, 0, 1);
  const out_b = new Uint32Array(sab, 4, 1);
  const dropped_b = new Uint32Array(sab, 8, 1);
  const w_ptr_b = new Uint32Array(sab, 12, 1);
  const r_ptr_b = new Uint32Array(sab, 16, 1);
  const wrap_flag_b = new Uint32Array(sab, 20, 1);
  const el_bytes = dataType.BYTES_PER_ELEMENT;
  let data_b = new dataType(sab, data_offset, ((sab.byteLength - data_offset) / el_bytes));
  const frame_len = frame_size * el_bytes;
  const max_len = (frame_len * max_frames) + data_offset;
  const in_count = () => Atomics.load(in_b, 0);
  const out_count = () => Atomics.load(out_b, 0);
  const dropped_count = () => Atomics.load(dropped_b, 0);
  const w_ptr = () => Atomics.load(w_ptr_b, 0);
  const r_ptr = () => Atomics.load(r_ptr_b, 0);
  const wrap_flag = () => Atomics.load(wrap_flag_b, 0) === 1;

  const current_offset = (count_func) => {
    return (count_func() * frame_size);
  };

  const wrapping_add = (count_func) => {
    const i = count_func();
    return i == max_frames - 1 ? 0 : i + 1;
  };

  const count = () => {
    return in_count() - out_count();
  }

  const push = (frame) => {
    if (sab.growable) {
      if (sab.byteLength - data_offset == current_offset(w_ptr) * el_bytes) {
        if (sab.byteLength - data_offset == max_len) {
        } else {
          sab.grow(sab.byteLength + frame_len);
          data_b = new dataType(sab, data_offset, ((sab.byteLength - data_offset) / el_bytes));
        }
      }
    }
    const offset = current_offset(w_ptr);
    for (let i = 0; i < frame_size; i++) {
      data_b[offset + i] = frame[i];
    }

    if (offset === 0) {
      Atomics.store(wrap_flag_b, 0, 1);
    }

    if (wrap_flag() && current_offset(r_ptr) === offset) {
      Atomics.store(wrap_flag_b, 0, 0);
      const dropped = dropped_count() + (in_count() - out_count());
      Atomics.store(dropped_b, 0, dropped);
      Atomics.store(out_b, 0, in_count());
    }

    Atomics.add(in_b, 0, 1);
    Atomics.store(w_ptr_b, 0, wrapping_add(w_ptr));

    return true;
  };

  const pop = () => {
    if (in_count() - out_count() === 0) {
      return;
    }

    data_b = new dataType(sab, data_offset, ((sab.byteLength - data_offset) / el_bytes));
    const res = [];
    let offset = current_offset(r_ptr);
    for (let i = 0; i < frame_size; i++) {
      res.push(data_b[offset + i]);
    }
    Atomics.add(out_b, 0, 1);
    Atomics.store(r_ptr_b, 0, wrapping_add(r_ptr));

    return new dataType(res);
  };

  return {
    sab,
    push,
    pop,
    dropped_count,
    count,
  };
}

if (typeof module !== 'undefined') {
  module.exports = {
    ringbuffer,
    ringbuffer_from_data,
    sharedbuffer,
    sharedbuffer_growable,
  }
}