refactor WebSocket integration for real-time MIDI generation, enhance AI music generation logic, and implement MIDI pitch clamping

index.html

@@ -5,6 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Bio-Vibe Web</title>
     <link rel="icon" href="data:,">
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/tone/14.8.49/Tone.js"></script>
     <style>
         body {
             font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
@@ -452,66 +453,110 @@
     // ===============================
     // GENERATE MUSIC
     // ===============================
+    // ===============================
+    // THIẾT LẬP NHẠC CỤ (TONE.JS)
+    // ===============================
+    // 1. Tạo hiệu ứng: Reverb rộng rãi và Lowpass Filter (cắt treble chói)
+    const filter = new Tone.Filter(800, "lowpass").toDestination();
+    const reverb = new Tone.Reverb({ decay: 5, wet: 0.6 }).connect(filter);
+
+    // 2. Dùng PolySynth (nhạc cụ ảo) thay vì Sampler (file mp3)
+    // FMSynth tạo ra âm sắc giống chuông/piano điện, rất êm ái
+    const piano = new Tone.PolySynth(Tone.FMSynth, {
+        harmonicity: 8,
+        modulationIndex: 2,
+        oscillator: {
+            type: "sine" // Sóng sine nghe êm nhất
+        },
+        envelope: {
+            attack: 0.05,
+            decay: 0.3,
+            sustain: 0.1,
+            release: 1.2 // Vang nhẹ khi buông nốt
+        },
+        modulation: {
+            type: "square"
+        },
+        modulationEnvelope: {
+            attack: 0.01,
+            decay: 0.5,
+            sustain: 0.2,
+            release: 0.1
+        }
+    }).connect(reverb);
+
+    // Do không cần tải file, coi như nhạc cụ luôn sẵn sàng
+    log("🎹 Đã khởi tạo Synthesizer.");
+    setStatus("Sẵn sàng sinh nhạc AI", "ok");
+
+    let ws = null; // Biến giữ kết nối WebSocket
+
+    // ===============================
+    // GENERATE MUSIC (CẬP NHẬT WEBSOCKET)
+    // ===============================
     btnGenerate.addEventListener('click', async () => {
         if (currentBpm === 0) {
             alert('Chưa có BPM! Kết nối đồng hồ hoặc nhập thủ công.');
             return;
         }
 
-        if (currentAudio) {
-            currentAudio.pause();
-            currentAudio.currentTime = 0;
-            bpmDisplay.style.animation = 'none';
-        }
-
-        setStatus(`Đang gửi ${currentBpm} BPM cho AI…`, 'info');
-        btnGenerate.textContent  = 'AI đang sáng tác…';
-        btnGenerate.disabled     = true;
-        btnStop.disabled         = true;
-
-        try {
-            const res  = await fetch('/generate-vibe', {
-                method:  'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body:    JSON.stringify({ bpm: currentBpm })
-            });
-            const data = await res.json();
-
-            if (data.status === 'success') {
-                currentAudio = new Audio(data.audio_url);
-                currentAudio.play();
-                bpmDisplay.style.animation = 'pulse 1s infinite';
-                setStatus('🎵 Đang phát nhạc…', 'ok');
-                btnStop.disabled = false;
-
-                currentAudio.onended = () => {
-                    bpmDisplay.style.animation = 'none';
-                    btnStop.disabled = true;
-                    setStatus('Nhạc đã kết thúc.', 'info');
-                };
-            } else {
-                setStatus('Lỗi AI: ' + (data.message || 'unknown'), 'err');
-            }
-        } catch (err) {
-            log('Generate error: ' + err.message);
-            setStatus('Mất kết nối server!', 'err');
-        } finally {
+        // Bắt buộc trình duyệt cho phép phát âm thanh
+        await Tone.start();
+        
+        if (ws) ws.close(); // Đóng kết nối cũ nếu có
+
+        setStatus(`Đang kết nối não AI với ${currentBpm} BPM…`, 'info');
+        btnGenerate.textContent = 'AI đang truyền nốt…';
+        btnGenerate.disabled = true;
+        btnStop.disabled = false;
+        bpmDisplay.style.animation = 'pulse 1s infinite';
+
+        // Mở kết nối WebSocket tới Server
+        const wsUrl = `ws://${window.location.host}/ws/vibe`;
+        ws = new WebSocket(wsUrl);
+
+        ws.onopen = () => {
+            setStatus('🎵 Đang phát nhạc Real-time vô tận…', 'ok');
+            // Gửi BPM lên server để AI lấy tempo
+            ws.send(JSON.stringify({ bpm: currentBpm }));
+        };
+
+        ws.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            
+            // Tone.js hỗ trợ đọc trực tiếp số MIDI
+            const freq = Tone.Frequency(data.note, "midi").toNote(); 
+            
+            // Velocity của Tone.js nằm trong khoảng 0.0 - 1.0
+            const normalizedVelocity = data.velocity / 127; 
+            
+            // Đánh nốt đàn ngay lập tức
+            piano.triggerAttackRelease(freq, data.duration, Tone.now(), normalizedVelocity);
+        };
+
+        ws.onerror = (err) => {
+            log('WebSocket Error: ' + err);
+            setStatus('Lỗi kết nối tới AI!', 'err');
+        };
+
+        ws.onclose = () => {
             btnGenerate.textContent = '2. Sinh nhạc AI';
-            btnGenerate.disabled    = false;
-        }
+            btnGenerate.disabled = false;
+            btnStop.disabled = true;
+            bpmDisplay.style.animation = 'none';
+        };
     });
 
     // ===============================
