refactor music generation by adjusting synth volumes and batching note processing for improved timing

index.html

@@ -523,7 +523,7 @@
 
     // 🌊 PAD (chord)
     const pad = new Tone.PolySynth(Tone.Synth, {
-        volume: -12,
+        volume: -8,
         oscillator: { type: "sine" },
         envelope: {
             attack: 1,
@@ -535,7 +535,7 @@
 
     // 🥁 KICK
     const kick = new Tone.MembraneSynth({
-        volume: -8,
+        volume: -12,
         pitchDecay: 0.05,
         octaves: 6,
         envelope: {
@@ -594,30 +594,30 @@
             ws.send(JSON.stringify({ bpm: currentBpm }));
         };
 
+        let startTime = Tone.now() + 0.1; // Thời gian bắt đầu chơi nhạc, cách hiện tại 100ms để đảm bảo đồng bộ    
+
         ws.onmessage = (event) => {
             const data = JSON.parse(event.data);
 
             data.notes.forEach(n => {
                 const note = Tone.Frequency(n.note, "midi").toNote();
-                const vel = Math.max(0.3, (n.velocity || 80) / 127);
-
-                const t = Tone.now();
+                const t = startTime + n.time;   // 🔥 timeline chuẩn
 
                 if (n.type === "melody") {
-                    piano.triggerAttackRelease(note, n.duration, t, vel);
+                    piano.triggerAttackRelease(note, n.duration, t);
                 }
 
                 else if (n.type === "chord") {
-                    pad.triggerAttackRelease(note, n.duration, t, vel * 0.7);
+                    pad.triggerAttackRelease(note, n.duration, t);
                 }
 
                 else if (n.type === "drum") {
-                    if (n.note === 36)
-                        kick.triggerAttackRelease("C1", "8n", t);
-                    if (n.note === 38)
-                        snare.triggerAttackRelease("16n", t);
+                    if (n.note === 36) kick.triggerAttackRelease("C1", "8n", t);
+                    if (n.note === 38) snare.triggerAttackRelease("16n", t);
                 }
             });
+
+            startTime += data.step * 16; // advance timeline
         };
 
         ws.onerror = (err) => {

main.py

@@ -114,66 +114,69 @@ async def websocket_vibe(websocket: WebSocket):
         return min(chord + [c+12 for c in chord], key=lambda x: abs(x - midi))
 
     try:
+        STEPS_PER_BATCH = 16
+
         while is_playing:
             beat = 60.0 / current_bpm
-            step = beat / 2  # 🔥 QUAN TRỌNG: nhanh hơn x2
+            step = beat / 2
 
-            inp[0] = torch.tensor(pattern)
+            batch = []
 
-            with torch.no_grad():
-                pred = model(inp)
-                probs = torch.softmax(pred / 0.8, dim=1).numpy()[0]
-                idx = np.random.choice(len(probs), p=probs)
+            for i in range(STEPS_PER_BATCH):
+                inp[0] = torch.tensor(pattern)
 
-            tok = int_to_note[idx]
-            pattern = pattern[1:] + [idx]
+                with torch.no_grad():
+                    pred = model(inp)
+                    probs = torch.softmax(pred / 0.8, dim=1).numpy()[0]
+                    idx = np.random.choice(len(probs), p=probs)
 
-            midi = None
-            try:
-                if tok.startswith("NOTE"):
-                    midi = note.Note(tok.split("_")[1]).pitch.midi
-            except:
-                pass
+                tok = int_to_note[idx]
+                pattern = pattern[1:] + [idx]
 
-            chord = CHORDS[(note_count // 8) % len(CHORDS)]
+                midi = None
+                try:
+                    if tok.startswith("NOTE"):
+                        midi = note.Note(tok.split("_")[1]).pitch.midi
+                except:
+                    pass
 
-            notes = []
+                chord = CHORDS[((note_count + i) // 8) % len(CHORDS)]
 
-            # 🎹 CHORD (pad)
-            if note_count % 8 == 0:
-                for c in chord:
-                    notes.append({
-                        "note": c,
-                        "velocity": 40,
-                        "duration": beat * 4,
-                        "type": "chord"
-                    })
+                notes = []
 
-            # 🎸 MELODY
-            if midi:
-                while midi < 55: midi += 12
-                while midi > 75: midi -= 12
+                # chord
+                if (note_count + i) % 8 == 0:
+                    for c in chord:
+                        notes.append({
+                            "note": c,
+                            "velocity": 40,
+                            "duration": beat * 4,
+                            "type": "chord",
+                            "time": i * step
+                        })
 
-                if random.random() < 0.7:
-                    midi = snap(midi, chord)
+                # melody
+                if midi:
+                    while midi < 55: midi += 12
+                    while midi > 75: midi -= 12
 
-                notes.append({
-                    "note": midi,
-                    "velocity": random.randint(55, 80),
-                    "duration": step * 1.2,
-                    "type": "melody"
-                })
+                    notes.append({
+                        "note": midi,
+                        "velocity": random.randint(55, 80),
+                        "duration": step * 1.2,
+                        "type": "melody",
+                        "time": i * step
+                    })
 
-            # 🥁 DRUM
-            if note_count % 4 == 0:
-                notes.append({"note": 36, "type": "drum"})
-            if note_count % 4 == 2:
-                notes.append({"note": 38, "type": "drum"})
+                batch.extend(notes)
 
-            await websocket.send_json({"notes": notes})
+            await websocket.send_json({
+                "notes": batch,
+                "step": step
+            })
 
-            note_count += 1
-            await asyncio.sleep(step)
+            note_count += STEPS_PER_BATCH
+            await asyncio.sleep(step * STEPS_PER_BATCH * 0.8)
 
     except:
         pass