g

app.py

@@ -464,46 +464,45 @@ def audionar_tts(text=None,
             'romanian': 'ron',
             'serbian (approx.)': 'rmc-script_latin',
         }
-    lang_code = lang_map.get(lang.lower(), lang.lower().split()[0].strip())
-
-    global cached_lang_code, cached_net_g, cached_tokenizer
-
-    if 'cached_lang_code' not in globals() or cached_lang_code != lang_code:
-        cached_lang_code = lang_code
-        cached_net_g = VitsModel.from_pretrained(f'facebook/mms-tts-{lang_code}').eval()
-        cached_tokenizer = VitsTokenizer.from_pretrained(f'facebook/mms-tts-{lang_code}')
-
-    net_g = cached_net_g
-    tokenizer = cached_tokenizer
-
-    total_audio = []
     
-    final_audio = None
-    speech_audio = None
-
-
     if text and text.strip():
+        if 'wav/' in lang:
+            # call StyleTTS2
+            speech_audio = _styletts2(text=text,
+                                    ref_s=lang)
         
+        else:  # VITS
+            
+            lang_code = lang_map.get(lang.lower(), lang.lower().split()[0].strip())
+
+            global cached_lang_code, cached_net_g, cached_tokenizer
+
+            if 'cached_lang_code' not in globals() or cached_lang_code != lang_code:
+                cached_lang_code = lang_code
+                cached_net_g = VitsModel.from_pretrained(f'facebook/mms-tts-{lang_code}').eval()
+                cached_tokenizer = VitsTokenizer.from_pretrained(f'facebook/mms-tts-{lang_code}')
 
-        text = only_greek_or_only_latin(text, lang=lang_code)
-        text = transliterate_number(text, lang=lang_code)
-        text = fix_vocals(text, lang=lang_code)
+            net_g = cached_net_g
+            tokenizer = cached_tokenizer
+            text = only_greek_or_only_latin(text, lang=lang_code)
+            text = transliterate_number(text, lang=lang_code)
+            text = fix_vocals(text, lang=lang_code)
 
 
-        sentences = textwrap.wrap(text, width=439)
+            sentences = textwrap.wrap(text, width=439)
 
-        total_audio_parts = []
-        for sentence in sentences:
-            inputs = cached_tokenizer(sentence, return_tensors="pt")
-            with torch.no_grad():
-                audio_part = cached_net_g(
-                    input_ids=inputs.input_ids.to(device),
-                    attention_mask=inputs.attention_mask.to(device),
-                    lang_code=lang_code,
-                )[0, :]
-            total_audio_parts.append(audio_part)
+            total_audio_parts = []
+            for sentence in sentences:
+                inputs = cached_tokenizer(sentence, return_tensors="pt")
+                with torch.no_grad():
+                    audio_part = cached_net_g(
+                        input_ids=inputs.input_ids.to(device),
+                        attention_mask=inputs.attention_mask.to(device),
+                        lang_code=lang_code,
+                    )[0, :]
+                total_audio_parts.append(audio_part)
 
-        speech_audio = torch.cat(total_audio_parts).cpu().numpy()
+            speech_audio = torch.cat(total_audio_parts).cpu().numpy()
 
     # AudioGen
     if soundscape and soundscape.strip():
@@ -1321,16 +1320,8 @@ def only_greek_or_only_latin(text, lang='grc'):
         return ''.join(output_chars)
 
 
-def other_tts(text='Hallov worlds Far over the',
-              ref_s='wav/af_ZA_google-nwu_0184.wav',
-              soundscape='birds fomig',
-              cache_lim=64):
-    
-    total_audio = []
-    
-    final_audio = None
-    speech_audio = None
-
+def _stylett2(text='Hallov worlds Far over the',
+              ref_s='wav/af_ZA_google-nwu_0184.wav'):
 
     if text and text.strip():
         
@@ -1345,56 +1336,7 @@ def other_tts(text='Hallov worlds Far over the',
                                                 original_rate=24000,
                                                 target_rate=16000)[0, :]   # 16 KHz
 
