Publish more bindings

Author: kunitoki

modules/yup_python/bindings/yup_YupAudioBasics_bindings.cpp

@@ -0,0 +1,166 @@
+/*
+  ==============================================================================
+
+   This file is part of the YUP library.
+   Copyright (c) 2025 - [email protected]
+
+   YUP is an open source library subject to open-source licensing.
+
+   The code included in this file is provided under the terms of the ISC license
+   http://www.isc.org/downloads/software-support-policy/isc-license. Permission
+   to use, copy, modify, and/or distribute this software for any purpose with or
+   without fee is hereby granted provided that the above copyright notice and
+   this permission notice appear in all copies.
+
+   YUP IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+#pragma once
+
+#if ! YUP_MODULE_AVAILABLE_yup_audio_basics
+#error This binding file requires adding the yup_audio_basics module in the project
+#else
+#include <yup_audio_basics/yup_audio_basics.h>
+#endif
+
+#include "yup_YupCore_bindings.h"
+
+#define YUP_PYTHON_INCLUDE_PYBIND11_OPERATORS
+#define YUP_PYTHON_INCLUDE_PYBIND11_STL
+#include "../utilities/yup_PyBind11Includes.h"
+
+namespace yup::Bindings
+{
+
+//==============================================================================
+
+void registerYupAudioBasicsBindings (pybind11::module_& m);
+
+//==============================================================================
+
+template <class Base = AudioSource>
+struct PyAudioSource : Base
+{
+    using Base::Base;
+
+    void prepareToPlay (int samplesPerBlockExpected, double sampleRate) override
+    {
+        PYBIND11_OVERRIDE_PURE (void, Base, prepareToPlay, samplesPerBlockExpected, sampleRate);
+    }
+
+    void releaseResources() override
+    {
+        PYBIND11_OVERRIDE_PURE (void, Base, releaseResources);
+    }
+
+    void getNextAudioBlock (const AudioSourceChannelInfo& bufferToFill) override
+    {
+        PYBIND11_OVERRIDE_PURE (void, Base, getNextAudioBlock, bufferToFill);
+    }
+};
+
+//==============================================================================
+
+template <class Base = PositionableAudioSource>
+struct PyPositionableAudioSource : PyAudioSource<Base>
+{
+    using PyAudioSource<Base>::PyAudioSource;
+
+    void setNextReadPosition (int64 newPosition) override
+    {
+        PYBIND11_OVERRIDE_PURE (void, Base, setNextReadPosition, newPosition);
+    }
+
+    int64 getNextReadPosition() const override
+    {
+        PYBIND11_OVERRIDE_PURE (int64, Base, getNextReadPosition);
+    }
+
+    int64 getTotalLength() const override
+    {
+        PYBIND11_OVERRIDE_PURE (int64, Base, getTotalLength);
+    }
+
+    bool isLooping() const override
+    {
+        PYBIND11_OVERRIDE_PURE (bool, Base, isLooping);
+    }
+
+    void setLooping (bool shouldLoop) override
+    {
+        PYBIND11_OVERRIDE (void, Base, setLooping, shouldLoop);
+    }
+};
+
+//==============================================================================
+
+struct PySynthesiserSound : SynthesiserSound
+{
+    bool appliesToNote (int midiNoteNumber) override
+    {
+        PYBIND11_OVERRIDE_PURE (bool, SynthesiserSound, appliesToNote, midiNoteNumber);
+    }
+
+    bool appliesToChannel (int midiChannel) override
+    {
+        PYBIND11_OVERRIDE_PURE (bool, SynthesiserSound, appliesToChannel, midiChannel);
+    }
+};
+
+//==============================================================================
+
+struct PySynthesiserVoice : SynthesiserVoice
+{
+    bool canPlaySound (SynthesiserSound* sound) override
+    {
+        PYBIND11_OVERRIDE_PURE (bool, SynthesiserVoice, canPlaySound, sound);
+    }
+
+    void startNote (int midiNoteNumber, float velocity, SynthesiserSound* sound, int currentPitchWheelPosition) override
+    {
+        PYBIND11_OVERRIDE_PURE (void, SynthesiserVoice, startNote, midiNoteNumber, velocity, sound, currentPitchWheelPosition);
+    }
+
+    void stopNote (float velocity, bool allowTailOff) override
+    {
+        PYBIND11_OVERRIDE_PURE (void, SynthesiserVoice, stopNote, velocity, allowTailOff);
+    }
+
+    void pitchWheelMoved (int newPitchWheelValue) override
+    {
+        PYBIND11_OVERRIDE_PURE (void, SynthesiserVoice, pitchWheelMoved, newPitchWheelValue);
+    }
+
+    void controllerMoved (int controllerNumber, int newControllerValue) override
+    {
+        PYBIND11_OVERRIDE_PURE (void, SynthesiserVoice, controllerMoved, controllerNumber, newControllerValue);
+    }
+
+    void renderNextBlock (AudioBuffer<float>& outputBuffer, int startSample, int numSamples) override
+    {
+        PYBIND11_OVERRIDE_PURE (void, SynthesiserVoice, renderNextBlock, outputBuffer, startSample, numSamples);
+    }
+
+    void setCurrentPlaybackSampleRate (double newRate) override
+    {
+        PYBIND11_OVERRIDE (void, SynthesiserVoice, setCurrentPlaybackSampleRate, newRate);
+    }
+
+    bool isVoiceActive() const override
+    {
+        PYBIND11_OVERRIDE (bool, SynthesiserVoice, isVoiceActive);
+    }
+};
+
+//==============================================================================
+
+struct PyAudioPlayHeadPositionInfo : AudioPlayHead::PositionInfo
+{
+    using AudioPlayHead::PositionInfo::PositionInfo;
+};
+
+} // namespace yup::Bindings

modules/yup_python/bindings/yup_YupAudioBasics_bindings.h

@@ -40,11 +40,11 @@
 #include "../bindings/yup_YupGui_bindings.h"
 #endif
 
-/*
 #if YUP_MODULE_AVAILABLE_yup_audio_basics
 #include "../bindings/yup_YupAudioBasics_bindings.h"
 #endif
 
+/*
 #if YUP_MODULE_AVAILABLE_yup_audio_devices
 #include "../bindings/yup_YupAudioDevices_bindings.h"
 #endif
@@ -92,11 +92,11 @@ PYBIND11_MODULE (YUP_PYTHON_MODULE_NAME, m)
     yup::Bindings::registerYupGuiBindings (m);
 #endif
 
-    /*
 #if YUP_MODULE_AVAILABLE_yup_audio_basics
     yup::Bindings::registerYupAudioBasicsBindings (m);
 #endif
 
+    /*
 #if YUP_MODULE_AVAILABLE_yup_audio_devices
     yup::Bindings::registerYupAudioDevicesBindings (m);
 #endif

modules/yup_python/modules/yup_YupMain_module.cpp

@@ -0,0 +1,22 @@
+/*
+  ==============================================================================
+
+   This file is part of the YUP library.
+   Copyright (c) 2025 - [email protected]
+
+   YUP is an open source library subject to open-source licensing.
+
+   The code included in this file is provided under the terms of the ISC license
+   http://www.isc.org/downloads/software-support-policy/isc-license. Permission
+   to use, copy, modify, and/or distribute this software for any purpose with or
+   without fee is hereby granted provided that the above copyright notice and
+   this permission notice appear in all copies.
+
+   YUP IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+   DISCLAIMED.
+
+  ==============================================================================
+*/
+
+#include "bindings/yup_YupAudioBasics_bindings.cpp"

