refactor music generation by batching note sending and improving timing dynamics

index.html

@@ -562,22 +562,24 @@
         ws.onmessage = (event) => {
             const data = JSON.parse(event.data);
 
+            if (data.bpm) {
+                Tone.Transport.bpm.value = data.bpm;
+            }
+
             if (data.notes) {
-                data.notes.forEach(n => {
+                const now = Tone.now();
 
+                data.notes.forEach(n => {
                     const noteName = Tone.Frequency(n.note, "midi").toNote();
 
-                    // 🎛 velocity humanize
-                    let velocity = n.velocity / 127;
-                    velocity = Math.max(0.25, velocity);
+                    const velocity = Math.max(0.3, n.velocity / 127);
 
-                    // 🎲 timing humanize
-                    const humanize = (Math.random() - 0.5) * 0.02;
+                    const humanize = (Math.random() - 0.5) * 0.01;
 
                     piano.triggerAttackRelease(
                         noteName,
                         n.duration,
-                        Tone.now() + humanize,
+                        now + n.time + humanize,
                         velocity
                     );
                 });

main.py

@@ -116,116 +116,141 @@ async def websocket_vibe(websocket: WebSocket):
             safe_notes = chord + [c + 12 for c in chord]
             return min(safe_notes, key=lambda p: abs(p - midi_val))
 
+        BATCH_SIZE = 12  # số step mỗi lần gửi (~1–2s nhạc)
+
         while is_playing:
             beat = 60.0 / current_bpm
 
-            # 🎧 SWING
-            swing = 0.12
-            if note_count % 2 == 0:
-                sleep_time = beat * (1 + swing)
-            else:
-                sleep_time = beat * (1 - swing)
-
-            # 🎼 phrase (16 step)
-            phrase_pos = note_count % 16
-
-            # 🎵 rest (nghỉ)
-            if random.random() < 0.12:
-                await asyncio.sleep(sleep_time)
-                note_count += 1
-                continue
-
-            current_chord = progression[(note_count // 4) % len(progression)]
-
-            inp_tensor[0] = torch.tensor(pattern, dtype=torch.long)
-
-            temp = max(0.5, min(1.2, 0.7 + (current_bpm - 60) / 120))
-
-            with torch.inference_mode():
-                pred = model(inp_tensor)
-                probs = torch.softmax(pred / temp, dim=1).numpy()[0]
-
-                top_idx = np.argsort(probs)[-10:]
-                probs_top = probs[top_idx] / probs[top_idx].sum()
-                idx = np.random.choice(top_idx, p=probs_top)
-
-            tok = int_to_note[idx]
-            pattern = pattern[1:] + [idx]
+            notes_batch = []
+            current_time = 0
+
+            for i in range(BATCH_SIZE):
+                global_step = note_count + i
+                phrase_pos = global_step % 16
+                chord = progression[(global_step // 4) % len(progression)]
+
+                inp_tensor[0] = torch.tensor(pattern, dtype=torch.long)
+
+                # 🎛 temperature ổn định
+                temp = max(0.6, min(1.0, 0.75 + (current_bpm - 70) / 140))
+
+                with torch.inference_mode():
+                    pred = model(inp_tensor)
+                    probs = torch.softmax(pred / temp, dim=1).numpy()[0]
+
+                    # 🔥 giảm random → đỡ nhảy loạn
+                    top_idx = np.argsort(probs)[-5:]
+                    probs_top = probs[top_idx] / probs[top_idx].sum()
+                    idx = np.random.choice(top_idx, p=probs_top)
+
+                tok = int_to_note[idx]
+                pattern = pattern[1:] + [idx]
+
+                midi_val = None
+                try:
+                    if tok.startswith("NOTE"):
+                        midi_val = note.Note(tok.split("_")[1]).pitch.midi
+                except:
+                    pass
+
+                # ===============================
+                # 🎼 TIME GRID (QUAN TRỌNG NHẤT)
+                # ===============================
+                step_time = beat * 0.5   # 8th note grid
+                note_time = current_time
+
+                # ===============================
+                # 🎹 CHORD
+                # ===============================
+                if global_step % 4 == 0:
+                    for c in chord:
+                        notes_batch.append({
+                            "note": c,
+                            "velocity": random.randint(40, 55),
+                            "duration": beat * 3.5,
+                            "time": note_time
+                        })
+
+                # ===============================
+                # 🎸 MELODY
+                # ===============================
+                if midi_val:
+                    while midi_val > 76: midi_val -= 12
+                    while midi_val < 60: midi_val += 12
+
+                    if random.random() < 0.8:
+                        melody = snap_to_chord(midi_val, chord)
+                    else:
+                        melody = midi_val
+
+                    # 🎯 giảm nhảy xa
+                    if hasattr(websocket, "last_note"):
+                        prev = websocket.last_note
+                        if abs(melody - prev) > 7:
+                            melody = prev + random.choice([-2, -1, 1, 2])
+
+                    websocket.last_note = melody
+
+                    # 🎼 velocity human
+                    if phrase_pos in [0,4,8,12]:
+                        vel = 85
+                    elif phrase_pos in [2,6,10,14]:
+                        vel = 65
+                    else:
+                        vel = 50
+
+                    # 🎵 duration theo groove
+                    dur = beat * (0.9 if phrase_pos % 2 == 0 else 0.5)
+
+                    notes_batch.append({
+                        "note": melody,
+                        "velocity": vel,
+                        "duration": dur,
+                        "time": note_time
+                    })
 
-            midi_val = None
-            try:
-                if tok.startswith("NOTE"):
-                    midi_val = note.Note(tok.split("_")[1]).pitch.midi
-            except:
-                pass
+                    # harmony nhẹ
+                    if random.random() < 0.25:
+                        notes_batch.append({
+                            "note": melody - 3,
+                            "velocity": vel - 25,
+                            "duration": dur,
+                            "time": note_time
+                        })
+
+                # ===============================
+                # 🥁 RHYTHM
+                # ===============================
+                if phrase_pos == 0:
+                    notes_batch.append({
+                        "note": 36,
+                        "velocity": 70,
+                        "duration": 0.1,
+                        "time": note_time
+                    })
+                elif phrase_pos == 8:
+                    notes_batch.append({
+                        "note": 38,
+                        "velocity": 60,
+                        "duration": 0.1,
+                        "time": note_time
+                    })
 
-            notes_to_send = []
+                # tăng timeline
+                current_time += step_time
 
-            # 🎹 CHORD (mỗi 4 beat)
-            if note_count % 4 == 0:
-                for c in current_chord:
-                    notes_to_send.append({
-                        "note": c,
-                        "velocity": random.randint(35, 55),
-                        "duration": beat * 4
-                    })
+            # ===============================
+            # 🚀 SEND BATCH
+            # ===============================
+            await websocket.send_json({
+                "notes": notes_batch,
+                "bpm": current_bpm
+            })
 
-            # 🎸 MELODY
-            if midi_val:
-                # clamp range (lofi range)
-                while midi_val > 76: midi_val -= 12
-                while midi_val < 58: midi_val += 12
-
-                # snap có xác suất (giữ tự nhiên)
-                if random.random() < 0.7:
-                    melody = snap_to_chord(midi_val, current_chord)
-                else:
-                    melody = midi_val
-
-                # 🎼 phrasing dynamics
-                if phrase_pos < 8:
-                    vel = 60
-                elif phrase_pos < 12:
-                    vel = 70
-                else:
-                    vel = 80
-
-                vel += int(8 * math.sin(note_count))
-
-                notes_to_send.append({
-                    "note": melody,
-                    "velocity": vel,
-                    "duration": sleep_time * 1.4
-                })
-
-                # 🎶 harmony (30%)
-                if random.random() < 0.3:
-                    harmony = snap_to_chord(melody - random.choice([3,4,7]), current_chord)
-                    notes_to_send.append({
-                        "note": harmony,
-                        "velocity": vel - 20,
-                        "duration": sleep_time * 1.2
-                    })
+            note_count += BATCH_SIZE
 
-            # 🎧 DRUM giả lập bằng velocity pulse (nếu frontend hỗ trợ thì tách channel)
-            if phrase_pos % 4 == 0:
-                notes_to_send.append({
-                    "note": 36,  # kick
-                    "velocity": 90,
-                    "duration": 0.1
-                })
-            elif phrase_pos % 4 == 2:
-                notes_to_send.append({
-                    "note": 38,  # snare
-                    "velocity": 70,
-                    "duration": 0.1
-                })
-
-            if notes_to_send:
-                await websocket.send_json({"notes": notes_to_send})
-
-            note_count += 1
-            await asyncio.sleep(sleep_time)
+            # ⏱ sleep NGẮN hơn để luôn buffer trước
+            await asyncio.sleep(beat * BATCH_SIZE * 0.4)
 
     except Exception as e:
         print("Connection closed:", e)