mirror of
https://github.com/RVC-Boss/GPT-SoVITS.git
synced 2026-05-16 15:28:14 +08:00
6a822b28c3
Refactor api_v2.py and api_v3.py to update sampling parameters and weight paths for better clarity and support for v3/v4 vocoders. Introduce new methods in PrepareCoordinator for handling empty text features and improve profiling capabilities. Additionally, update unified engine components to streamline audio processing and state management, enhancing overall performance and maintainability of the TTS system.
203 lines
8.4 KiB
Python
203 lines
8.4 KiB
Python
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from typing import Any, Dict, List, Optional
|
|
|
|
import numpy as np
|
|
|
|
from GPT_SoVITS.TTS_infer_pack.t2s_scheduler import SchedulerRequestSpec, T2SActiveBatch, T2SFinishedItem, T2SRequestState
|
|
from GPT_SoVITS.TTS_infer_pack.unified_engine_bridge import EngineBridgeFacade
|
|
from GPT_SoVITS.TTS_infer_pack.unified_engine_components import EngineDispatchTask, EngineRequestState, SchedulerFinalizeTask, SchedulerPendingJob
|
|
|
|
|
|
class EngineBridgeDelegates:
|
|
def _register_request_state(
|
|
self,
|
|
request_id: str,
|
|
api_mode: str,
|
|
backend: str,
|
|
media_type: str,
|
|
response_streaming: bool,
|
|
deadline_ts: float | None = None,
|
|
meta: Optional[Dict[str, Any]] = None,
|
|
) -> EngineRequestState:
|
|
return self.bridge_facade._register_request_state(
|
|
request_id=request_id,
|
|
api_mode=api_mode,
|
|
backend=backend,
|
|
media_type=media_type,
|
|
response_streaming=response_streaming,
|
|
deadline_ts=deadline_ts,
|
|
meta=meta,
|
|
)
|
|
|
|
def _update_request_state(self, request_id: str, status: str, extra: Optional[Dict[str, Any]] = None) -> None:
|
|
self.bridge_facade._update_request_state(request_id, status, extra)
|
|
|
|
def _merge_request_state_profile(self, request_id: str, extra: Optional[Dict[str, Any]] = None) -> None:
|
|
self.bridge_facade._merge_request_state_profile(request_id, extra)
|
|
|
|
def _snapshot_engine_prepare_state(self) -> Dict[str, Any]:
|
|
return self.bridge_facade._snapshot_engine_prepare_state()
|
|
|
|
def _snapshot_engine_finalize_state(self) -> Dict[str, Any]:
|
|
return self.bridge_facade._snapshot_engine_finalize_state()
|
|
|
|
def _snapshot_engine_dispatch_state(self) -> Dict[str, Any]:
|
|
return self.bridge_facade._snapshot_engine_dispatch_state()
|
|
|
|
def _register_engine_job(self, job: SchedulerPendingJob) -> None:
|
|
self.bridge_facade._register_engine_job(job)
|
|
|
|
def _get_engine_job(self, request_id: str) -> SchedulerPendingJob | None:
|
|
return self.bridge_facade._get_engine_job(request_id)
|
|
|
|
def _pop_engine_job(self, request_id: str) -> SchedulerPendingJob | None:
|
|
return self.bridge_facade._pop_engine_job(request_id)
|
|
|
|
def _snapshot_engine_job_registry(self) -> Dict[str, Any]:
|
|
return self.bridge_facade._snapshot_engine_job_registry()
|
|
|
|
def _is_engine_drained(self) -> bool:
|
|
return self.bridge_facade._is_engine_drained()
|
|
|
|
def _record_engine_job_done(self, request_id: str) -> None:
|
|
self.bridge_facade._record_engine_job_done(request_id)
|
|
|
|
def _complete_engine_job(
|
|
self,
|
|
job: SchedulerPendingJob,
|
|
item: T2SFinishedItem,
|
|
*,
|
|
sample_rate: int,
|
|
audio_data: np.ndarray,
|
|
) -> None:
|
|
self.bridge_facade._complete_engine_job(job, item, sample_rate=sample_rate, audio_data=audio_data)
|
|
|
|
def _fail_engine_jobs(self, request_ids: List[str], error: str) -> None:
|
|
self.bridge_facade._fail_engine_jobs(request_ids, error)
|
|
|
|
def _add_engine_prefill_time(self, jobs: List[SchedulerPendingJob], elapsed_s: float) -> None:
|
|
self.bridge_facade._add_engine_prefill_time(jobs, elapsed_s)
|
|
|
|
def _add_engine_merge_time(self, request_ids: List[str], elapsed_s: float) -> None:
|
|
self.bridge_facade._add_engine_merge_time(request_ids, elapsed_s)
|
|
|
|
def _add_engine_decode_time(self, request_ids: List[str], elapsed_s: float) -> None:
|
|
self.bridge_facade._add_engine_decode_time(request_ids, elapsed_s)
|
|
|
|
def _enqueue_engine_finished_items(self, items: List[T2SFinishedItem]) -> None:
|
|
self.bridge_facade._enqueue_engine_finished_items(items)
|
|
|
|
def _snapshot_engine_decode_pending_queue_state(self) -> Dict[str, Any]:
|
|
return self.bridge_facade._snapshot_engine_decode_pending_queue_state()
|
|
|
|
@staticmethod
|
|
def _summarize_active_batch(active_batch: T2SActiveBatch | None) -> Dict[str, Any]:
|
|
return EngineBridgeFacade._summarize_active_batch(active_batch)
|
|
|
|
def _refresh_engine_decode_runtime_state(self, last_event: str) -> None:
|
|
self.bridge_facade._refresh_engine_decode_runtime_state(last_event)
|
|
|
|
def _update_engine_decode_runtime_state(self, snapshot: Dict[str, Any]) -> None:
|
|
self.bridge_facade._update_engine_decode_runtime_state(snapshot)
|
|
|
|
def _snapshot_engine_decode_runtime_state(self) -> Dict[str, Any]:
|
|
return self.bridge_facade._snapshot_engine_decode_runtime_state()
|
|
|
|
def _snapshot_engine_arbiter_state(self) -> Dict[str, Any]:
|
|
return self.bridge_facade._snapshot_engine_arbiter_state()
|
|
|
|
def _notify_engine_arbiter(self) -> None:
|
|
self.bridge_facade._notify_engine_arbiter()
|
|
|
|
def _enqueue_engine_decode_pending_job(self, job: SchedulerPendingJob) -> None:
|
|
self.bridge_facade._enqueue_engine_decode_pending_job(job)
|
|
|
|
def _take_engine_decode_pending_jobs_nonblocking(self, wait_for_batch: bool) -> List[SchedulerPendingJob]:
|
|
return self.bridge_facade._take_engine_decode_pending_jobs_nonblocking(wait_for_batch)
|
|
|
|
def _peek_queue_age_ms(self, queue_name: str) -> float:
|
|
return self.bridge_facade._peek_queue_age_ms(queue_name)
|
|
|
|
def _engine_has_pending_work(self) -> bool:
|
|
return self.bridge_facade._engine_has_pending_work()
|
|
|
|
async def _prepare_state_via_engine_gpu_queue(
|
|
self,
|
|
*,
|
|
spec: SchedulerRequestSpec,
|
|
prepare_submit_at: float,
|
|
engine_request_id: str | None,
|
|
) -> tuple[T2SRequestState, float, float]:
|
|
return await self.bridge_facade._prepare_state_via_engine_gpu_queue(
|
|
spec=spec,
|
|
prepare_submit_at=prepare_submit_at,
|
|
engine_request_id=engine_request_id,
|
|
)
|
|
|
|
def _enqueue_worker_finished_for_finalize(self, tasks: List[SchedulerFinalizeTask]) -> None:
|
|
self.bridge_facade._enqueue_worker_finished_for_finalize(tasks)
|
|
|
|
def _take_engine_finalize_batch_nonblocking(self) -> List[SchedulerFinalizeTask]:
|
|
return self.bridge_facade._take_engine_finalize_batch_nonblocking()
|
|
|
|
async def _enqueue_prepared_state_for_dispatch(
|
|
self,
|
|
*,
|
|
state: T2SRequestState,
|
|
speed_factor: float,
|
|
sample_steps: int,
|
|
media_type: str,
|
|
super_sampling: bool,
|
|
prepare_wall_ms: float,
|
|
prepare_profile_total_ms: float,
|
|
done_loop: asyncio.AbstractEventLoop | None,
|
|
done_future: asyncio.Future | None,
|
|
engine_request_id: str | None,
|
|
timeout_sec: float | None,
|
|
) -> EngineDispatchTask:
|
|
return await self.bridge_facade._enqueue_prepared_state_for_dispatch(
|
|
state=state,
|
|
speed_factor=speed_factor,
|
|
sample_steps=sample_steps,
|
|
media_type=media_type,
|
|
super_sampling=super_sampling,
|
|
prepare_wall_ms=prepare_wall_ms,
|
|
prepare_profile_total_ms=prepare_profile_total_ms,
|
|
done_loop=done_loop,
|
|
done_future=done_future,
|
|
engine_request_id=engine_request_id,
|
|
timeout_sec=timeout_sec,
|
|
)
|
|
|
|
def _mark_arbiter_tick(self, *, stage: str, reason: str, policy_allowed: bool) -> None:
|
|
self.bridge_facade._mark_arbiter_tick(stage=stage, reason=reason, policy_allowed=policy_allowed)
|
|
|
|
def _select_engine_stage(self) -> tuple[str, str, Dict[str, Any], Dict[str, Any]]:
|
|
return self.bridge_facade._select_engine_stage()
|
|
|
|
def _run_engine_prepare_once(self) -> bool:
|
|
return self.bridge_facade._run_engine_prepare_once()
|
|
|
|
def _run_engine_finalize_once(self) -> bool:
|
|
return self.bridge_facade._run_engine_finalize_once()
|
|
|
|
def _run_engine_dispatch_once(self, policy_snapshot: Dict[str, Any], worker_state: Dict[str, Any]) -> bool:
|
|
return self.bridge_facade._run_engine_dispatch_once(policy_snapshot, worker_state)
|
|
|
|
def _run_engine_decode_runtime_once(self) -> bool:
|
|
return self.bridge_facade._run_engine_decode_runtime_once()
|
|
|
|
def _run_engine_arbiter_loop(self) -> None:
|
|
self.bridge_facade._run_engine_arbiter_loop()
|
|
|
|
def _complete_request_state(self, request_id: str, extra: Optional[Dict[str, Any]] = None) -> None:
|
|
self.bridge_facade._complete_request_state(request_id, extra)
|
|
|
|
def _fail_request_state(self, request_id: str, error: str) -> None:
|
|
self.bridge_facade._fail_request_state(request_id, error)
|
|
|
|
def _snapshot_request_registry(self) -> Dict[str, Any]:
|
|
return self.bridge_facade._snapshot_request_registry()
|