import os import shutil from huggingface_hub import snapshot_download import gradio as gr from gradio_client import Client, handle_file from mutagen.mp3 import MP3 from pydub import AudioSegment from PIL import Image os.chdir(os.path.dirname(os.path.abspath(__file__))) from scripts.inference import inference_process import argparse import uuid is_shared_ui = True if "fudan-generative-ai/hallo" in os.environ['SPACE_ID'] else False AUDIO_MAX_DURATION = 4000 if(not is_shared_ui): hallo_dir = snapshot_download(repo_id="fudan-generative-ai/hallo", local_dir="pretrained_models") ############# # UTILITIES # ############# def is_mp3(file_path): try: audio = MP3(file_path) return True except Exception as e: return False def convert_mp3_to_wav(mp3_file_path, wav_file_path): # Load the MP3 file audio = AudioSegment.from_mp3(mp3_file_path) # Export as WAV file audio.export(wav_file_path, format="wav") return wav_file_path def trim_audio(file_path, output_path, max_duration): # Load the audio file audio = AudioSegment.from_wav(file_path) # Check the length of the audio in milliseconds audio_length = len(audio) # If the audio is longer than the maximum duration, trim it if audio_length > max_duration: trimmed_audio = audio[:max_duration] else: trimmed_audio = audio # Export the trimmed audio to a new file trimmed_audio.export(output_path, format="wav") return output_path def add_silence_to_wav(wav_file_path, duration_s=1): # Load the WAV file audio = AudioSegment.from_wav(wav_file_path) # Create 1 second of silence silence = AudioSegment.silent(duration=duration_s * 1000) # duration is in milliseconds # Add silence to the end of the audio file audio_with_silence = audio + silence # Export the modified audio audio_with_silence.export(wav_file_path, format="wav") return wav_file_path def check_mp3(file_path): if is_mp3(file_path): unique_id = uuid.uuid4() wav_file_path = f"{os.path.splitext(file_path)[0]}-{unique_id}.wav" converted_audio = convert_mp3_to_wav(file_path, wav_file_path) print(f"File converted to {wav_file_path}") return converted_audio, gr.update(value=converted_audio, visible=True) else: print("The file is not an MP3 file.") return file_path, gr.update(value=file_path, visible=True) def check_and_convert_webp_to_png(input_path, output_path): try: # Open the image file with Image.open(input_path) as img: # Check if the image is in WebP format if img.format == 'WEBP': # Convert and save as PNG img.save(output_path, 'PNG') print(f"Converted {input_path} to {output_path}") return output_path else: print(f"The file {input_path} is not in WebP format.") return input_path except IOError: print(f"Cannot open {input_path}. The file might not exist or is not an image.") def clear_audio_elms(): return gr.update(value=None, visible=False) ####################################################### # Gradio APIs for optional image and voice generation # ####################################################### def generate_portrait(prompt_image): if prompt_image is None or prompt_image == "": raise gr.Error("Can't generate a portrait without a prompt !") try: client = Client("ByteDance/SDXL-Lightning") except: raise gr.Error(f"ByteDance/SDXL-Lightning space's api might not be ready, please wait, or upload an image instead.") result = client.predict( prompt = prompt_image, ckpt = "4-Step", api_name = "/generate_image" ) print(result) # convert to png if necessary input_file = result unique_id = uuid.uuid4() output_file = f"converted_to_png_portrait-{unique_id}.png" ready_png = check_and_convert_webp_to_png(input_file, output_file) print(f"PORTRAIT PNG FILE: {ready_png}") return ready_png def generate_voice_with_parler(prompt_audio, voice_description): if prompt_audio is None or prompt_audio == "" : raise gr.Error(f"Can't generate a voice without text to synthetize !") if voice_description is None or voice_description == "": gr.Info( "For better control, You may want to provide a voice character description next time.", duration = 10, visible = True ) try: client = Client("parler-tts/parler_tts_mini") except: raise gr.Error(f"parler-tts/parler_tts_mini space's api might not be ready, please wait, or upload an audio instead.") result = client.predict( text = prompt_audio, description = voice_description, api_name = "/gen_tts" ) print(result) return result, gr.update(value=result, visible=True) def get_whisperspeech(prompt_audio_whisperspeech, audio_to_clone): try: client = Client("collabora/WhisperSpeech") except: raise gr.Error(f"collabora/WhisperSpeech space's api might not be ready, please wait, or upload an audio instead.") result = client.predict( multilingual_text = prompt_audio_whisperspeech, speaker_audio = handle_file(audio_to_clone), speaker_url = "", cps = 14, api_name = "/whisper_speech_demo" ) print(result) return result, gr.update(value=result, visible=True) ######################## # TALKING PORTRAIT GEN # ######################## def run_hallo(source_image, driving_audio, progress=gr.Progress(track_tqdm=True)): unique_id = uuid.uuid4() args = argparse.Namespace( config = 'configs/inference/default.yaml', source_image = source_image, driving_audio = driving_audio, output = f'output-{unique_id}.mp4', pose_weight = 1.0, face_weight = 1.0, lip_weight = 1.0, face_expand_ratio = 1.2, checkpoint = None ) inference_process(args) return f'output-{unique_id}.mp4' def generate_talking_portrait(portrait, voice, progress=gr.Progress(track_tqdm=True)): if portrait is None: raise gr.Error("Please provide a portrait to animate.") if voice is None: raise gr.Error("Please provide audio (4 seconds max).") if is_shared_ui : # Trim audio to AUDIO_MAX_DURATION for better shared experience with community input_file = voice unique_id = uuid.uuid4() trimmed_output_file = f"-{unique_id}.wav" trimmed_output_file = trim_audio(input_file, trimmed_output_file, AUDIO_MAX_DURATION) voice = trimmed_output_file # Add 1 second of silence at the end to avoid last word being cut by hallo ready_audio = add_silence_to_wav(voice) print(f"1 second of silence added to {voice}") # Call hallo talking_portrait_vid = run_hallo(portrait, ready_audio) return talking_portrait_vid css = ''' #col-container { margin: 0 auto; } #column-names { margin-top: 50px; } #main-group { background-color: none; } .tabs { background-color: unset; } #image-block { flex: 1; } #video-block { flex: 9; } #audio-block, #audio-clone-elm { flex: 1; } div#audio-clone-elm > .audio-container > button { height: 180px!important; } div#audio-clone-elm > .audio-container > button > .wrap { font-size: 0.9em; } #text-synth, #voice-desc{ height: 130px; } #text-synth-wsp { height: 120px; } #audio-column, #result-column { display: flex; } #gen-voice-btn { flex: 1; } #parler-tab, #whisperspeech-tab { padding: 0; } #main-submit{ flex: 1; } #pro-tips { margin-top: 50px; } div#warning-ready { background-color: #ecfdf5; padding: 0 16px 16px; margin: 20px 0; color: #030303!important; } div#warning-ready > .gr-prose > h2, div#warning-ready > .gr-prose > p { color: #057857!important; } div#warning-duplicate { background-color: #ebf5ff; padding: 0 16px 16px; margin: 20px 0; color: #030303!important; } div#warning-duplicate > .gr-prose > h2, div#warning-duplicate > .gr-prose > p { color: #0f4592!important; } div#warning-duplicate strong { color: #0f4592; } p.actions { display: flex; align-items: center; margin: 20px 0; } div#warning-duplicate .actions a { display: inline-block; margin-right: 10px; } .dark #warning-duplicate { background-color: #0c0c0c !important; border: 1px solid white !important; } ''' with gr.Blocks(css=css) as demo: with gr.Column(elem_id="col-container"): gr.Markdown(""" # TTS x Hallo Talking Portrait Generator This demo allows you to generate a talking portrait with the help of several open-source projects: SDXL Lightning | Parler TTS | WhisperSpeech | Hallo To let the community try and enjoy this demo, video length is limited to 4 seconds audio maximum. Duplicate this space to skip the queue and get unlimited video duration. 4-5 seconds of audio will take ~5 minutes per inference, please be patient. """) with gr.Row(elem_id="column-names"): gr.Markdown("## 1. Load Portrait") gr.Markdown("## 2. Load Voice") gr.Markdown("## 3. Result") with gr.Group(elem_id="main-group"): with gr.Row(): with gr.Column(): portrait = gr.Image( sources = ["upload"], type = "filepath", format = "png", elem_id = "image-block" ) prompt_image = gr.Textbox( label = "Generate image", lines = 2, max_lines = 2 ) gen_image_btn = gr.Button("Generate portrait (optional)") with gr.Column(elem_id="audio-column"): voice = gr.Audio( type = "filepath", elem_id = "audio-block" ) preprocess_audio_file = gr.File(visible=False) with gr.Tab("Parler TTS", elem_id="parler-tab"): prompt_audio = gr.Textbox( label = "Text to synthetize", lines = 3, max_lines = 3, elem_id = "text-synth" ) voice_description = gr.Textbox( label = "Voice description", lines = 3, max_lines = 3, elem_id = "voice-desc" ) gen_voice_btn = gr.Button("Generate voice (optional)") with gr.Tab("WhisperSpeech", elem_id="whisperspeech-tab"): prompt_audio_whisperspeech = gr.Textbox( label = "Text to synthetize", lines = 2, max_lines = 2, elem_id = "text-synth-wsp" ) audio_to_clone = gr.Audio( label = "Voice to clone", type = "filepath", elem_id = "audio-clone-elm" ) gen_wsp_voice_btn = gr.Button("Generate voice clone (optional)") with gr.Column(elem_id="result-column"): result = gr.Video( elem_id="video-block" ) submit_btn = gr.Button("Go talking Portrait !", elem_id="main-submit") with gr.Row(elem_id="pro-tips"): gr.Markdown(""" # Hallo Pro Tips: Hallo has a few simple requirements for input data: For the source image: 1. It should be cropped into squares. 2. The face should be the main focus, making up 50%-70% of the image. 3. The face should be facing forward, with a rotation angle of less than 30° (no side profiles). For the driving audio: 1. It must be in WAV format. 2. It must be in English since our training datasets are only in this language. 3. Ensure the vocals are clear; background music is acceptable. """) gr.Markdown(""" # TTS Pro Tips: For Parler TTS: - Include the term "very clear audio" to generate the highest quality audio, and "very noisy audio" for high levels of background noise - Punctuation can be used to control the prosody of the generations, e.g. use commas to add small breaks in speech - The remaining speech features (gender, speaking rate, pitch and reverberation) can be controlled directly through the prompt For WhisperSpeech: WhisperSpeech is able to quickly clone a voice from an audio sample. - Upload a voice sample in the WhisperSpeech tab - Add text to synthetize, hit Generate voice clone button """) voice.upload( fn = check_mp3, inputs = [voice], outputs = [voice, preprocess_audio_file], queue = False, show_api = False ) voice.clear( fn = clear_audio_elms, inputs = None, outputs = [preprocess_audio_file], queue = False, show_api = False ) gen_image_btn.click( fn = generate_portrait, inputs = [prompt_image], outputs = [portrait], queue = False, show_api = False ) gen_voice_btn.click( fn = generate_voice_with_parler, inputs = [prompt_audio, voice_description], outputs = [voice, preprocess_audio_file], queue = False, show_api = False ) gen_wsp_voice_btn.click( fn = get_whisperspeech, inputs = [prompt_audio_whisperspeech, audio_to_clone], outputs = [voice, preprocess_audio_file], queue = False, show_api = False ) submit_btn.click( fn = generate_talking_portrait, inputs = [portrait, voice], outputs = [result], show_api = False ) demo.queue(max_size=2).launch(show_error=True, show_api=False)