sonusai 0.16.1__py3-none-any.whl → 0.17.2__py3-none-any.whl

sonusai/onnx_predict.py

@@ -1,19 +1,21 @@
-"""sonusai predict
+"""sonusai onnx_predict
 
-usage: predict [-hvr] [-i MIXID] (-m MODEL) INPUT
+usage: onnx_predict [-hvlwr] [--include GLOB] [-i MIXID] MODEL DATA ...
 
 options:
     -h, --help
     -v, --verbose               Be verbose.
     -i MIXID, --mixid MIXID     Mixture ID(s) to generate if input is a mixture database. [default: *].
-    -m MODEL, --model MODEL     Trained ONNX model file.
-    -r, --reset                 Reset model between each file.
+    --include GLOB              Search only files whose base name matches GLOB. [default: *.{wav,flac}].
+    -w, --write-wav             Calculate inverse transform of prediction and write .wav files
 
-Run prediction on a trained ONNX model using SonusAI genft or WAV data.
+Run prediction (inference) using an ONNX model on a SonusAI mixture dataset or audio files from a glob path.
+The ONNX Runtime (ort) inference engine is used to execute the inference.
 
 Inputs:
-    MODEL       A SonusAI trained ONNX model file.
-    INPUT       The input data must be one of the following:
+    MODEL       ONNX model .onnx file of a trained model (weights are expected to be in the file).
+
+    DATA        The input data must be one of the following:
                 * WAV
                   Using the given model, generate feature data and run prediction. A model file must be
                   provided. The MIXID is ignored.
@@ -22,19 +24,30 @@ Inputs:
                   Using the given SonusAI mixture database directory, generate feature and truth data if not found.
                   Run prediction. The MIXID is required.
 
