torchaudio 2.0.2__cp311-cp311-manylinux2014_aarch64.whl → 2.1.1__cp311-cp311-manylinux2014_aarch64.whl

torchaudio/_extension/utils.py

@@ -6,15 +6,18 @@ Anything that depends on external state should happen in __init__.py
 """
 
 
+import importlib
+import logging
 import os
+import platform
+import warnings
 from functools import wraps
 from pathlib import Path
 
 import torch
-
 import torchaudio
-from torchaudio._internal.module_utils import is_module_available
 
+_LG = logging.getLogger(__name__)
 _LIB_DIR = Path(__file__).parent.parent / "lib"
 
 
@@ -67,7 +70,7 @@ def _init_sox():
     _load_lib("libtorchaudio_sox")
     import torchaudio.lib._torchaudio_sox  # noqa
 
-    torch.ops.torchaudio.sox_utils_set_verbosity(0)
+    torchaudio.lib._torchaudio_sox.set_verbosity(0)
 
     import atexit
 
@@ -75,22 +78,92 @@ def _init_sox():
     atexit.register(torch.ops.torchaudio.sox_effects_shutdown_sox_effects)
 
 
-def _init_ffmpeg():
-    if not is_module_available("torchaudio.lib._torchaudio_ffmpeg"):
-        raise RuntimeError(
-            "torchaudio is not compiled with FFmpeg integration. Please set USE_FFMPEG=1 when compiling torchaudio."
-        )
+def _try_access_avutil(ffmpeg_ver):
+    libname_template = {
+        "Linux": "libavutil.so.{ver}",
+        "Darwin": "libavutil.{ver}.dylib",
+        "Windows": "avutil-{ver}.dll",
+    }[platform.system()]
+    avutil_ver = {"6": 58, "5": 57, "4": 56}[ffmpeg_ver]
+    libavutil = libname_template.format(ver=avutil_ver)
+    torchaudio.lib._torchaudio.find_avutil(libavutil)
+
+
+def _find_versionsed_ffmpeg_extension(ffmpeg_ver: str):
+    _LG.debug("Attempting to load FFmpeg version %s.", ffmpeg_ver)
+
+    library = f"libtorchaudio_ffmpeg{ffmpeg_ver}"
+    extension = f"_torchaudio_ffmpeg{ffmpeg_ver}"
+
+    if not _get_lib_path(extension).exists():
+        raise RuntimeError(f"FFmpeg {ffmpeg_ver} extension is not available.")
+
+    if ffmpeg_ver:
+        # A simple check for FFmpeg availability.
+        # This is not technically sufficient as other libraries could be missing,
+        # but usually this is sufficient.
+        #
+        # Note: the reason why this check is performed is because I don't know
+        # if the next `_load_lib` (which calls `ctypes.CDLL` under the hood),
+        # could leak handle to shared libraries of dependencies, in case it fails.
+        #
+        # i.e. If the `ctypes.CDLL("foo")` fails because one of `foo`'s dependency
+        # does not exist while `foo` and some other dependencies exist, is it guaranteed
+        # that none-of them are kept in memory after the failure??
+        _try_access_avutil(ffmpeg_ver)
+
+    _load_lib(library)
 
-    try:
-        _load_lib("libtorchaudio_ffmpeg")
-    except OSError as err:
-        raise ImportError("FFmpeg libraries are not found. Please install FFmpeg.") from err
+    _LG.debug("Found FFmpeg version %s.", ffmpeg_ver)
+    return importlib.import_module(f"torchaudio.lib.{extension}")
 
-    import torchaudio.lib._torchaudio_ffmpeg  # noqa
 
-    torch.ops.torchaudio.ffmpeg_init()
-    if torch.ops.torchaudio.ffmpeg_get_log_level() > 8:
-        torch.ops.torchaudio.ffmpeg_set_log_level(8)
+_FFMPEG_VERS = ["6", "5", "4", ""]
+
+
+def _find_ffmpeg_extension(ffmpeg_vers, show_error):
+    logger = _LG.error if show_error else _LG.debug
+    for ffmpeg_ver in ffmpeg_vers:
+        try:
+            return _find_versionsed_ffmpeg_extension(ffmpeg_ver)
+        except Exception:
+            logger("Failed to load FFmpeg %s extension.", ffmpeg_ver, exc_info=True)
+            continue
+    raise ImportError(f"Failed to intialize FFmpeg extension. Tried versions: {ffmpeg_vers}")
+
+
+def _find_available_ffmpeg_ext():
+    ffmpeg_vers = ["6", "5", "4", ""]
+    return [v for v in ffmpeg_vers if _get_lib_path(f"_torchaudio_ffmpeg{v}").exists()]
+
+
+def _init_ffmpeg(show_error=False):
+    ffmpeg_vers = _find_available_ffmpeg_ext()
+    if not ffmpeg_vers:
+        raise RuntimeError(
+            # fmt: off
+            "TorchAudio is not built with FFmpeg integration. "
+            "Please build torchaudio with USE_FFMPEG=1."
+            # fmt: on
+        )
+
+    # User override
+    if ffmpeg_ver := os.environ.get("TORCHAUDIO_USE_FFMPEG_VERSION"):
+        if ffmpeg_vers == [""]:
+            warnings.warn("TorchAudio is built in single FFmpeg mode. TORCHAUDIO_USE_FFMPEG_VERSION is ignored.")
+        else:
+            if ffmpeg_ver not in ffmpeg_vers:
+                raise ValueError(
+                    f"The FFmpeg version {ffmpeg_ver} (read from TORCHAUDIO_USE_FFMPEG_VERSION) "
+                    f"is not available. Available versions are {[v for v in ffmpeg_vers if v]}"
+                )
+            ffmpeg_vers = [ffmpeg_ver]
+
+    ext = _find_ffmpeg_extension(ffmpeg_vers, show_error)
+    ext.init()
+    if ext.get_log_level() > 8:
+        ext.set_log_level(8)
+    return ext
 
 
 def _init_dll_path():
@@ -124,6 +197,25 @@ def _check_cuda_version():
     return version
 
 
+def _fail_since_no_sox(func):
+    @wraps(func)
+    def wrapped(*_args, **_kwargs):
+        try:
+            # Note:
+            # We run _init_sox again just to show users the stacktrace.
+            # _init_sox would not succeed here.
+            _init_sox()
+        except Exception as err:
+            raise RuntimeError(
+                f"{func.__name__} requires sox extension which is not available. "
+                "Please refer to the stacktrace above for how to resolve this."
+            ) from err
+        # This should not happen in normal execution, but just in case.
+        return func(*_args, **_kwargs)
+
+    return wrapped
+
+
 def _fail_since_no_ffmpeg(func):
     @wraps(func)
     def wrapped(*_args, **_kwargs):
@@ -131,7 +223,7 @@ def _fail_since_no_ffmpeg(func):
             # Note:
             # We run _init_ffmpeg again just to show users the stacktrace.
             # _init_ffmpeg would not succeed here.
-            _init_ffmpeg()
+            _init_ffmpeg(show_error=True)
         except Exception as err:
             raise RuntimeError(
                 f"{func.__name__} requires FFmpeg extension which is not available. "

torchaudio/_internal/__init__.py

@@ -1,4 +1,7 @@
-from torch.hub import download_url_to_file, load_state_dict_from_url
+try:
+    from .fb import download_url_to_file, load_state_dict_from_url
+except ImportError:
+    from torch.hub import download_url_to_file, load_state_dict_from_url
 
 
 __all__ = [

torchaudio/_internal/module_utils.py

@@ -1,9 +1,29 @@
 import importlib.util
+import os
 import warnings
 from functools import wraps
 from typing import Optional
 
 
+def eval_env(var, default):
+    """Check if environment varable has True-y value"""
+    if var not in os.environ:
+        return default
+
+    val = os.environ.get(var, "0")
+    trues = ["1", "true", "TRUE", "on", "ON", "yes", "YES"]
+    falses = ["0", "false", "FALSE", "off", "OFF", "no", "NO"]
+    if val in trues:
+        return True
+    if val not in falses:
+        # fmt: off
+        raise RuntimeError(
+            f"Unexpected environment variable value `{var}={val}`. "
+            f"Expected one of {trues + falses}")
+        # fmt: on
+    return False
+
+
 def is_module_available(*modules: str) -> bool:
     r"""Returns if a top-level module with :attr:`name` exists *without**
     importing it. This is generally safer than try-catch block around a
