torchaudio 2.7.1__cp310-cp310-win_amd64.whl → 2.9.0__cp310-cp310-win_amd64.whl

torchaudio/backend/sox_io_backend.py

@@ -1,14 +0,0 @@
-def __getattr__(name: str):
-    import warnings
-
-    warnings.warn(
-        "Torchaudio's I/O functions now support par-call bakcend dispatch. "
-        "Importing backend implementation directly is no longer guaranteed to work. "
-        "Please use `backend` keyword with load/save/info function, instead of "
-        "calling the udnerlying implementation directly.",
-        stacklevel=2,
-    )
-
-    from . import _sox_io_backend
-
-    return getattr(_sox_io_backend, name)

torchaudio/io/__init__.py

@@ -1,13 +0,0 @@
-from torio.io import CodecConfig, StreamingMediaDecoder as StreamReader, StreamingMediaEncoder as StreamWriter
-
-from ._effector import AudioEffector
-from ._playback import play_audio
-
-
-__all__ = [
-    "AudioEffector",
-    "StreamReader",
-    "StreamWriter",
-    "CodecConfig",
-    "play_audio",
-]

torchaudio/io/_effector.py

@@ -1,347 +0,0 @@
-import io
-from typing import Iterator, List, Optional
-
-import torch
-from torch import Tensor
-
-from torio.io._streaming_media_decoder import _get_afilter_desc, StreamingMediaDecoder as StreamReader
-from torio.io._streaming_media_encoder import CodecConfig, StreamingMediaEncoder as StreamWriter
-
-
-class _StreamingIOBuffer:
-    """Streaming Bytes IO buffer. Data are dropped when read."""
-
-    def __init__(self):
-        self._buffer: List(bytes) = []
-
-    def write(self, b: bytes):
-        if b:
-            self._buffer.append(b)
-        return len(b)
-
-    def pop(self, n):
-        """Pop the oldest byte string. It does not necessary return the requested amount"""
-        if not self._buffer:
-            return b""
-        if len(self._buffer[0]) <= n:
-            return self._buffer.pop(0)
-        ret = self._buffer[0][:n]
-        self._buffer[0] = self._buffer[0][n:]
-        return ret
-
-
-def _get_sample_fmt(dtype: torch.dtype):
-    types = {
-        torch.uint8: "u8",
-        torch.int16: "s16",
-        torch.int32: "s32",
-        torch.float32: "flt",
-        torch.float64: "dbl",
-    }
-    if dtype not in types:
-        raise ValueError(f"Unsupported dtype is provided {dtype}. Supported dtypes are: {types.keys()}")
-    return types[dtype]
-
-
-class _AudioStreamingEncoder:
-    """Given a waveform, encode on-demand and return bytes"""
-
-    def __init__(
-        self,
-        src: Tensor,
-        sample_rate: int,
-        effect: str,
-        muxer: str,
-        encoder: Optional[str],
-        codec_config: Optional[CodecConfig],
-        frames_per_chunk: int,
-    ):
-        self.src = src
-        self.buffer = _StreamingIOBuffer()
-        self.writer = StreamWriter(self.buffer, format=muxer)
-        self.writer.add_audio_stream(
-            num_channels=src.size(1),
-            sample_rate=sample_rate,
-            format=_get_sample_fmt(src.dtype),
-            encoder=encoder,
-            filter_desc=effect,
-            codec_config=codec_config,
-        )
-        self.writer.open()
-        self.fpc = frames_per_chunk
-
-        # index on the input tensor (along time-axis)
-        # we use -1 to indicate that we finished iterating the tensor and
-        # the writer is closed.
-        self.i_iter = 0
-
-    def read(self, n):
-        while not self.buffer._buffer and self.i_iter >= 0:
-            self.writer.write_audio_chunk(0, self.src[self.i_iter : self.i_iter + self.fpc])
-            self.i_iter += self.fpc
-            if self.i_iter >= self.src.size(0):
-                self.writer.flush()
-                self.writer.close()
-                self.i_iter = -1
-        return self.buffer.pop(n)
-
-
-def _encode(
-    src: Tensor,
-    sample_rate: int,
-    effect: str,
-    muxer: str,
-    encoder: Optional[str],
-    codec_config: Optional[CodecConfig],
-):
-    buffer = io.BytesIO()
-    writer = StreamWriter(buffer, format=muxer)
-    writer.add_audio_stream(
-        num_channels=src.size(1),
-        sample_rate=sample_rate,
-        format=_get_sample_fmt(src.dtype),
-        encoder=encoder,
-        filter_desc=effect,
-        codec_config=codec_config,
-    )
-    with writer.open():
-        writer.write_audio_chunk(0, src)
-    buffer.seek(0)
-    return buffer
-
-
-def _get_muxer(dtype: torch.dtype):
-    # TODO: check if this works in Windows.
-    types = {
-        torch.uint8: "u8",
-        torch.int16: "s16le",
-        torch.int32: "s32le",
-        torch.float32: "f32le",
-        torch.float64: "f64le",
-    }
-    if dtype not in types:
-        raise ValueError(f"Unsupported dtype is provided {dtype}. Supported dtypes are: {types.keys()}")
-    return types[dtype]
-
-
-class AudioEffector:
-    """Apply various filters and/or codecs to waveforms.
-
-    .. versionadded:: 2.1
-
-    Args:
-        effect (str or None, optional): Filter expressions or ``None`` to apply no filter.
-            See https://ffmpeg.org/ffmpeg-filters.html#Audio-Filters for the
-            details of filter syntax.
-
-        format (str or None, optional): When provided, encode the audio into the
-            corresponding format. Default: ``None``.
-
-        encoder (str or None, optional): When provided, override the encoder used
-            by the ``format``. Default: ``None``.
-
-        codec_config (CodecConfig or None, optional): When provided, configure the encoding codec.
-            Should be provided in conjunction with ``format`` option.
-
-        pad_end (bool, optional): When enabled, and if the waveform becomes shorter after applying
-            effects/codec, then pad the end with silence.
-
-    Example - Basic usage
-        To use ``AudioEffector``, first instantiate it with a set of
-        ``effect`` and ``format``.
-
-        >>> # instantiate the effector
-        >>> effector = AudioEffector(effect=..., format=...)
-
-        Then, use :py:meth:`~AudioEffector.apply` or :py:meth:`~AudioEffector.stream`
-        method to apply them.
-
-        >>> # Apply the effect to the whole waveform
-        >>> applied = effector.apply(waveform, sample_rate)
-
-        >>> # Apply the effect chunk-by-chunk
-        >>> for chunk in effector.stream(waveform, sample_rate):
-        >>>    ...
-
-    Example - Applying effects
-        Please refer to
-        https://ffmpeg.org/ffmpeg-filters.html#Filtergraph-description
-        for the overview of filter description, and
-        https://ffmpeg.org/ffmpeg-filters.html#toc-Audio-Filters
-        for the list of available filters.
-
-        Tempo - https://ffmpeg.org/ffmpeg-filters.html#atempo
-
-        >>> AudioEffector(effect="atempo=1.5")
-
-        Echo - https://ffmpeg.org/ffmpeg-filters.html#aecho
-
-        >>> AudioEffector(effect="aecho=0.8:0.88:60:0.4")
-
-        Flanger - https://ffmpeg.org/ffmpeg-filters.html#flanger
-
-        >>> AudioEffector(effect="aflanger")
-
-        Vibrato - https://ffmpeg.org/ffmpeg-filters.html#vibrato
-
-        >>> AudioEffector(effect="vibrato")
-
-        Tremolo - https://ffmpeg.org/ffmpeg-filters.html#tremolo
-
-        >>> AudioEffector(effect="vibrato")
-
-        You can also apply multiple effects at once.
-
-        >>> AudioEffector(effect="")
-
-    Example - Applying codec
-        One can apply codec using ``format`` argument. ``format`` can be
-        audio format or container format. If the container format supports
-        multiple encoders, you can specify it with ``encoder`` argument.
-
-        Wav format
-        (no compression is applied but samples are converted to
-        16-bit signed integer)
-
-        >>> AudioEffector(format="wav")
-
-        Ogg format with default encoder
-
-        >>> AudioEffector(format="ogg")
-
-        Ogg format with vorbis
-
-        >>> AudioEffector(format="ogg", encoder="vorbis")
-
-        Ogg format with opus
-
-        >>> AudioEffector(format="ogg", encoder="opus")
-
-        Webm format with opus
-
-        >>> AudioEffector(format="webm", encoder="opus")
-
-    Example - Applying codec with configuration
-        Reference: https://trac.ffmpeg.org/wiki/Encode/MP3
-
-        MP3 with default config
-
-        >>> AudioEffector(format="mp3")
-
-        MP3 with variable bitrate
-
-        >>> AudioEffector(format="mp3", codec_config=CodecConfig(qscale=5))
-
-        MP3 with constant bitrate
-
-        >>> AudioEffector(format="mp3", codec_config=CodecConfig(bit_rate=32_000))
-    """
-
-    def __init__(
-        self,
-        effect: Optional[str] = None,
-        format: Optional[str] = None,
-        *,
-        encoder: Optional[str] = None,
-        codec_config: Optional[CodecConfig] = None,
-        pad_end: bool = True,
-    ):
-        if format is None:
-            if encoder is not None or codec_config is not None:
-                raise ValueError("`encoder` and/or `condec_config` opions are provided without `format` option.")
-        self.effect = effect
-        self.format = format
-        self.encoder = encoder
-        self.codec_config = codec_config
-        self.pad_end = pad_end
-
-    def _get_reader(self, waveform, sample_rate, output_sample_rate, frames_per_chunk=None):
-        num_frames, num_channels = waveform.shape
-
-        if self.format is not None:
-            muxer = self.format
-            encoder = self.encoder
-            option = {}
-            # Some formats are headerless, so need to provide these infomation.
-            if self.format == "mulaw":
-                option = {"sample_rate": f"{sample_rate}", "channels": f"{num_channels}"}
-
-        else:  # PCM
-            muxer = _get_muxer(waveform.dtype)
-            encoder = None
-            option = {"sample_rate": f"{sample_rate}", "channels": f"{num_channels}"}
-
-        if frames_per_chunk is None:
-            src = _encode(waveform, sample_rate, self.effect, muxer, encoder, self.codec_config)
-        else:
-            src = _AudioStreamingEncoder(
-                waveform, sample_rate, self.effect, muxer, encoder, self.codec_config, frames_per_chunk
-            )
-
-        output_sr = sample_rate if output_sample_rate is None else output_sample_rate
-        filter_desc = _get_afilter_desc(output_sr, _get_sample_fmt(waveform.dtype), num_channels)
-        if self.pad_end:
-            filter_desc = f"{filter_desc},apad=whole_len={num_frames}"
-
-        reader = StreamReader(src, format=muxer, option=option)
-        reader.add_audio_stream(frames_per_chunk or -1, -1, filter_desc=filter_desc)
-        return reader
-
-    def apply(self, waveform: Tensor, sample_rate: int, output_sample_rate: Optional[int] = None) -> Tensor:
-        """Apply the effect and/or codecs to the whole tensor.
-
-        Args:
-            waveform (Tensor): The input waveform. Shape: ``(time, channel)``
-            sample_rate (int): Sample rate of the input waveform.
-            output_sample_rate (int or None, optional): Output sample rate.
-                If provided, override the output sample rate.
-                Otherwise, the resulting tensor is resampled to have
-                the same sample rate as the input.
-                Default: ``None``.
-
-        Returns:
-            Tensor:
-                Resulting Tensor. Shape: ``(time, channel)``. The number of frames
-                could be different from that of the input.
-        """
-        if waveform.ndim != 2:
-            raise ValueError(f"Expected the input waveform to be 2D. Found: {waveform.ndim}")
-
-        if waveform.numel() == 0:
-            return waveform
-
-        reader = self._get_reader(waveform, sample_rate, output_sample_rate)
-        reader.process_all_packets()
-        (applied,) = reader.pop_chunks()
-        return Tensor(applied)
-
-    def stream(
-        self, waveform: Tensor, sample_rate: int, frames_per_chunk: int, output_sample_rate: Optional[int] = None
-    ) -> Iterator[Tensor]:
-        """Apply the effect and/or codecs to the given tensor chunk by chunk.
-
-        Args:
-            waveform (Tensor): The input waveform. Shape: ``(time, channel)``
-            sample_rate (int): Sample rate of the waveform.
-            frames_per_chunk (int): The number of frames to return at a time.
-            output_sample_rate (int or None, optional): Output sample rate.
-                If provided, override the output sample rate.
-                Otherwise, the resulting tensor is resampled to have
-                the same sample rate as the input.
-                Default: ``None``.
-
-        Returns:
-            Iterator[Tensor]:
-                Series of processed chunks. Shape: ``(time, channel)``, where the
-                the number of frames matches ``frames_per_chunk`` except the
-                last chunk, which could be shorter.
-        """
-        if waveform.ndim != 2:
-            raise ValueError(f"Expected the input waveform to be 2D. Found: {waveform.ndim}")
-
-        if waveform.numel() == 0:
-            return waveform
-
-        reader = self._get_reader(waveform, sample_rate, output_sample_rate, frames_per_chunk)
-        for (applied,) in reader.stream():
-            yield Tensor(applied)