+
+Note there are multiple ways to process model prediction over multiple audio data files:
+1. TSE (timestep single extension): mixture transform frames are fit into the timestep dimension and the model run as
+   a single inference call.  If batch_size is > 1 then run multiple mixtures in one call with shorter mixtures
+   zero-padded to the size of the largest mixture.
+2. TME (timestep multi-extension): mixture is split into multiple timesteps, i.e. batch[0] is starting timesteps, ...
+   Note that batches are run independently, thus sequential state from one set of timesteps to the next will not be
+   maintained, thus results for such models (i.e. conv, LSTMs, in the timestep dimension) would not match using
+   TSE mode.
+
+TBD not sure below make sense, need to continue ??
+2. BSE (batch single extension): mixture transform frames are fit into the batch dimension. This make sense only if
+   independent predictions are made on each frame w/o considering previous frames (timesteps=1) or there is no
+   timestep dimension in the model (timesteps=0).
+3. Classification
+
 Outputs the following to opredict-<TIMESTAMP> directory:
     <id>.h5
         dataset:    predict
     onnx_predict.log
 
 """
-
 import signal
 
-from sonusai.mixture import Feature
-from sonusai.mixture import Predict
-from sonusai.utils import SonusAIMetaData
-
 
 def signal_handler(_sig, _frame):
     import sys
@@ -57,193 +70,138 @@ def main() -> None:
     args = docopt(trim_docstring(__doc__), version=sonusai.__version__, options_first=True)
 
     verbose = args['--verbose']
+    wav = args['--write-wav']
     mixids = args['--mixid']
-    model_name = args['--model']
-    reset = args['--reset']
-    input_name = args['INPUT']
+    include = args['--include']
+    model_path = args['MODEL']
+    data_paths = args['DATA']
 
     from os import makedirs
+    from os.path import abspath
+    from os.path import basename
     from os.path import isdir
     from os.path import join
+    from os.path import normpath
+    from os.path import realpath
     from os.path import splitext
 
     import h5py
-    import onnxruntime as rt
     import numpy as np
+    import onnxruntime as ort
 
     from sonusai import create_file_handler
     from sonusai import initial_log_messages
     from sonusai import logger
     from sonusai import update_console_handler
     from sonusai.mixture import MixtureDatabase
-    from sonusai.mixture import get_feature_from_audio
-    from sonusai.mixture import read_audio
+    from sonusai.mixture import get_audio_from_feature
+    from sonusai.utils import PathInfo
+    from sonusai.utils import braced_iglob
     from sonusai.utils import create_ts_name
-    from sonusai.utils import get_frames_per_batch
-    from sonusai.utils import get_sonusai_metadata
+    from sonusai.utils import load_ort_session
+    from sonusai.utils import reshape_inputs
+    from sonusai.utils import write_wav
 
-    output_dir = create_ts_name('opredict')
+    mixdb_path = None
+    mixdb = None
+    p_mixids = None
+    entries: list[PathInfo] = []
+
+    if len(data_paths) == 1 and isdir(data_paths[0]):
+        # Assume it's a single path to SonusAI mixdb subdir
+        in_basename = basename(normpath(data_paths[0]))
+        mixdb_path = data_paths[0]
+    else:
+        # search all data paths for .wav, .flac (or whatever is specified in include)
+        in_basename = ''
+
+    output_dir = create_ts_name('opredict-' + in_basename)
     makedirs(output_dir, exist_ok=True)
 
     # Setup logging file
-    create_file_handler(join(output_dir, 'onnx_predict.log'))
+    create_file_handler(join(output_dir, 'onnx-predict.log'))
     update_console_handler(verbose)
     initial_log_messages('onnx_predict')
 
-    model = rt.InferenceSession(model_name, providers=['CPUExecutionProvider'])
-    model_metadata = get_sonusai_metadata(model)
-
-    batch_size = model_metadata.input_shape[0]
-    if model_metadata.timestep:
-        timesteps = model_metadata.input_shape[1]
-    else:
-        timesteps = 0
-    num_classes = model_metadata.output_shape[-1]
-
-    frames_per_batch = get_frames_per_batch(batch_size, timesteps)
-
-    logger.info('')
-    logger.info(f'feature       {model_metadata.feature}')
-    logger.info(f'num_classes   {num_classes}')
-    logger.info(f'batch_size    {batch_size}')
-    logger.info(f'timesteps     {timesteps}')
-    logger.info(f'flatten       {model_metadata.flattened}')
-    logger.info(f'add1ch        {model_metadata.channel}')
-    logger.info(f'truth_mutex   {model_metadata.mutex}')
-    logger.info(f'input_shape   {model_metadata.input_shape}')
-    logger.info(f'output_shape  {model_metadata.output_shape}')
-    logger.info('')
-
-    if splitext(input_name)[1] == '.wav':
-        # Convert WAV to feature data
-        logger.info('')
-        logger.info(f'Run prediction on {input_name}')
-        audio = read_audio(input_name)
-        feature = get_feature_from_audio(audio=audio, feature_mode=model_metadata.feature)
-
-        predict = pad_and_predict(feature=feature,
-                                  model_name=model_name,
-                                  model_metadata=model_metadata,
-                                  frames_per_batch=frames_per_batch,
-                                  batch_size=batch_size,
-                                  timesteps=timesteps,
-                                  reset=reset)
-
-        output_name = splitext(input_name)[0] + '.h5'
-        with h5py.File(output_name, 'a') as f:
-            if 'feature' in f:
-                del f['feature']
-            f.create_dataset(name='feature', data=feature)
-
-            if 'predict' in f:
-                del f['predict']
-            f.create_dataset(name='predict', data=predict)
-
-        logger.info(f'Saved results to {output_name}')
-        return
-
-    if not isdir(input_name):
-        logger.exception(f'Do not know how to process input from {input_name}')
-        raise SystemExit(1)
-
-    mixdb = MixtureDatabase(input_name)
+    providers = ort.get_available_providers()
+    logger.info(f'Loaded ONNX Runtime, available providers: {providers}.')
 
-    if mixdb.feature != model_metadata.feature:
-        logger.exception(f'Feature in mixture database does not match feature in model')
+    session, options, model_root, hparams, sess_inputs, sess_outputs = load_ort_session(model_path)
+    if hparams is None:
+        logger.error(f'Error: ONNX model does not have required SonusAI hyperparameters, cannot proceed.')
         raise SystemExit(1)
-
-    mixids = mixdb.mixids_to_list(mixids)
-    if reset:
-        # reset mode cycles through each file one at a time
-        for mixid in mixids:
-            feature, _ = mixdb.mixture_ft(mixid)
-
-            predict = pad_and_predict(feature=feature,
-                                      model_name=model_name,
-                                      model_metadata=model_metadata,
-                                      frames_per_batch=frames_per_batch,
-                                      batch_size=batch_size,
-                                      timesteps=timesteps,
-                                      reset=reset)
-
-            output_name = join(output_dir, mixdb.mixtures[mixid].name)
-            with h5py.File(output_name, 'a') as f:
-                if 'predict' in f:
-                    del f['predict']
-                f.create_dataset(name='predict', data=predict)
+    if len(sess_inputs) != 1:
+        logger.error(f'Error: ONNX model does not have 1 input, but {len(sess_inputs)}. Exit due to unknown input.')
+
+    in0name = sess_inputs[0].name
+    in0type = sess_inputs[0].type
+    out_names = [n.name for n in session.get_outputs()]
+
+    logger.info(f'Read and compiled ONNX model from {model_path}.')
+
+    if mixdb_path is not None:
+        # Assume it's a single path to SonusAI mixdb subdir
+        logger.debug(f'Attempting to load mixture database from {mixdb_path}')
+        mixdb = MixtureDatabase(mixdb_path)
+        logger.info(f'SonusAI mixdb: found {mixdb.num_mixtures} mixtures with {mixdb.num_classes} classes')
+        p_mixids = mixdb.mixids_to_list(mixids)
+        if len(p_mixids) != mixdb.num_mixtures:
+            logger.info(f'Processing a subset of {p_mixids} from available mixtures.')
+    else:
+        for p in data_paths:
+            location = join(realpath(abspath(p)), '**', include)
+            logger.debug(f'Processing {location}')
+            for file in braced_iglob(pathname=location, recursive=True):
+                name = file
+                entries.append(PathInfo(abs_path=file, audio_filepath=name))
+        logger.info(f'{len(data_paths)} data paths specified, found {len(entries)} audio files.')
+
+    if in0type.find('float16') != -1:
+        model_is_fp16 = True
+        logger.info(f'Detected input of float16, converting all feature inputs to that type.')
     else:
-        features: list[Feature] = []
-        file_indices: list[slice] = []
-        total_frames = 0
-        for mixid in mixids:
-            current_feature, _ = mixdb.mixture_ft(mixid)
-            current_frames = current_feature.shape[0]
-            features.append(current_feature)
-            file_indices.append(slice(total_frames, total_frames + current_frames))
-            total_frames += current_frames
-        feature = np.vstack([features[i] for i in range(len(features))])
-
-        predict = pad_and_predict(feature=feature,
-                                  model_name=model_name,
-                                  model_metadata=model_metadata,
-                                  frames_per_batch=frames_per_batch,
-                                  batch_size=batch_size,
-                                  timesteps=timesteps,
-                                  reset=reset)
-
-        # Write data to separate files
-        for idx, mixid in enumerate(mixids):
-            output_name = join(output_dir, mixdb.mixtures[mixid].name)
-            with h5py.File(output_name, 'a') as f:
+        model_is_fp16 = False
+
+    if mixdb_path is not None and hparams['batch_size'] == 1:
+        # mixdb input
+        # Assume (of course) that mixdb feature, etc. is what model expects
+        if hparams['feature'] != mixdb.feature:
+            logger.warning(f'Mixture feature does not match model feature, this inference run may fail.')
+        # no choice, can't use hparams.feature since it's different from the mixdb
+        feature_mode = mixdb.feature
+
+        for mixid in p_mixids:
+            # frames x stride x feature_params
+            feature, _ = mixdb.mixture_ft(mixid)
+            if hparams['timesteps'] == 0:
+                # no timestep dimension, reshape will handle
+                timesteps = 0
+            else:
+                # fit frames into timestep dimension (TSE mode)
+                timesteps = feature.shape[0]
+
+            feature, _ = reshape_inputs(feature=feature,
+                                        batch_size=1,
+                                        timesteps=timesteps,
+                                        flatten=hparams['flatten'],
+                                        add1ch=hparams['add1ch'])
+            if model_is_fp16:
+                feature = np.float16(feature)  # type: ignore
+            # run inference, ort session wants i.e. batch x timesteps x feat_params, outputs numpy BxTxFP or BxFP
+            predict = session.run(out_names, {in0name: feature})[0]
+            # predict, _ = reshape_outputs(predict=predict[0], timesteps=frames)  # frames x feat_params
+            output_fname = join(output_dir, mixdb.mixtures[mixid].name)
+            with h5py.File(output_fname, 'a') as f:
                 if 'predict' in f:
                     del f['predict']
-                f.create_dataset('predict', data=predict[file_indices[idx]])
-
-    logger.info(f'Saved results to {output_dir}')
-
-
-def pad_and_predict(feature: Feature,
-                    model_name: str,
-                    model_metadata: SonusAIMetaData,
-                    frames_per_batch: int,
-                    batch_size: int,
-                    timesteps: int,
-                    reset: bool) -> Predict:
-    import onnxruntime as rt
-    import numpy as np
-
-    from sonusai.utils import reshape_inputs
-    from sonusai.utils import reshape_outputs
-
-    frames = feature.shape[0]
-    padding = frames_per_batch - frames % frames_per_batch
-    feature = np.pad(array=feature, pad_width=((0, padding), (0, 0), (0, 0)))
-    feature, _ = reshape_inputs(feature=feature,
-                                batch_size=batch_size,
-                                timesteps=timesteps,
-                                flatten=model_metadata.flattened,
-                                add1ch=model_metadata.channel)
-    sequences = feature.shape[0] // model_metadata.input_shape[0]
-    feature = np.reshape(feature, [sequences, *model_metadata.input_shape])
-
-    model = rt.InferenceSession(model_name, providers=['CPUExecutionProvider'])
-    output_names = [n.name for n in model.get_outputs()]
-    input_names = [n.name for n in model.get_inputs()]
-
-    predict = []
-    for sequence in range(sequences):
-        predict.append(model.run(output_names, {input_names[0]: feature[sequence]}))
-        if reset:
-            model = rt.InferenceSession(model_name, providers=['CPUExecutionProvider'])
-
-    predict_arr = np.vstack(predict)
-    # Combine [sequences, batch_size, ...] into [frames, ...]
-    predict_shape = predict_arr.shape
-    predict_arr = np.reshape(predict_arr, [predict_shape[0] * predict_shape[1], *predict_shape[2:]])
-    predict_arr, _ = reshape_outputs(predict=predict_arr, timesteps=timesteps)
-    predict_arr = predict_arr[:frames, :]
-
-    return predict_arr
+                f.create_dataset('predict', data=predict)
+            if wav:
+                # note only makes sense if model is predicting audio, i.e., timestep dimension exists
+                # predict_audio wants [frames, channels, feature_parameters] equivalent to timesteps, batch, bins
+                predict = np.transpose(predict, [1, 0, 2])
+                predict_audio = get_audio_from_feature(feature=predict, feature_mode=feature_mode)
+                owav_name = splitext(output_fname)[0] + '_predict.wav'
+                write_wav(owav_name, predict_audio)
 
 
 if __name__ == '__main__':

sonusai/queries/queries.py

@@ -134,7 +134,7 @@ def get_mixids_from_target(mixdb: MixtureDatabase,
     """
     return get_mixids_from_mixture_field_predicate(mixdb=mixdb,
                                                    mixids=mixids,
-                                                   field='target_id',
+                                                   field='target_ids',
                                                    predicate=predicate)
 
 

