torchaudio 2.7.1__cp311-cp311-win_amd64.whl → 2.8.0__cp311-cp311-win_amd64.whl

torchaudio/__init__.py

@@ -1,14 +1,23 @@
+from torchaudio._internal.module_utils import dropping_io_support, dropping_class_io_support
+
 # Initialize extension and backend first
 from . import _extension  # noqa  # usort: skip
 from ._backend import (  # noqa  # usort: skip
-    AudioMetaData,
-    get_audio_backend,
-    info,
-    list_audio_backends,
+    AudioMetaData as _AudioMetaData,
+    get_audio_backend as _get_audio_backend,
+    info as _info,
+    list_audio_backends as _list_audio_backends,
     load,
     save,
-    set_audio_backend,
+    set_audio_backend as _set_audio_backend,
 )
+from ._torchcodec import load_with_torchcodec, save_with_torchcodec
+
+AudioMetaData = dropping_class_io_support(_AudioMetaData)
+get_audio_backend = dropping_io_support(_get_audio_backend)
+info = dropping_io_support(_info)
+list_audio_backends = dropping_io_support(_list_audio_backends)
+set_audio_backend = dropping_io_support(_set_audio_backend)
 
 from . import (  # noqa: F401
     compliance,
@@ -35,6 +44,8 @@ except ImportError:
 __all__ = [
     "AudioMetaData",
     "load",
+    "load_with_torchcodec",
+    "save_with_torchcodec",
     "info",
     "save",
     "io",

torchaudio/_backend/sox.py

@@ -41,7 +41,7 @@ class SoXBackend(Backend):
                 "Please use an alternative backend that does support loading from file-like objects, e.g. FFmpeg.",
             )
         else:
-            ret = sox_ext.load_audio_file(uri, frame_offset, num_frames, normalize, channels_first, format)
+            ret = sox_ext.load_audio_file(str(uri), frame_offset, num_frames, normalize, channels_first, format)
             if not ret:
                 raise RuntimeError(f"Failed to load audio from {uri}.")
             return ret
@@ -70,7 +70,7 @@ class SoXBackend(Backend):
             )
         else:
             sox_ext.save_audio_file(
-                uri,
+                str(uri),
                 src,
                 sample_rate,
                 channels_first,

torchaudio/_backend/utils.py

@@ -1,6 +1,7 @@
 import os
 from functools import lru_cache
 from typing import BinaryIO, Dict, Optional, Tuple, Type, Union
+import warnings
 
 import torch
 
@@ -127,6 +128,14 @@ def get_load_func():
     ) -> Tuple[torch.Tensor, int]:
         """Load audio data from source.
 
+        .. warning::
+            In 2.9, this function's implementation will be changed to use
+            :func:`~torchaudio.load_with_torchcodec` under the hood. Some
+            parameters like ``normalize``, ``format``, ``buffer_size``, and
+            ``backend`` will be ignored. We recommend that you port your code to
+            rely directly on TorchCodec's decoder instead:
+            https://docs.pytorch.org/torchcodec/stable/generated/torchcodec.decoders.AudioDecoder.html#torchcodec.decoders.AudioDecoder.
+
         By default (``normalize=True``, ``channels_first=True``), this function returns Tensor with
         ``float32`` dtype, and the shape of `[channel, time]`.
 
@@ -201,6 +210,14 @@ def get_load_func():
                 integer type, else ``float32`` type. If ``channels_first=True``, it has
                 `[channel, time]` else `[time, channel]`.
         """
+        warnings.warn(
+            "In 2.9, this function's implementation will be changed to use "
+            "torchaudio.load_with_torchcodec` under the hood. Some "
+            "parameters like ``normalize``, ``format``, ``buffer_size``, and "
+            "``backend`` will be ignored. We recommend that you port your code to "
+            "rely directly on TorchCodec's decoder instead: "
+            "https://docs.pytorch.org/torchcodec/stable/generated/torchcodec.decoders.AudioDecoder.html#torchcodec.decoders.AudioDecoder."
+        )
         backend = dispatcher(uri, format, backend)
         return backend.load(uri, frame_offset, num_frames, normalize, channels_first, format, buffer_size)
 
