Update app.py

app.py

@@ -6,9 +6,9 @@ if hf_spaces:
     except Exception as e:
         print(e)
 import os
+import numpy as np
 import gradio as gr
 
-from kokoro import KPipeline
 from demo.infer import LiveCCDemoInfer
 
 class GradioBackend:
@@ -20,7 +20,6 @@ class GradioBackend:
     }
     def __init__(self, model_path: str = 'chenjoya/LiveCC-7B-Instruct'):
         self.infer = LiveCCDemoInfer(model_path)
-        self.audio_pipeline = KPipeline(lang_code='a')
     
     def __call__(self, message: str = None, history: list[str] = None, state: dict = {}, mode: str = 'Real-Time Commentary', **kwargs):
         return getattr(self.infer, self.mode2api[mode])(message=message, history=history, state=state, **kwargs)
@@ -33,7 +32,7 @@ with gr.Blocks() as demo:
     gr.Markdown("1️⃣ Select Mode, Real-Time Commentary (LiveCC) or Conversation (Common QA)")
     gr.Markdown("2️⃣🅰️ **Real-Time Commentary:  Input a query (optional) -> Click or upload a video**.")
     gr.Markdown("2️⃣🅱️ **Conversation: Click or upload a video -> Input a query**. But as the past_key_values support in ZeroGPU is not good, multi-turn conversation could be slower.")
-    gr.Markdown("*Web Gradio has unexpected latency (3s~5s). If you want to enjoy the very real-time experience, please deploy locally https://github.com/showlab/livecc*")
+    gr.Markdown("*HF Space Gradio has unsolvable latency (10s~20s). If you want to enjoy the very real-time experience, please deploy locally https://github.com/showlab/livecc*")
     gr_state = gr.State({}, render=False) # control all useful state, including kv cache
     gr_video_state = gr.JSON({}, visible=False) # only record video state, belong to gr_state but lightweight
     gr_static_trigger = gr.Number(value=0, visible=False) # control start streaming or stop
@@ -53,7 +52,10 @@ with gr.Blocks() as demo:
             gr_examples = gr.Examples(
                 examples=[
                     'demo/sources/howto_fix_laptop_mute_1080p.mp4',
-                    'demo/sources/writing_mute_1080p.mp4'
+                    'demo/sources/writing_mute_1080p.mp4',
+                    'demo/sources/spacex_falcon9_mute_1080p.mp4',
+                    'demo/sources/warriors_vs_rockets_2025wcr1_mute_1080p.mp4',
+                    'demo/sources/dota2_facelessvoid_mute_1080p.mp4'
                 ],
                 inputs=[gr_video],
             )
@@ -76,22 +78,29 @@ with gr.Blocks() as demo:
                 response, state = gradio_backend(message=message, history=history, state=state, mode=mode, hf_spaces=hf_spaces)
                 yield response, state
                 
-            def gr_chatinterface_chatbot_clear_fn():
-                return {}, {}, 0, 0
+            def gr_chatinterface_chatbot_clear_fn(gr_dynamic_trigger):
+                return {}, {}, 0, gr_dynamic_trigger
             gr_chatinterface = gr.ChatInterface(
                 fn=gr_chatinterface_fn,
                 type="messages", 
                 additional_inputs=[gr_state, gr_video, gr_radio_mode],
                 additional_outputs=[gr_state]
             )
-            gr_chatinterface.chatbot.clear(fn=gr_chatinterface_chatbot_clear_fn, outputs=[gr_video_state, gr_state, gr_static_trigger, gr_dynamic_trigger])
-            gr_clean_button.click(fn=lambda :[[], *gr_chatinterface_chatbot_clear_fn()], outputs=[gr_video_state, gr_state, gr_static_trigger, gr_dynamic_trigger])
-            
+            gr_chatinterface.chatbot.clear(fn=gr_chatinterface_chatbot_clear_fn, inputs=[gr_dynamic_trigger], outputs=[gr_video_state, gr_state, gr_static_trigger, gr_dynamic_trigger])
+            gr_clean_button.click(fn=lambda :[[], *gr_chatinterface_chatbot_clear_fn()], inputs=[gr_dynamic_trigger], outputs=[gr_video_state, gr_state, gr_static_trigger, gr_dynamic_trigger])
+
+            @spaces.GPU
             def gr_for_streaming(history: list[gr.ChatMessage], video_state: dict, state: dict, mode: str, static_trigger: int, dynamic_trigger: int): 
                 if static_trigger == 0:
                     yield [], {}, dynamic_trigger
                     return
-                yield history + [gr.ChatMessage(role="assistant", content='Loading video... thanks for waiting...')], state, dynamic_trigger
+                global gradio_backend
+                if gradio_backend is None:
+                    yield '(ZeroGPU needs to initialize model under @spaces.GPU, thanks for waiting...)', state
+                    gradio_backend = GradioBackend()
+                    yield '(finished initialization, responding...)', state
+                waiting_prompt = 'Loading video now... thanks for waiting...'
+                yield history + [gr.ChatMessage(role="assistant", content=waiting_prompt)], state, dynamic_trigger
                 if not js_monitor:
                     video_state['video_timestamp'] = 19260817 # 👓
                 state.update(video_state)
@@ -141,6 +150,7 @@ with gr.Blocks() as demo:
                 inputs=[gr_radio_mode], 
                 outputs=[gr_static_trigger, gr_dynamic_trigger]
             )
+            
             gr_dynamic_trigger.change(
                 fn=gr_get_video_state,
                 inputs=[gr_video_state],
@@ -151,28 +161,6 @@ with gr.Blocks() as demo:
                 inputs=[gr_chatinterface.chatbot, gr_video_state, gr_state, gr_radio_mode, gr_static_trigger, gr_dynamic_trigger], 
                 outputs=[gr_chatinterface.chatbot, gr_state, gr_dynamic_trigger], 
             )
-            
+    
     demo.queue(max_size=5, default_concurrency_limit=5)
-    demo.launch(share=True)
-
-
-    # --- for streaming ---
-
-    # gr_tts = gr.Audio(visible=False, elem_id="gr_tts", streaming=True, autoplay=True)
-    # def tts():
-    #     while True:
-    #         contents = ''
-    #         while not gradio_backend.contents.empty():
-    #             content = gradio_backend.contents.get()
-    #             contents += ' ' + content.rstrip(' ...')
-    #         contents = contents.strip()
-    #         if contents:
-    #             generator = gradio_backend.audio_pipeline(contents, voice='af_heart', speed=1.2)
-    #             for _, _, audio_torch in generator:
-    #                 audio_np = audio_torch.cpu().numpy()
-    #                 max_val = np.max(np.abs(audio_np))
-    #                 if max_val > 0:
-    #                     audio_np = audio_np / max_val
-    #                 audio_int16 = (audio_np * 32767).astype(np.int16)
-    #                 yield (24000, audio_int16)
-    # gr_video.change(fn=tts, outputs=[gr_tts])
+    demo.launch(share=True)