sonusai/speech/__init__.py

@@ -0,0 +1,3 @@
+from .textgrid import annotate_textgrid
+from .textgrid import create_textgrid
+from .types import TimeAlignedType

sonusai/speech/l2arctic.py

@@ -0,0 +1,116 @@
+import os
+import string
+from pathlib import Path
+from typing import Optional
+
+from .types import TimeAlignedType
+
+
+def _get_duration(name: str) -> float:
+    import soundfile
+
+    from sonusai import SonusAIError
+
+    try:
+        return soundfile.info(name).duration
+    except Exception as e:
+        raise SonusAIError(f'Error reading {name}: {e}')
+
+
+def load_text(audio: str | os.PathLike[str]) -> Optional[TimeAlignedType]:
+    """Load time-aligned text data given a L2-ARCTIC audio file.
+
+    :param audio: Path to the L2-ARCTIC audio file.
+    :return: A TimeAlignedType object.
+    """
+    file = Path(audio).parent.parent / 'transcript' / (Path(audio).stem + '.txt')
+    if not os.path.exists(file):
+        return None
+
+    with open(file, mode='r', encoding='utf-8') as f:
+        line = f.read()
+
+    return TimeAlignedType(0,
+                           _get_duration(str(audio)),
+                           line.strip().lower().translate(str.maketrans('', '', string.punctuation)))
+
+
+def load_words(audio: str | os.PathLike[str]) -> Optional[list[TimeAlignedType]]:
+    """Load time-aligned word data given a L2-ARCTIC audio file.
+
+    :param audio: Path to the L2-ARCTIC audio file.
+    :return: A list of TimeAlignedType objects.
+    """
+    return _load_ta(audio, 'words')
+
+
+def load_phonemes(audio: str | os.PathLike[str]) -> Optional[list[TimeAlignedType]]:
+    """Load time-aligned phonemes data given a L2-ARCTIC audio file.
+
+    :param audio: Path to the L2-ARCTIC audio file.
+    :return: A list of TimeAlignedType objects.
+    """
+    return _load_ta(audio, 'phones')
+
+
+def _load_ta(audio: str | os.PathLike[str], tier: str) -> Optional[list[TimeAlignedType]]:
+    from praatio import textgrid
+
+    file = Path(audio).parent.parent / 'textgrid' / (Path(audio).stem + '.TextGrid')
+    if not os.path.exists(file):
+        return None
+
+    tg = textgrid.openTextgrid(str(file), includeEmptyIntervals=False)
+    if tier not in tg.tierNames:
+        return None
+
+    entries: list[TimeAlignedType] = []
+    for entry in tg.getTier(tier).entries:
+        entries.append(TimeAlignedType(text=entry.label, start=entry.start, end=entry.end))
+
+    return entries
+
+
+def load_annotations(audio: str | os.PathLike[str]) -> Optional[dict[str, list[TimeAlignedType]]]:
+    """Load time-aligned annotation data given a L2-ARCTIC audio file.
+
+    :param audio: Path to the L2-ARCTIC audio file.
+    :return: A dictionary of a list of TimeAlignedType objects.
+    """
+    from praatio import textgrid
+
+    file = Path(audio).parent.parent / 'annotation' / (Path(audio).stem + '.TextGrid')
+    if not os.path.exists(file):
+        return None
+
+    tg = textgrid.openTextgrid(str(file), includeEmptyIntervals=False)
+    result: dict[str, list[TimeAlignedType]] = {}
+    for tier in tg.tierNames:
+        entries: list[TimeAlignedType] = []
+        for entry in tg.getTier(tier).entries:
+            entries.append(TimeAlignedType(text=entry.label, start=entry.start, end=entry.end))
+        result[tier] = entries
+
+    return result
+
+
+def load_speakers(input_dir: Path) -> dict:
+    speakers = {}
+    with open(input_dir / 'readme-download.txt') as file:
+        processing = False
+        for line in file:
+            if not processing and line.startswith('|---|'):
+                processing = True
+                continue
+
+            if processing:
+                if line.startswith('|**Total**|'):
+                    break
+                else:
+                    fields = line.strip().split('|')
+                    speaker_id = fields[1]
+                    gender = fields[2]
+                    dialect = fields[3]
+                    speakers[speaker_id] = {'gender': gender, 'dialect': dialect}
+
+    return speakers