@@ -235,6 +252,14 @@ def get_save_func():
     ):
         """Save audio data to file.
 
+        .. warning::
+            In 2.9, this function's implementation will be changed to use
+            :func:`~torchaudio.save_with_torchcodec` under the hood. Some
+            parameters like format, encoding, bits_per_sample, buffer_size, and
+            ``backend`` will be ignored. We recommend that you port your code to
+            rely directly on TorchCodec's decoder instead:
+            https://docs.pytorch.org/torchcodec/stable/generated/torchcodec.encoders.AudioEncoder
+
         Note:
             The formats this function can handle depend on the availability of backends.
             Please use the following functions to fetch the supported formats.
@@ -309,6 +334,14 @@ def get_save_func():
                 Refer to http://sox.sourceforge.net/soxformat.html for more details.
 
         """
+        warnings.warn(
+            "In 2.9, this function's implementation will be changed to use "
+            "torchaudio.save_with_torchcodec` under the hood. Some "
+            "parameters like format, encoding, bits_per_sample, buffer_size, and "
+            "``backend`` will be ignored. We recommend that you port your code to "
+            "rely directly on TorchCodec's encoder instead: "
+            "https://docs.pytorch.org/torchcodec/stable/generated/torchcodec.encoders.AudioEncoder"
+        )
         backend = dispatcher(uri, format, backend)
         return backend.save(
             uri, src, sample_rate, channels_first, format, encoding, bits_per_sample, buffer_size, compression

torchaudio/_internal/module_utils.py

@@ -1,7 +1,7 @@
 import importlib.util
 import os
 import warnings
-from functools import wraps
+from functools import wraps, partial
 from typing import Optional
 
 
@@ -59,6 +59,17 @@ def requires_module(*modules: str):
 
     return decorator
 
+UNSUPPORTED = []
+
+def wrap_deprecated(func, name, direction: str, version: Optional[str] = None, remove: bool = False):
+    @wraps(func)
+    def wrapped(*args, **kwargs):
+        message = f"{name} has been deprecated. {direction}"
+        if remove:
+            message += f' It will be removed from {"a future" if version is None else "the " + str(version)} release. '
+        warnings.warn(message, stacklevel=2)
+        return func(*args, **kwargs)
+    return wrapped
 
 def deprecated(direction: str, version: Optional[str] = None, remove: bool = False):
     """Decorator to add deprecation message
@@ -70,30 +81,68 @@ def deprecated(direction: str, version: Optional[str] = None, remove: bool = Fal
     """
 
     def decorator(func):
-        @wraps(func)
-        def wrapped(*args, **kwargs):
-            message = f"{func.__module__}.{func.__name__} has been deprecated. {direction}"
-            if remove:
-                message += f' It will be removed from {"future" if version is None else version} release. '
-            warnings.warn(message, stacklevel=2)
-            return func(*args, **kwargs)
+        wrapped = wrap_deprecated(func, f"{func.__module__}.{func.__name__}", direction, version=version, remove=remove)
 
         message = "This function has been deprecated. "
         if remove:
             message += f'It will be removed from {"future" if version is None else version} release. '
 
-        wrapped.__doc__ = f"""DEPRECATED: {func.__doc__}
+        wrapped.__doc__ = f"""DEPRECATED
 
     .. warning::
 
        {message}
        {direction}
-        """
 
+    {func.__doc__}
+    """
+
+        UNSUPPORTED.append(wrapped)
         return wrapped
 
     return decorator
 
+DEPRECATION_MSG = (
+    "This deprecation is part of a large refactoring effort to transition TorchAudio into a maintenance phase. "
+    "Please see https://github.com/pytorch/audio/issues/3902 for more information."
+)
+
+IO_DEPRECATION_MSG = (
+    "This deprecation is part of a large refactoring effort to transition TorchAudio into a maintenance phase. "
+    "The decoding and encoding capabilities of PyTorch for both audio and video are being consolidated into TorchCodec. "
+    "Please see https://github.com/pytorch/audio/issues/3902 for more information."
+)
+
+dropping_support = deprecated(DEPRECATION_MSG, version="2.9", remove=True)
+
+def dropping_class_support(c, msg=DEPRECATION_MSG):
+    c.__init__ = wrap_deprecated(c.__init__, f"{c.__module__}.{c.__name__}", msg, version="2.9", remove=True)
+    c.__doc__ = f"""DEPRECATED
+
+.. warning::
+
+    This class is deprecated from version 2.8. It will be removed in the 2.9 release.
+    {msg}
+{c.__doc__}
+"""
+
+    UNSUPPORTED.append(c)
+    return c
+
+def dropping_const_support(c, msg=DEPRECATION_MSG, name=None):
+    c.__doc__ = f"""[DEPRECATED]
+
+.. warning::
+
+    This object is deprecated deprecated from version 2.8. It will be removed in the 2.9 release.
+    {msg}
+{c.__doc__}
+    """
+    return c
+
+dropping_class_io_support = partial(dropping_class_support, msg=IO_DEPRECATION_MSG)
+
+dropping_io_support = deprecated(IO_DEPRECATION_MSG, version="2.9", remove=True)
 
 def fail_with_message(message):
     """Generate decorator to give users message about missing TorchAudio extension."""

torchaudio/_torchcodec.py

@@ -0,0 +1,352 @@
+"""TorchCodec integration for TorchAudio."""
+
+import os
+from typing import BinaryIO, Optional, Tuple, Union
+
+import torch
+
+
+def load_with_torchcodec(
+    uri: Union[BinaryIO, str, os.PathLike],
+    frame_offset: int = 0,
+    num_frames: int = -1,
+    normalize: bool = True,
+    channels_first: bool = True,
+    format: Optional[str] = None,
+    buffer_size: int = 4096,
+    backend: Optional[str] = None,
+) -> Tuple[torch.Tensor, int]:
+    """Load audio data from source using TorchCodec's AudioDecoder.
+    
+    .. note::
+        
+        This function supports the same API as :func:`~torchaudio.load`, and
+        relies on TorchCodec's decoding capabilities under the hood. It is
+        provided for convenience, but we do recommend that you port your code to
+        natively use ``torchcodec``'s ``AudioDecoder`` class for better
+        performance:
+        https://docs.pytorch.org/torchcodec/stable/generated/torchcodec.decoders.AudioDecoder.
+        In TorchAudio 2.9, :func:`~torchaudio.load` will be relying on
+        :func:`~torchaudio.load_with_torchcodec`. Note that some parameters of
+        :func:`~torchaudio.load`, like ``normalize``, ``buffer_size``, and
+        ``backend``, are ignored by :func:`~torchaudio.load_with_torchcodec`.
+    
+    
+    Args:
+        uri (path-like object or file-like object):
+            Source of audio data. The following types are accepted:
+            
+            * ``path-like``: File path or URL.
+            * ``file-like``: Object with ``read(size: int) -> bytes`` method.
+            
+        frame_offset (int, optional):
+            Number of samples to skip before start reading data.
+        num_frames (int, optional):
+            Maximum number of samples to read. ``-1`` reads all the remaining samples,
+            starting from ``frame_offset``.
+        normalize (bool, optional):
+            TorchCodec always returns normalized float32 samples. This parameter
+            is ignored and a warning is issued if set to False.
+            Default: ``True``.
+        channels_first (bool, optional):
+            When True, the returned Tensor has dimension `[channel, time]`.
+            Otherwise, the returned Tensor's dimension is `[time, channel]`.
+        format (str or None, optional):
+            Format hint for the decoder. May not be supported by all TorchCodec
+            decoders. (Default: ``None``)
+        buffer_size (int, optional):
+            Not used by TorchCodec AudioDecoder. Provided for API compatibility.
+        backend (str or None, optional):
+            Not used by TorchCodec AudioDecoder. Provided for API compatibility.
+            
+    Returns:
+        (torch.Tensor, int): Resulting Tensor and sample rate.
+        Always returns float32 tensors. If ``channels_first=True``, shape is
+        `[channel, time]`, otherwise `[time, channel]`.
+        
+    Raises:
+        ImportError: If torchcodec is not available.
+        ValueError: If unsupported parameters are used.
+        RuntimeError: If TorchCodec fails to decode the audio.
+        
+    Note:
+        - TorchCodec always returns normalized float32 samples, so the ``normalize``
+          parameter has no effect.
+        - The ``buffer_size`` and ``backend`` parameters are ignored.
+        - Not all audio formats supported by torchaudio backends may be supported
+          by TorchCodec.
+    """
+    # Import torchcodec here to provide clear error if not available
+    try:
+        from torchcodec.decoders import AudioDecoder
+    except ImportError as e:
+        raise ImportError(
+            "TorchCodec is required for load_with_torchcodec. "
+            "Please install torchcodec to use this function."
+        ) from e
+    
+    # Parameter validation and warnings
+    if not normalize:
+        import warnings
+        warnings.warn(
+            "TorchCodec AudioDecoder always returns normalized float32 samples. "
+            "The 'normalize=False' parameter is ignored.",
+            UserWarning,
+            stacklevel=2
+        )
+    
+    if buffer_size != 4096:
+        import warnings
+        warnings.warn(
+            "The 'buffer_size' parameter is not used by TorchCodec AudioDecoder.",
+            UserWarning,
+            stacklevel=2
+        )
+        
+    if backend is not None:
+        import warnings
+        warnings.warn(
+            "The 'backend' parameter is not used by TorchCodec AudioDecoder.",
+            UserWarning,
+            stacklevel=2
+        )
+    
+    if format is not None:
+        import warnings
+        warnings.warn(
+            "The 'format' parameter is not supported by TorchCodec AudioDecoder.",
+            UserWarning,
+            stacklevel=2
+        )
+    
+    # Create AudioDecoder
+    try:
+        decoder = AudioDecoder(uri)
+    except Exception as e:
+        raise RuntimeError(f"Failed to create AudioDecoder for {uri}: {e}") from e
+    
+    # Get sample rate from metadata
+    sample_rate = decoder.metadata.sample_rate
+    if sample_rate is None:
+        raise RuntimeError("Unable to determine sample rate from audio metadata")
+    
+    # Decode the entire file first, then subsample manually
+    # This is the simplest approach since torchcodec uses time-based indexing
+    try:
+        audio_samples = decoder.get_all_samples()
+    except Exception as e:
+        raise RuntimeError(f"Failed to decode audio samples: {e}") from e
+        
+    data = audio_samples.data
+    
+    # Apply frame_offset and num_frames (which are actually sample offsets)
+    if frame_offset > 0:
+        if frame_offset >= data.shape[1]:
+            # Return empty tensor if offset is beyond available data
+            empty_shape = (data.shape[0], 0) if channels_first else (0, data.shape[0])
+            return torch.zeros(empty_shape, dtype=torch.float32), sample_rate
+        data = data[:, frame_offset:]
+    
+    if num_frames == 0:
+        # Return empty tensor if num_frames is 0
+        empty_shape = (data.shape[0], 0) if channels_first else (0, data.shape[0])
+        return torch.zeros(empty_shape, dtype=torch.float32), sample_rate
+    elif num_frames > 0:
+        data = data[:, :num_frames]
+    
+    # TorchCodec returns data in [channel, time] format by default
+    # Handle channels_first parameter
+    if not channels_first:
+        data = data.transpose(0, 1)  # [channel, time] -> [time, channel]
+    
+    return data, sample_rate
+
+
+def save_with_torchcodec(
+    uri: Union[str, os.PathLike],
+    src: torch.Tensor,
+    sample_rate: int,
+    channels_first: bool = True,
+    format: Optional[str] = None,
+    encoding: Optional[str] = None,
+    bits_per_sample: Optional[int] = None,
+    buffer_size: int = 4096,
+    backend: Optional[str] = None,
+    compression: Optional[Union[float, int]] = None,
+) -> None:
+    """Save audio data to file using TorchCodec's AudioEncoder.
+
+    .. note::
+        
+        This function supports the same API as :func:`~torchaudio.save`, and
+        relies on TorchCodec's encoding capabilities under the hood. It is
+        provided for convenience, but we do recommend that you port your code to
+        natively use ``torchcodec``'s ``AudioEncoder`` class for better
+        performance:
+        https://docs.pytorch.org/torchcodec/stable/generated/torchcodec.encoders.AudioEncoder.
+        In TorchAudio 2.9, :func:`~torchaudio.save` will be relying on
+        :func:`~torchaudio.save_with_torchcodec`. Note that some parameters of
+        :func:`~torchaudio.save`, like ``format``, ``encoding``,
+        ``bits_per_sample``, ``buffer_size``, and ``backend``, are ignored by
+        are ignored by :func:`~torchaudio.save_with_torchcodec`.
+    
+    This function provides a TorchCodec-based alternative to torchaudio.save
+    with the same API. TorchCodec's AudioEncoder provides efficient encoding
+    with FFmpeg under the hood.
+    
+    Args:
+        uri (path-like object):
+            Path to save the audio file. The file extension determines the format.
+            
+        src (torch.Tensor):
+            Audio data to save. Must be a 1D or 2D tensor with float32 values
+            in the range [-1, 1]. If 2D, shape should be [channel, time] when
+            channels_first=True, or [time, channel] when channels_first=False.
+            
+        sample_rate (int):
+            Sample rate of the audio data.
+            
+        channels_first (bool, optional):
+            Indicates whether the input tensor has channels as the first dimension.
+            If True, expects [channel, time]. If False, expects [time, channel].
+            Default: True.
+            
+        format (str or None, optional):
+            Audio format hint. Not used by TorchCodec (format is determined by
+            file extension). A warning is issued if provided.
+            Default: None.
+            
+        encoding (str or None, optional):
+            Audio encoding. Not fully supported by TorchCodec AudioEncoder.
+            A warning is issued if provided. Default: None.
+            
+        bits_per_sample (int or None, optional):
+            Bits per sample. Not directly supported by TorchCodec AudioEncoder.
+            A warning is issued if provided. Default: None.
+            
+        buffer_size (int, optional):
+            Not used by TorchCodec AudioEncoder. Provided for API compatibility.
+            A warning is issued if not default value. Default: 4096.
+            
+        backend (str or None, optional):
+            Not used by TorchCodec AudioEncoder. Provided for API compatibility.
+            A warning is issued if provided. Default: None.
+            
+        compression (float, int or None, optional):
+            Compression level or bit rate. Maps to bit_rate parameter in
+            TorchCodec AudioEncoder. Default: None.
+            
+    Raises:
+        ImportError: If torchcodec is not available.
+        ValueError: If input parameters are invalid.
+        RuntimeError: If TorchCodec fails to encode the audio.
+        
+    Note:
+        - TorchCodec AudioEncoder expects float32 samples in [-1, 1] range.
+        - Some parameters (format, encoding, bits_per_sample, buffer_size, backend)
+          are not used by TorchCodec but are provided for API compatibility.
+        - The output format is determined by the file extension in the uri.
+        - TorchCodec uses FFmpeg under the hood for encoding.
+    """
+    # Import torchcodec here to provide clear error if not available
+    try:
+        from torchcodec.encoders import AudioEncoder
+    except ImportError as e:
+        raise ImportError(
+            "TorchCodec is required for save_with_torchcodec. "
+            "Please install torchcodec to use this function."
+        ) from e
+    
+    # Parameter validation and warnings
+    if format is not None:
+        import warnings
+        warnings.warn(
+            "The 'format' parameter is not used by TorchCodec AudioEncoder. "
+            "Format is determined by the file extension.",
+            UserWarning,
+            stacklevel=2
+        )
+    
+    if encoding is not None:
+        import warnings
+        warnings.warn(
+            "The 'encoding' parameter is not fully supported by TorchCodec AudioEncoder.",
+            UserWarning,
+            stacklevel=2
+        )
+    
+    if bits_per_sample is not None:
+        import warnings
+        warnings.warn(
+            "The 'bits_per_sample' parameter is not directly supported by TorchCodec AudioEncoder.",
+            UserWarning,
+            stacklevel=2
+        )
+    
+    if buffer_size != 4096:
+        import warnings
+        warnings.warn(
+            "The 'buffer_size' parameter is not used by TorchCodec AudioEncoder.",
+            UserWarning,
+            stacklevel=2
+        )
+        
+    if backend is not None:
+        import warnings
+        warnings.warn(
+            "The 'backend' parameter is not used by TorchCodec AudioEncoder.",
+            UserWarning,
+            stacklevel=2
+        )
+    
+    # Input validation
+    if not isinstance(src, torch.Tensor):
+        raise ValueError(f"Expected src to be a torch.Tensor, got {type(src)}")
+    
+    if src.dtype != torch.float32:
+        src = src.float()
+    
+    if sample_rate <= 0:
+        raise ValueError(f"sample_rate must be positive, got {sample_rate}")
+    
+    # Handle tensor shape and channels_first
+    if src.ndim == 1:
+        # Convert to 2D: [1, time] for channels_first=True
+        if channels_first:
+            data = src.unsqueeze(0)  # [1, time]
+        else:
+            # For channels_first=False, input is [time] -> reshape to [time, 1] -> transpose to [1, time]
+            data = src.unsqueeze(1).transpose(0, 1)  # [time, 1] -> [1, time]
+    elif src.ndim == 2:
+        if channels_first:
+            data = src  # Already [channel, time]
+        else:
+            data = src.transpose(0, 1)  # [time, channel] -> [channel, time]
+    else:
+        raise ValueError(f"Expected 1D or 2D tensor, got {src.ndim}D tensor")
+    
+    # Create AudioEncoder
+    try:
+        encoder = AudioEncoder(data, sample_rate=sample_rate)
+    except Exception as e:
+        raise RuntimeError(f"Failed to create AudioEncoder: {e}") from e
+    
+    # Determine bit_rate from compression parameter
+    bit_rate = None
+    if compression is not None:
+        if isinstance(compression, (int, float)):
+            bit_rate = int(compression)
+        else:
+            import warnings
+            warnings.warn(
+                f"Unsupported compression type {type(compression)}. "
+                "TorchCodec AudioEncoder expects int or float for bit_rate.",
+                UserWarning,
+                stacklevel=2
+            )
+    
+    # Save to file
+    try:
+        encoder.to_file(uri, bit_rate=bit_rate)
+    except Exception as e:
+        raise RuntimeError(f"Failed to save audio to {uri}: {e}") from e

torchaudio/backend/no_backend.py

@@ -2,10 +2,10 @@ def __getattr__(name: str):
     import warnings
 
     warnings.warn(
-        "Torchaudio's I/O functions now support par-call bakcend dispatch. "
+        "Torchaudio's I/O functions now support per-call backend 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.",
+        "calling the underlying implementation directly.",
         stacklevel=2,
     )
 

torchaudio/backend/soundfile_backend.py

@@ -2,10 +2,10 @@ def __getattr__(name: str):
     import warnings
 
     warnings.warn(
-        "Torchaudio's I/O functions now support par-call bakcend dispatch. "
+        "Torchaudio's I/O functions now support per-call backend 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.",
+        "calling the underlying implementation directly.",
         stacklevel=2,
     )
 

torchaudio/backend/sox_io_backend.py

@@ -2,10 +2,10 @@ def __getattr__(name: str):
     import warnings
 
     warnings.warn(
-        "Torchaudio's I/O functions now support par-call bakcend dispatch. "
+        "Torchaudio's I/O functions now support per-call backend 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.",
+        "calling the underlying implementation directly.",
         stacklevel=2,
     )
 

torchaudio/functional/__init__.py

@@ -1,4 +1,6 @@
-from ._alignment import forced_align, merge_tokens, TokenSpan
+from torchaudio._internal.module_utils import dropping_support
+
+from ._alignment import forced_align as _forced_align, merge_tokens, TokenSpan
 from .filtering import (
     allpass_biquad,
     band_biquad,
@@ -23,6 +25,9 @@ from .filtering import (
     treble_biquad,
     vad,
 )
+
+forced_align = dropping_support(_forced_align)
+
 from .functional import (
     add_noise,
     amplitude_to_DB,

torchaudio/functional/functional.py

@@ -9,7 +9,8 @@ from typing import List, Optional, Tuple, Union
 import torch
 import torchaudio
 from torch import Tensor
-from torchaudio._internal.module_utils import deprecated
+from torchaudio._internal.module_utils import deprecated, dropping_support
+
 
 from .filtering import highpass_biquad, treble_biquad
 
@@ -1760,7 +1761,7 @@ def _fix_waveform_shape(
     return waveform_shift
 
 
-def rnnt_loss(
+def _rnnt_loss(
     logits: Tensor,
     targets: Tensor,
     logit_lengths: Tensor,
@@ -1864,6 +1865,9 @@ def psd(
     psd = psd.sum(dim=-3)
     return psd
 
+# Expose both deprecated wrapper as well as original because torchscript breaks on
+# wrapped functions.
+rnnt_loss = dropping_support(_rnnt_loss)
 
 def _compute_mat_trace(input: torch.Tensor, dim1: int = -1, dim2: int = -2) -> torch.Tensor:
     r"""Compute the trace of a Tensor along ``dim1`` and ``dim2`` dimensions.
@@ -2494,7 +2498,7 @@ def deemphasis(waveform, coeff: float = 0.97) -> torch.Tensor:
     """
     a_coeffs = torch.tensor([1.0, -coeff], dtype=waveform.dtype, device=waveform.device)
     b_coeffs = torch.tensor([1.0, 0.0], dtype=waveform.dtype, device=waveform.device)
-    return torchaudio.functional.lfilter(waveform, a_coeffs=a_coeffs, b_coeffs=b_coeffs)
+    return torchaudio.functional.filtering.lfilter(waveform, a_coeffs=a_coeffs, b_coeffs=b_coeffs)
 
 
 def frechet_distance(mu_x, sigma_x, mu_y, sigma_y):