app.py

import os
import sys
import subprocess
import gradio as gr
from pydub import AudioSegment
import tempfile
from scipy.io.wavfile import write, read
from TTS.api import TTS
import numpy as np
import torch
import torchaudio
from resemble_enhance.enhancer.inference import denoise
from seedvc import voice_conversion


# Установка переменных окружения для принятия лицензионных условий
os.environ["COQUI_TOS_AGREED"] = "1"

# Определение устройства (CUDA или CPU)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

def normalize_audio(wave):
    """
    Нормализует аудиосигнал так, чтобы максимальное абсолютное значение было <= 1.0
    """
    max_val = np.max(np.abs(wave))
    if max_val > 1.0:
        wave = wave / max_val
    return wave



# Глобальные переменные и настройки
language_options = {
    "English (en)": "en",
    "Spanish (es)": "es",
    "French (fr)": "fr",
    "German (de)": "de",
    "Italian (it)": "it",
    "Portuguese (pt)": "pt",
    "Polish (pl)": "pl",
    "Turkish (tr)": "tr",
    "Russian (ru)": "ru",
    "Dutch (nl)": "nl",
    "Czech (cs)": "cs",
    "Arabic (ar)": "ar",
    "Chinese (zh-cn)": "zh-cn",
    "Japanese (ja)": "ja",
    "Hungarian (hu)": "hu",
    "Korean (ko)": "ko",
    "Hindi (hi)": "hi"
}

other_language = {
    "Vietnamese": "vie",
    "Serbian": "srp",
    "Romanian": "ron",
    "Indonesian": "ind",
    "Philippine": "tgl",
    "Bulgarian": "bul",
}

# Инициализация модели TTS
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")

# Функции для голосового клонирования
def check_audio_length(audio_path, max_duration=120):
    try:
        audio = AudioSegment.from_file(audio_path)
        duration = audio.duration_seconds
        if duration > max_duration:
            print(f"Audio is too long: {duration} seconds. Max allowed is {max_duration} seconds.")
            return False
        return True
    except Exception as e:
        print(f"Error while checking audio length: {e}")
        return False


def synthesize_and_convert_voice(text, language_iso, voice_audio_path, speed, device='cpu'):
    """
    Синтезирует речь на основе текста, выполняет денойзинг для клонируемого аудио и преобразование голоса.
    
    Параметры:
    - text (str): Текст для синтеза речи.
    - language_iso (str): ISO-код языка для TTS.
    - voice_audio_path (str): Путь к аудио-файлу для клонирования голоса.
    - speed (float): Скорость синтеза речи.
    - device (str): Устройство для обработки (например, 'cpu' или 'cuda').
    
    Возвращает:
    - tuple: (частота дискретизации, numpy массив аудио данных)
    """
    # Загрузка аудио для клонирования
    voice_wav_tensor, voice_sample_rate = torchaudio.load(voice_audio_path)

    # Преобразование в моно, если аудио стерео
    if voice_wav_tensor.dim() > 1:
        voice_wav_tensor = voice_wav_tensor.mean(dim=0, keepdim=True)

    # Применение денойзинга к аудио для клонирования
    denoised_voice_wav_tensor, denoised_voice_sample_rate = denoise(
        voice_wav_tensor.squeeze(), voice_sample_rate, device=device
    )

    # Сохранение денойзенного аудио во временный файл
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_denoised_voice_file:
        temp_denoised_voice_path = temp_denoised_voice_file.name
        torchaudio.save(
            temp_denoised_voice_path,
            denoised_voice_wav_tensor.unsqueeze(0).cpu(),
            denoised_voice_sample_rate
        )

    # Синтез речи с использованием TTS
    tts_synthesis = TTS(model_name=f"tts_models/{language_iso}/fairseq/vits")
    wav_data = tts_synthesis.tts(text, speed=speed)

    # Преобразование в NumPy массив и нормализация
    wav_data_np = np.array(wav_data, dtype=np.float32)
    wav_data_np = wav_data_np / max(1.0, np.max(np.abs(wav_data_np)))

    # Масштабирование до int16 и временное сохранение
    wav_data_int16 = np.int16(wav_data_np * 32767)
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_tts_wav_file:
        temp_tts_wav_path = temp_tts_wav_file.name
        write(temp_tts_wav_path, 22050, wav_data_int16)

    # Загрузка синтезированного аудио
    wav_tensor, sample_rate = torchaudio.load(temp_tts_wav_path)

    # Преобразование в моно, если требуется
    if wav_tensor.dim() > 1:
        wav_tensor = wav_tensor.mean(dim=0, keepdim=True)

    # Применение денойзинга
    denoised_wav_tensor, denoised_sample_rate = denoise(wav_tensor.squeeze(), sample_rate, device=device)

    # Преобразование денойзенного тензора в NumPy массив
    denoised_wav_np = denoised_wav_tensor.cpu().numpy()

    # Масштабирование денойзенного аудио до int16
    denoised_wav_int16 = np.int16(denoised_wav_np * 32767)

    # Сохранение денойзенного аудио во временный файл
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_denoised_wav_file:
        temp_denoised_wav_path = temp_denoised_wav_file.name
        write(temp_denoised_wav_path, denoised_sample_rate, denoised_wav_int16)

    # Параметры для voice_conversion
    diffusion_steps = 30
    length_adjust = 1.0
    inference_cfg_rate = 0.6
    f0_condition = True
    auto_f0_adjust = True
    pitch_shift = 0

    # Вызов функции voice_conversion
    output_sample_rate, output_audio_data = voice_conversion(
        source=temp_denoised_wav_path,
        target=temp_denoised_voice_path,
        diffusion_steps=diffusion_steps,
        length_adjust=length_adjust,
        inference_cfg_rate=inference_cfg_rate,
        f0_condition=f0_condition,
        auto_f0_adjust=auto_f0_adjust,
        pitch_shift=pitch_shift
    )

    # Очистка временных файлов
    os.remove(temp_denoised_voice_path)
    os.remove(temp_tts_wav_path)
    os.remove(temp_denoised_wav_path)

    return output_sample_rate, output_audio_data