sonusai/speech/librispeech.py

@@ -0,0 +1,99 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+from .types import TimeAlignedType
+
+
+def _get_num_samples(audio: str | os.PathLike[str]) -> int:
+    """Get number of samples from audio file using soundfile
+
+    :param audio: Audio file name
+    :return: Number of samples
+    """
+    import soundfile
+    from pydub import AudioSegment
+
+    if Path(audio).suffix == '.mp3':
+        return AudioSegment.from_mp3(audio).frame_count()
+
+    if Path(audio).suffix == '.m4a':
+        return AudioSegment.from_file(audio).frame_count()
+
+    return soundfile.info(audio).frames
+
+
+def load_text(audio: str | os.PathLike[str]) -> Optional[TimeAlignedType]:
+    """Load text data from a LibriSpeech transcription file given a LibriSpeech audio filename.
+
+    :param audio: Path to the LibriSpeech audio file.
+    :return: A TimeAlignedType object.
+    """
+    import string
+
+    from sonusai.mixture import get_sample_rate
+
+    path = Path(audio)
+    name = path.stem
+    transcript_filename = path.parent / f'{path.parent.parent.name}-{path.parent.name}.trans.txt'
+
+    if not os.path.exists(transcript_filename):
+        return None
+
+    with open(transcript_filename, mode='r', encoding='utf-8') as f:
+        for line in f.readlines():
+            fields = line.strip().split()
+            key = fields[0]
+            if key == name:
+                text = ' '.join(fields[1:]).lower().translate(str.maketrans('', '', string.punctuation))
+                return TimeAlignedType(0, _get_num_samples(audio) / get_sample_rate(str(audio)), text)
+
+    return None
+
+
+def load_words(audio: str | os.PathLike[str]) -> Optional[list[TimeAlignedType]]:
+    """Load time-aligned word data given a LibriSpeech audio file.
+
+    :param audio: Path to the Librispeech audio file.
+    :return: A list of TimeAlignedType objects.
+    """
+    return _load_ta(audio, 'words')
+
+
+def load_phonemes(audio: str | os.PathLike[str]) -> Optional[list[TimeAlignedType]]:
+    """Load time-aligned phonemes data given a LibriSpeech audio file.
+
+    :param audio: Path to the LibriSpeech audio file.
+    :return: A list of TimeAlignedType objects.
+    """
+    return _load_ta(audio, 'phones')
+
+
+def _load_ta(audio: str | os.PathLike[str], tier: str) -> Optional[list[TimeAlignedType]]:
+    from praatio import textgrid
+
+    file = Path(audio).with_suffix('.TextGrid')
+    if not os.path.exists(file):
+        return None
+
+    tg = textgrid.openTextgrid(str(file), includeEmptyIntervals=False)
+    if tier not in tg.tierNames:
+        return None
+
+    entries: list[TimeAlignedType] = []
+    for entry in tg.getTier(tier).entries:
+        entries.append(TimeAlignedType(text=entry.label, start=entry.start, end=entry.end))
+
+    return entries
+
+
+def load_speakers(input_dir: Path) -> dict:
+    speakers = {}
+    with open(input_dir / 'SPEAKERS.TXT') as file:
+        for line in file:
+            if not line.startswith(';'):
+                fields = line.strip().split('|')
+                speaker_id = fields[0].strip()
+                gender = fields[1].strip()
+                speakers[speaker_id] = {'gender': gender}
+    return speakers

