Update app.py

app.py

@@ -144,13 +144,13 @@ with gr.Blocks(css=custom_css) as app:
                     step=0.01,
                     info="Defina a duração do cross-fade entre os clipes de áudio.",
                 )
-                sentence_count_slider = gr.Slider(
-                    label="Número de Sentenças por Vez",
+                chunk_size_slider = gr.Slider(
+                    label="Número de Sentenças por Chunk",
                     minimum=1,
                     maximum=10,
                     value=1,
                     step=1,
-                    info="Selecione quantas sentenças serão geradas por vez.",
+                    info="Defina quantas sentenças serão processadas em cada chunk.",
                 )
 
             audio_output = gr.Audio(label="Áudio Sintetizado")
@@ -159,26 +159,31 @@ with gr.Blocks(css=custom_css) as app:
             analyzer = SentenceAnalyzer()
 
             @gpu_decorator
-            def basic_tts(
+            def process_chunks(
                 ref_audio_input,
                 ref_text_input,
                 gen_text_input,
                 remove_silence,
                 cross_fade_duration_slider,
                 speed_slider,
-                sentence_count_slider,
+                chunk_size_slider,
             ):
-                # Divida o texto em sentenças
+                # Dividir o texto em sentenças
                 sentences = analyzer.split_into_sentences(gen_text_input)
-                num_sentences = min(len(sentences), sentence_count_slider)
 
-                # Gere áudio para o número selecionado de sentenças
+                # Agrupar sentenças em chunks
+                chunks = [
+                    " ".join(sentences[i : i + chunk_size_slider])
+                    for i in range(0, len(sentences), chunk_size_slider)
+                ]
+
+                # Processar cada chunk
                 audio_segments = []
-                for i in range(num_sentences):
+                for chunk in chunks:
                     audio_out, spectrogram_path, ref_text_out = infer(
                         ref_audio_input,
                         ref_text_input,
-                        sentences[i],
+                        chunk,  # Passa o chunk atual
                         remove_silence,
                         cross_fade_duration_slider,
                         speed_slider,
@@ -186,7 +191,7 @@ with gr.Blocks(css=custom_css) as app:
                     sr, audio_data = audio_out
                     audio_segments.append(audio_data)
 
-                # Concatene os segmentos de áudio
+                # Concatenar os segmentos de áudio gerados
                 if audio_segments:
                     final_audio_data = np.concatenate(audio_segments)
                     return (sr, final_audio_data), spectrogram_path, gr.update(value=ref_text_out)
@@ -195,7 +200,7 @@ with gr.Blocks(css=custom_css) as app:
                     return None, None, gr.update(value=ref_text_out)
 
             generate_btn.click(
-                basic_tts,
+                process_chunks,
                 inputs=[
                     ref_audio_input,
                     ref_text_input,
@@ -203,201 +208,13 @@ with gr.Blocks(css=custom_css) as app:
                     remove_silence,
                     cross_fade_duration_slider,
                     speed_slider,
-                    sentence_count_slider,
+                    chunk_size_slider,
                 ],
                 outputs=[audio_output, spectrogram_output],
             )
 
         
-        with gr.Tab("Multi-Speech"):
-            gr.Markdown("# Geração Multi-Speech com F5-TTS")
-            with gr.Row():
-                with gr.Column():
-                    regular_name = gr.Textbox(value="Regular", label="Speech Type Name")
-                    regular_insert = gr.Button("Insert Label", variant="secondary")
-                regular_audio = gr.Audio(label="Regular Reference Audio", type="filepath")
-                regular_ref_text = gr.Textbox(label="Reference Text (Regular)", lines=2)
-            # Regular speech type (max 100)
-            max_speech_types = 100
-            speech_type_rows = []  # 99
-            speech_type_names = [regular_name]  # 100
-            speech_type_audios = [regular_audio]  # 100
-            speech_type_ref_texts = [regular_ref_text]  # 100
-            speech_type_delete_btns = []  # 99
-            speech_type_insert_btns = [regular_insert]  # 100
-            # Additional speech types (99 more)
-            for i in range(max_speech_types - 1):
-                with gr.Row(visible=False) as row:
-                    with gr.Column():
-                        name_input = gr.Textbox(label="Speech Type Name")
-                        delete_btn = gr.Button("Delete Type", variant="secondary")
-                        insert_btn = gr.Button("Insert Label", variant="secondary")
-                    audio_input = gr.Audio(label="Reference Audio", type="filepath")
-                    ref_text_input = gr.Textbox(label="Reference Text", lines=2)
-                speech_type_rows.append(row)
-                speech_type_names.append(name_input)
-                speech_type_audios.append(audio_input)
-                speech_type_ref_texts.append(ref_text_input)
-                speech_type_delete_btns.append(delete_btn)
-                speech_type_insert_btns.append(insert_btn)
-            # Button to add speech type
-            add_speech_type_btn = gr.Button("Add Speech Type")
-            # Keep track of current number of speech types
-            speech_type_count = gr.State(value=1)
-            # Function to add a speech type
-            def add_speech_type_fn(speech_type_count):
-                if speech_type_count < max_speech_types:
-                    speech_type_count += 1
-                    # Prepare updates for the rows
-                    row_updates = []
-                    for i in range(1, max_speech_types):
-                        if i < speech_type_count:
-                            row_updates.append(gr.update(visible=True))
-                        else:
-                            row_updates.append(gr.update())
-                else:
-                    # Optionally, show a warning
-                    row_updates = [gr.update() for _ in range(1, max_speech_types)]
-                return [speech_type_count] + row_updates
-            add_speech_type_btn.click(
-                add_speech_type_fn, inputs=speech_type_count, outputs=[speech_type_count] + speech_type_rows
-            )
-            # Function to delete a speech type
-            def make_delete_speech_type_fn(index):
-                def delete_speech_type_fn(speech_type_count):
-                    # Prepare updates
-                    row_updates = []
-                    for i in range(1, max_speech_types):
-                        if i == index:
-                            row_updates.append(gr.update(visible=False))
-                        else:
-                            row_updates.append(gr.update())
-                    speech_type_count = max(1, speech_type_count)
-                    return [speech_type_count] + row_updates
-                return delete_speech_type_fn
-            # Update delete button clicks
-            for i, delete_btn in enumerate(speech_type_delete_btns):
-                delete_fn = make_delete_speech_type_fn(i)
-                delete_btn.click(delete_fn, inputs=speech_type_count, outputs=[speech_type_count] + speech_type_rows)
-            # Text input for the prompt
-            gen_text_input_multistyle = gr.Textbox(
-                label="Text to Generate",
-                lines=10,
-                placeholder="Enter the script with speaker names (or emotion types) at the start of each block, e.g.:\n\n{Regular} Hello, I'd like to order a sandwich please.\n{Surprised} What do you mean you're out of bread?\n{Sad} I really wanted a sandwich though...\n{Angry} You know what, darn you and your little shop!\n{Whisper} I'll just go back home and cry now.\n{Shouting} Why me?!",
-            )
-            def make_insert_speech_type_fn(index):
-                def insert_speech_type_fn(current_text, speech_type_name):
-                    current_text = current_text or ""
-                    speech_type_name = speech_type_name or "None"
-                    updated_text = current_text + f"{{{speech_type_name}}} "
-                    return gr.update(value=updated_text)
-                return insert_speech_type_fn
-            for i, insert_btn in enumerate(speech_type_insert_btns):
-                insert_fn = make_insert_speech_type_fn(i)
-                insert_btn.click(
-                    insert_fn,
-                    inputs=[gen_text_input_multistyle, speech_type_names[i]],
-                    outputs=gen_text_input_multistyle,
-                )
-            with gr.Accordion("Advanced Settings", open=False):
-                remove_silence_multistyle = gr.Checkbox(
-                    label="Remove Silences",
-                    value=True,
-                )
-            # Generate button
-            generate_multistyle_btn = gr.Button("Generate Multi-Style Speech", variant="primary")
-            # Output audio
-            audio_output_multistyle = gr.Audio(label="Synthesized Audio")
-            @gpu_decorator
-            def generate_multistyle_speech(
-                gen_text,
-                *args,
-            ):
-                speech_type_names_list = args[:max_speech_types]
-                speech_type_audios_list = args[max_speech_types : 2 * max_speech_types]
-                speech_type_ref_texts_list = args[2 * max_speech_types : 3 * max_speech_types]
-                remove_silence = args[3 * max_speech_types]
-                # Collect the speech types and their audios into a dict
-                speech_types = OrderedDict()
-                ref_text_idx = 0
-                for name_input, audio_input, ref_text_input in zip(
-                    speech_type_names_list, speech_type_audios_list, speech_type_ref_texts_list
-                ):
-                    if name_input and audio_input:
-                        speech_types[name_input] = {"audio": audio_input, "ref_text": ref_text_input}
-                    else:
-                        speech_types[f"@{ref_text_idx}@"] = {"audio": "", "ref_text": ""}
-                    ref_text_idx += 1
-                # Parse the gen_text into segments
-                segments = parse_speechtypes_text(gen_text)
-                # For each segment, generate speech
-                generated_audio_segments = []
-                current_style = "Regular"
-                for segment in segments:
-                    style = segment["style"]
-                    text = segment["text"]
-                    if style in speech_types:
-                        current_style = style
-                    else:
-                        # If style not available, default to Regular
-                        current_style = "Regular"
-                    ref_audio = speech_types[current_style]["audio"]
-                    ref_text = speech_types[current_style].get("ref_text", "")
-                    # Generate speech for this segment
-                    audio_out, _, ref_text_out = infer(
-                        ref_audio, ref_text, text, remove_silence, 0, show_info=print
-                    )  # show_info=print no pull to top when generating
-                    sr, audio_data = audio_out
-                    generated_audio_segments.append(audio_data)
-                    speech_types[current_style]["ref_text"] = ref_text_out
-                # Concatenate all audio segments
-                if generated_audio_segments:
-                    final_audio_data = np.concatenate(generated_audio_segments)
-                    return [(sr, final_audio_data)] + [
-                        gr.update(value=speech_types[style]["ref_text"]) for style in speech_types
-                    ]
-                else:
-                    gr.Warning("No audio generated.")
-                    return [None] + [gr.update(value=speech_types[style]["ref_text"]) for style in speech_types]
-            generate_multistyle_btn.click(
-                generate_multistyle_speech,
-                inputs=[
-                    gen_text_input_multistyle,
-                ]
-                + speech_type_names
-                + speech_type_audios
-                + speech_type_ref_texts
-                + [
-                    remove_silence_multistyle,
-                ],
-                outputs=[audio_output_multistyle] + speech_type_ref_texts,
-            )
-            # Validation function to disable Generate button if speech types are missing
-            def validate_speech_types(gen_text, regular_name, *args):
-                speech_type_names_list = args[:max_speech_types]
-                # Collect the speech types names
-                speech_types_available = set()
-                if regular_name:
-                    speech_types_available.add(regular_name)
-                for name_input in speech_type_names_list:
-                    if name_input:
-                        speech_types_available.add(name_input)
-                # Parse the gen_text to get the speech types used
-                segments = parse_speechtypes_text(gen_text)
-                speech_types_in_text = set(segment["style"] for segment in segments)
-                # Check if all speech types in text are available
-                missing_speech_types = speech_types_in_text - speech_types_available
-                if missing_speech_types:
-                    # Disable the generate button
-                    return gr.update(interactive=False)
-                else:
-                    # Enable the generate button
-                    return gr.update(interactive=True)
-            gen_text_input_multistyle.change(
-                validate_speech_types,
-                inputs=[gen_text_input_multistyle, regular_name] + speech_type_names,
-                outputs=generate_multistyle_btn,
-            )
+        
             
 @click.command()
 @click.option("--port", "-p", default=None, type=int, help="Port to run the app on")