fixup! Update stuff

Author: mthrok

test/torchaudio_unittest/backend/sox_io/common.py

@@ -1,2 +1,14 @@
 def name_func(func, _, params):
     return f'{func.__name__}_{"_".join(str(arg) for arg in params.args)}'
+
+
+def get_enc_params(dtype):
+    if dtype == 'float32':
+        return 'PCM_F', 32
+    if dtype == 'int32':
+        return 'PCM_S', 32
+    if dtype == 'int16':
+        return 'PCM_S', 16
+    if dtype == 'uint8':
+        return 'PCM_U', 8
+    raise ValueError(f'Unexpected dtype: {dtype}')

test/torchaudio_unittest/backend/sox_io/roundtrip_test.py

@@ -12,6 +12,7 @@
 )
 from .common import (
     name_func,
+    get_enc_params,
 )
 
 
@@ -27,10 +28,11 @@ class TestRoundTripIO(TempDirMixin, PytorchTestCase):
     def test_wav(self, dtype, sample_rate, num_channels):
         """save/load round trip should not degrade data for wav formats"""
         original = get_wav_data(dtype, num_channels, normalize=False)
+        enc, bps = get_enc_params(dtype)
         data = original
         for i in range(10):
             path = self.get_temp_path(f'{i}.wav')
-            sox_io_backend.save(path, data, sample_rate)
+            sox_io_backend.save(path, data, sample_rate, encoding=enc, bits_per_sample=bps)
             data, sr = sox_io_backend.load(path, normalize=False)
             assert sr == sample_rate
             self.assertEqual(original, data)

test/torchaudio_unittest/backend/sox_io/save_test.py

@@ -16,6 +16,7 @@
 )
 from .common import (
     name_func,
+    get_enc_params,
 )
 
 
@@ -41,7 +42,6 @@ def assert_save_consistency(
             sample_rate: float = 8000,
             num_channels: int = 2,
             num_frames: float = 3 * 8000,
-            src_dtype: str = 'int32',
             rtol: float = 1.3e-06,
             atol: float = 1e-05,
     ):