torchaudio/io/_playback.py

@@ -1,72 +0,0 @@
-import warnings
-from sys import platform
-from typing import Optional
-
-import torch
-import torchaudio
-
-dict_format = {
-    torch.uint8: "u8",
-    torch.int16: "s16",
-    torch.int32: "s32",
-    torch.int64: "s64",
-    torch.float32: "flt",
-    torch.float64: "dbl",
-}
-
-
-def play_audio(
-    waveform: torch.Tensor,
-    sample_rate: Optional[float],
-    device: Optional[str] = None,
-) -> None:
-    """Plays audio through specified or available output device.
-
-    .. warning::
-       This function is currently only supported on MacOS, and requires
-       libavdevice (FFmpeg) with ``audiotoolbox`` output device.
-
-    .. note::
-       This function can play up to two audio channels.
-
-    Args:
-        waveform: Tensor containing the audio to play.
-            Expected shape: `(time, num_channels)`.
-        sample_rate: Sample rate of the audio to play.
-        device: Output device to use. If None, the default device is used.
-    """
-
-    if platform == "darwin":
-        device = device or "audiotoolbox"
-        path = "-"
-    else:
-        raise ValueError(f"This function only supports MacOS, but current OS is {platform}")
-
-    available_devices = list(torchaudio.utils.ffmpeg_utils.get_output_devices().keys())
-    if device not in available_devices:
-        raise ValueError(f"Device {device} is not available. Available devices are: {available_devices}")
-
-    if waveform.dtype not in dict_format:
-        raise ValueError(f"Unsupported type {waveform.dtype}. The list of supported types is: {dict_format.keys()}")
-    format = dict_format[waveform.dtype]
-
-    if waveform.ndim != 2:
-        raise ValueError(f"Expected 2D tensor with shape `(time, num_channels)`, got {waveform.ndim}D tensor instead")
-
-    time, num_channels = waveform.size()
-    if num_channels > 2:
-        warnings.warn(
-            f"Expected up to 2 channels, got {num_channels} channels instead. "
-            "Only the first 2 channels will be played.",
-            stacklevel=2,
-        )
-
-    # Write to speaker device
-    s = torchaudio.io.StreamWriter(dst=path, format=device)
-    s.add_audio_stream(sample_rate, num_channels, format=format)
-
-    # write audio to the device
-    block_size = 256
-    with s.open():
-        for i in range(0, time, block_size):
-            s.write_audio_chunk(0, waveform[i : i + block_size, :])