modules/yup_python/yup_python_audio_basics.cpp

@@ -0,0 +1 @@
+# Test package for yup_audio_basics bindings

python/tests/test_yup_audio_basics/__init__.py

@@ -0,0 +1,169 @@
+import yup
+
+#==================================================================================================
+
+def test_adsr_parameters_construction():
+    # Test default construction
+    params = yup.ADSR.Parameters()
+    assert params.attack >= 0.0
+    assert params.decay >= 0.0
+    assert params.sustain >= 0.0
+    assert params.release >= 0.0
+
+    # Test construction with values
+    params = yup.ADSR.Parameters(0.1, 0.2, 0.7, 0.5)
+    assert abs(params.attack - 0.1) < 0.001
+    assert abs(params.decay - 0.2) < 0.001
+    assert abs(params.sustain - 0.7) < 0.001
+    assert abs(params.release - 0.5) < 0.001
+
+#==================================================================================================
+
+def test_adsr_parameters_fields():
+    params = yup.ADSR.Parameters()
+
+    # Test setting fields
+    params.attack = 0.05
+    params.decay = 0.1
+    params.sustain = 0.8
+    params.release = 0.3
+
+    assert abs(params.attack - 0.05) < 0.001
+    assert abs(params.decay - 0.1) < 0.001
+    assert abs(params.sustain - 0.8) < 0.001
+    assert abs(params.release - 0.3) < 0.001
+
+#==================================================================================================
+
+def test_adsr_construction():
+    adsr = yup.ADSR()
+    assert not adsr.isActive()
+
+#==================================================================================================
+
+def test_adsr_set_parameters():
+    adsr = yup.ADSR()
+    params = yup.ADSR.Parameters(0.1, 0.2, 0.7, 0.5)
+
+    adsr.setParameters(params)
+    retrieved = adsr.getParameters()
+
+    assert abs(retrieved.attack - params.attack) < 0.001
+    assert abs(retrieved.decay - params.decay) < 0.001
+    assert abs(retrieved.sustain - params.sustain) < 0.001
+    assert abs(retrieved.release - params.release) < 0.001
+
+#==================================================================================================
+
+def test_adsr_set_sample_rate():
+    adsr = yup.ADSR()
+    adsr.setSampleRate(44100.0)
+
+    # Should not throw, exact behavior depends on implementation
+    params = yup.ADSR.Parameters(0.1, 0.2, 0.7, 0.5)
+    adsr.setParameters(params)
+
+#==================================================================================================
+
+def test_adsr_note_on_off():
+    adsr = yup.ADSR()
+    adsr.setSampleRate(44100.0)
+
+    params = yup.ADSR.Parameters(0.01, 0.01, 0.7, 0.1)
+    adsr.setParameters(params)
+
+    # Initially not active
+    assert not adsr.isActive()
+
+    # Note on activates
+    adsr.noteOn()
+    assert adsr.isActive()
+
+    # Get some samples during attack
+    for _ in range(100):
+        sample = adsr.getNextSample()
+        assert sample >= 0.0
+
+    # Note off starts release
+    adsr.noteOff()
+
+    # Still active during release
+    active_after_noteoff = adsr.isActive()
+
+    # Process through release phase
+    for _ in range(10000):
+        sample = adsr.getNextSample()
+        if not adsr.isActive():
+            break
+
+    # Eventually becomes inactive
+    # (May or may not be inactive depending on release time and samples processed)
+
+#==================================================================================================
+
+def test_adsr_reset():
+    adsr = yup.ADSR()
+    adsr.setSampleRate(44100.0)
+
+    params = yup.ADSR.Parameters(0.01, 0.01, 0.7, 0.1)
+    adsr.setParameters(params)
+
+    adsr.noteOn()
+    assert adsr.isActive()
+
+    # Get some samples
+    for _ in range(100):
+        adsr.getNextSample()
+
+    # Reset should stop immediately
+    adsr.reset()
+    assert not adsr.isActive()
+
+#==================================================================================================
+
+def test_adsr_envelope_shape():
+    adsr = yup.ADSR()
+    adsr.setSampleRate(44100.0)
+
+    # Very short times for testing
+    params = yup.ADSR.Parameters(0.001, 0.001, 0.5, 0.001)
+    adsr.setParameters(params)
+
+    adsr.noteOn()
+
+    # Collect samples during attack phase
+    attack_samples = []
+    for _ in range(100):
+        attack_samples.append(adsr.getNextSample())
+
+    # Attack phase should generally increase
+    # (allowing for some tolerance due to discrete sampling)
+    increasing_count = 0
+    for i in range(len(attack_samples) - 1):
+        if attack_samples[i + 1] >= attack_samples[i]:
+            increasing_count += 1
+
+    # Most samples should be increasing during attack (allow some tolerance)
+    assert increasing_count > len(attack_samples) * 0.4
+
+#==================================================================================================
+
+def test_adsr_sustain_level():
+    adsr = yup.ADSR()
+    adsr.setSampleRate(44100.0)
+
+    sustain_level = 0.6
+    params = yup.ADSR.Parameters(0.0001, 0.0001, sustain_level, 0.1)
+    adsr.setParameters(params)
+
+    adsr.noteOn()
+
+    # Process through attack and decay to reach sustain
+    for _ in range(1000):
+        adsr.getNextSample()
+
+    # Sample during sustain phase should be close to sustain level
+    sustain_sample = adsr.getNextSample()
+
+    # Allow generous tolerance for sustain level
+    assert abs(sustain_sample - sustain_level) < 0.3