def synthesize_speech(text, speaker_wav_path, language_iso, speed, device='cpu'):
    """
    Синтезирует речь на основе текста, предварительно очищая входящее аудио от шумов
    и выполняя преобразование голоса с помощью функции voice_conversion.

    Параметры:
    - text (str): Текст для синтеза речи.
    - speaker_wav_path (str): Путь к аудио говорящего для клонирования голоса.
    - language_iso (str): ISO-код языка для TTS.
    - speed (float): Скорость синтеза речи.
    - device (str): Устройство для обработки (например, 'cpu' или 'cuda').

    Возвращает:
    - tuple: (частота дискретизации, numpy массив аудио данных)
    """
    # Загрузка аудио говорящего
    speaker_wav_tensor, speaker_sample_rate = torchaudio.load(speaker_wav_path)

    # Преобразование в моно, если аудио стерео
    if speaker_wav_tensor.dim() > 1 and speaker_wav_tensor.size(0) > 1:
        speaker_wav_tensor = speaker_wav_tensor.mean(dim=0, keepdim=True)

    # Применение денойзинга к аудио говорящего
    denoised_speaker_wav_tensor, denoised_speaker_sample_rate = denoise(
        speaker_wav_tensor.squeeze(), speaker_sample_rate, device
    )

    # Сохранение денойзенного аудио говорящего во временный файл
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_denoised_speaker_file:
        temp_denoised_speaker_path = temp_denoised_speaker_file.name
        torchaudio.save(
            temp_denoised_speaker_path,
            denoised_speaker_wav_tensor.unsqueeze(0).cpu(),
            denoised_speaker_sample_rate
        )

    # Генерация речи с помощью TTS и сохранение во временный файл
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_tts_output:
        temp_tts_output_path = temp_tts_output.name
        tts.tts_to_file(
            text=text,
            file_path=temp_tts_output_path,
            speed=speed,
            speaker_wav=temp_denoised_speaker_path,
            language=language_iso
        )

    # Загрузка сгенерированного аудио
    wav_tensor, sample_rate = torchaudio.load(temp_tts_output_path)

    # Преобразование в моно, если аудио стерео
    if wav_tensor.dim() > 1 and wav_tensor.size(0) > 1:
        wav_tensor = wav_tensor.mean(dim=0, keepdim=True)

    # Сохранение сгенерированного аудио во временный файл для voice_conversion
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_vc_input_file:
        temp_vc_input_path = temp_vc_input_file.name
        torchaudio.save(temp_vc_input_path, wav_tensor.cpu(), sample_rate)

    # Параметры для voice_conversion
    diffusion_steps = 30
    length_adjust = 1.0
    inference_cfg_rate = 0.6
    f0_condition = True
    auto_f0_adjust = True
    pitch_shift = 0

    # Вызов функции voice_conversion
    output_sample_rate, output_audio_data = voice_conversion(
        source=temp_vc_input_path,
        target=temp_denoised_speaker_path,
        diffusion_steps=diffusion_steps,
        length_adjust=length_adjust,
        inference_cfg_rate=inference_cfg_rate,
        f0_condition=f0_condition,
        auto_f0_adjust=auto_f0_adjust,
        pitch_shift=pitch_shift
    )

    # Удаление временных файлов
    os.remove(temp_denoised_speaker_path)
    os.remove(temp_tts_output_path)
    os.remove(temp_vc_input_path)

    return output_sample_rate, output_audio_data