-    # AudioGen
-    if soundscape and soundscape.strip():
-
-        
-        speech_duration_secs = len(speech_audio) / 16000 if speech_audio is not None else 0
-        target_duration = max(speech_duration_secs + 0.74, 2.0)
-
-
-        background_audio = audiogen.generate(
-            soundscape,
-            duration=target_duration,
-            cache_lim=max(4, int(cache_lim))  # at least allow 10 A/R stEps
-         ).numpy()
-
-        if speech_audio is not None:
-
-            len_speech = len(speech_audio)
-            len_background = len(background_audio)
-            
-            if len_background > len_speech:
-                padding = np.zeros(len_background - len_speech,
-                                   dtype=np.float32)
-                speech_audio = np.concatenate([speech_audio, padding])
-            elif len_speech > len_background:
-                padding = np.zeros(len_speech - len_background,
-                                   dtype=np.float32)
-                background_audio = np.concatenate([background_audio, padding])
-
-            # Convert to 2D arrays for stereo blending
-            speech_audio_stereo = speech_audio[None, :]
-            background_audio_stereo = background_audio[None, :]
-
-
-            final_audio = np.concatenate([
-                0.49 * speech_audio_stereo + 0.51 * background_audio_stereo,
-                0.51 * background_audio_stereo + 0.49 * speech_audio_stereo
-            ],0)
-        else:
-            final_audio = background_audio
-
-    elif speech_audio is not None:
-        final_audio = speech_audio
-
-    # If both inputs are empty, create a 2s silent audio file.
-    if final_audio is None:
-        final_audio = np.zeros(16000 * 2, dtype=np.float32)
-
-    wavfile = '_audionar_.wav'
-    audiofile.write(wavfile, final_audio, 16000)    
-    return wavfile
+    return speech_audio
 
 def update_selected_voice(voice_filename):
     return 'wav/' + voice_filename + '.wav'
@@ -1412,40 +1354,8 @@ description = (
 )
 
 
-def other_tts(text_input, selected_voice, soundscape_input, kv_input):
-    """
-    This function would handle the TTS generation for 'other TTS' voices.
-    """
-    print(f"Generating TTS for voice: {selected_voice}")
-    print(f"Text: {text_input}")
-    print(f"Soundscape: {soundscape_input}")
-    print(f"KV Period: {kv_input}")
-    # Replace with your actual TTS generation code
-    return "path/to/generated/audio.wav"
-
-def audionar_tts(text_input, lang_dropdown, soundscape_input, kv_input):
-    """
-    This function would handle the TTS generation for 'audionar TTS' languages.
-    """
-    print(f"Generating TTS for language: {lang_dropdown}")
-    print(f"Text: {text_input}")
-    print(f"Soundscape: {soundscape_input}")
-    print(f"KV Period: {kv_input}")
-    # Replace with your actual TTS generation code
-    return "path/to/generated/audio.wav"
-
-def recognize(audio):
-    """
-    This function handles speech analysis.
-    """
-    print(f"Analyzing audio from: {audio}")
-    # Replace with your actual speech analysis code
-    return "30", "Male", "Happy"
-
-
-
 with gr.Blocks(theme='huggingface') as demo:
-    with gr.Tab(label="TTS Generation"):
+    with gr.Tab(label="TTS"):
         with gr.Row():
             text_input = gr.Textbox(
                 label="Type text for TTS:",
@@ -1474,18 +1384,8 @@ with gr.Blocks(theme='huggingface') as demo:
 
         output_audio = gr.Audio(label="TTS Output")
 
-        def generate_audio_unified(text, choice, soundscape, kv):
-            """
-            Unified function to call the correct TTS backend based on the dropdown choice.
-            """
-            # Logic to determine which function to call based on the choice
-            if choice in VOICES:
-                return other_tts(text, choice, soundscape, kv)
-            elif choice in language_names:
-                return audionar_tts(text, choice, soundscape, kv)
-
         generate_button.click(
-            fn=generate_audio_unified,
+            fn=audionar_tts,
             inputs=[text_input, choice_dropdown, soundscape_input, kv_input],
             outputs=output_audio
         )