|
|
|
|
@@ -15,7 +15,6 @@ import (
|
|
|
|
|
"io"
|
|
|
|
|
"log/slog"
|
|
|
|
|
"net/http"
|
|
|
|
|
"os"
|
|
|
|
|
"strconv"
|
|
|
|
|
"strings"
|
|
|
|
|
"sync"
|
|
|
|
|
@@ -39,12 +38,17 @@ type Server struct {
|
|
|
|
|
kokoroURL string // Kokoro-FastAPI base URL, e.g. http://kokoro:8880
|
|
|
|
|
kokoroVoice string // default voice, e.g. af_bella
|
|
|
|
|
|
|
|
|
|
// audioMu guards audioInFlight.
|
|
|
|
|
// audioInFlight maps an audio cache key to a channel that is closed when
|
|
|
|
|
// the in-flight Kokoro request for that key finishes (successfully or not).
|
|
|
|
|
// This prevents duplicate concurrent TTS generation for the same file.
|
|
|
|
|
// voiceMu guards cachedVoices.
|
|
|
|
|
voiceMu sync.RWMutex
|
|
|
|
|
cachedVoices []string // populated on first request from Kokoro /v1/audio/voices
|
|
|
|
|
|
|
|
|
|
// audioMu guards audioCache and audioInFlight.
|
|
|
|
|
// audioCache maps a cache key to the Kokoro download filename returned by
|
|
|
|
|
// POST /v1/audio/speech with return_download_link=true.
|
|
|
|
|
// audioInFlight deduplicates concurrent generation requests for the same key.
|
|
|
|
|
audioMu sync.Mutex
|
|
|
|
|
audioInFlight map[string]chan struct{}
|
|
|
|
|
audioCache map[string]string // cacheKey → kokoro download filename
|
|
|
|
|
audioInFlight map[string]chan struct{} // cacheKey → closed when done
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// New creates a new Server.
|
|
|
|
|
@@ -57,10 +61,50 @@ func New(addr string, oCfg orchestrator.Config, novel scraper.NovelScraper, log
|
|
|
|
|
writer: writer.New(oCfg.StaticRoot),
|
|
|
|
|
kokoroURL: kokoroURL,
|
|
|
|
|
kokoroVoice: kokoroVoice,
|
|
|
|
|
audioCache: make(map[string]string),
|
|
|
|
|
audioInFlight: make(map[string]chan struct{}),
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// voices returns the list of available Kokoro voices. On the first call it
|
|
|
|
|
// fetches GET /v1/audio/voices from the Kokoro service and caches the result.
|
|
|
|
|
// If the fetch fails (Kokoro not up yet, network error, etc.) it falls back to
|
|
|
|
|
// the hardcoded kokoroVoices list so the UI is never empty.
|
|
|
|
|
func (s *Server) voices() []string {
|
|
|
|
|
s.voiceMu.RLock()
|
|
|
|
|
cached := s.cachedVoices
|
|
|
|
|
s.voiceMu.RUnlock()
|
|
|
|
|
if len(cached) > 0 {
|
|
|
|
|
return cached
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if s.kokoroURL != "" {
|
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
|
|
|
defer cancel()
|
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, s.kokoroURL+"/v1/audio/voices", nil)
|
|
|
|
|
if err == nil {
|
|
|
|
|
req.Header.Set("Accept", "application/json")
|
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
|
|
|
if err == nil {
|
|
|
|
|
defer resp.Body.Close()
|
|
|
|
|
var payload struct {
|
|
|
|
|
Voices []string `json:"voices"`
|
|
|
|
|
}
|
|
|
|
|
if resp.StatusCode == http.StatusOK && json.NewDecoder(resp.Body).Decode(&payload) == nil && len(payload.Voices) > 0 {
|
|
|
|
|
s.voiceMu.Lock()
|
|
|
|
|
s.cachedVoices = payload.Voices
|
|
|
|
|
s.voiceMu.Unlock()
|
|
|
|
|
s.log.Info("fetched kokoro voices", "count", len(payload.Voices))
|
|
|
|
|
return payload.Voices
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
s.log.Warn("could not fetch kokoro voices, using built-in list")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return kokoroVoices
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ListenAndServe starts the HTTP server and blocks until the provided context
|
|
|
|
|
// is cancelled.
|
|
|
|
|
func (s *Server) ListenAndServe(ctx context.Context) error {
|
|
|
|
|
@@ -82,18 +126,18 @@ func (s *Server) ListenAndServe(ctx context.Context) error {
|
|
|
|
|
mux.HandleFunc("GET /ui/ranking/status", s.handleRankingStatus)
|
|
|
|
|
// Plain-text chapter content for browser-side TTS
|
|
|
|
|
mux.HandleFunc("GET /ui/chapter-text/{slug}/{n}", s.handleChapterText)
|
|
|
|
|
// Server-side audio generation and serving.
|
|
|
|
|
// Audio generation can take several minutes for long chapters, so wrap it
|
|
|
|
|
// in its own timeout handler instead of relying on the server WriteTimeout.
|
|
|
|
|
// Server-side audio generation via Kokoro /v1/audio/speech.
|
|
|
|
|
// Generation can take several minutes, so wrap in its own timeout handler.
|
|
|
|
|
audioGenHandler := http.TimeoutHandler(
|
|
|
|
|
http.HandlerFunc(s.handleAudioGenerate),
|
|
|
|
|
10*time.Minute,
|
|
|
|
|
`{"error":"audio generation timed out"}`,
|
|
|
|
|
)
|
|
|
|
|
mux.Handle("POST /ui/audio/{slug}/{n}", audioGenHandler)
|
|
|
|
|
mux.HandleFunc("GET /ui/audio/{slug}/{n}/status", s.handleAudioStatus)
|
|
|
|
|
mux.HandleFunc("GET /ui/audio-file/{slug}/{n}", s.handleAudioFile)
|
|
|
|
|
mux.HandleFunc("GET /ui/audio-file/{slug}/{n}/part/{p}", s.handleAudioFilePart)
|
|
|
|
|
// Status route: returns the proxy URL if audio was already generated, 404 otherwise.
|
|
|
|
|
mux.HandleFunc("GET /ui/audio/{slug}/{n}", s.handleAudioStatus)
|
|
|
|
|
// Proxy route: fetches the generated file from Kokoro /v1/download/{filename}.
|
|
|
|
|
mux.HandleFunc("GET /ui/audio-proxy/{slug}/{n}", s.handleAudioProxy)
|
|
|
|
|
|
|
|
|
|
srv := &http.Server{
|
|
|
|
|
Addr: s.addr,
|
|
|
|
|
@@ -142,25 +186,18 @@ func (s *Server) handleChapterText(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
fmt.Fprint(w, stripMarkdown(raw))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ─── Chunked audio generation ────────────────────────────────────────────────
|
|
|
|
|
// ─── Audio generation via Kokoro /v1/audio/speech ────────────────────────────
|
|
|
|
|
//
|
|
|
|
|
// handleAudioGenerate handles POST /ui/audio/{slug}/{n}.
|
|
|
|
|
//
|
|
|
|
|
// Flow:
|
|
|
|
|
// 1. If the merged MP3 already exists on disk → return it immediately.
|
|
|
|
|
// 2. Otherwise split the chapter text into up to audioParts equal-ish chunks
|
|
|
|
|
// (by paragraph), generate part 0 synchronously (so the browser can start
|
|
|
|
|
// playing right away), then launch a background goroutine that generates
|
|
|
|
|
// parts 1…N and merges them into the final file.
|
|
|
|
|
// 3. Response: {"url":"<part-0-url>","parts":N,"merged":false}
|
|
|
|
|
// (or {"url":"<final-url>","parts":1,"merged":true} on a cache hit).
|
|
|
|
|
// It calls Kokoro's POST /v1/audio/speech with return_download_link=true.
|
|
|
|
|
// Kokoro generates the audio, saves it to its own temp storage, and returns
|
|
|
|
|
// the download filename in the X-Download-Path response header.
|
|
|
|
|
// We cache that filename (in memory, keyed by slug/chapter/voice/speed) and
|
|
|
|
|
// return a proxy URL that the browser sets as audio.src.
|
|
|
|
|
//
|
|
|
|
|
// Deduplication: if another request is already generating the *merged* file
|
|
|
|
|
// for the same (slug,n,voice,speed) key, the new request blocks until it
|
|
|
|
|
// finishes and then serves the cached result.
|
|
|
|
|
const audioParts = 10
|
|
|
|
|
|
|
|
|
|
// handleAudioGenerate handles POST /ui/audio/{slug}/{n}.
|
|
|
|
|
// On a cache hit the proxy URL is returned immediately without re-generating.
|
|
|
|
|
// Concurrent requests for the same key are deduplicated.
|
|
|
|
|
func (s *Server) handleAudioGenerate(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
slug := r.PathValue("slug")
|
|
|
|
|
n, err := strconv.Atoi(r.PathValue("n"))
|
|
|
|
|
@@ -186,18 +223,17 @@ func (s *Server) handleAudioGenerate(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
speed = body.Speed
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
audioPath := s.writer.AudioPath(slug, n, voice, speed)
|
|
|
|
|
cacheKey := fmt.Sprintf("%s/%d/%s/%.2f", slug, n, voice, speed)
|
|
|
|
|
|
|
|
|
|
// Fast path: merged file already on disk.
|
|
|
|
|
if _, err := os.Stat(audioPath); err == nil {
|
|
|
|
|
s.writeAudioResponse(w, slug, n, voice, speed, 1, true)
|
|
|
|
|
// Fast path: already generated this session.
|
|
|
|
|
s.audioMu.Lock()
|
|
|
|
|
if filename, ok := s.audioCache[cacheKey]; ok {
|
|
|
|
|
s.audioMu.Unlock()
|
|
|
|
|
s.writeAudioResponse(w, slug, n, voice, speed, filename)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Deduplicate concurrent generation requests for the same merged file.
|
|
|
|
|
cacheKey := fmt.Sprintf("%s/%d/%s/%.2f", slug, n, voice, speed)
|
|
|
|
|
|
|
|
|
|
s.audioMu.Lock()
|
|
|
|
|
// Deduplicate concurrent generation for the same key.
|
|
|
|
|
if ch, ok := s.audioInFlight[cacheKey]; ok {
|
|
|
|
|
s.audioMu.Unlock()
|
|
|
|
|
select {
|
|
|
|
|
@@ -206,8 +242,11 @@ func (s *Server) handleAudioGenerate(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
http.Error(w, `{"error":"request cancelled"}`, http.StatusServiceUnavailable)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if _, err := os.Stat(audioPath); err == nil {
|
|
|
|
|
s.writeAudioResponse(w, slug, n, voice, speed, 1, true)
|
|
|
|
|
s.audioMu.Lock()
|
|
|
|
|
filename, ok := s.audioCache[cacheKey]
|
|
|
|
|
s.audioMu.Unlock()
|
|
|
|
|
if ok {
|
|
|
|
|
s.writeAudioResponse(w, slug, n, voice, speed, filename)
|
|
|
|
|
} else {
|
|
|
|
|
http.Error(w, `{"error":"audio generation failed"}`, http.StatusInternalServerError)
|
|
|
|
|
}
|
|
|
|
|
@@ -240,207 +279,86 @@ func (s *Server) handleAudioGenerate(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Ensure audio dir exists.
|
|
|
|
|
if err := os.MkdirAll(s.writer.AudioDir(slug), 0o755); err != nil {
|
|
|
|
|
http.Error(w, `{"error":"failed to create audio dir"}`, http.StatusInternalServerError)
|
|
|
|
|
// Call Kokoro POST /v1/audio/speech with return_download_link=true.
|
|
|
|
|
// Kokoro saves the generated audio to its own temp storage and returns the
|
|
|
|
|
// download path in the X-Download-Path response header.
|
|
|
|
|
filename, err := s.generateSpeech(r.Context(), text, voice, speed)
|
|
|
|
|
if err != nil {
|
|
|
|
|
s.log.Error("kokoro speech generation failed", "slug", slug, "chapter", n, "err", err)
|
|
|
|
|
http.Error(w, `{"error":"speech generation failed"}`, http.StatusBadGateway)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
parts := splitTextIntoParts(text, audioParts)
|
|
|
|
|
totalParts := len(parts)
|
|
|
|
|
s.audioMu.Lock()
|
|
|
|
|
s.audioCache[cacheKey] = filename
|
|
|
|
|
s.audioMu.Unlock()
|
|
|
|
|
|
|
|
|
|
// Generate part 0 synchronously so the browser can start playing immediately.
|
|
|
|
|
if err := s.generateAudioPart(r.Context(), slug, n, voice, speed, 0, parts[0]); err != nil {
|
|
|
|
|
s.log.Error("part 0 generation failed", "err", err)
|
|
|
|
|
http.Error(w, `{"error":"part 0 generation failed"}`, http.StatusBadGateway)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if totalParts == 1 {
|
|
|
|
|
// Only one part — rename it to the final path directly.
|
|
|
|
|
partPath := s.writer.AudioPartPath(slug, n, voice, speed, 0)
|
|
|
|
|
if err := os.Rename(partPath, audioPath); err != nil {
|
|
|
|
|
http.Error(w, `{"error":"failed to save audio"}`, http.StatusInternalServerError)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
s.log.Info("audio generated (single part)", "slug", slug, "chapter", n)
|
|
|
|
|
s.writeAudioResponse(w, slug, n, voice, speed, 1, true)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Return part-0 URL immediately; generate the rest in the background.
|
|
|
|
|
s.writeAudioResponse(w, slug, n, voice, speed, totalParts, false)
|
|
|
|
|
|
|
|
|
|
// Background: generate parts 1…N then merge.
|
|
|
|
|
go func() {
|
|
|
|
|
bgCtx := context.Background()
|
|
|
|
|
for p := 1; p < totalParts; p++ {
|
|
|
|
|
if err := s.generateAudioPart(bgCtx, slug, n, voice, speed, p, parts[p]); err != nil {
|
|
|
|
|
s.log.Error("background part generation failed", "part", p, "err", err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if err := s.mergeAudioParts(slug, n, voice, speed, totalParts); err != nil {
|
|
|
|
|
s.log.Error("audio merge failed", "slug", slug, "chapter", n, "err", err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
s.log.Info("audio merged", "slug", slug, "chapter", n, "parts", totalParts)
|
|
|
|
|
}()
|
|
|
|
|
s.log.Info("audio generated", "slug", slug, "chapter", n, "filename", filename)
|
|
|
|
|
s.writeAudioResponse(w, slug, n, voice, speed, filename)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// splitTextIntoParts divides text (paragraphs separated by blank lines) into
|
|
|
|
|
// at most n equal-ish chunks. Returns at least 1 element.
|
|
|
|
|
func splitTextIntoParts(text string, n int) []string {
|
|
|
|
|
// Split into paragraphs on blank lines.
|
|
|
|
|
raw := strings.Split(text, "\n\n")
|
|
|
|
|
var paras []string
|
|
|
|
|
for _, p := range raw {
|
|
|
|
|
p = strings.TrimSpace(p)
|
|
|
|
|
if p != "" {
|
|
|
|
|
paras = append(paras, p)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if len(paras) == 0 {
|
|
|
|
|
return []string{text}
|
|
|
|
|
}
|
|
|
|
|
if n > len(paras) {
|
|
|
|
|
n = len(paras)
|
|
|
|
|
}
|
|
|
|
|
if n < 1 {
|
|
|
|
|
n = 1
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
chunks := make([]string, n)
|
|
|
|
|
chunkSize := (len(paras) + n - 1) / n // ceiling division
|
|
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
|
start := i * chunkSize
|
|
|
|
|
end := start + chunkSize
|
|
|
|
|
if start >= len(paras) {
|
|
|
|
|
// Fewer paragraphs than requested parts: return what we have.
|
|
|
|
|
chunks = chunks[:i]
|
|
|
|
|
break
|
|
|
|
|
}
|
|
|
|
|
if end > len(paras) {
|
|
|
|
|
end = len(paras)
|
|
|
|
|
}
|
|
|
|
|
chunks[i] = strings.Join(paras[start:end], "\n\n")
|
|
|
|
|
}
|
|
|
|
|
if len(chunks) == 0 {
|
|
|
|
|
return []string{text}
|
|
|
|
|
}
|
|
|
|
|
return chunks
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// generateAudioPart calls Kokoro for a single text chunk and writes the result
|
|
|
|
|
// atomically to AudioPartPath(…, part).
|
|
|
|
|
func (s *Server) generateAudioPart(ctx context.Context, slug string, n int, voice string, speed float64, part int, text string) error {
|
|
|
|
|
// generateSpeech calls POST /v1/audio/speech on Kokoro with return_download_link=true
|
|
|
|
|
// and returns the filename from the X-Download-Path response header.
|
|
|
|
|
func (s *Server) generateSpeech(ctx context.Context, text, voice string, speed float64) (string, error) {
|
|
|
|
|
reqBody, _ := json.Marshal(map[string]interface{}{
|
|
|
|
|
"model": "kokoro",
|
|
|
|
|
"input": text,
|
|
|
|
|
"voice": voice,
|
|
|
|
|
"response_format": "mp3",
|
|
|
|
|
"speed": speed,
|
|
|
|
|
"stream": false,
|
|
|
|
|
"model": "kokoro",
|
|
|
|
|
"input": text,
|
|
|
|
|
"voice": voice,
|
|
|
|
|
"response_format": "mp3",
|
|
|
|
|
"speed": speed,
|
|
|
|
|
"stream": false,
|
|
|
|
|
"return_download_link": true,
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost,
|
|
|
|
|
s.kokoroURL+"/v1/audio/speech", bytes.NewReader(reqBody))
|
|
|
|
|
if err != nil {
|
|
|
|
|
return fmt.Errorf("build request: %w", err)
|
|
|
|
|
return "", fmt.Errorf("build request: %w", err)
|
|
|
|
|
}
|
|
|
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
|
|
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return fmt.Errorf("kokoro request: %w", err)
|
|
|
|
|
return "", fmt.Errorf("kokoro request: %w", err)
|
|
|
|
|
}
|
|
|
|
|
defer resp.Body.Close()
|
|
|
|
|
// Drain body so the connection can be reused.
|
|
|
|
|
_, _ = io.Copy(io.Discard, resp.Body)
|
|
|
|
|
|
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
|
|
|
body, _ := io.ReadAll(resp.Body)
|
|
|
|
|
return fmt.Errorf("kokoro status %d: %s", resp.StatusCode, string(body))
|
|
|
|
|
return "", fmt.Errorf("kokoro status %d", resp.StatusCode)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
partPath := s.writer.AudioPartPath(slug, n, voice, speed, part)
|
|
|
|
|
tmpPath := partPath + ".tmp"
|
|
|
|
|
f, err := os.Create(tmpPath)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return fmt.Errorf("create temp file: %w", err)
|
|
|
|
|
// X-Download-Path is e.g. "/download/speech_abc123.mp3"
|
|
|
|
|
dlPath := resp.Header.Get("X-Download-Path")
|
|
|
|
|
if dlPath == "" {
|
|
|
|
|
return "", fmt.Errorf("kokoro did not return X-Download-Path header")
|
|
|
|
|
}
|
|
|
|
|
if _, err := io.Copy(f, resp.Body); err != nil {
|
|
|
|
|
f.Close()
|
|
|
|
|
os.Remove(tmpPath)
|
|
|
|
|
return fmt.Errorf("write audio: %w", err)
|
|
|
|
|
|
|
|
|
|
// Extract just the filename from the path.
|
|
|
|
|
filename := dlPath
|
|
|
|
|
if idx := strings.LastIndex(dlPath, "/"); idx >= 0 {
|
|
|
|
|
filename = dlPath[idx+1:]
|
|
|
|
|
}
|
|
|
|
|
f.Close()
|
|
|
|
|
if err := os.Rename(tmpPath, partPath); err != nil {
|
|
|
|
|
os.Remove(tmpPath)
|
|
|
|
|
return fmt.Errorf("rename temp file: %w", err)
|
|
|
|
|
if filename == "" {
|
|
|
|
|
return "", fmt.Errorf("empty filename in X-Download-Path: %q", dlPath)
|
|
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
return filename, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// mergeAudioParts concatenates totalParts part files in order into AudioPath,
|
|
|
|
|
// then removes the individual part files.
|
|
|
|
|
func (s *Server) mergeAudioParts(slug string, n int, voice string, speed float64, totalParts int) error {
|
|
|
|
|
audioPath := s.writer.AudioPath(slug, n, voice, speed)
|
|
|
|
|
tmpPath := audioPath + ".tmp"
|
|
|
|
|
|
|
|
|
|
out, err := os.Create(tmpPath)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return fmt.Errorf("create merged temp: %w", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for p := 0; p < totalParts; p++ {
|
|
|
|
|
partPath := s.writer.AudioPartPath(slug, n, voice, speed, p)
|
|
|
|
|
data, err := os.ReadFile(partPath)
|
|
|
|
|
if err != nil {
|
|
|
|
|
out.Close()
|
|
|
|
|
os.Remove(tmpPath)
|
|
|
|
|
return fmt.Errorf("read part %d: %w", p, err)
|
|
|
|
|
}
|
|
|
|
|
if _, err := out.Write(data); err != nil {
|
|
|
|
|
out.Close()
|
|
|
|
|
os.Remove(tmpPath)
|
|
|
|
|
return fmt.Errorf("write merged part %d: %w", p, err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
out.Close()
|
|
|
|
|
|
|
|
|
|
if err := os.Rename(tmpPath, audioPath); err != nil {
|
|
|
|
|
os.Remove(tmpPath)
|
|
|
|
|
return fmt.Errorf("rename merged: %w", err)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Clean up part files (best-effort).
|
|
|
|
|
for p := 0; p < totalParts; p++ {
|
|
|
|
|
os.Remove(s.writer.AudioPartPath(slug, n, voice, speed, p))
|
|
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (s *Server) writeAudioResponse(w http.ResponseWriter, slug string, n int, voice string, speed float64, parts int, merged bool) {
|
|
|
|
|
var url string
|
|
|
|
|
if merged {
|
|
|
|
|
url = fmt.Sprintf("/ui/audio-file/%s/%d?voice=%s&speed=%.1f", slug, n, voice, speed)
|
|
|
|
|
} else {
|
|
|
|
|
url = fmt.Sprintf("/ui/audio-file/%s/%d/part/0?voice=%s&speed=%.1f", slug, n, voice, speed)
|
|
|
|
|
}
|
|
|
|
|
// writeAudioResponse writes the JSON response for a generated audio chapter.
|
|
|
|
|
// The URL points to our proxy handler which fetches from Kokoro on demand.
|
|
|
|
|
func (s *Server) writeAudioResponse(w http.ResponseWriter, slug string, n int, voice string, speed float64, filename string) {
|
|
|
|
|
proxyURL := fmt.Sprintf("/ui/audio-proxy/%s/%d?voice=%s&speed=%.1f", slug, n, voice, speed)
|
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
|
_ = json.NewEncoder(w).Encode(map[string]interface{}{
|
|
|
|
|
"url": url,
|
|
|
|
|
"parts": parts,
|
|
|
|
|
"merged": merged,
|
|
|
|
|
"url": proxyURL,
|
|
|
|
|
"filename": filename,
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// writeAudioURL is kept for backward compatibility (used by dedup waiters).
|
|
|
|
|
func (s *Server) writeAudioURL(w http.ResponseWriter, slug string, n int, voice string, speed float64) {
|
|
|
|
|
s.writeAudioResponse(w, slug, n, voice, speed, 1, true)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// handleAudioStatus handles GET /ui/audio/{slug}/{n}/status.
|
|
|
|
|
// Returns {"merged":true/false,"url":"..."} so the browser can poll for the
|
|
|
|
|
// merged file after receiving a parts response from handleAudioGenerate.
|
|
|
|
|
// handleAudioStatus handles GET /ui/audio/{slug}/{n}.
|
|
|
|
|
// Returns the proxy URL if audio was already generated this session, 404 otherwise.
|
|
|
|
|
func (s *Server) handleAudioStatus(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
slug := r.PathValue("slug")
|
|
|
|
|
n, err := strconv.Atoi(r.PathValue("n"))
|
|
|
|
|
@@ -460,23 +378,22 @@ func (s *Server) handleAudioStatus(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
audioPath := s.writer.AudioPath(slug, n, voice, speed)
|
|
|
|
|
merged := false
|
|
|
|
|
if _, err := os.Stat(audioPath); err == nil {
|
|
|
|
|
merged = true
|
|
|
|
|
}
|
|
|
|
|
cacheKey := fmt.Sprintf("%s/%d/%s/%.2f", slug, n, voice, speed)
|
|
|
|
|
s.audioMu.Lock()
|
|
|
|
|
filename, ok := s.audioCache[cacheKey]
|
|
|
|
|
s.audioMu.Unlock()
|
|
|
|
|
|
|
|
|
|
mergedURL := fmt.Sprintf("/ui/audio-file/%s/%d?voice=%s&speed=%.1f", slug, n, voice, speed)
|
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
|
_ = json.NewEncoder(w).Encode(map[string]interface{}{
|
|
|
|
|
"merged": merged,
|
|
|
|
|
"url": mergedURL,
|
|
|
|
|
})
|
|
|
|
|
if !ok {
|
|
|
|
|
http.Error(w, `{"error":"not generated"}`, http.StatusNotFound)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
s.writeAudioResponse(w, slug, n, voice, speed, filename)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// handleAudioFile handles GET /ui/audio-file/{slug}/{n}.
|
|
|
|
|
// Serves the cached merged MP3 file identified by voice and speed query params.
|
|
|
|
|
func (s *Server) handleAudioFile(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
// handleAudioProxy handles GET /ui/audio-proxy/{slug}/{n}.
|
|
|
|
|
// It looks up the Kokoro download filename for this chapter (voice/speed) and
|
|
|
|
|
// proxies GET /v1/download/{filename} from the Kokoro server back to the browser.
|
|
|
|
|
func (s *Server) handleAudioProxy(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
slug := r.PathValue("slug")
|
|
|
|
|
n, err := strconv.Atoi(r.PathValue("n"))
|
|
|
|
|
if err != nil || n < 1 {
|
|
|
|
|
@@ -495,52 +412,41 @@ func (s *Server) handleAudioFile(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
audioPath := s.writer.AudioPath(slug, n, voice, speed)
|
|
|
|
|
if _, err := os.Stat(audioPath); err != nil {
|
|
|
|
|
http.NotFound(w, r)
|
|
|
|
|
cacheKey := fmt.Sprintf("%s/%d/%s/%.2f", slug, n, voice, speed)
|
|
|
|
|
s.audioMu.Lock()
|
|
|
|
|
filename, ok := s.audioCache[cacheKey]
|
|
|
|
|
s.audioMu.Unlock()
|
|
|
|
|
|
|
|
|
|
if !ok {
|
|
|
|
|
http.Error(w, "audio not generated yet", http.StatusNotFound)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
kokoroURL := s.kokoroURL + "/v1/download/" + filename
|
|
|
|
|
req, err := http.NewRequestWithContext(r.Context(), http.MethodGet, kokoroURL, nil)
|
|
|
|
|
if err != nil {
|
|
|
|
|
http.Error(w, "failed to build proxy request", http.StatusInternalServerError)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
|
|
|
if err != nil {
|
|
|
|
|
http.Error(w, "kokoro download failed", http.StatusBadGateway)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
defer resp.Body.Close()
|
|
|
|
|
|
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
|
|
|
http.Error(w, fmt.Sprintf("kokoro returned %d", resp.StatusCode), http.StatusBadGateway)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
w.Header().Set("Content-Type", "audio/mpeg")
|
|
|
|
|
w.Header().Set("Cache-Control", "public, max-age=86400")
|
|
|
|
|
http.ServeFile(w, r, audioPath)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// handleAudioFilePart handles GET /ui/audio-file/{slug}/{n}/part/{p}.
|
|
|
|
|
// Serves a specific MP3 part file.
|
|
|
|
|
func (s *Server) handleAudioFilePart(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
slug := r.PathValue("slug")
|
|
|
|
|
n, err := strconv.Atoi(r.PathValue("n"))
|
|
|
|
|
if err != nil || n < 1 {
|
|
|
|
|
http.NotFound(w, r)
|
|
|
|
|
return
|
|
|
|
|
w.Header().Set("Cache-Control", "public, max-age=3600")
|
|
|
|
|
if cl := resp.Header.Get("Content-Length"); cl != "" {
|
|
|
|
|
w.Header().Set("Content-Length", cl)
|
|
|
|
|
}
|
|
|
|
|
p, err := strconv.Atoi(r.PathValue("p"))
|
|
|
|
|
if err != nil || p < 0 {
|
|
|
|
|
http.NotFound(w, r)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
voice := r.URL.Query().Get("voice")
|
|
|
|
|
if voice == "" {
|
|
|
|
|
voice = s.kokoroVoice
|
|
|
|
|
}
|
|
|
|
|
speedStr := r.URL.Query().Get("speed")
|
|
|
|
|
speed := 1.0
|
|
|
|
|
if speedStr != "" {
|
|
|
|
|
if v, err := strconv.ParseFloat(speedStr, 64); err == nil && v > 0 {
|
|
|
|
|
speed = v
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
partPath := s.writer.AudioPartPath(slug, n, voice, speed, p)
|
|
|
|
|
if _, err := os.Stat(partPath); err != nil {
|
|
|
|
|
http.NotFound(w, r)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
w.Header().Set("Content-Type", "audio/mpeg")
|
|
|
|
|
w.Header().Set("Cache-Control", "no-store")
|
|
|
|
|
http.ServeFile(w, r, partPath)
|
|
|
|
|
_, _ = io.Copy(w, resp.Body)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (s *Server) handleScrapeCatalogue(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
|