-    // STOP MUSIC
+    // STOP MUSIC (CẬP NHẬT WEBSOCKET)
     // ===============================
     btnStop.addEventListener('click', () => {
-        if (currentAudio) {
-            currentAudio.pause();
-            currentAudio.currentTime   = 0;
-            bpmDisplay.style.animation = 'none';
-            btnStop.disabled           = true;
-            setStatus('Đã dừng nhạc.', 'info');
+        if (ws) {
+            ws.close(); // Cắt kết nối, Server sẽ tự động dừng suy luận
+            ws = null;
         }
+        piano.releaseAll(); // Ngắt ngay lập tức các âm vang còn sót lại
+        setStatus('Đã dừng nhạc.', 'info');
     });
 </script>
 </body>

main.py

@@ -2,6 +2,9 @@ from fastapi import FastAPI, Request
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
 from pydantic import BaseModel
+from fastapi import WebSocket, WebSocketDisconnect
+import asyncio
+import math
 from pydub import AudioSegment
 from pydub.effects import normalize, compress_dynamic_range
 import mido
@@ -77,275 +80,86 @@ model.eval() # Chuyển sang chế độ suy luận
 # Nạp kho dữ liệu cũ để lấy Seed (đoạn nhạc mồi)
 with open('notes_corpus.pkl', 'rb') as f:
     corpus = pickle.load(f)
-
-def generate_ai_midi(bpm: int, output_file: str, num_notes: int = 40):
-    temperature = max(0.5, min(1.1, 0.6 + (bpm - 60) / 100))
-
-    PENTATONIC_MIDI = [60, 62, 64, 67, 69, 72, 74, 76]  # C D E G A (2 octave)
-
-    # Chord prog: (alberti notes, bass midi)
-    CHORD_PROG = [
-        ([60, 64, 67], 48),  # C major  → bass C3
-        ([57, 60, 64], 45),  # A minor  → bass A2
-        ([53, 57, 60], 41),  # F major  → bass F2
-        ([55, 59, 62], 43),  # G major  → bass G2
-    ]
-    BEATS_PER_CHORD = 4
-
-    RHYTHM_PATTERNS = [
-        [1.0, 1.0, 1.0, 1.0],
-        [0.5, 0.5, 1.0, 1.0, 1.0],
-        [1.0, 0.5, 0.5, 1.0, 1.0],
-        [1.5, 0.5, 1.0, 1.0],
-    ]
-
-    # ── Tốc độ: seed 50, tensor tái dùng, inference_mode ──────────────────
-    SEQ_LEN = 50
-    seed = random.sample(corpus, SEQ_LEN)
-    pattern = [note_to_int[n] for n in seed]
-    inp_tensor = torch.zeros(1, SEQ_LEN, dtype=torch.long)
-
-    raw_generated = []
-    with torch.inference_mode():
-        for _ in range(num_notes):
-            inp_tensor[0] = torch.tensor(pattern, dtype=torch.long)
-            pred = model(inp_tensor)
-            probs = torch.softmax(pred / temperature, dim=1).numpy()[0]
-            top_idx = np.argsort(probs)[-8:]
-            top_p = probs[top_idx]; top_p /= top_p.sum()
-            idx = np.random.choice(top_idx, p=top_p)
-            raw_generated.append(int_to_note[idx])
-            pattern = pattern[1:] + [idx]
-
-    # ── Extract MIDI pitch ─────────────────────────────────────────────────
-    def token_to_midi(tok):
-        parts = tok.split("_")
-        try:
-            if parts[0] == "NOTE":
-                return note.Note(parts[1]).pitch.midi
-            elif parts[0] == "CHORD":
-                return note.Note(parts[1].split(".")[0]).pitch.midi
-        except:
-            pass
-        return None
-
-    raw_midis = [m for tok in raw_generated if (m := token_to_midi(tok)) is not None]
-
-    # ── BUG FIX: Fallback nếu model gen toàn REST/lỗi ─────────────────────
-    if len(raw_midis) < 8:
-        print(f"⚠️  raw_midis chỉ có {len(raw_midis)} nốt → dùng pentatonic fallback")
-        raw_midis = [random.choice(PENTATONIC_MIDI) for _ in range(40)]
-
-    # ── Snap + smooth ──────────────────────────────────────────────────────
-    def snap(midi_val):
-        return min(PENTATONIC_MIDI, key=lambda p: abs(p - midi_val))
-
-    def build_phrase(chunk):
-        snapped = [snap(m) for m in chunk]
-        smoothed = [snapped[0]]
-        for curr in snapped[1:]:
-            prev = smoothed[-1]
-            if abs(curr - prev) > 5:
-                curr = snap(prev + random.choice([-2, 2, 3, -3]))
-            smoothed.append(curr)
-
-        rhythm = random.choice(RHYTHM_PATTERNS)[:]
-        while len(rhythm) < len(smoothed):
-            rhythm += random.choice(RHYTHM_PATTERNS)
-        rhythm = rhythm[:len(smoothed)]
-
-        n = len(smoothed)
-        velocities = [
-            int(62 + 28 * (i / max(n-1,1) / 0.6)) if i/max(n-1,1) < 0.6
-            else int(90 - 25 * ((i/max(n-1,1) - 0.6) / 0.4))
-            for i in range(n)
-        ]
-        return list(zip(smoothed, rhythm, velocities))
-
-    PHRASE_LEN = 8
-    phrases = [
-        build_phrase(raw_midis[i:i+PHRASE_LEN])
-        for i in range(0, len(raw_midis), PHRASE_LEN)
-        if len(raw_midis[i:i+PHRASE_LEN]) >= 4   # bỏ phrase quá ngắn
-    ]
-
-    if not phrases:
-        phrases = [build_phrase(PENTATONIC_MIDI)]
-
-    # ══════════════════════════════════════════════════════════════════════
-    # VIẾT MIDI BẰNG MIDO (nhanh hơn music21 ~10×)
-    # ══════════════════════════════════════════════════════════════════════
-    midi = MidiFile(type=1, ticks_per_beat=480)
-    tempo_val = mido.bpm2tempo(max(55, min(bpm, 110)))
-
-    def beats_to_ticks(beats, tpb=480):
-        return int(beats * tpb)
-
-    # ── Track 0: tempo ─────────────────────────────────────────────────────
-    tempo_track = MidiTrack()
-    midi.tracks.append(tempo_track)
-    tempo_track.append(mido.MetaMessage('set_tempo', tempo=tempo_val, time=0))
-
-    # ── Track 1: Melody (channel 0) ────────────────────────────────────────
-    mel_track = MidiTrack()
-    midi.tracks.append(mel_track)
-    mel_track.append(Message('program_change', channel=0, program=0, time=0))
-
-    # Build absolute events → convert sang delta
-    mel_events = []   # (abs_tick, 'on'/'off', pitch, velocity)
-    abs_tick = 0
-    anchor_phrase = None
-
-    for p_idx, phrase in enumerate(phrases):
-        if p_idx > 0 and p_idx % 3 == 0 and anchor_phrase:
-            phrase = anchor_phrase
-
-        for midi_val, dur, vel in phrase:
-            dur_ticks = beats_to_ticks(dur)
-            mel_events.append((abs_tick,          'on',  midi_val, vel))
-            mel_events.append((abs_tick+dur_ticks, 'off', midi_val, 0))
-            abs_tick += dur_ticks
-
-        if p_idx == 0:
-            anchor_phrase = list(phrase)
-
-        abs_tick += beats_to_ticks(random.choice([0.5, 1.0]))  # breath
-
-    total_ticks = abs_tick
-
-    mel_events.sort(key=lambda e: e[0])
-    prev = 0
-    for abs_t, kind, pitch, vel in mel_events:
-        delta = abs_t - prev
-        if kind == 'on':
-            mel_track.append(Message('note_on',  channel=0, note=pitch, velocity=vel, time=delta))
-        else:
-            mel_track.append(Message('note_off', channel=0, note=pitch, velocity=0,   time=delta))
-        prev = abs_t
-
-    # ── Track 2: Alberti bass (channel 1) ─────────────────────────────────
-    acc_track = MidiTrack()
-    midi.tracks.append(acc_track)
-    acc_track.append(Message('program_change', channel=1, program=0, time=0))
-
-    acc_events = []
-    acc_tick = 0
-    chord_idx = 0
-
-    while acc_tick < total_ticks:
-        alberti, bass_midi = CHORD_PROG[chord_idx % len(CHORD_PROG)]
-        lo, mid_n, hi = alberti
-
-        # Alberti: lo–hi–mid–hi mỗi 0.5 beat
-        seq = [lo, hi, mid_n, hi] * BEATS_PER_CHORD
-        for i, p in enumerate(seq):
-            t = acc_tick + beats_to_ticks(i * 0.5)
-            if t >= total_ticks:
-                break
-            dur = beats_to_ticks(0.4)
-            acc_events.append((t,       'on',  p,          40))
-            acc_events.append((t + dur, 'off', p,          0))
-
-        # Bass root
-        acc_events.append((acc_tick,                              'on',  bass_midi, 50))
-        acc_events.append((acc_tick + beats_to_ticks(BEATS_PER_CHORD), 'off', bass_midi, 0))
-
-        acc_tick += beats_to_ticks(BEATS_PER_CHORD)
-        chord_idx += 1
-
-    acc_events.sort(key=lambda e: e[0])
-    prev = 0
-    for abs_t, kind, pitch, vel in acc_events:
-        delta = abs_t - prev
-        if kind == 'on':
-            acc_track.append(Message('note_on',  channel=1, note=pitch, velocity=vel, time=delta))
-        else:
-            acc_track.append(Message('note_off', channel=1, note=pitch, velocity=0,   time=delta))
-        prev = abs_t
-
-    midi.save(output_file)
-    print(f"✅ MIDI saved: {output_file} | phrases={len(phrases)} | notes={len(raw_midis)}")
+    
 # ==========================================
 # 4. API ENDPOINT
-# ==========================================
-# Low-pass filter
-def apply_audio_pipeline(wav_path):
-    sound = AudioSegment.from_wav(wav_path)
-
-    # =============================
-    # 1. NORMALIZE
-    # =============================
-    sound = normalize(sound)
-
-    # =============================
-    # 2. COMPRESSOR (giống YouTube)
-    # =============================
-    sound = compress_dynamic_range(sound, threshold=-20, ratio=4)
-
-    # =============================
-    # 3. EQ (ấm + bớt chói)
-    # =============================
-    low = sound.low_pass_filter(3000)
-    mid = sound.high_pass_filter(120)
-    sound = low.overlay(mid)
-
-    # =============================
-    # 4. FAKE REVERB (delay thủ công)
-    # =============================
-    delay_ms = 80
-
-    delayed = AudioSegment.silent(duration=delay_ms) + sound - 8
-    delayed2 = AudioSegment.silent(duration=delay_ms * 2) + sound - 12
-
-    sound = sound.overlay(delayed)
-    sound = sound.overlay(delayed2)
-
-    # =============================
-    # 5. FADE (mượt)
-    # =============================
-    dur = len(sound)
-    fade_in = min(2000, int(dur * 0.1))
-    fade_out = min(3000, int(dur * 0.1))
-
-    sound = sound.fade_in(fade_in).fade_out(fade_out)
-
-    # =============================
-    # 6. BOOST VOLUME
-    # =============================
-    sound = sound + 4
-
-    sound.export(wav_path, format="wav")
-@app.post("/generate-vibe")
-async def generate_vibe(data: HeartRateData, request: Request):
-    # Đường dẫn file
-    midi_file = f"music/ai_vibe_{data.bpm}.mid"
-    wav_file = f"music/ai_vibe_{data.bpm}.wav"
-    soundfont_path = "soundfonts/softPiano.sf2" # Đường dẫn tới file sf2 bạn vừa tải
-    
-    # Bước 1: PyTorch sinh ra cấu trúc nốt nhạc (MIDI)
-    generate_ai_midi(data.bpm, midi_file)
+# ==========================================    
+@app.websocket("/ws/vibe")
+async def websocket_vibe(websocket: WebSocket):
+    await websocket.accept()
     
-    # Bước 2: Tự viết lệnh Render bằng Subprocess chuẩn xác cho FluidSynth 2.5+
-    print("Đang render MIDI thành âm thanh Piano...")
     try:
-        subprocess.run([
-            "fluidsynth",
-            "-ni",
-            "-g", "1.5",
-            "-r", "44100",
-            "-F", wav_file,
-            soundfont_path,
-            midi_file
-        ], check=True)
+        # 1. Nhận BPM từ Frontend
+        data = await websocket.receive_json()
+        bpm = int(data.get("bpm", 60))
+        
+        # 2. Khởi tạo trạng thái AI
+        SEQ_LEN = 50
+        seed = random.sample(corpus, SEQ_LEN)
+        pattern = [note_to_int[n] for n in seed]
+        inp_tensor = torch.zeros(1, SEQ_LEN, dtype=torch.long)
+        
+        base_temperature = max(0.5, min(1.1, 0.6 + (bpm - 60) / 100))
+        note_count = 0
+        
+        PENTATONIC_MIDI = [60, 62, 64, 67, 69, 72, 74, 76]
+        
+        # Hàm ép cao độ để nhạc không chói (giới hạn ở nốt G5 = 79)
+        def snap_and_clamp(midi_val):
+            snapped = min(PENTATONIC_MIDI, key=lambda p: abs(p - midi_val))
+            while snapped > 79:
+                snapped -= 12
+            return snapped
+
+        # 3. Vòng lặp VÔ TẬN (chạy cho đến khi user tắt nhạc)
+        while True:
+            # Nhiệt độ dao động theo hình sin (tạo cảm giác thở/sáng tạo)
+            temp = base_temperature + 0.15 * math.sin(note_count / 10.0)
+            
+            # Suy luận AI
+            inp_tensor[0] = torch.tensor(pattern, dtype=torch.long)
+            with torch.inference_mode():
+                pred = model(inp_tensor)
+                probs = torch.softmax(pred / temp, dim=1).numpy()[0]
+                top_idx = np.argsort(probs)[-8:]
+                top_p = probs[top_idx]; top_p /= top_p.sum()
+                idx = np.random.choice(top_idx, p=top_p)
+                
+            tok = int_to_note[idx]
+            pattern = pattern[1:] + [idx] # Cập nhật cửa sổ trượt
+            
+            # Giải mã Token thành MIDI Pitch
+            midi_val = None
+            try:
+                parts = tok.split("_")
+                if parts[0] == "NOTE":
+                    midi_val = note.Note(parts[1]).pitch.midi
+            except: pass
+            
+            if midi_val:
+                midi_val = snap_and_clamp(midi_val)
+                
+                # Tính toán lực đánh (Velocity) êm ái, dao động nhẹ
+                # Scale từ 0-127. 40-60 là lực đánh rất nhẹ (Soft Piano)
+                velocity = int(45 + 15 * math.sin(note_count / 5.0))
+                
+                # Gửi thẳng nốt nhạc xuống Frontend
+                await websocket.send_json({
+                    "note": midi_val,
+                    "velocity": velocity,
+                    "duration": "8n" # Độ dài cơ bản (1/8 nốt)
+                })
+            else:
+                # Nếu AI ra REST, gửi nốt tĩnh (hoặc không gửi)
+                pass
+                
+            note_count += 1
+            
+            # Tốc độ đẩy nốt nhạc phụ thuộc vào BPM
+            # BPM càng cao, sleep càng ngắn -> nốt nhạc rơi xuống càng nhanh
+            sleep_time = 30.0 / bpm 
+            await asyncio.sleep(sleep_time)
+            
+    except WebSocketDisconnect:
+        print("Client đã đóng kết nối WebSocket.")
 
-        # --- BƯỚC MỚI: LỌC ÂM THANH NHỨC ÓC ---
-        apply_audio_pipeline(wav_file)
-        # -------------------------------------
-    except Exception as e:
-        print(f"Lỗi khi render âm thanh: {e}")
-        return {"status": "error", "message": "Render failed"}
-    
-    server_url = str(request.base_url).rstrip("/")
-    
-    # Bước 3: Trả về link file âm thanh xịn xò cho App Flutter
-    return {"status": "success", "audio_url": f"{server_url}/{wav_file}"}