torchaudio/kaldi_io.py

@@ -1,144 +0,0 @@
-# To use this file, the dependency (https://github.com/vesis84/kaldi-io-for-python)
-# needs to be installed. This is a light wrapper around kaldi_io that returns
-# torch.Tensors.
-from typing import Any, Callable, Iterable, Tuple
-
-import torch
-from torch import Tensor
-from torchaudio._internal import module_utils as _mod_utils
-
-if _mod_utils.is_module_available("numpy"):
-    import numpy as np
-
-
-__all__ = [
-    "read_vec_int_ark",
-    "read_vec_flt_scp",
-    "read_vec_flt_ark",
-    "read_mat_scp",
-    "read_mat_ark",
-]
-
-
-def _convert_method_output_to_tensor(
-    file_or_fd: Any, fn: Callable, convert_contiguous: bool = False
-) -> Iterable[Tuple[str, Tensor]]:
-    r"""Takes a method invokes it. The output is converted to a tensor.
-
-    Args:
-        file_or_fd (str/FileDescriptor): File name or file descriptor
-        fn (Callable): Function that has the signature (file name/descriptor) and converts it to
-            Iterable[Tuple[str, Tensor]].
-        convert_contiguous (bool, optional): Determines whether the array should be converted into a
-            contiguous layout. (Default: ``False``)
-
-    Returns:
-        Iterable[Tuple[str, Tensor]]: The string is the key and the tensor is vec/mat
-    """
-    for key, np_arr in fn(file_or_fd):
-        if convert_contiguous:
-            np_arr = np.ascontiguousarray(np_arr)
-        yield key, torch.from_numpy(np_arr)
-
-
-@_mod_utils.requires_module("kaldi_io", "numpy")
-def read_vec_int_ark(file_or_fd: Any) -> Iterable[Tuple[str, Tensor]]:
-    r"""Create generator of (key,vector<int>) tuples, which reads from the ark file/stream.
-
-    Args:
-        file_or_fd (str/FileDescriptor): ark, gzipped ark, pipe or opened file descriptor
-
-    Returns:
-        Iterable[Tuple[str, Tensor]]: The string is the key and the tensor is the vector read from file
-
-    Example
-        >>> # read ark to a 'dictionary'
-        >>> d = { u:d for u,d in torchaudio.kaldi_io.read_vec_int_ark(file) }
-    """
-
-    import kaldi_io
-
-    # Requires convert_contiguous to be True because elements from int32 vector are
-    # sorted in tuples: (sizeof(int32), value) so strides are (5,) instead of (4,) which will throw an error
-    # in from_numpy as it expects strides to be a multiple of 4 (int32).
-    return _convert_method_output_to_tensor(file_or_fd, kaldi_io.read_vec_int_ark, convert_contiguous=True)
-
-
-@_mod_utils.requires_module("kaldi_io", "numpy")
-def read_vec_flt_scp(file_or_fd: Any) -> Iterable[Tuple[str, Tensor]]:
-    r"""Create generator of (key,vector<float32/float64>) tuples, read according to Kaldi scp.
-
-    Args:
-        file_or_fd (str/FileDescriptor): scp, gzipped scp, pipe or opened file descriptor
-
-    Returns:
-        Iterable[Tuple[str, Tensor]]: The string is the key and the tensor is the vector read from file
-
-    Example
-        >>> # read scp to a 'dictionary'
-        >>> # d = { u:d for u,d in torchaudio.kaldi_io.read_vec_flt_scp(file) }
-    """
-
-    import kaldi_io
-
-    return _convert_method_output_to_tensor(file_or_fd, kaldi_io.read_vec_flt_scp)
-
-
-@_mod_utils.requires_module("kaldi_io", "numpy")
-def read_vec_flt_ark(file_or_fd: Any) -> Iterable[Tuple[str, Tensor]]:
-    r"""Create generator of (key,vector<float32/float64>) tuples, which reads from the ark file/stream.
-
-    Args:
-        file_or_fd (str/FileDescriptor): ark, gzipped ark, pipe or opened file descriptor
-
-    Returns:
-        Iterable[Tuple[str, Tensor]]: The string is the key and the tensor is the vector read from file
-
-    Example
-        >>> # read ark to a 'dictionary'
-        >>> d = { u:d for u,d in torchaudio.kaldi_io.read_vec_flt_ark(file) }
-    """
-
-    import kaldi_io
-
-    return _convert_method_output_to_tensor(file_or_fd, kaldi_io.read_vec_flt_ark)
-
-
-@_mod_utils.requires_module("kaldi_io", "numpy")
-def read_mat_scp(file_or_fd: Any) -> Iterable[Tuple[str, Tensor]]:
-    r"""Create generator of (key,matrix<float32/float64>) tuples, read according to Kaldi scp.
-
-    Args:
-        file_or_fd (str/FileDescriptor): scp, gzipped scp, pipe or opened file descriptor
-
-    Returns:
-        Iterable[Tuple[str, Tensor]]: The string is the key and the tensor is the matrix read from file
-
-    Example
-        >>> # read scp to a 'dictionary'
-        >>> d = { u:d for u,d in torchaudio.kaldi_io.read_mat_scp(file) }
-    """
-
-    import kaldi_io
-
-    return _convert_method_output_to_tensor(file_or_fd, kaldi_io.read_mat_scp)
-
-
-@_mod_utils.requires_module("kaldi_io", "numpy")
-def read_mat_ark(file_or_fd: Any) -> Iterable[Tuple[str, Tensor]]:
-    r"""Create generator of (key,matrix<float32/float64>) tuples, which reads from the ark file/stream.
-
-    Args:
-        file_or_fd (str/FileDescriptor): ark, gzipped ark, pipe or opened file descriptor
-
-    Returns:
-        Iterable[Tuple[str, Tensor]]: The string is the key and the tensor is the matrix read from file
-
-    Example
-        >>> # read ark to a 'dictionary'
-        >>> d = { u:d for u,d in torchaudio.kaldi_io.read_mat_ark(file) }
-    """
-
-    import kaldi_io
-
-    return _convert_method_output_to_tensor(file_or_fd, kaldi_io.read_mat_ark)