def get_language_code(selected_language):
    if selected_language in language_options:
        return language_options[selected_language]
    elif selected_language in other_language:
        return other_language[selected_language]
    else:
        return None

def process_speech(text, speaker_wav_path, selected_language, speed):
    """
    Обрабатывает текст, выполняет синтез речи и голосовое клонирование,
    а также возвращает путь к сгенерированному аудио-файлу.
    """
    language_code = get_language_code(selected_language)

    if language_code is None:
        raise ValueError("Выбранный язык не поддерживается.")

    if speaker_wav_path is None:
        raise ValueError("Пожалуйста, загрузите аудио файл говорящего.")

    # Проверка длины аудио
    try:
        audio = AudioSegment.from_file(speaker_wav_path)
        duration = audio.duration_seconds
        if duration > 120:
            raise ValueError("Длина аудио превышает допустимый лимит в 2 минуты.")
    except Exception as e:
        raise ValueError(f"Ошибка при проверке аудио: {e}")

    try:
        if selected_language in other_language:
            output_sample_rate, output_audio_data = synthesize_and_convert_voice(
                text, language_code, speaker_wav_path, speed
            )
        else:
            output_sample_rate, output_audio_data = synthesize_speech(
                text, speaker_wav_path, language_code, speed
            )

        # Сохранение результата в файл для вывода
        with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_output_file:
            temp_output_path = temp_output_file.name
            write(temp_output_path, output_sample_rate, output_audio_data)

        return temp_output_path  # Возвращаем путь к сгенерированному аудио

    except Exception as e:
        raise ValueError(f"Ошибка при обработке речи: {e}")

def restart_program():
    python = sys.executable
    os.execl(python, python, *sys.argv)

# Функции для липсинка
def generate(video, audio, checkpoint, no_smooth, resize_factor, pad_top, pad_bottom, pad_left, pad_right, save_as_video):
    if video is None or audio is None or checkpoint is None:
        return "Пожалуйста, загрузите видео/изображение и аудио файл, а также выберите чекпойнт."

    print(f"Текущая рабочая директория: {os.getcwd()}")
    print(f"Содержимое текущей директории: {os.listdir('.')}")
    print(f"Проверка наличия 'inference.py': {os.path.exists('inference.py')}")

    video_path = video  # Путь к видео или изображению
    audio_path = audio  # Путь к аудио

    print(f"Путь к видео: {video_path}")
    print(f"Путь к аудио: {audio_path}")

    output_dir = "outputs"
    os.makedirs(output_dir, exist_ok=True)

    output_path = os.path.join(output_dir, "output.mp4")
    print(f"Путь к выходному файлу: {output_path}")

    args = [
        "--checkpoint_path", f"checkpoints/{checkpoint}.pth",
        "--segmentation_path", "checkpoints/face_segmentation.pth",
        "--no_seg",
        "--no_sr",
        "--face", video_path,
        "--audio", audio_path,
        "--outfile", output_path,
        "--resize_factor", str(resize_factor),
        "--face_det_batch_size", "4",
        "--wav2lip_batch_size", "64",
        "--fps", "30",
        "--pads", str(pad_top), str(pad_bottom), str(pad_left), str(pad_right)
    ]

    if no_smooth:
        args.append("--nosmooth")

    if save_as_video:
        args.append("--save_as_video")

    try:
        cmd = ["python", "inference.py"] + args
        print(f"Запуск инференса с командой: {' '.join(cmd)}")
        subprocess.run(cmd, check=True)
    except subprocess.CalledProcessError as e:
        print(f"Ошибка при выполнении команды: {e}")
        return f"Произошла ошибка при обработке: {e}"

    if not os.path.exists(output_path):
        print("Выходной файл не существует.")
        return "Не удалось создать выходное видео."

    print(f"Выходной файл создан по пути: {output_path}")
    return output_path  # Возвращаем путь к выходному видео

