Skip to content

πŸŽ› πŸ”Š A Python library for audio.

9.5 KB
Raw Blame
#! /usr/bin/env python
#
# Copyright 2022 Spotify AB
#
# Licensed under the GNU Public License, Version 3.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    https://www.gnu.org/licenses/gpl-3.0.html
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import time
from io import BytesIO

import numpy as np
import pytest

from pedalboard import Resample
from pedalboard.io import AudioFile, ResampledReadableAudioFile, StreamResampler

from .utils import generate_sine_at


def expected_output(
    input_signal, sample_rate: float, target_sample_rate: float, num_channels: int, quality
) -> np.ndarray:
    if sample_rate == target_sample_rate:
        if len(input_signal.shape) == 1:
            return np.expand_dims(input_signal, 0)
        else:
            return input_signal
    resampler = StreamResampler(sample_rate, target_sample_rate, num_channels, quality)
    output = np.concatenate([resampler.process(input_signal), resampler.process(None)], axis=1)
    return output


QUALITIES: list[Resample.Quality] = [
    getattr(Resample.Quality, name)
    for name in dir(Resample.Quality)
    if not name.startswith("_") and name[0].isupper()
]


def test_read_resampled_constructor():
    sine_wave = generate_sine_at(44100, 440, num_seconds=1, num_channels=1).astype(np.float32)

    read_buffer = BytesIO()
    read_buffer.name = "test.wav"
    with AudioFile(read_buffer, "w", 44100, 1, bit_depth=32) as f:
        f.write(sine_wave)

    with AudioFile(BytesIO(read_buffer.getvalue())) as f:
        with f.resampled_to(22050) as r:
            assert isinstance(r, ResampledReadableAudioFile)
        assert r.closed
        assert not f.closed
    assert f.closed


def test_read_resampled_constructor_does_nothing():
    sine_wave = generate_sine_at(44100, 440, num_seconds=1, num_channels=1).astype(np.float32)

    read_buffer = BytesIO()
    read_buffer.name = "test.wav"
    with AudioFile(read_buffer, "w", 44100, 1, bit_depth=32) as f:
        f.write(sine_wave)

    with AudioFile(BytesIO(read_buffer.getvalue())) as f:
        with f.resampled_to(44100) as r:
            assert r is f


def test_read_zero():
    sine_wave = generate_sine_at(44100, 440, num_seconds=1, num_channels=1).astype(np.float32)

    read_buffer = BytesIO()
    read_buffer.name = "test.wav"
    with AudioFile(read_buffer, "w", 44100, 1, bit_depth=32) as f:
        f.write(sine_wave)

    with AudioFile(BytesIO(read_buffer.getvalue())).resampled_to(22050) as f:
        with pytest.raises(ValueError):
            f.read()


@pytest.mark.parametrize("fundamental_hz", [440])
@pytest.mark.parametrize("sample_rate", [8000, 11025, 22050, 44100, 48000])
@pytest.mark.parametrize("target_sample_rate", [123.45, 8000, 11025, 12345.67, 22050, 44100, 48000])
@pytest.mark.parametrize("num_channels", [1, 2])
@pytest.mark.parametrize("quality", QUALITIES, ids=[q.name for q in QUALITIES])
def test_read_resampled(
    fundamental_hz: float,
    sample_rate: float,
    target_sample_rate: float,
    num_channels: int,
    quality,
):
    sine_wave = generate_sine_at(
        sample_rate, fundamental_hz, num_seconds=1, num_channels=num_channels
    ).astype(np.float32)
    expected_sine_wave = expected_output(
        sine_wave, sample_rate, target_sample_rate, num_channels, quality
    )

    read_buffer = BytesIO()
    read_buffer.name = "test.wav"
    with AudioFile(read_buffer, "w", sample_rate, num_channels, bit_depth=32) as f:
        f.write(sine_wave)

    with AudioFile(BytesIO(read_buffer.getvalue())).resampled_to(target_sample_rate, quality) as f:
        actual = f.read(float(f.frames))
        np.testing.assert_allclose(expected_sine_wave, actual, verbose=True)


@pytest.mark.parametrize("sample_rate", [8000, 11025, 22050, 44100, 48000])
@pytest.mark.parametrize("target_sample_rate", [8000, 11025, 12345.67, 22050, 44100, 48000])
@pytest.mark.parametrize("chunk_size", [10, 100])
@pytest.mark.parametrize("quality", QUALITIES, ids=[q.name for q in QUALITIES])
def test_tell_resampled(sample_rate: int, target_sample_rate: float, chunk_size: int, quality):
    signal = np.linspace(1, sample_rate, sample_rate).astype(np.float32)

    read_buffer = BytesIO()
    read_buffer.name = "test.wav"
    with AudioFile(read_buffer, "w", sample_rate, 1, bit_depth=32) as f:
        f.write(signal)

    with AudioFile(BytesIO(read_buffer.getvalue())).resampled_to(target_sample_rate, quality) as f:
        for i in range(0, f.frames, chunk_size):
            assert f.tell() == i
            if f.read(chunk_size).shape[-1] < chunk_size:
                break