@@ -52,7 +52,6 @@ def assert_save_consistency(
             compression (float, optional): `compression` value for `save` function
             encoding (str, optional): `encoding` value for `save` function
             bits_per_sample (int, optional): `bits_per_sample` value for `save` function.
-            src_dtype: (str, optional): Dtype for generating the source WAV file.
 
         To compare that the file produced by `save` function agains the file produced by
         the equivalent `sox` command, we need to load both files.
@@ -99,7 +98,7 @@ def assert_save_consistency(
         ref_path = self.get_temp_path('3.2.ref.wav')
 
         # 1. Generate original wav
-        data = get_wav_data(src_dtype, num_channels, normalize=False, num_frames=num_frames)
+        data = get_wav_data('int32', num_channels, normalize=False, num_frames=num_frames)
         save_wav(src_path, data, sample_rate)
 
         # 2.1. Convert the original wav to target format with torchaudio
@@ -128,17 +127,15 @@ def assert_save_consistency(
 
 class SaveTestEncode(SaveTestBase):
     @parameterized.expand([
-        ('PCM_U', 8, 'uint8'),
-        ('PCM_S', 16, 'int16'),
-        ('PCM_S', 32, 'int32'),
-        ('PCM_F', 32, 'float32'),
-        ('ULAW', 8, 'float32'),
-        ('ALAW', 8, 'float32'),
+        ('PCM_U', 8),
+        ('PCM_S', 16),
+        ('PCM_S', 32),
+        ('PCM_F', 32),
+        ('ULAW', 8),
+        ('ALAW', 8),
     ], name_func=name_func)
-    def test_wav(self, encoding, bits_per_sample, src_dtype):
-        self.assert_save_consistency(
-            "wav", encoding=encoding, bits_per_sample=bits_per_sample, src_dtype=src_dtype,
-        )
+    def test_wav(self, encoding, bits_per_sample):
+        self.assert_save_consistency("wav", encoding=encoding, bits_per_sample=bits_per_sample)
 
     @parameterized.expand([
         (None, ),
@@ -249,7 +246,9 @@ def test_large(self, format):
     ], name_func=name_func)
     def test_multi_channels(self, num_channels):
         """`sox_io_backend.save` can save audio with many channels"""
-        self.assert_save_consistency("wav", num_channels=num_channels)
+        self.assert_save_consistency(
+            "wav", encoding="PCM_U", bits_per_sample=16,
+            num_channels=num_channels)
 
 
 @skipIfNoExec('sox')
@@ -260,10 +259,11 @@ class TestSaveParams(TempDirMixin, PytorchTestCase):
     def test_channels_first(self, channels_first):
         """channels_first swaps axes"""
         path = self.get_temp_path('data.wav')
-        data = get_wav_data('int32', 2, channels_first=channels_first)
+        data = get_wav_data(
+            'int16', 2, channels_first=channels_first, normalize=False)
         sox_io_backend.save(
             path, data, 8000, channels_first=channels_first)
-        found = load_wav(path)[0]
+        found = load_wav(path, normalize=False)[0]
         expected = data if channels_first else data.transpose(1, 0)
         self.assertEqual(found, expected)
 
@@ -273,10 +273,12 @@ def test_channels_first(self, channels_first):
     def test_noncontiguous(self, dtype):
         """Noncontiguous tensors are saved correctly"""
         path = self.get_temp_path('data.wav')
-        expected = get_wav_data(dtype, 4)[::2, ::2]
+        enc, bps = get_enc_params(dtype)
+        expected = get_wav_data(dtype, 4, normalize=False)[::2, ::2]
         assert not expected.is_contiguous()
-        sox_io_backend.save(path, expected, 8000)
-        found = load_wav(path)[0]
+        sox_io_backend.save(
+            path, expected, 8000, encoding=enc, bits_per_sample=bps)
+        found = load_wav(path, normalize=False)[0]
         self.assertEqual(found, expected)
 
     @parameterized.expand([
@@ -285,7 +287,7 @@ def test_noncontiguous(self, dtype):
     def test_tensor_preserve(self, dtype):
         """save function should not alter Tensor"""
         path = self.get_temp_path('data.wav')
-        expected = get_wav_data(dtype, 4)[::2, ::2]
+        expected = get_wav_data(dtype, 4, normalize=False)[::2, ::2]
 
         data = expected.clone()
         sox_io_backend.save(path, data, 8000)

test/torchaudio_unittest/backend/sox_io/torchscript_test.py

@@ -17,6 +17,7 @@
 )
 from .common import (
     name_func,
+    get_enc_params,
 )
 
 
@@ -35,8 +36,12 @@ def py_save_func(
         sample_rate: int,
         channels_first: bool = True,
         compression: Optional[float] = None,
+        encoding: Optional[str] = None,
+        bits_per_sample: Optional[int] = None,
 ):
-    torchaudio.save(filepath, tensor, sample_rate, channels_first, compression)
+    torchaudio.save(
+        filepath, tensor, sample_rate, channels_first,
+        compression, None, encoding, bits_per_sample)
 
 
 @skipIfNoExec('sox')
@@ -102,15 +107,16 @@ def test_save_wav(self, dtype, sample_rate, num_channels):
         torch.jit.script(py_save_func).save(script_path)
         ts_save_func = torch.jit.load(script_path)
 
-        expected = get_wav_data(dtype, num_channels)
+        expected = get_wav_data(dtype, num_channels, normalize=False)
         py_path = self.get_temp_path(f'test_save_py_{dtype}_{sample_rate}_{num_channels}.wav')
         ts_path = self.get_temp_path(f'test_save_ts_{dtype}_{sample_rate}_{num_channels}.wav')
+        enc, bps = get_enc_params(dtype)
 
-        py_save_func(py_path, expected, sample_rate, True, None)
-        ts_save_func(ts_path, expected, sample_rate, True, None)
+        py_save_func(py_path, expected, sample_rate, True, None, enc, bps)
+        ts_save_func(ts_path, expected, sample_rate, True, None, enc, bps)
 
-        py_data, py_sr = load_wav(py_path)
-        ts_data, ts_sr = load_wav(ts_path)
+        py_data, py_sr = load_wav(py_path, normalize=False)
+        ts_data, ts_sr = load_wav(ts_path, normalize=False)
 
         self.assertEqual(sample_rate, py_sr)
         self.assertEqual(sample_rate, ts_sr)
@@ -131,8 +137,8 @@ def test_save_flac(self, sample_rate, num_channels, compression_level):
         py_path = self.get_temp_path(f'test_save_py_{sample_rate}_{num_channels}_{compression_level}.flac')
         ts_path = self.get_temp_path(f'test_save_ts_{sample_rate}_{num_channels}_{compression_level}.flac')
 
-        py_save_func(py_path, expected, sample_rate, True, compression_level)
-        ts_save_func(ts_path, expected, sample_rate, True, compression_level)
+        py_save_func(py_path, expected, sample_rate, True, compression_level, None, None)
+        ts_save_func(ts_path, expected, sample_rate, True, compression_level, None, None)
 
         # converting to 32 bit because flac file has 24 bit depth which scipy cannot handle.
         py_path_wav = f'{py_path}.wav'

torchaudio/backend/sox_io_backend.py

@@ -147,29 +147,6 @@ def load(
         filepath, frame_offset, num_frames, normalize, channels_first, format)
 
 
-@torch.jit.unused
-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,
-):
-    if hasattr(filepath, 'write'):
-        if format is None:
-            raise RuntimeError('`format` is required when saving to file object.')
-        torchaudio._torchaudio.save_audio_fileobj(
-            filepath, src, sample_rate, channels_first, compression,
-            format, encoding, bits_per_sample)
-    else:
-        torch.ops.torchaudio.sox_io_save_audio_file(
-            os.fspath(filepath), src, sample_rate, channels_first, compression,
-            format, encoding, bits_per_sample)
-
-
 @_mod_utils.requires_module('torchaudio._torchaudio')
 def save(
         filepath: str,