Skip to content

利用 AI 大模型和自动化工作流,根据主题或关键词一键生成高清短视频。Generate HD short videos from a topic or keyword with an automated AI workflow.

fix(voxcpm): bound streaming speech data (#1557)

Rudy Mizrahi Celekli01e9eccc1beb
diff --git a/app/services/voice.py b/app/services/voice.py
index f0a3ea0f..dba0fadc 100644
--- a/app/services/voice.py
+++ b/app/services/voice.py
@@ -89,6 +89,10 @@ VOXCPM_REFERENCE_AUDIO_FILE_TYPES = ("wav", "mp3", "m4a", "aac", "ogg", "flac")
_DEFAULT_TTS_FFMPEG_TIMEOUT_SECONDS = 600
_VOXCPM_NON_RETRYABLE_STATUS_CODES = {400, 401, 403, 404, 422}
_VOXCPM_RETRY_DELAY_SECONDS = (1.0, 2.0)
+# Match the existing generated-speech ceiling; allow one full Base64 WAV event
+# plus JSON framing while bounding both transport lines and multiline events.
+_VOXCPM_TTS_MAX_AUDIO_BYTES = 50 * 1024 * 1024
+_VOXCPM_SSE_MAX_EVENT_BYTES = 4 * ((_VOXCPM_TTS_MAX_AUDIO_BYTES + 2) // 3) + 64 * 1024
NO_VOICE_NAME = "no-voice"
# `none` 是 PR #981 里曾使用过的无配音标识。这里短期兼容这个值,避免
# 已经手动调用过该分支的 API 用户升级后立即失效;WebUI 和新代码统一使用
@@ -2876,25 +2880,63 @@ def fish_audio_tts(
def _iter_voxcpm_sse_events(response):
- """Yield JSON payloads from ModelBest's Server-Sent Event stream."""
+ """Yield bounded SSE events without Requests' unbounded line buffer."""
+ def lines():
+ pending = bytearray()
+ skip_lf = False
+ for chunk in response.iter_content(chunk_size=64 * 1024):
+ if not chunk:
+ continue
+ # Consume the optional LF after a CR, even across transport chunks.
+ if skip_lf:
+ skip_lf = False
+ if chunk.startswith(b"\n"):
+ chunk = chunk[1:]
+ if not chunk:
+ continue
+ for piece in chunk.splitlines(keepends=True):
+ if piece.endswith(b"\r\n"):
+ payload, terminated = piece[:-2], True
+ elif piece.endswith((b"\r", b"\n")):
+ payload, terminated = piece[:-1], True
+ else:
+ payload, terminated = piece, False
+ if len(pending) + len(payload) > _VOXCPM_SSE_MAX_EVENT_BYTES:
+ raise ValueError("VoxCPM SSE line exceeds the size limit")
+ pending.extend(payload)
+ if terminated:
+ yield bytes(pending).decode("utf-8")
+ pending.clear()
+ skip_lf = chunk.endswith(b"\r")
+ if pending:
+ yield bytes(pending).decode("utf-8")
+
+ def parse_event(data):
+ try:
+ event = json.loads("\n".join(data))
+ except (TypeError, ValueError) as exc:
+ raise ValueError("VoxCPM returned invalid SSE event data") from exc
+ if not isinstance(event, dict):
+ raise ValueError("VoxCPM returned a non-object SSE event")
+ return event
+
event_data = []
- for raw_line in response.iter_lines(decode_unicode=True):
- line = raw_line.decode("utf-8") if isinstance(raw_line, bytes) else raw_line
+ event_bytes = 0
+ for line in lines():
if not line:
if event_data:
- try:
- yield json.loads("\n".join(event_data))
- except (TypeError, ValueError) as exc:
- raise ValueError("VoxCPM returned invalid SSE event data") from exc
+ yield parse_event(event_data)
event_data = []
+ event_bytes = 0
continue
if line.startswith("data:"):
- event_data.append(line.removeprefix("data:").strip())
+ data = line.removeprefix("data:").strip()
+ event_bytes += len(data.encode("utf-8")) + 1
+ if event_bytes > _VOXCPM_SSE_MAX_EVENT_BYTES:
+ raise ValueError("VoxCPM SSE event exceeds the size limit")
+ event_data.append(data)
if event_data:
- try:
- yield json.loads("\n".join(event_data))
- except (TypeError, ValueError) as exc:
- raise ValueError("VoxCPM returned invalid trailing SSE event data") from exc
+ yield parse_event(event_data)
def prepare_voxcpm_reference_audio(uploaded_audio: bytes, suffix: str = "") -> bytes:
@@ -3113,6 +3155,7 @@ def voxcpm_tts(
continue
audio_chunks = []
+ total_audio_bytes = 0
completed = False
for event in _iter_voxcpm_sse_events(response):
event_type = event.get("type")
@@ -3121,9 +3164,13 @@ def voxcpm_tts(
if not isinstance(encoded_chunk, str) or not encoded_chunk:
raise ValueError("VoxCPM returned an empty audio chunk")
try:
- audio_chunks.append(base64.b64decode(encoded_chunk, validate=True))
+ chunk = base64.b64decode(encoded_chunk, validate=True)
except (ValueError, TypeError) as exc:
raise ValueError("VoxCPM returned invalid Base64 audio") from exc
+ total_audio_bytes += len(chunk)
+ if total_audio_bytes > _VOXCPM_TTS_MAX_AUDIO_BYTES:
+ raise ValueError("VoxCPM generated audio exceeds the size limit")
+ audio_chunks.append(chunk)
elif event_type == "speech.audio.done":
completed = True
break
diff --git a/test/services/test_voxcpm.py b/test/services/test_voxcpm.py
index dc3c63d7..cfa8e330 100644
--- a/test/services/test_voxcpm.py
+++ b/test/services/test_voxcpm.py
@@ -32,6 +32,10 @@ def _sse_event(event_type, **payload):
return f"data: {json.dumps({'type': event_type, **payload})}"
+def _sse_content(lines):
+ return ["\n".join(lines).encode("utf-8")]
+
+
def _sse_lines(*events):
lines = []
for event in events:
@@ -84,11 +88,11 @@ def test_voxcpm_tts_assembles_sse_wav_and_converts_to_mp3(
response = SimpleNamespace(
status_code=200,
text="",
- iter_lines=lambda decode_unicode: _sse_lines(
+ iter_content=lambda chunk_size: _sse_content(_sse_lines(
_sse_event("speech.audio.delta", audio=base64.b64encode(audio_chunks[0]).decode()),
_sse_event("speech.audio.delta", audio=base64.b64encode(audio_chunks[1]).decode()),
_sse_event("speech.audio.done", usage={"total_tokens": 1}),
- ),
+ )),
close=Mock(),
)
post = Mock(return_value=response)
@@ -263,7 +267,7 @@ def test_voxcpm_tts_failure_never_overwrites_existing_audio(
response = SimpleNamespace(
status_code=200,
text="",
- iter_lines=lambda decode_unicode: events,
+ iter_content=lambda chunk_size: _sse_content(events),
close=lambda: None,
)
post = Mock(return_value=response)
@@ -315,16 +319,15 @@ def test_voxcpm_does_not_repeat_speech_after_ambiguous_transport_failure(
"""A dropped POST response or SSE stream can follow a completed generation."""
def interrupted_stream(**_kwargs):
- yield _sse_event(
+ yield (_sse_event(
"speech.audio.delta", audio=base64.b64encode(b"partial").decode()
- )
- yield ""
+ ) + "\n\n").encode("utf-8")
raise requests.ReadTimeout("stream dropped")
response = SimpleNamespace(
status_code=200,
text="",
- iter_lines=interrupted_stream,
+ iter_content=interrupted_stream,
close=Mock(),
)
post = Mock(
diff --git a/test/services/test_voxcpm_stream_bounds.py b/test/services/test_voxcpm_stream_bounds.py
new file mode 100644
index 00000000..3e245a81
--- /dev/null
+++ b/test/services/test_voxcpm_stream_bounds.py
@@ -0,0 +1,145 @@
+import base64
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+from app.config import config
+from app.services import voice
+
+
+def response_for(chunks):
+ # Both interfaces let the unchanged parser exercise the same hostile bytes.
+ return SimpleNamespace(iter_content=lambda **kw: iter(chunks), iter_lines=lambda **kw: (line for chunk in chunks for line in chunk.split(b"\n")))
+
+
+def test_unterminated_sse_line_is_rejected_before_reading_more(monkeypatch):
+ monkeypatch.setattr(voice, "_VOXCPM_SSE_MAX_EVENT_BYTES", 12, raising=False)
+ def chunks():
+ yield b"data: " + b"x" * 20
+ raise AssertionError("must stop at the first oversized chunk")
+ response = SimpleNamespace(iter_content=lambda **kw: chunks(), iter_lines=lambda **kw: chunks())
+ with pytest.raises(ValueError, match="size limit"):
+ list(voice._iter_voxcpm_sse_events(response))
+
+
+def test_multiline_event_cannot_bypass_aggregate_limit(monkeypatch):
+ monkeypatch.setattr(voice, "_VOXCPM_SSE_MAX_EVENT_BYTES", 32, raising=False)
+ with pytest.raises(ValueError, match="size limit"):
+ list(voice._iter_voxcpm_sse_events(response_for([b'data: {"value":\ndata: "' + b"x" * 24 + b'"}\n\n'])))
+
+
+def test_utf8_fragmented_multiline_crlf_and_trailing_events(monkeypatch):
+ monkeypatch.setattr(voice, "_VOXCPM_SSE_MAX_EVENT_BYTES", 256, raising=False)
+ content = ': keepalive\r\nevent: speech\r\ndata: {"type":"speech.audio.delta",\r\ndata: "note":"é"}\r\n\r\ndata: {"type":"speech.audio.done"}'.encode("utf-8")
+ split = content.index(b"\xc3") + 1
+ assert list(voice._iter_voxcpm_sse_events(response_for([content[:split], content[split:]]))) == [{"type":"speech.audio.delta", "note":"é"}, {"type":"speech.audio.done"}]
+
+
[email protected]("ending", [b"\n", b"\r\n", b"\r"])
+def test_sse_line_endings_at_every_transport_split(monkeypatch, ending):
+ monkeypatch.setattr(voice, "_VOXCPM_SSE_MAX_EVENT_BYTES", 256)
+ content = ending.join([
+ b": keepalive",
+ b'event: speech',
+ b'data: {"type":"speech.audio.delta",',
+ 'data: "note":"é"}'.encode("utf-8"),
+ b"",
+ b'data: {"type":"speech.audio.done"}',
+ b"",
+ b"",
+ ])
+ expected = [{"type": "speech.audio.delta", "note": "é"},
+ {"type": "speech.audio.done"}]
+ for split in range(len(content) + 1):
+ chunks = [content[:split], b"", content[split:]]
+ assert list(voice._iter_voxcpm_sse_events(response_for(chunks))) == expected
+ assert list(voice._iter_voxcpm_sse_events(
+ response_for([content[i:i + 1] for i in range(len(content))])
+ )) == expected
+
+
+def test_split_crlf_does_not_dispatch_a_multiline_event_early():
+ chunks = [b'data: {"type":\r', b"", b'\ndata: "speech.audio.done"}\r', b'\n\r', b'\n']
+ assert list(voice._iter_voxcpm_sse_events(response_for(chunks))) == [
+ {"type": "speech.audio.done"}
+ ]
+
+
[email protected]("ending", [b"\n", b"\r\n", b"\r"])
+def test_line_ending_variants_keep_the_aggregate_event_limit(monkeypatch, ending):
+ monkeypatch.setattr(voice, "_VOXCPM_SSE_MAX_EVENT_BYTES", 32)
+ content = ending.join([b'data: {"value":', b'data: "' + b"x" * 24 + b'"}', b"", b""])
+ with pytest.raises(ValueError, match="size limit"):
+ list(voice._iter_voxcpm_sse_events(response_for([content])))
+
+
[email protected]("ending", [b"\n", b"\r\n", b"\r"])
+def test_line_endings_through_real_chunked_http(ending):
+ body = ending.join([
+ b'data: {"type":"speech.audio.delta",',
+ 'data: "note":"é"}'.encode("utf-8"),
+ b"",
+ b'data: {"type":"speech.audio.done"}',
+ b"",
+ b"",
+ ])
+
+ class Handler(BaseHTTPRequestHandler):
+ protocol_version = "HTTP/1.1"
+
+ def do_GET(self):
+ self.send_response(200)
+ self.send_header("Content-Type", "text/event-stream")
+ self.send_header("Transfer-Encoding", "chunked")
+ self.send_header("Connection", "close")
+ self.end_headers()
+ for byte in body:
+ self.wfile.write(b"1\r\n" + bytes([byte]) + b"\r\n")
+ self.wfile.write(b"0\r\n\r\n")
+ self.wfile.flush()
+
+ def log_message(self, *args):
+ pass
+
+ server = HTTPServer(("127.0.0.1", 0), Handler)
+ thread = threading.Thread(target=server.serve_forever, daemon=True)
+ thread.start()
+ try:
+ with voice.requests.get(
+ f"http://127.0.0.1:{server.server_port}/events", stream=True, timeout=5
+ ) as response:
+ assert list(voice._iter_voxcpm_sse_events(response)) == [
+ {"type": "speech.audio.delta", "note": "é"},
+ {"type": "speech.audio.done"},
+ ]
+ finally:
+ server.shutdown()
+ server.server_close()
+ thread.join(timeout=5)
+
+
+def test_assembled_audio_limit_stops_decode_and_preserves_previous_file(monkeypatch, tmp_path):
+ monkeypatch.setattr(voice, "_VOXCPM_TTS_MAX_AUDIO_BYTES", 5, raising=False)
+ monkeypatch.setattr(config, "voxcpm", {"api_key":"test", "model_id":"test"})
+ read_past_limit = Mock()
+ def chunks():
+ for audio in [b"123", b"456"]:
+ yield ("data: " + json.dumps({"type":"speech.audio.delta", "audio":base64.b64encode(audio).decode()}) + "\n\n").encode()
+ read_past_limit()
+ yield b'data: {"type":"speech.audio.done"}\n\n'
+ response = SimpleNamespace(status_code=200, close=Mock(), iter_content=lambda **kw:chunks(), iter_lines=lambda **kw:(line for chunk in chunks() for line in chunk.split(b"\n")))
+ post=Mock(return_value=response)
+ monkeypatch.setattr(voice.requests,"post",post)
+ decode=Mock(side_effect=AssertionError("oversized audio must not decode"))
+ monkeypatch.setattr("pydub.AudioSegment.from_file",decode)
+ target = tmp_path / "previous.mp3"
+ target.write_bytes(b"last good narration")
+ assert voice.voxcpm_tts("hello", "default", str(target)) is None
+ post.assert_called_once()
+ response.close.assert_called_once()
+ decode.assert_not_called()
+ read_past_limit.assert_not_called()
+ assert target.read_bytes()==b"last good narration"