@pytest.mark.parametrize("sample_rate", [8000, 11025, 22050, 44100, 48000])
@pytest.mark.parametrize("target_sample_rate", [8000, 11025, 12345.67, 22050, 44100, 48000])
@pytest.mark.parametrize("offset", [2, 10, 100, -10, -1000])
@pytest.mark.parametrize("chunk_size", [2, 10, 50, 100, 1_000_000])
@pytest.mark.parametrize("quality", QUALITIES, ids=[q.name for q in QUALITIES])
def test_seek_resampled(
    sample_rate: int, target_sample_rate: float, offset: int, chunk_size: int, quality
):
    signal = np.linspace(1, sample_rate, sample_rate).astype(np.float32)

    read_buffer = BytesIO()
    read_buffer.name = "test.wav"
    with AudioFile(read_buffer, "w", sample_rate, 1, bit_depth=32) as f:
        f.write(signal)

    with AudioFile(BytesIO(read_buffer.getvalue())).resampled_to(target_sample_rate, quality) as f:
        effective_offset = offset if offset >= 0 else f.frames + offset
        f.read(effective_offset)
        expected = f.read(chunk_size)
        f.seek(effective_offset)
        actual = f.read(chunk_size)
        np.testing.assert_allclose(expected, actual)


@pytest.mark.parametrize("sample_rate", [8000, 11025])
@pytest.mark.parametrize("target_sample_rate", [8000, 11025, 12345.67])
def test_seek_resampled_is_constant_time(sample_rate: int, target_sample_rate: float):
    signal = np.random.rand(sample_rate * 60).astype(np.float32)

    read_buffer = BytesIO()
    read_buffer.name = "test.wav"
    with AudioFile(read_buffer, "w", sample_rate, 1) as f:
        f.write(signal)

    with AudioFile(BytesIO(read_buffer.getvalue())).resampled_to(target_sample_rate) as f:
        timings = []
        for i in range(0, f.frames, sample_rate):
            a = time.time()
            f.seek(i)
            b = time.time()
            timings.append(b - a)
        assert np.std(timings) < 0.02


@pytest.mark.parametrize("sample_rate", [8000, 11025, 22050, 44100, 48000])
@pytest.mark.parametrize("target_sample_rate", [8000, 11025, 12345.67, 22050, 44100, 48000])
@pytest.mark.parametrize("chunk_size", [1000])
@pytest.mark.parametrize("duration", [1.0])
@pytest.mark.parametrize("quality", QUALITIES, ids=[q.name for q in QUALITIES])
def test_read_resampled_in_chunks(
    sample_rate: float, target_sample_rate: float, chunk_size: int, duration: float, quality
):
    signal = np.linspace(1, sample_rate, int(sample_rate * duration)).astype(np.float32)
    expected_signal = expected_output(signal, sample_rate, target_sample_rate, 1, quality)

    read_buffer = BytesIO()
    read_buffer.name = "test.wav"
    with AudioFile(read_buffer, "w", sample_rate, 1, bit_depth=32) as f:
        f.write(signal)
    read_buffer.seek(0)

    with AudioFile(read_buffer).resampled_to(target_sample_rate, quality) as f:
        samples_received = 0
        while f.tell() < expected_signal.shape[-1]:
            expected_num_frames = min(chunk_size, expected_signal.shape[-1] - f.tell())
            pos = f.tell()
            output = f.read(chunk_size)
            output_size = output.shape[-1]
            assert output_size == expected_num_frames

            np.testing.assert_allclose(
                expected_signal[:, samples_received : samples_received + output_size],
                output,
                err_msg=f"Output mismatch from {pos:,} to {f.tell():,} of {f.frames:,} samples.",
            )

            samples_received += output_size
        assert samples_received == f.tell()


@pytest.mark.parametrize("sample_rate", [8000, 48000])
@pytest.mark.parametrize("target_sample_rate", [8000, 12345.67, 22050, 44100, 48000])
@pytest.mark.parametrize("chunk_size", [1, 4, 5])
@pytest.mark.parametrize("duration", [0.1])
@pytest.mark.parametrize("quality", QUALITIES, ids=[q.name for q in QUALITIES])
def test_read_resampled_with_tiny_chunks(
    sample_rate: float, target_sample_rate: float, chunk_size: int, duration, quality
):
    if sample_rate == target_sample_rate:
        return
    test_read_resampled_in_chunks(sample_rate, target_sample_rate, chunk_size, duration, quality)


@pytest.mark.parametrize("sample_rate", [8000, 11025, 22050, 44100, 48000])
@pytest.mark.parametrize("target_sample_rate", [8000, 11025, 12345.67, 22050, 44100, 48000])
@pytest.mark.parametrize("quality", QUALITIES, ids=[q.name for q in QUALITIES])
def test_frame_count(sample_rate: int, target_sample_rate: float, quality):
    signal = np.linspace(1, sample_rate, sample_rate).astype(np.float32)
    expected_signal = expected_output(signal, sample_rate, target_sample_rate, 1, quality)

    read_buffer = BytesIO()
    read_buffer.name = "test.wav"
    with AudioFile(read_buffer, "w", sample_rate, 1, bit_depth=32) as f:
        f.write(signal)

    with AudioFile(BytesIO(read_buffer.getvalue())).resampled_to(target_sample_rate, quality) as f:
        assert f.frames == expected_signal.shape[-1]