small fixes

app.py

@@ -21,8 +21,12 @@
 
 
 import logging
+import os
+
 import gradio as gr
-from model import language_to_models
+
+from decode import decode
+from model import get_pretrained_model, get_vad, language_to_models
 
 title = "# Next-gen Kaldi: Generate subtitles for videos"
 
@@ -70,6 +74,11 @@ def build_html_output(s: str, style: str = "result_item_success"):
     """
 
 
+def show_file_info(in_filename: str):
+    logging.info(f"Input file: {in_filename}")
+    _ = os.system(f"ffprob -hide_banner -i '{in_filename}'")
+
+
 def process_uploaded_file(
     language: str,
     repo_id: str,
@@ -84,7 +93,12 @@ def process_uploaded_file(
 
     logging.info(f"Processing uploaded file: {in_filename}")
 
-    return "Done", build_html_output("ok", "result_item_success")
+    recognizer = get_pretrained_model(repo_id)
+    vad = get_vad()
+
+    result = decode(recognizer, vad, in_filename)
+
+    return result, build_html_output("ok", "result_item_success")
 
 
 demo = gr.Blocks(css=css)
@@ -118,6 +132,7 @@ with demo:
                 source="upload",
                 interactive=True,
                 label="Upload from disk",
+                show_share_button=True,
             )
             upload_button = gr.Button("Submit for recognition")
             uploaded_output = gr.Textbox(label="Recognized speech from uploaded file")

decode.py

@@ -0,0 +1,117 @@
+# Copyright      2022-2023  Xiaomi Corp.        (authors: Fangjun Kuang)
+#
+# See LICENSE for clarification regarding multiple authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import subprocess
+from dataclasses import dataclass
+from datetime import timedelta
+import logging
+
+import numpy as np
+import sherpa_onnx
+
+from model import sample_rate
+
+
+@dataclass
+class Segment:
+    start: float
+    duration: float
+    text: str = ""
+
+    @property
+    def end(self):
+        return self.start + self.duration
+
+    def __str__(self):
+        s = f"{timedelta(seconds=self.start)}"[:-3]
+        s += " --> "
+        s += f"{timedelta(seconds=self.end)}"[:-3]
+        s = s.replace(".", ",")
+        s += "\n"
+        s += self.text
+        return s
+
+
+def decode(
+    recognizer: sherpa_onnx.OfflineRecognizer,
+    vad: sherpa_onnx.VoiceActivityDetector,
+    filename: str,
+) -> str:
+    ffmpeg_cmd = [
+        "ffmpeg",
+        "-i",
+        filename,
+        "-f",
+        "s16le",
+        "-acodec",
+        "pcm_s16le",
+        "-ac",
+        "1",
+        "-ar",
+        str(sample_rate),
+        "-",
+    ]
+
+    process = subprocess.Popen(
+        ffmpeg_cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL
+    )
+
+    frames_per_read = int(sample_rate * 100)  # 100 second
+
+    window_size = 512
+
+    buffer = []
+
+    segment_list = []
+
+    logging.info("Started!")
+
+    while True:
+        # *2 because int16_t has two bytes
+        data = process.stdout.read(frames_per_read * 2)
+        if not data:
+            break
+
+        samples = np.frombuffer(data, dtype=np.int16)
+        samples = samples.astype(np.float32) / 32768
+
+        buffer = np.concatenate([buffer, samples])
+        while len(buffer) > window_size:
+            vad.accept_waveform(buffer[:window_size])
+            buffer = buffer[window_size:]
+
+        streams = []
+        segments = []
+        while not vad.empty():
+            segment = Segment(
+                start=vad.front.start / sample_rate,
+                duration=len(vad.front.samples) / sample_rate,
+            )
+            segments.append(segment)
+
+            stream = recognizer.create_stream()
+            stream.accept_waveform(sample_rate, vad.front.samples)
+
+            streams.append(stream)
+
+            vad.pop()
+
+        recognizer.decode_streams(streams)
+        for seg, stream in zip(segments, streams):
+            seg.text = stream.result.text
+            segment_list.append(seg)
+
+    return "\n\n".join(f"{i}\n{seg} " for i, seg in enumerate(segment_list, 1))

model.py

@@ -165,6 +165,40 @@ def _get_russian_pre_trained_model(repo_id: str) -> sherpa_onnx.OfflineRecognize
     return recognizer
 
 
+@lru_cache(maxsize=2)
+def get_vad() -> sherpa_onnx.VoiceActivityDetector:
+    vad_model = _get_nn_model_filename(
+        repo_id="csukuangfj/vad",
+        filename="silero_vad.onnx",
+        subfolder=".",
+    )
+
+    config = sherpa_onnx.VadModelConfig()
+    config.silero_vad.model = vad_model
+    config.silero_vad.min_silence_duration = 0.15
+    config.silero_vad.min_speech_duration = 0.25
+    config.sample_rate = sample_rate
+
+    vad = sherpa_onnx.VoiceActivityDetector(
+        config,
+        buffer_size_in_seconds=180,
+    )
+
+    return vad
+
+
+@lru_cache(maxsize=10)
+def get_pretrained_model(repo_id: str) -> sherpa_onnx.OfflineRecognizer:
+    if repo_id in english_models:
+        return english_models[repo_id](repo_id)
+    elif repo_id in chinese_english_mixed_models:
+        return chinese_english_mixed_models[repo_id](repo_id)
+    elif repo_id in russian_models:
+        return russian_models[repo_id](repo_id)
+    else:
+        raise ValueError(f"Unsupported repo_id: {repo_id}")
+
+
 english_models = {
     "whisper-tiny.en": _get_whisper_model,
     "whisper-base.en": _get_whisper_model,