torchaudio/prototype/datasets/__init__.py

@@ -1,4 +0,0 @@
-from .musan import Musan
-
-
-__all__ = ["Musan"]

torchaudio/prototype/datasets/musan.py

@@ -1,67 +0,0 @@
-from pathlib import Path
-from typing import Tuple, Union
-
-import torch
-from torch.utils.data import Dataset
-from torchaudio.datasets.utils import _load_waveform
-
-
-_SUBSETS = ["music", "noise", "speech"]
-_SAMPLE_RATE = 16_000
-
-
-class Musan(Dataset):
-    r"""*MUSAN* :cite:`musan2015` dataset.
-
-    Args:
-        root (str or Path): Root directory where the dataset's top-level directory exists.
-        subset (str): Subset of the dataset to use. Options: [``"music"``, ``"noise"``, ``"speech"``].
-    """
-
-    def __init__(self, root: Union[str, Path], subset: str):
-        if subset not in _SUBSETS:
-            raise ValueError(f"Invalid subset '{subset}' given. Please provide one of {_SUBSETS}")
-
-        subset_path = Path(root) / subset
-        self._walker = [str(p) for p in subset_path.glob("*/*.*")]
-
-    def get_metadata(self, n: int) -> Tuple[str, int, str]:
-        r"""Get metadata for the n-th sample in the dataset. Returns filepath instead of waveform,
-        but otherwise returns the same fields as :py:func:`__getitem__`.
-
-        Args:
-            n (int): Index of sample to be loaded.
-
-        Returns:
-            (str, int, str):
-                str
-                    Path to audio.
-                int
-                    Sample rate.
-                str
-                    File name.
-        """
-        audio_path = self._walker[n]
-        return audio_path, _SAMPLE_RATE, Path(audio_path).name
-
-    def __getitem__(self, n: int) -> Tuple[torch.Tensor, int, str]:
-        r"""Return the n-th sample in the dataset.
-
-        Args:
-            n (int): Index of sample to be loaded.
-
-        Returns:
-            (torch.Tensor, int, str):
-                torch.Tensor
-                    Waveform.
-                int
-                    Sample rate.
-                str
-                    File name.
-        """
-        audio_path, sample_rate, filename = self.get_metadata(n)
-        path = Path(audio_path)
-        return _load_waveform(path.parent, path.name, sample_rate), sample_rate, filename
-
-    def __len__(self) -> int:
-        return len(self._walker)

torchaudio/prototype/functional/__init__.py

@@ -1,26 +0,0 @@
-from ._dsp import (
-    adsr_envelope,
-    exp_sigmoid,
-    extend_pitch,
-    filter_waveform,
-    frequency_impulse_response,
-    oscillator_bank,
-    sinc_impulse_response,
-)
-from ._rir import ray_tracing, simulate_rir_ism
-from .functional import barkscale_fbanks, chroma_filterbank
-
-
-__all__ = [
-    "adsr_envelope",
-    "exp_sigmoid",
-    "barkscale_fbanks",
-    "chroma_filterbank",
-    "extend_pitch",
-    "filter_waveform",
-    "frequency_impulse_response",
-    "oscillator_bank",
-    "ray_tracing",
-    "sinc_impulse_response",
-    "simulate_rir_ism",
-]