# Создание Gradio интерфейса с вкладками
with gr.Blocks() as app:
    gr.Markdown("# Voice Clone Union")

    with gr.Tabs():
        with gr.TabItem("Voice Clone"):
            # Интерфейс для голосового клонирования
            text_input = gr.Textbox(label="Введите текст для генерации", placeholder="Введите ваш текст здесь...")
            speaker_wav_input = gr.Audio(label="Загрузите аудио файла говорящего (WAV формат)", type="filepath")

            all_languages = list(language_options.keys()) + list(other_language.keys())
            language_input = gr.Dropdown(
                label="Язык",
                choices=all_languages,
                value="English (en)"
            )

            speed_input = gr.Slider(
                label="Скорость синтеза",
                minimum=0.1,
                maximum=10,
                step=0.1,
                value=1.0,
                info="Выберите скорость"
            )

            output_audio = gr.Audio(label="Сгенерированное аудио", type="filepath")

            with gr.Row():
                synthesize_button = gr.Button("Сгенерировать")
                gr.HTML("<div style='width:300px;'></div>")
                reload_button = gr.Button("Перезапустить")

            synthesize_button.click(
                fn=process_speech,
                inputs=[text_input, speaker_wav_input, language_input, speed_input],
                outputs=output_audio
            )

            reload_button.click(fn=restart_program, inputs=None, outputs=None)

        with gr.TabItem("Lipsync"):
            # Интерфейс для липсинка
            gr.Markdown("## Lipsync")
            with gr.Row():
                video = gr.File(label="Видео или Изображение", type="filepath")
                audio = gr.File(label="Аудио", type="filepath")
                with gr.Column():
                    checkpoint = gr.Radio(["wav2lip", "wav2lip_gan"], label="Чекпойнт", value="wav2lip_gan", visible=False)
                    no_smooth = gr.Checkbox(label="Без сглаживания", value=False)
                    resize_factor = gr.Slider(minimum=1, maximum=4, step=1, label="Фактор изменения размера", value=2)
            with gr.Row():
                with gr.Column():
                    pad_top = gr.Slider(minimum=0, maximum=50, step=1, value=0, label="Отступ сверху")
                    pad_bottom = gr.Slider(minimum=0, maximum=50, step=1, value=10, label="Отступ снизу")
                    pad_left = gr.Slider(minimum=0, maximum=50, step=1, value=0, label="Отступ слева")
                    pad_right = gr.Slider(minimum=0, maximum=50, step=1, value=0, label="Отступ справа")
                    save_as_video = gr.Checkbox(label="Сохранять как видео", value=True)
                    generate_btn = gr.Button("Сгенерировать")
                with gr.Column():
                    result = gr.Video(label="Результат")

            generate_btn.click(
                generate,
                inputs=[video, audio, checkpoint, no_smooth, resize_factor, pad_top, pad_bottom, pad_left, pad_right, save_as_video],
                outputs=result,
            )

    def launch_gradio():
        app.launch(
            # Вы можете добавить параметры запуска здесь, если необходимо
        )

if __name__ == "__main__":
    launch_gradio()