Skip to content

Open-source speech recognition toolkit for training, inference, streaming ASR, VAD, punctuation, speaker diarization pipelines, and OpenAI-compatible/MCP serving.

feat(audio): support explicit PCM16 input without container probing

LauraGPT9d611293f44b
diff --git a/.github/workflows/test-numpy-compatibility.yml b/.github/workflows/test-numpy-compatibility.yml
index d23e0c8ff..d4606f8d3 100644
--- a/.github/workflows/test-numpy-compatibility.yml
+++ b/.github/workflows/test-numpy-compatibility.yml
@@ -5,6 +5,10 @@ on:
paths:
- "setup.py"
- "funasr/__init__.py"
+ - "funasr/auto/auto_model.py"
+ - "funasr/utils/load_utils.py"
+ - "tests/test_pcm_input_format.py"
+ - "tests/test_load_audio_bytes.py"
- "funasr/frontends/**"
- "funasr/models/emotion2vec/**"
- "funasr/models/campplus/**"
@@ -21,6 +25,10 @@ on:
paths:
- "setup.py"
- "funasr/__init__.py"
+ - "funasr/auto/auto_model.py"
+ - "funasr/utils/load_utils.py"
+ - "tests/test_pcm_input_format.py"
+ - "tests/test_load_audio_bytes.py"
- "funasr/frontends/**"
- "funasr/models/emotion2vec/**"
- "funasr/models/campplus/**"
@@ -76,6 +84,8 @@ jobs:
tests/test_eend_feature_compatibility.py \
tests/test_pypi_metadata.py \
tests/test_sensevoice_word_timestamps.py \
+ tests/test_pcm_input_format.py \
+ tests/test_load_audio_bytes.py \
--junitxml=numpy-results.xml
- uses: actions/upload-artifact@v4
if: always()
diff --git a/docs/python_api.md b/docs/python_api.md
index db6caef08..2cadd9633 100644
--- a/docs/python_api.md
+++ b/docs/python_api.md
@@ -104,7 +104,15 @@ for result in results:
`batch_size=1` processes a list serially through direct inference; raise it only for a model that supports batching and after measuring memory use. `batch_size_s` has a different meaning and only controls the wrapper's VAD path. VAD segmentation is not incremental microphone streaming, and it does not guarantee unlimited recording length or bounded total memory.
-Use a one-dimensional mono float32 waveform with a known sample rate. For models using the common audio loader, `fs` in `generate()` describes the array's source sample rate (fallback 16000); the model frontend supplies the target rate. Do not pass a stereo matrix or a list of numbers and assume it will be treated as one waveform: a Python list is normally a list of inputs. File decoding depends on the installed audio backends. Top-level bytes are handled by `load_bytes`: recognized containers are decoded/resampled to 16 kHz, otherwise bytes are interpreted as int16 PCM without sample-rate metadata. Prefer a decoded array with an explicit rate for ambiguous inputs. See [audio loading](../funasr/utils/load_utils.py) and [byte-input tests](../tests/test_load_audio_bytes.py).
+Use a one-dimensional mono float32 waveform with a known sample rate. For models using the common audio loader, `fs` in `generate()` describes the array's source sample rate (fallback 16000); the model frontend supplies the target rate. Do not pass a stereo matrix or a list of numbers and assume it will be treated as one waveform: a Python list is normally a list of inputs. File decoding depends on the installed audio backends. With the default `input_format="auto"`, top-level bytes are handled by `load_bytes`: recognized containers are decoded/resampled to 16 kHz, otherwise bytes are interpreted as int16 PCM without sample-rate metadata. Prefer a decoded array with an explicit rate for ambiguous inputs. See [audio loading](../funasr/utils/load_utils.py) and [byte-input tests](../tests/test_load_audio_bytes.py).
+
+For known **mono signed 16-bit little-endian raw PCM**, explicitly bypass format detection:
+
+```python
+result = model.generate(input=pcm_bytes, input_format="pcm_s16le", fs=16000)
+```
+
+This option also applies to byte strings in a batch and to the VAD preprocessing path. It normalizes samples to float32 without invoking a container decoder; raw bytes can otherwise accidentally resemble a file header. It does not resample at byte-conversion time: use the actual source sample rate in `fs`. Do not select this format for WAV/MP3 file bytes, float PCM, other bit depths, big-endian samples, or interleaved stereo. A partial two-byte sample raises `ValueError`; assemble complete samples in the receiving layer. Streaming callers must still preserve their per-session `cache`, chunk settings, and final-chunk handling. This opt-in path avoids ambiguous probing, but does not diagnose every source of inference delays.
`prepare_data_iterator` also accepts manifests. A `.scp` line can be `utterance_id /path/to/audio.wav`; `.jsonl` records use `{"source": "/path/to/audio.wav", "key": "utterance_id"}`. `.json` is not parsed as an arbitrary JSON array by this iterator. Do not expose unrestricted paths or URLs directly to untrusted callers.
diff --git a/docs/python_api_zh.md b/docs/python_api_zh.md
index 4b9864b4e..71eae9811 100644
--- a/docs/python_api_zh.md
+++ b/docs/python_api_zh.md
@@ -103,7 +103,15 @@ for result in results:
`batch_size=1` 在直接推理路径中逐条处理列表;只有确认模型支持批量并测量过内存占用后再增大它。`batch_size_s` 的含义不同,只控制包装层的 VAD 路径。VAD 切分不是麦克风增量流式识别,也不保证无限录音长度或固定的总内存占用。
-波形应为采样率已知的一维单声道 float32 数组。使用通用音频加载器的模型,在 `generate()` 中通过 `fs` 指定数组的原始采样率,回退值为 16000;目标采样率由模型前端决定。不要把立体声矩阵或数字列表默认当作单条波形,Python 列表通常被解释为多条输入。文件解码能力取决于已安装的音频后端。顶层 bytes 由 `load_bytes` 处理:识别出的容器格式会被解码并重采样为 16 kHz,否则按没有采样率元数据的 int16 PCM 解释。输入格式有歧义时,优先使用解码后的数组并明确采样率。参见[音频加载代码](../funasr/utils/load_utils.py) 和 [bytes 输入测试](../tests/test_load_audio_bytes.py)。
+波形应为采样率已知的一维单声道 float32 数组。使用通用音频加载器的模型,在 `generate()` 中通过 `fs` 指定数组的原始采样率,回退值为 16000;目标采样率由模型前端决定。不要把立体声矩阵或数字列表默认当作单条波形,Python 列表通常被解释为多条输入。文件解码能力取决于已安装的音频后端。默认 `input_format="auto"` 时,顶层 bytes 由 `load_bytes` 处理:识别出的容器格式会被解码并重采样为 16 kHz,否则按没有采样率元数据的 int16 PCM 解释。输入格式有歧义时,优先使用解码后的数组并明确采样率。参见[音频加载代码](../funasr/utils/load_utils.py) 和 [bytes 输入测试](../tests/test_load_audio_bytes.py)。
+
+对于格式已知的**单声道、有符号 16 位、小端原始 PCM**,可以显式跳过格式探测:
+
+```python
+result = model.generate(input=pcm_bytes, input_format="pcm_s16le", fs=16000)
+```
+
+该选项也适用于批量输入中的 bytes 和 VAD 预处理路径。它直接把采样值归一化为 float32,不调用容器解码器,避免原始字节偶然匹配文件头。字节转换本身不做重采样,请通过 `fs` 传入真实原始采样率。不要用于 WAV/MP3 文件字节、浮点 PCM、其他位深、大端数据或交错排列的立体声。若字节数不足以组成完整的双字节采样点,会抛出 `ValueError`,收包层应先拼接完整采样。流式调用仍须保留每会话的 `cache`、分块配置和末帧处理。这个显式入口避免了探测歧义,但不代表已经定位所有推理卡顿的原因。
`prepare_data_iterator` 也接受清单文件。`.scp` 的一行可以是 `utterance_id /path/to/audio.wav`;`.jsonl` 使用 `{"source": "/path/to/audio.wav", "key": "utterance_id"}`。该迭代器不会把 `.json` 文件当作任意 JSON 数组解析。不要向不可信调用方直接开放任意路径或 URL 输入。
diff --git a/funasr/auto/auto_model.py b/funasr/auto/auto_model.py
index 49adfea21..e814cba84 100644
--- a/funasr/auto/auto_model.py
+++ b/funasr/auto/auto_model.py
@@ -448,8 +448,10 @@ except:
pass
-def prepare_data_iterator(data_in, input_len=None, data_type=None, key=None):
- """ """
+def prepare_data_iterator(
+ data_in, input_len=None, data_type=None, key=None, input_format="auto"
+):
+ """Prepare inputs, optionally interpreting audio bytes as explicit PCM16."""
data_list = []
key_list = []
filelist = [".scp", ".txt", ".json", ".jsonl", ".text"]
@@ -490,7 +492,7 @@ def prepare_data_iterator(data_in, input_len=None, data_type=None, key=None):
data_list_tmp = []
for data_in_i, data_type_i in zip(data_in, data_type):
key_list, data_list_i = prepare_data_iterator(
- data_in=data_in_i, data_type=data_type_i
+ data_in=data_in_i, data_type=data_type_i, input_format=input_format
)
data_list_tmp.append(data_list_i)
data_list = []
@@ -499,6 +501,12 @@ def prepare_data_iterator(data_in, input_len=None, data_type=None, key=None):
else:
# [audio sample point, fbank, text]
data_list = data_in
+ if input_format != "auto":
+ data_list = [
+ load_bytes(item, input_format=input_format)
+ if isinstance(item, bytes) else item
+ for item in data_in
+ ]
key_list = []
for data_i in data_in:
if isinstance(data_i, str) and os.path.exists(data_i):
@@ -510,7 +518,7 @@ def prepare_data_iterator(data_in, input_len=None, data_type=None, key=None):
else: # raw text; audio sample point, fbank; bytes
if isinstance(data_in, bytes): # audio bytes
- data_in = load_bytes(data_in)
+ data_in = load_bytes(data_in, input_format=input_format)
if key is None:
key = "rand_key_" + "".join(random.choice(chars) for _ in range(13))
data_list = [data_in]
@@ -833,6 +841,9 @@ class AutoModel:
- device: Placement is selected at construction. Runtime device overrides
are ignored; create another AutoModel to use a different device.
- cache (dict): State cache for streaming mode. Pass {} for first call.
+ - input_format (str): "auto" (default) or "pcm_s16le" to bypass
+ container detection for mono little-endian PCM16 byte inputs.
+ Use fs for the source sample rate.
- hotword (str/list): Keywords to boost recognition accuracy.
- postprocess_hotwords (str/list/dict): Text-level hotword correction after
decoding. Unlike model-level ``hotword``, this runs on the final text.
@@ -915,7 +926,8 @@ class AutoModel:
# batch_size = 1
key_list, data_list = prepare_data_iterator(
- input, input_len=input_len, data_type=kwargs.get("data_type", None), key=key
+ input, input_len=input_len, data_type=kwargs.get("data_type", None), key=key,
+ input_format=kwargs.get("input_format", "auto"),
)
speed_stats = {}
@@ -1002,8 +1014,13 @@ class AutoModel:
kwargs = self.kwargs
# step.1: compute the vad model
beg_vad = time.time()
+ vad_cfg = {
+ "input_format": kwargs.get("input_format", "auto"),
+ "fs": kwargs.get("fs", 16000),
+ **cfg,
+ }
res = self.inference(
- input, input_len=input_len, model=self.vad_model, kwargs=self.vad_kwargs, **cfg
+ input, input_len=input_len, model=self.vad_model, kwargs=self.vad_kwargs, **vad_cfg
)
end_vad = time.time()
@@ -1022,9 +1039,12 @@ class AutoModel:
kwargs["batch_size"] = batch_size
key_list, data_list = prepare_data_iterator(
- input, input_len=input_len, data_type=kwargs.get("data_type", None)
+ input, input_len=input_len, data_type=kwargs.get("data_type", None),
+ input_format=kwargs.get("input_format", "auto"),
)
results_ret_list = []
+ # ASR updates kwargs with the resampled rate; retain the original for each input.
+ input_fs = kwargs.get("fs", 16000)
time_speech_total_all_samples = 1e-6
beg_total = time.time()
@@ -1038,7 +1058,7 @@ class AutoModel:
vadsegments = res[i]["value"]
input_i = data_list[i]
fs = kwargs["frontend"].fs if hasattr(kwargs["frontend"], "fs") else 16000
- speech = load_audio_text_image_video(input_i, fs=fs, audio_fs=kwargs.get("fs", 16000))
+ speech = load_audio_text_image_video(input_i, fs=fs, audio_fs=input_fs)
speech_lengths = len(speech)
n = len(vadsegments)
data_with_index = [(vadsegments[i], i) for i in range(n)]
@@ -1084,7 +1104,7 @@ class AutoModel:
speech, speech_lengths, sorted_data[beg_idx:end_idx]
)
results = self.inference(
- speech_j, input_len=None, model=model, kwargs=kwargs, **cfg
+ speech_j, input_len=None, model=model, kwargs=kwargs, **{**cfg, "fs": fs}
)
if self.spk_model is not None:
# compose vad segments: [[start_time_sec, end_time_sec, speech], [...]]
@@ -1435,7 +1455,8 @@ class AutoModel:
type = kwargs.get("type", "onnx")
key_list, data_list = prepare_data_iterator(
- input, input_len=None, data_type=kwargs.get("data_type", None), key=None
+ input, input_len=None, data_type=kwargs.get("data_type", None), key=None,
+ input_format=kwargs.get("input_format", "auto"),
)
with torch.no_grad():
diff --git a/funasr/utils/load_utils.py b/funasr/utils/load_utils.py
index 35c341c87..b689d65ec 100644
--- a/funasr/utils/load_utils.py
+++ b/funasr/utils/load_utils.py
@@ -312,15 +312,25 @@ def _is_audio_container(data: bytes) -> bool:
return False
-def load_bytes(input):
+def load_bytes(input, input_format="auto"):
"""Convert raw PCM or container-formatted audio bytes to a waveform.
Args:
input (bytes): Raw int16 PCM or encoded audio-file bytes.
+ input_format (str): "auto" preserves format detection. "pcm_s16le"
+ reads mono signed little-endian PCM16 without probing or decoding.
Returns:
- numpy.ndarray: Mono float32 samples at 16 kHz.
+ numpy.ndarray: Normalized float32 samples. Containers are resampled to
+ 16 kHz; raw PCM keeps its source rate and is not resampled here.
"""
+ if input_format not in ("auto", "pcm_s16le"):
+ raise ValueError("input_format must be 'auto' or 'pcm_s16le'")
+ if input_format == "pcm_s16le":
+ if len(input) % 2:
+ raise ValueError("PCM16 input must contain complete 2-byte samples")
+ return np.frombuffer(input, dtype="<i2").astype(np.float32) / 32768.0
+
if _is_audio_container(input):
try:
waveform = load_audio_text_image_video(BytesIO(input), fs=16000)
diff --git a/tests/test_pcm_input_format.py b/tests/test_pcm_input_format.py
new file mode 100644
index 000000000..94e32a192
--- /dev/null
+++ b/tests/test_pcm_input_format.py
@@ -0,0 +1,237 @@
+"""Explicit PCM routing tests; no model weights or inference are required."""
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import torch
+
+from funasr.auto.auto_model import AutoModel, prepare_data_iterator
+from funasr.utils import load_utils
+
+
+def _ambiguous_pcm():
+ data = bytearray(6400)
+ for offset in (0, 417):
+ data[offset : offset + 4] = b"\xff\xfb\x90\x00"
+ return bytes(data)
+
+
+def _expected(data):
+ return np.frombuffer(data, dtype="<i2").astype(np.float32) / 32768.0
+
+
+def _forbid_decode(*args, **kwargs):
+ raise AssertionError("container decoding must not run for explicit PCM")
+
+
+ "data",
+ [
+ b"",
+ b"\x00\x80\xff\xff\x00\x00\x01\x00\xff\x7f",
+ b"RIFF\x00\x00\x00\x00WAVE\x00\x00",
+ b"ID3\x00",
+ _ambiguous_pcm(),
+ ],
+ ids=["empty", "limits", "wav-like", "id3-like", "mpeg-like"],
+)
+def test_explicit_pcm_never_probes_or_decodes(data, monkeypatch):
+ monkeypatch.setattr(load_utils, "_is_audio_container", _forbid_decode)
+ monkeypatch.setattr(load_utils, "load_audio_text_image_video", _forbid_decode)
+ actual = load_utils.load_bytes(data, input_format="pcm_s16le")
+ assert actual.dtype == np.float32
+ np.testing.assert_array_equal(actual, _expected(data))
+
+
+def test_ambiguous_pcm_really_matches_automatic_container_detection(monkeypatch):
+ data = _ambiguous_pcm()
+ assert load_utils._is_audio_container(data)
+ decoded = np.array([0.25, -0.25], dtype=np.float32)
+ monkeypatch.setattr(
+ load_utils, "load_audio_text_image_video", lambda *a, **kw: decoded
+ )
+ np.testing.assert_array_equal(load_utils.load_bytes(data), decoded)
+
+
[email protected]("value", ["pcm", "wav", None])
+def test_invalid_byte_format_is_rejected(value):
+ with pytest.raises(ValueError, match="input_format"):
+ load_utils.load_bytes(b"\x00\x00", input_format=value)
+
+
+def test_partial_pcm_sample_is_rejected_without_probing(monkeypatch):
+ monkeypatch.setattr(load_utils, "_is_audio_container", _forbid_decode)
+ with pytest.raises(ValueError, match="complete 2-byte samples"):
+ load_utils.load_bytes(b"\x00", input_format="pcm_s16le")
+
+
[email protected]("batch", [False, True])
+def test_iterator_decodes_explicit_pcm_and_preserves_keys(batch, monkeypatch):
+ monkeypatch.setattr(load_utils, "load_audio_text_image_video", _forbid_decode)
+ data = _ambiguous_pcm()
+ value = [data, data] if batch else data
+ keys, samples = prepare_data_iterator(
+ value, input_format="pcm_s16le", key="session"
+ )
+ assert keys == ["session"] * (2 if batch else 1)
+ for sample in samples:
+ np.testing.assert_array_equal(sample, _expected(data))
+
+
+def test_multimodal_iterator_forwards_byte_format(monkeypatch):
+ monkeypatch.setattr(load_utils, "load_audio_text_image_video", _forbid_decode)
+ data = _ambiguous_pcm()
+ keys, values = prepare_data_iterator(
+ ([data], ["context"]), data_type=("sound", "text"),
+ input_format="pcm_s16le"
+ )
+ assert len(keys) == len(values) == 1
+ np.testing.assert_array_equal(values[0][0], _expected(data))
+ assert values[0][1] == "context"
+
+
+def test_default_batch_behavior_is_unchanged():
+ data = [_ambiguous_pcm()]
+ _, values = prepare_data_iterator(data)
+ assert values is data
+
+
+class _RecordingModel(torch.nn.Module):
+ def __init__(self, vad=False):
+ super().__init__()
+ self.anchor = torch.nn.Parameter(torch.zeros(1))
+ self.vad = vad
+ self.segments = []
+ self.calls = []
+
+ def inference(self, data_in, key, **kwargs):
+ self.calls.append((data_in, kwargs))
+ if self.vad:
+ results = [{"key": k, "value": self.segments} for k in key]
+ else:
+ results = [{"key": k, "text": "ok"} for k in key]
+ return results, {"batch_data_time": 0.2}
+
+
+def _wrapper(vad=False, default_format=None):
+ wrapper = AutoModel.__new__(AutoModel)
+ wrapper.model = _RecordingModel()
+ wrapper.vad_model = _RecordingModel(vad=True) if vad else None
+ wrapper.punc_model = None
+ wrapper.spk_model = None
+ wrapper.kwargs = {
+ "device": "cpu", "disable_pbar": True, "model": "pcm-routing-probe",
+ "frontend": SimpleNamespace(fs=16000), "ncpu": torch.get_num_threads(),
+ }
+ if default_format is not None:
+ wrapper.kwargs["input_format"] = default_format
+ wrapper.vad_kwargs = {"device": "cpu", "disable_pbar": True}
+ wrapper._store_base_configs()
+ return wrapper
+
+
[email protected]("vad", [False, True])
[email protected]("at_construction", [False, True])
+def test_generate_forwards_pcm_format_without_model_download(
+ vad, at_construction, monkeypatch
+):
+ monkeypatch.setattr(load_utils, "load_audio_text_image_video", _forbid_decode)
+ wrapper = _wrapper(vad, "pcm_s16le" if at_construction else None)
+ options = {} if at_construction else {"input_format": "pcm_s16le"}
+ data = _ambiguous_pcm()
+ result = wrapper.generate(input=data, fs=16000, **options)
+ recorder = wrapper.vad_model if vad else wrapper.model
+ np.testing.assert_array_equal(recorder.calls[0][0][0], _expected(data))
+ assert result[0]["text"] == ("" if vad else "ok")
+
+
+def test_generate_pcm_flag_does_not_leak_to_next_call(monkeypatch):
+ monkeypatch.setattr(load_utils, "load_audio_text_image_video", _forbid_decode)
+ wrapper = _wrapper()
+ data = _ambiguous_pcm()
+ wrapper.generate(input=data, input_format="pcm_s16le")
+ with pytest.raises(RuntimeError, match="container-formatted"):
+ wrapper.generate(input=data)
+
+
+def test_generate_vad_segments_reach_asr_with_same_samples(monkeypatch):
+ monkeypatch.setattr(load_utils, "load_audio_text_image_video", _forbid_decode)
+ wrapper = _wrapper(vad=True)
+ wrapper.vad_model.segments = [[0, 200]]
+ data = _ambiguous_pcm()
+ result = wrapper.generate(input=data, input_format="pcm_s16le", fs=16000)
+ assert result[0]["text"] == "ok"
+ np.testing.assert_array_equal(wrapper.model.calls[0][0][0], _expected(data))
+
+
+def test_streaming_options_are_preserved(monkeypatch):
+ monkeypatch.setattr(load_utils, "load_audio_text_image_video", _forbid_decode)
+ wrapper = _wrapper()
+ wrapper.generate(
+ input=_ambiguous_pcm(), input_format="pcm_s16le",
+ fs=8000, cache={"marker": 7}, is_final=True, chunk_size=200,
+ )
+ samples, options = wrapper.model.calls[0]
+ assert len(samples[0]) == 3200
+ assert options["fs"] == 8000
+ assert options["cache"] == {"marker": 7}
+ assert options["is_final"] is True
+ assert options["chunk_size"] == 200
+
+
[email protected]("at_construction", [False, True])
+def test_export_preparation_forwards_pcm_format(at_construction, monkeypatch):
+ import importlib
+
+ auto_module = importlib.import_module("funasr.auto.auto_model")
+ monkeypatch.setattr(load_utils, "load_audio_text_image_video", _forbid_decode)
+ wrapper = _wrapper(default_format="pcm_s16le" if at_construction else None)
+ data = _ambiguous_pcm()
+
+ def capture_export(model, data_in, **kwargs):
+ np.testing.assert_array_equal(data_in[0], _expected(data))
+ return "prepared"
+
+ monkeypatch.setattr(auto_module.export_utils, "export", capture_export)
+ options = {} if at_construction else {"input_format": "pcm_s16le"}
+ assert wrapper.export(input=data, **options) == "prepared"
+
+
[email protected]("source_rate", [8000, 48000])
[email protected]("batch", [False, True])
[email protected]("at_construction", [False, True])
[email protected]("input_kind", ["array", "pcm"])
+def test_vad_source_rates_are_not_reapplied_to_resampled_segments(
+ source_rate, batch, at_construction, input_kind, monkeypatch
+):
+ count = source_rate // 5
+ pcm = np.round(
+ np.sin(2 * np.pi * 440 * np.arange(count) / source_rate) * 12000
+ ).astype("<i2").tobytes()
+ waveform = _expected(pcm)
+ expected = load_utils.load_audio_text_image_video(
+ waveform, fs=16000, audio_fs=source_rate
+ )
+ monkeypatch.setattr(load_utils, "_is_audio_container", _forbid_decode)
+ wrapper = _wrapper(vad=True)
+ wrapper.vad_model.segments = [[0, 200]]
+ if at_construction:
+ wrapper.kwargs["fs"] = source_rate
+ wrapper._store_base_configs()
+ options = {} if at_construction else {"fs": source_rate}
+ if input_kind == "pcm":
+ options["input_format"] = "pcm_s16le"
+ value = pcm if input_kind == "pcm" else waveform
+ results = wrapper.generate(input=[value, value] if batch else value, **options)
+ assert len(results) == (2 if batch else 1)
+ for _, vad_options in wrapper.vad_model.calls:
+ assert vad_options["fs"] == source_rate
+ for samples, asr_options in wrapper.model.calls:
+ assert asr_options["fs"] == 16000
+ np.testing.assert_allclose(samples[0], expected, atol=1e-6, rtol=0)
+ loaded = load_utils.load_audio_text_image_video(
+ samples[0], fs=16000, audio_fs=asr_options["fs"]
+ )
+ assert len(loaded) == 3200
+ np.testing.assert_allclose(loaded, expected, atol=1e-6, rtol=0)
diff --git a/tests/test_python_api_docs_contract.py b/tests/test_python_api_docs_contract.py
index d4a3de5de..9749b7fa1 100644
--- a/tests/test_python_api_docs_contract.py
+++ b/tests/test_python_api_docs_contract.py
@@ -46,7 +46,7 @@ class PythonApiDocsContract(unittest.TestCase):
"funasr/models/paraformer_streaming/model.py")))
for path in DOCS:
blocks = python_blocks(path)
- self.assertEqual(len(blocks), 5, path.name)
+ self.assertEqual(len(blocks), 6, path.name)
for index, block in enumerate(blocks):
with self.subTest(doc=path.name, block=index):
compile(block, str(path), "exec")