@@ -40,25 +60,36 @@ def requires_module(*modules: str):
     return decorator
 
 
-def deprecated(direction: str, version: Optional[str] = None):
+def deprecated(direction: str, version: Optional[str] = None, remove: bool = False):
     """Decorator to add deprecation message
 
     Args:
         direction (str): Migration steps to be given to users.
         version (str or int): The version when the object will be removed
+        remove (bool): If enabled, append future removal message.
     """
 
     def decorator(func):
         @wraps(func)
         def wrapped(*args, **kwargs):
-            message = (
-                f"{func.__module__}.{func.__name__} has been deprecated "
-                f'and will be removed from {"future" if version is None else version} release. '
-                f"{direction}"
-            )
+            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)
 
+        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__}
+
+    .. warning::
+
+       {message}
+       {direction}
+        """
+
         return wrapped
 
     return decorator

torchaudio/backend/__init__.py

@@ -1,14 +1,10 @@
-# flake8: noqa
-import torchaudio
+# NOTE:
+# The entire `torchaudio.backend` module is deprecated.
+# New things should be added to `torchaudio._backend`.
+# Only things related to backward compatibility should be placed here.
 
-from . import utils
-from .utils import _is_backend_dispatcher_enabled, get_audio_backend, list_audio_backends, set_audio_backend
 
-if _is_backend_dispatcher_enabled():
-    from torchaudio._backend.utils import get_info_func, get_load_func, get_save_func
+from . import common, no_backend, soundfile_backend, sox_io_backend  # noqa
+from .utils import _init_backend, get_audio_backend, list_audio_backends, set_audio_backend
 
-    torchaudio.info = get_info_func()
-    torchaudio.load = get_load_func()
-    torchaudio.save = get_save_func()
-else:
-    utils._init_audio_backend()
+__all__ = ["_init_backend", "get_audio_backend", "list_audio_backends", "set_audio_backend"]

torchaudio/backend/_no_backend.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from typing import Callable, Optional, Tuple, Union
+
+from torch import Tensor
+
+
+def load(
+    filepath: Union[str, Path],
+    out: Optional[Tensor] = None,
+    normalization: Union[bool, float, Callable] = True,
+    channels_first: bool = True,
+    num_frames: int = 0,
+    offset: int = 0,
+    filetype: Optional[str] = None,
+) -> Tuple[Tensor, int]:
+    raise RuntimeError("No audio I/O backend is available.")
+
+
+def save(filepath: str, src: Tensor, sample_rate: int, precision: int = 16, channels_first: bool = True) -> None:
+    raise RuntimeError("No audio I/O backend is available.")
+
+
+def info(filepath: str) -> None:
+    raise RuntimeError("No audio I/O backend is available.")

torchaudio/backend/_sox_io_backend.py

@@ -0,0 +1,297 @@
+import os
+from typing import Optional, Tuple
+
+import torch
+import torchaudio
+from torchaudio import AudioMetaData
+
+
+@torchaudio._extension.fail_if_no_sox
+def info(
+    filepath: str,
+    format: Optional[str] = None,
+) -> AudioMetaData:
+    """Get signal information of an audio file.
+
+    Args:
+        filepath (str):
+            Source of audio data.
+
+        format (str or None, optional):
+            Override the format detection with the given format.
+            Providing the argument might help when libsox can not infer the format
+            from header or extension.
+
+    Returns:
+        AudioMetaData: Metadata of the given audio.
+    """
+    if not torch.jit.is_scripting():
+        if hasattr(filepath, "read"):
+            raise RuntimeError("sox_io backend does not support file-like object.")
+        filepath = os.fspath(filepath)
+    sinfo = torch.ops.torchaudio.sox_io_get_info(filepath, format)
+    return AudioMetaData(*sinfo)
+
+
+@torchaudio._extension.fail_if_no_sox
+def load(
+    filepath: str,
+    frame_offset: int = 0,
+    num_frames: int = -1,
+    normalize: bool = True,
+    channels_first: bool = True,
+    format: Optional[str] = None,
+) -> Tuple[torch.Tensor, int]:
+    """Load audio data from file.
+
+    Note:
+        This function can handle all the codecs that underlying libsox can handle,
+        however it is tested on the following formats;
+
+        * WAV, AMB
+
+            * 32-bit floating-point
+            * 32-bit signed integer
+            * 24-bit signed integer
+            * 16-bit signed integer
+            * 8-bit unsigned integer (WAV only)
+
+        * MP3
+        * FLAC
+        * OGG/VORBIS
+        * OPUS
+        * SPHERE
+        * AMR-NB
+
+        To load ``MP3``, ``FLAC``, ``OGG/VORBIS``, ``OPUS`` and other codecs ``libsox`` does not
+        handle natively, your installation of ``torchaudio`` has to be linked to ``libsox``
+        and corresponding codec libraries such as ``libmad`` or ``libmp3lame`` etc.
+
+    By default (``normalize=True``, ``channels_first=True``), this function returns Tensor with
+    ``float32`` dtype, and the shape of `[channel, time]`.
+
+    .. warning::
+
+       ``normalize`` argument does not perform volume normalization.
+       It only converts the sample type to `torch.float32` from the native sample
+       type.
+
+       When the input format is WAV with integer type, such as 32-bit signed integer, 16-bit
+       signed integer, 24-bit signed integer, and 8-bit unsigned integer, by providing ``normalize=False``,
+       this function can return integer Tensor, where the samples are expressed within the whole range
+       of the corresponding dtype, that is, ``int32`` tensor for 32-bit signed PCM,
+       ``int16`` for 16-bit signed PCM and ``uint8`` for 8-bit unsigned PCM. Since torch does not
+       support ``int24`` dtype, 24-bit signed PCM are converted to ``int32`` tensors.
+
+       ``normalize`` argument has no effect on 32-bit floating-point WAV and other formats, such as
+       ``flac`` and ``mp3``.
+
+       For these formats, this function always returns ``float32`` Tensor with values.
+
+    Args:
+        filepath (path-like object): Source of audio data.
+        frame_offset (int):
+            Number of frames to skip before start reading data.
+        num_frames (int, optional):
+            Maximum number of frames to read. ``-1`` reads all the remaining samples,
+            starting from ``frame_offset``.
+            This function may return the less number of frames if there is not enough
+            frames in the given file.
+        normalize (bool, optional):
+            When ``True``, this function converts the native sample type to ``float32``.
+            Default: ``True``.
+
+            If input file is integer WAV, giving ``False`` will change the resulting Tensor type to
+            integer type.
+            This argument has no effect for formats other than integer WAV type.
+
+        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):
+            Override the format detection with the given format.
+            Providing the argument might help when libsox can not infer the format
+            from header or extension.
+
+    Returns:
+        (torch.Tensor, int): Resulting Tensor and sample rate.
+            If the input file has integer wav format and ``normalize=False``, then it has
+            integer type, else ``float32`` type. If ``channels_first=True``, it has
+            `[channel, time]` else `[time, channel]`.
+    """
+    if not torch.jit.is_scripting():
+        if hasattr(filepath, "read"):
+            raise RuntimeError("sox_io backend does not support file-like object.")
+        filepath = os.fspath(filepath)
+    return torch.ops.torchaudio.sox_io_load_audio_file(
+        filepath, frame_offset, num_frames, normalize, channels_first, format
+    )
+
+
+@torchaudio._extension.fail_if_no_sox
+def save(
+    filepath: str,
+    src: torch.Tensor,
+    sample_rate: int,
+    channels_first: bool = True,
+    compression: Optional[float] = None,
+    format: Optional[str] = None,
+    encoding: Optional[str] = None,
+    bits_per_sample: Optional[int] = None,
+):
+    """Save audio data to file.
+
+    Args:
+        filepath (path-like object): Path to save file.
+        src (torch.Tensor): Audio data to save. must be 2D tensor.
+        sample_rate (int): sampling rate
+        channels_first (bool, optional): If ``True``, the given tensor is interpreted as `[channel, time]`,
+            otherwise `[time, channel]`.
+        compression (float or None, optional): Used for formats other than WAV.
+            This corresponds to ``-C`` option of ``sox`` command.
+
+            ``"mp3"``
+                Either bitrate (in ``kbps``) with quality factor, such as ``128.2``, or
+                VBR encoding with quality factor such as ``-4.2``. Default: ``-4.5``.
+
+            ``"flac"``
+                Whole number from ``0`` to ``8``. ``8`` is default and highest compression.
+
+            ``"ogg"``, ``"vorbis"``
+                Number from ``-1`` to ``10``; ``-1`` is the highest compression
+                and lowest quality. Default: ``3``.
+
+            See the detail at http://sox.sourceforge.net/soxformat.html.
+        format (str or None, optional): Override the audio format.
+            When ``filepath`` argument is path-like object, audio format is infered from
+            file extension. If file extension is missing or different, you can specify the
+            correct format with this argument.
+
+            When ``filepath`` argument is file-like object, this argument is required.
+
+            Valid values are ``"wav"``, ``"mp3"``, ``"ogg"``, ``"vorbis"``, ``"amr-nb"``,
+            ``"amb"``, ``"flac"``, ``"sph"``, ``"gsm"``, and ``"htk"``.
+
+        encoding (str or None, optional): Changes the encoding for the supported formats.
+            This argument is effective only for supported formats, such as ``"wav"``, ``""amb"``
+            and ``"sph"``. Valid values are;
+
+                - ``"PCM_S"`` (signed integer Linear PCM)
+                - ``"PCM_U"`` (unsigned integer Linear PCM)
+                - ``"PCM_F"`` (floating point PCM)
+                - ``"ULAW"`` (mu-law)
+                - ``"ALAW"`` (a-law)
+
+            Default values
+                If not provided, the default value is picked based on ``format`` and ``bits_per_sample``.
+
+                ``"wav"``, ``"amb"``
+                    - | If both ``encoding`` and ``bits_per_sample`` are not provided, the ``dtype`` of the
+                      | Tensor is used to determine the default value.
+
+                        - ``"PCM_U"`` if dtype is ``uint8``
+                        - ``"PCM_S"`` if dtype is ``int16`` or ``int32``
+                        - ``"PCM_F"`` if dtype is ``float32``
+
+                    - ``"PCM_U"`` if ``bits_per_sample=8``
+                    - ``"PCM_S"`` otherwise
+
+                ``"sph"`` format;
+                    - the default value is ``"PCM_S"``
+
+        bits_per_sample (int or None, optional): Changes the bit depth for the supported formats.
+            When ``format`` is one of ``"wav"``, ``"flac"``, ``"sph"``, or ``"amb"``, you can change the
+            bit depth. Valid values are ``8``, ``16``, ``32`` and ``64``.
+
+            Default Value;
+                If not provided, the default values are picked based on ``format`` and ``"encoding"``;
+
+                ``"wav"``, ``"amb"``;
+                    - | If both ``encoding`` and ``bits_per_sample`` are not provided, the ``dtype`` of the
+                      | Tensor is used.
+
+                        - ``8`` if dtype is ``uint8``
+                        - ``16`` if dtype is ``int16``
+                        - ``32`` if dtype is  ``int32`` or ``float32``
+
+                    - ``8`` if ``encoding`` is ``"PCM_U"``, ``"ULAW"`` or ``"ALAW"``
+                    - ``16`` if ``encoding`` is ``"PCM_S"``
+                    - ``32`` if ``encoding`` is ``"PCM_F"``
+
+                ``"flac"`` format;
+                    - the default value is ``24``
+
+                ``"sph"`` format;
+                    - ``16`` if ``encoding`` is ``"PCM_U"``, ``"PCM_S"``, ``"PCM_F"`` or not provided.
+                    - ``8`` if ``encoding`` is ``"ULAW"`` or ``"ALAW"``
+
+                ``"amb"`` format;
+                    - ``8`` if ``encoding`` is ``"PCM_U"``, ``"ULAW"`` or ``"ALAW"``
+                    - ``16`` if ``encoding`` is ``"PCM_S"`` or not provided.
+                    - ``32`` if ``encoding`` is ``"PCM_F"``
+
+    Supported formats/encodings/bit depth/compression are;
+
+    ``"wav"``, ``"amb"``
+        - 32-bit floating-point PCM
+        - 32-bit signed integer PCM
+        - 24-bit signed integer PCM
+        - 16-bit signed integer PCM
+        - 8-bit unsigned integer PCM
+        - 8-bit mu-law
+        - 8-bit a-law
+
+        Note: Default encoding/bit depth is determined by the dtype of the input Tensor.
+
+    ``"mp3"``
+        Fixed bit rate (such as 128kHz) and variable bit rate compression.
+        Default: VBR with high quality.
+
+    ``"flac"``
+        - 8-bit
+        - 16-bit
+        - 24-bit (default)
+
+    ``"ogg"``, ``"vorbis"``
+        - Different quality level. Default: approx. 112kbps
+
+    ``"sph"``
+        - 8-bit signed integer PCM
+        - 16-bit signed integer PCM
+        - 24-bit signed integer PCM
+        - 32-bit signed integer PCM (default)
+        - 8-bit mu-law
+        - 8-bit a-law
+        - 16-bit a-law
+        - 24-bit a-law
+        - 32-bit a-law
+
+    ``"amr-nb"``
+        Bitrate ranging from 4.75 kbit/s to 12.2 kbit/s. Default: 4.75 kbit/s
+
+    ``"gsm"``
+        Lossy Speech Compression, CPU intensive.
+
+    ``"htk"``
+        Uses a default single-channel 16-bit PCM format.
+
+    Note:
+        To save into formats that ``libsox`` does not handle natively, (such as ``"mp3"``,
+        ``"flac"``, ``"ogg"`` and ``"vorbis"``), your installation of ``torchaudio`` has
+        to be linked to ``libsox`` and corresponding codec libraries such as ``libmad``
+        or ``libmp3lame`` etc.
+    """
+    if not torch.jit.is_scripting():
+        if hasattr(filepath, "write"):
+            raise RuntimeError("sox_io backend does not handle file-like object.")
+        filepath = os.fspath(filepath)
+    torch.ops.torchaudio.sox_io_save_audio_file(
+        filepath,
+        src,
+        sample_rate,
+        channels_first,
+        compression,
+        format,
+        encoding,
+        bits_per_sample,
+    )

torchaudio/backend/common.py

@@ -1,53 +1,13 @@
-class AudioMetaData:
-    """Return type of ``torchaudio.info`` function.
-
-    This class is used by :py:mod:`"sox_io" backend<torchaudio.backends.sox_io_backend>` and
-    :py:mod:`"soundfile" backend<torchaudio.backends.soundfile_backend>`.
-
-    :ivar int sample_rate: Sample rate
-    :ivar int num_frames: The number of frames
-    :ivar int num_channels: The number of channels
-    :ivar int bits_per_sample: The number of bits per sample. This is 0 for lossy formats,
-        or when it cannot be accurately inferred.
-    :ivar str encoding: Audio encoding
-        The values encoding can take are one of the following:
-
-            * ``PCM_S``: Signed integer linear PCM
-            * ``PCM_U``: Unsigned integer linear PCM
-            * ``PCM_F``: Floating point linear PCM
-            * ``FLAC``: Flac, Free Lossless Audio Codec
-            * ``ULAW``: Mu-law
-            * ``ALAW``: A-law
-            * ``MP3`` : MP3, MPEG-1 Audio Layer III
-            * ``VORBIS``: OGG Vorbis
-            * ``AMR_WB``: Adaptive Multi-Rate Wideband
-            * ``AMR_NB``: Adaptive Multi-Rate Narrowband
-            * ``OPUS``: Opus
-            * ``HTK``: Single channel 16-bit PCM
-            * ``UNKNOWN`` : None of above
-    """
-
-    def __init__(
-        self,
-        sample_rate: int,
-        num_frames: int,
-        num_channels: int,
-        bits_per_sample: int,
-        encoding: str,
-    ):
-        self.sample_rate = sample_rate
-        self.num_frames = num_frames
-        self.num_channels = num_channels
-        self.bits_per_sample = bits_per_sample
-        self.encoding = encoding
-
-    def __str__(self):
-        return (
-            f"AudioMetaData("
-            f"sample_rate={self.sample_rate}, "
-            f"num_frames={self.num_frames}, "
-            f"num_channels={self.num_channels}, "
-            f"bits_per_sample={self.bits_per_sample}, "
-            f"encoding={self.encoding}"
-            f")"
+def __getattr__(name: str):
+    import warnings
+
+    if name == "AudioMetaData":
+        warnings.warn(
+            "`torchaudio.backend.common.AudioMetaData` has been moved to "
+            "`torchaudio.AudioMetaData`. Please update the import path.",
+            stacklevel=2,
         )
+        from torchaudio._backend.common import AudioMetaData
+
+        return AudioMetaData
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")