sonusai/speech/mcgill.py

@@ -0,0 +1,70 @@
+import os
+from typing import Optional
+
+from .types import TimeAlignedType
+
+
+def load_text(audio: str | os.PathLike[str]) -> Optional[TimeAlignedType]:
+    """Load time-aligned text data given a McGill-Speech audio file.
+
+    :param audio: Path to the McGill-Speech audio file.
+    :return: A TimeAlignedType object.
+    """
+    import string
+    import struct
+
+    from sonusai.mixture import get_sample_rate
+
+    if not os.path.exists(audio):
+        return None
+
+    sample_rate = get_sample_rate(str(audio))
+
+    with open(audio, mode='rb') as f:
+        content = f.read()
+
+    riff_id, file_size, wave_id = struct.unpack('<4si4s', content[:12])
+    if riff_id.decode('utf-8') != 'RIFF':
+        return None
+
+    if wave_id.decode('utf-8') != 'WAVE':
+        return None
+
+    fmt_id, fmt_size = struct.unpack('<4si', content[12:20])
+
+    if fmt_id.decode('utf-8') != 'fmt ':
+        return None
+
+    if fmt_size != 16:
+        return None
+
+    (_wave_format_tag,
+     channels,
+     _samples_per_sec,
+     _avg_bytes_per_sec,
+     _block_align,
+     bits_per_sample) = struct.unpack('<hhiihh', content[20:36])
+
+    i = 36
+    samples = None
+    text = None
+    while i < file_size:
+        chunk_id = struct.unpack('<4s', content[i:i + 4])[0].decode('utf-8')
+        chunk_size = struct.unpack('<i', content[i + 4:i + 8])[0]
+
+        if chunk_id == 'data':
+            samples = chunk_size / channels / (bits_per_sample / 8)
+            break
+
+        if chunk_id == 'afsp':
+            chunks = struct.unpack(f'<{chunk_size}s', content[i + 8:i + 8 + chunk_size])[0]
+            chunks = chunks.decode('utf-8').split('\x00')
+            for chunk in chunks:
+                if chunk.startswith('text: "'):
+                    text = chunk[7:-1].lower().translate(str.maketrans('', '', string.punctuation))
+        i += 8 + chunk_size + chunk_size % 2
+
+    if text and samples:
+        return TimeAlignedType(start=0, end=samples / sample_rate, text=text)
+
+    return None