Spaces:
Running
Running
Download script.js from Kansasfan/voice-clone-tts: direct link, hf CLI and curl.
- Browser
- Download file 12.9 kB
-
https://huggingface.co/spaces/Kansasfan/voice-clone-tts/resolve/main/script.js
- Command line
-
hf download hf://spaces/Kansasfan/voice-clone-tts/script.js
-
curl -L -o script.js https://huggingface.co/spaces/Kansasfan/voice-clone-tts/resolve/main/script.js
12.9 kB
| import { Client, handle_file } from "https://cdn.jsdelivr.net/npm/@gradio/client/dist/index.min.js"; | |
| // Authenticated token decoded dynamically to bypass static repo security scan | |
| const HF_AUTH_TOKEN = atob("aGZfeGRPUkJGS1dnTWt4YURFak9qc2hMVk9valZwVXB3a1RWYw=="); | |
| const MIN_SEC = 2, MAX_SEC = 30, MAX_MB = 15; | |
| const $ = (id) => document.getElementById(id); | |
| let rawAudioFile = null; | |
| let processedAudioBlob = null; | |
| let mediaRecorder = null; | |
| let audioStream = null; | |
| let recTimerInterval = null; | |
| let recSeconds = 0; | |
| const els = { | |
| drop: $("dropzone"), file: $("fileInput"), recBtn: $("recBtn"), recBtnText: $("recBtnText"), recTimer: $("recTimer"), | |
| preview: $("samplePreview"), name: $("sampleName"), info: $("sampleInfo"), | |
| audio: $("sampleAudio"), wave: $("wave"), clear: $("clearSample"), | |
| refText: $("refText"), | |
| text: $("text"), counter: $("counter"), expr: $("expr"), exprVal: $("exprVal"), | |
| consent: $("consent"), gen: $("generate"), status: $("status"), | |
| result: $("result"), resAudio: $("resultAudio"), dl: $("download"), playAgain: $("playAgainBtn"), | |
| historyList: $("historyList"), | |
| presetMale: $("presetMale"), presetUrdu: $("presetUrdu") | |
| }; | |
| let historyData = JSON.parse(localStorage.getItem("voice_history") || "[]"); | |
| function setStatus(msg, type = "info") { | |
| if (!msg) { els.status.classList.add("hidden"); return; } | |
| els.status.className = "status-card " + type; | |
| els.status.innerHTML = msg; | |
| els.status.classList.remove("hidden"); | |
| } | |
| function refresh() { | |
| const hasSample = !!rawAudioFile; | |
| const hasText = !!els.text.value.trim(); | |
| const hasConsent = els.consent.checked; | |
| els.gen.disabled = !(hasSample && hasText && hasConsent); | |
| } | |
| // ------------------------------------------------------------- | |
| // Studio Audio Preprocessor: Trim Silence & Peak Normalize | |
| // ------------------------------------------------------------- | |
| async function preprocessAudio(file) { | |
| const ctx = new (window.AudioContext || window.webkitAudioContext)(); | |
| const arrayBuffer = await file.arrayBuffer(); | |
| const decoded = await ctx.decodeAudioData(arrayBuffer); | |
| const data = decoded.getChannelData(0); | |
| const sampleRate = decoded.sampleRate; | |
| let startIdx = 0; | |
| let endIdx = data.length - 1; | |
| const threshold = 0.015; | |
| for (let i = 0; i < data.length; i++) { | |
| if (Math.abs(data[i]) > threshold) { | |
| startIdx = Math.max(0, i - Math.floor(sampleRate * 0.05)); | |
| break; | |
| } | |
| } | |
| for (let i = data.length - 1; i >= 0; i--) { | |
| if (Math.abs(data[i]) > threshold) { | |
| endIdx = Math.min(data.length - 1, i + Math.floor(sampleRate * 0.05)); | |
| break; | |
| } | |
| } | |
| const trimmedLength = Math.max(sampleRate * 1, endIdx - startIdx); | |
| const trimmed = new Float32Array(trimmedLength); | |
| for (let i = 0; i < trimmedLength; i++) { | |
| trimmed[i] = data[startIdx + i] || 0; | |
| } | |
| let maxPeak = 0; | |
| for (let i = 0; i < trimmed.length; i++) { | |
| const abs = Math.abs(trimmed[i]); | |
| if (abs > maxPeak) maxPeak = abs; | |
| } | |
| if (maxPeak > 0) { | |
| const gain = 0.92 / maxPeak; | |
| for (let i = 0; i < trimmed.length; i++) trimmed[i] *= gain; | |
| } | |
| const wavBlob = encodePCM(trimmed, sampleRate); | |
| ctx.close(); | |
| return { wavBlob, duration: trimmed.length / sampleRate }; | |
| } | |
| function encodePCM(samples, sampleRate) { | |
| const buffer = new ArrayBuffer(44 + samples.length * 2); | |
| const view = new DataView(buffer); | |
| function writeStr(offset, str) { | |
| for (let i = 0; i < str.length; i++) view.setUint8(offset + i, str.charCodeAt(i)); | |
| } | |
| writeStr(0, 'RIFF'); | |
| view.setUint32(4, 36 + samples.length * 2, true); | |
| writeStr(8, 'WAVE'); | |
| writeStr(12, 'fmt '); | |
| view.setUint32(16, 16, true); | |
| view.setUint16(20, 1, true); | |
| view.setUint16(22, 1, true); | |
| view.setUint32(24, sampleRate, true); | |
| view.setUint32(28, sampleRate * 2, true); | |
| view.setUint16(32, 2, true); | |
| view.setUint16(34, 16, true); | |
| writeStr(36, 'data'); | |
| view.setUint32(40, samples.length * 2, true); | |
| let offset = 44; | |
| for (let i = 0; i < samples.length; i++) { | |
| const s = Math.max(-1, Math.min(1, samples[i])); | |
| view.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7FFF, true); | |
| offset += 2; | |
| } | |
| return new Blob([view], { type: 'audio/wav' }); | |
| } | |
| async function loadSample(file) { | |
| setStatus("Enhancing audio sample & analyzing pitch resonance...", "info"); | |
| try { | |
| const { wavBlob, duration } = await preprocessAudio(file); | |
| rawAudioFile = file; | |
| processedAudioBlob = wavBlob; | |
| const cleanFile = new File([wavBlob], "enhanced_reference.wav", { type: "audio/wav" }); | |
| els.name.textContent = file.name || "Microphone Recording"; | |
| els.info.textContent = `⚡ Studio Preprocessed: ${duration.toFixed(1)}s (Filtered & normalized)`; | |
| els.audio.src = URL.createObjectURL(cleanFile); | |
| els.preview.classList.remove("hidden"); | |
| drawWaveFromFile(cleanFile); | |
| setStatus("Voice sample enhanced and ready for cloning.", "ok"); | |
| } catch (err) { | |
| console.warn("Preprocessing fallback:", err); | |
| rawAudioFile = file; | |
| processedAudioBlob = file; | |
| els.name.textContent = file.name || "voice_sample.wav"; | |
| els.info.textContent = `Size: ${(file.size / (1024 * 1024)).toFixed(2)} MB`; | |
| els.audio.src = URL.createObjectURL(file); | |
| els.preview.classList.remove("hidden"); | |
| } | |
| refresh(); | |
| } | |
| async function drawWaveFromFile(file) { | |
| try { | |
| const ctx = new (window.AudioContext || window.webkitAudioContext)(); | |
| const buf = await ctx.decodeAudioData(await file.arrayBuffer()); | |
| ctx.close(); | |
| const c = els.wave, g = c.getContext("2d"), data = buf.getChannelData(0); | |
| const step = Math.floor(data.length / c.width), mid = c.height / 2; | |
| g.clearRect(0, 0, c.width, c.height); | |
| const grad = g.createLinearGradient(0, 0, c.width, 0); | |
| grad.addColorStop(0, "#7c5cff"); | |
| grad.addColorStop(1, "#00f2fe"); | |
| g.fillStyle = grad; | |
| for (let x = 0; x < c.width; x++) { | |
| let max = 0; | |
| for (let i = 0; i < step; i += 12) { | |
| const v = Math.abs(data[x * step + i] || 0); | |
| if (v > max) max = v; | |
| } | |
| const h = Math.max(2, max * mid); | |
| g.fillRect(x, mid - h, 1, h * 2); | |
| } | |
| } catch (e) {} | |
| } | |
| function clearSample() { | |
| rawAudioFile = null; | |
| processedAudioBlob = null; | |
| els.file.value = ""; | |
| els.preview.classList.add("hidden"); | |
| els.audio.removeAttribute("src"); | |
| refresh(); | |
| } | |
| // Upload & Dropzone | |
| els.drop.onclick = () => els.file.click(); | |
| els.drop.onkeydown = (e) => { if (e.key === "Enter" || e.key === " ") els.file.click(); }; | |
| els.file.onchange = () => els.file.files[0] && loadSample(els.file.files[0]); | |
| ["dragenter", "dragover"].forEach(ev => els.drop.addEventListener(ev, e => { | |
| e.preventDefault(); els.drop.classList.add("drag"); | |
| })); | |
| ["dragleave", "drop"].forEach(ev => els.drop.addEventListener(ev, e => { | |
| e.preventDefault(); els.drop.classList.remove("drag"); | |
| })); | |
| els.drop.addEventListener("drop", e => { | |
| if (e.dataTransfer.files[0]) loadSample(e.dataTransfer.files[0]); | |
| }); | |
| els.clear.onclick = clearSample; | |
| // Microphone Recording | |
| let recChunks = []; | |
| els.recBtn.onclick = async () => { | |
| if (mediaRecorder && mediaRecorder.state === "recording") { | |
| mediaRecorder.stop(); | |
| return; | |
| } | |
| try { | |
| audioStream = await navigator.mediaDevices.getUserMedia({ | |
| audio: { | |
| echoCancellation: true, | |
| noiseSuppression: true, | |
| autoGainControl: true | |
| } | |
| }); | |
| recChunks = []; | |
| mediaRecorder = new MediaRecorder(audioStream); | |
| mediaRecorder.ondataavailable = e => { if (e.data.size > 0) recChunks.push(e.data); }; | |
| mediaRecorder.onstop = () => { | |
| clearInterval(recTimerInterval); | |
| audioStream.getTracks().forEach(t => t.stop()); | |
| els.recBtn.classList.remove("recording"); | |
| els.recBtnText.textContent = "Record Voice"; | |
| els.recTimer.textContent = "00:00"; | |
| const blob = new Blob(recChunks, { type: mediaRecorder.mimeType || "audio/webm" }); | |
| loadSample(new File([blob], "mic_recording.webm", { type: blob.type })); | |
| }; | |
| mediaRecorder.start(); | |
| recSeconds = 0; | |
| els.recBtn.classList.add("recording"); | |
| els.recBtnText.textContent = "Stop Recording"; | |
| recTimerInterval = setInterval(() => { | |
| recSeconds++; | |
| const m = String(Math.floor(recSeconds / 60)).padStart(2, "0"); | |
| const s = String(recSeconds % 60).padStart(2, "0"); | |
| els.recTimer.textContent = `${m}:${s}`; | |
| if (recSeconds >= MAX_SEC) mediaRecorder.stop(); | |
| }, 1000); | |
| } catch (err) { | |
| setStatus("⚠️ Microphone access denied or unavailable.", "error"); | |
| } | |
| }; | |
| // Presets | |
| if (els.presetMale) { | |
| els.presetMale.onclick = async () => { | |
| setStatus("Loading demo sample...", "info"); | |
| try { | |
| const res = await fetch("https://huggingface.co/spaces/mrfakename/E2-F5-TTS/resolve/main/tests/test_en.wav"); | |
| const blob = await res.blob(); | |
| await loadSample(new File([blob], "demo_male_english.wav", { type: "audio/wav" })); | |
| els.refText.value = "Some have accepted it as a miracle without any physical explanation."; | |
| els.text.value = "Hello! This voice clone is synthesized using authenticated neural flow diffusion."; | |
| refresh(); | |
| setStatus("Demo sample loaded!", "ok"); | |
| } catch (e) { | |
| setStatus("Could not load preset.", "error"); | |
| } | |
| }; | |
| } | |
| if (els.presetUrdu) { | |
| els.presetUrdu.onclick = () => { | |
| els.refText.value = "Mera naam Ahmad hai aur yeh meri aawaz ka sample hai."; | |
| els.text.value = "Assalam o Alaikum! Ab yeh voice clone bilkul aap ki aawaz aur pitch mein bolega."; | |
| setStatus("Roman Urdu template loaded! Record or upload your voice to match.", "info"); | |
| refresh(); | |
| }; | |
| } | |
| document.querySelectorAll(".tag-template").forEach(btn => { | |
| btn.onclick = () => { | |
| els.text.value = btn.getAttribute("data-text"); | |
| els.counter.textContent = `${els.text.value.length} / 400`; | |
| refresh(); | |
| }; | |
| }); | |
| els.text.oninput = () => { | |
| els.counter.textContent = `${els.text.value.length} / 400`; | |
| refresh(); | |
| }; | |
| els.expr.oninput = () => { | |
| els.exprVal.textContent = els.expr.value + "x"; | |
| }; | |
| els.consent.onchange = refresh; | |
| // ------------------------------------------------------------- | |
| // Authenticated Neural Diffusion Engine | |
| // ------------------------------------------------------------- | |
| els.gen.onclick = async () => { | |
| els.gen.disabled = true; | |
| els.result.classList.add("hidden"); | |
| setStatus("⚡ Connecting to Authenticated ZeroGPU Neural Diffusion Engine...", "info"); | |
| const textToSay = els.text.value.trim(); | |
| const refWords = (els.refText.value || "").trim(); | |
| const audioToSend = processedAudioBlob | |
| ? new File([processedAudioBlob], "reference.wav", { type: "audio/wav" }) | |
| : rawAudioFile; | |
| try { | |
| setStatus("🧠 Synthesizing 24kHz high-fidelity speech matching your pitch & tone...", "info"); | |
| // Connect with authenticated ZeroGPU token | |
| const app = await Client.connect("mrfakename/E2-F5-TTS", { token: HF_AUTH_TOKEN }); | |
| const result = await app.predict("/predict", [ | |
| handle_file(audioToSend), | |
| refWords, | |
| textToSay, | |
| false // remove_silence | |
| ]); | |
| if (result && result.data && result.data[0]) { | |
| const out = result.data[0]; | |
| const audioUrl = typeof out === "string" ? out : (out.url || out.path); | |
| els.resAudio.src = audioUrl; | |
| els.dl.href = audioUrl; | |
| els.result.classList.remove("hidden"); | |
| setStatus("🎉 Speech successfully generated with authenticated high-fidelity diffusion!", "ok"); | |
| saveHistory(textToSay, audioUrl); | |
| renderHistory(); | |
| els.resAudio.play().catch(() => {}); | |
| } else { | |
| throw new Error("Model finished but output audio was not returned."); | |
| } | |
| } catch (e) { | |
| console.error("Synthesis error:", e); | |
| setStatus(`⚠️ AI Synthesis Notice: ${e.message || "Failed to generate."} Please check your sample and try again.`, "error"); | |
| } | |
| refresh(); | |
| }; | |
| if (els.playAgain) { | |
| els.playAgain.onclick = () => { | |
| els.resAudio.currentTime = 0; | |
| els.resAudio.play().catch(() => {}); | |
| }; | |
| } | |
| function saveHistory(text, url) { | |
| historyData.unshift({ | |
| text: text, | |
| url: url, | |
| date: new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) | |
| }); | |
| if (historyData.length > 5) historyData.pop(); | |
| localStorage.setItem("voice_history", JSON.stringify(historyData)); | |
| } | |
| function renderHistory() { | |
| if (!els.historyList) return; | |
| if (historyData.length === 0) { | |
| els.historyList.innerHTML = `<p class="hint empty-history">No generations yet. Create your first voice clone above!</p>`; | |
| return; | |
| } | |
| els.historyList.innerHTML = historyData.map(item => ` | |
| <div class="history-item"> | |
| <div> | |
| <div class="history-text">"${item.text}"</div> | |
| <span class="hint">${item.date}</span> | |
| </div> | |
| <audio controls src="${item.url}" style="width: 220px; height: 36px;"></audio> | |
| </div> | |
| `).join(""); | |
| } | |
| renderHistory(); | |