Merge pull request #543 from scratchcpp/global_volume_api

Add global volume API

Author: adazem009

include/scratchcpp/iengine.h

@@ -87,6 +87,12 @@ class LIBSCRATCHCPP_EXPORT IEngine
         /*! Stops all currently playing sounds. */
         virtual void stopSounds() = 0;
 
+        /*! Returns the global volume of all sounds (in %). */
+        virtual double globalVolume() const = 0;
+
+        /*! Sets the global volume of all sounds (in %). */
+        virtual void setGlobalVolume(double volume) = 0;
+
         /*! Updates the values of stage monitors. */
         virtual void updateMonitors() = 0;
 

src/audio/CMakeLists.txt

@@ -15,6 +15,7 @@ endif()
 
 target_sources(scratchcpp-audio
   PUBLIC
+    iaudioengine.h
     iaudioplayer.h
     iaudiooutput.h
     audiooutput.cpp
@@ -38,6 +39,8 @@ if (LIBSCRATCHCPP_AUDIO_SUPPORT)
 else()
     target_sources(scratchcpp-audio
       PUBLIC
+        internal/audioenginestub.cpp
+        internal/audioenginestub.h
         internal/audioplayerstub.cpp
         internal/audioplayerstub.h
         internal/audioloudnessstub.cpp

src/audio/iaudioengine.h

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+
+namespace libscratchcpp
+{
+
+class IAudioEngine
+{
+    public:
+        virtual ~IAudioEngine() { }
+
+        static IAudioEngine *instance();
+
+        virtual float volume() const = 0;
+        virtual void setVolume(float volume) = 0;
+};
+
+} // namespace libscratchcpp

src/audio/internal/audioengine.cpp

@@ -1,19 +1,25 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <iostream>
+#include <miniaudio.h>
 
 #include "audioengine.h"
 
 using namespace libscratchcpp;
 
 AudioEngine AudioEngine::instance;
 
+IAudioEngine *IAudioEngine::instance()
+{
+    return &AudioEngine::instance;
+}
+
 ma_engine *AudioEngine::engine()
 {
     if (!instance.m_initialized)
         instance.init();
 
-    return instance.m_initialized ? &instance.m_engine : nullptr;
+    return instance.m_initialized ? instance.m_engine : nullptr;
 }
 
 bool AudioEngine::initialized()
@@ -24,20 +30,36 @@ bool AudioEngine::initialized()
     return instance.m_initialized;
 }
 
+float AudioEngine::volume() const
+{
+    return m_volume;
+}
+
+void AudioEngine::setVolume(float volume)
+{
+    m_volume = volume;
+
+    if (m_initialized)
+        ma_engine_set_volume(m_engine, volume);
+}
+
 AudioEngine::AudioEngine()
 {
 }
 
 AudioEngine::~AudioEngine()
 {
-    if (m_initialized)
-        ma_engine_uninit(&m_engine);
+    if (m_initialized && m_engine) {
+        ma_engine_uninit(m_engine);
+        delete m_engine;
+    }
 }
 
 void AudioEngine::init()
 {
     ma_result result;
-    result = ma_engine_init(NULL, &m_engine);
+    m_engine = new ma_engine;
+    result = ma_engine_init(NULL, m_engine);
 
     if (result != MA_SUCCESS) {
         std::cerr << "Failed to initialize audio engine." << std::endl;

src/audio/internal/audioengine.h

@@ -3,27 +3,37 @@
 #pragma once
 
 #include <memory>
-#include <miniaudio.h>
+
+#include "../iaudioengine.h"
+
+struct ma_engine;
 
 namespace libscratchcpp
 {
 
 // This is a singleton which initializes and uninitializes the miniaudio engine
-class AudioEngine
+class AudioEngine : public IAudioEngine
 {
     public:
+        friend class IAudioEngine;
+
         static ma_engine *engine();
         static bool initialized();
 
+        float volume() const override;
+        void setVolume(float volume) override;
+
     private:
         AudioEngine();
         ~AudioEngine();
 
         void init();
 
         static AudioEngine instance;
-        ma_engine m_engine;
+
+        ma_engine *m_engine = nullptr;
         bool m_initialized = false;
+        float m_volume = 1.0f;
 };
 
 } // namespace libscratchcpp

src/audio/internal/audioenginestub.cpp

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "audioenginestub.h"
+
+using namespace libscratchcpp;
+
+AudioEngineStub AudioEngineStub::instance;
+
+IAudioEngine *IAudioEngine::instance()
+{
+    return &AudioEngineStub::instance;
+}
+
+AudioEngineStub::AudioEngineStub()
+{
+}
+
+float AudioEngineStub::volume() const
+{
+    return m_volume;
+}
+
+void AudioEngineStub::setVolume(float volume)
+{
+    m_volume = volume;
+}

src/audio/internal/audioenginestub.h

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "../iaudioengine.h"
+
+namespace libscratchcpp
+{
+
+class AudioEngineStub : public IAudioEngine
+{
+    public:
+        friend class IAudioEngine;
+        AudioEngineStub();
+
+        float volume() const override;
+        void setVolume(float volume) override;
+
+    private:
+        static AudioEngineStub instance;
+        float m_volume = 1.0f;
+};
+
+} // namespace libscratchcpp

src/audio/internal/audioplayer.cpp

@@ -2,6 +2,7 @@
 
 #include <iostream>
 #include <cassert>
+#include <miniaudio.h>
 
 #include "audioplayer.h"
 #include "audioengine.h"

src/engine/internal/engine.cpp

@@ -26,6 +26,7 @@
 #include "blocksectioncontainer.h"
 #include "timer.h"
 #include "clock.h"
+#include "audio/iaudioengine.h"
 #include "blocks/standardblocks.h"
 #include "blocks/variableblocks.h"
 #include "blocks/listblocks.h"
@@ -46,7 +47,8 @@ const std::unordered_map<Engine::HatType, bool> Engine::m_hatEdgeActivated = {
 Engine::Engine() :
     m_defaultTimer(std::make_unique<Timer>()),
     m_timer(m_defaultTimer.get()),
-    m_clock(Clock::instance().get())
+    m_clock(Clock::instance().get()),
+    m_audioEngine(IAudioEngine::instance())
 {
 }
 
@@ -469,6 +471,16 @@ void Engine::stopSounds()
     }
 }
 
+double Engine::globalVolume() const
+{
+    return m_audioEngine->volume() * 100;
+}
+
+void Engine::setGlobalVolume(double volume)
+{
+    m_audioEngine->setVolume(volume / 100);
+}
+
 void Engine::updateMonitors()
 {
     // Execute the "script" of each visible monitor

src/engine/internal/engine.h

@@ -19,6 +19,7 @@ namespace libscratchcpp
 
 class Entity;
 class IClock;
+class IAudioEngine;
 
 class Engine : public IEngine
 {
@@ -41,7 +42,10 @@ class Engine : public IEngine
         void stopTarget(Target *target, VirtualMachine *exceptScript) override;
         void initClone(std::shared_ptr<Sprite> clone) override;
         void deinitClone(std::shared_ptr<Sprite> clone) override;
+
         void stopSounds() override;
+        virtual double globalVolume() const override;
+        virtual void setGlobalVolume(double volume) override;
 
         void updateMonitors() override;
         void step() override;
@@ -163,6 +167,7 @@ class Engine : public IEngine
         void setUserAgent(const std::string &agent) override;
 
         IClock *m_clock = nullptr;
+        IAudioEngine *m_audioEngine = nullptr;
 
     private:
         enum class HatType

test/audio/CMakeLists.txt

@@ -1,3 +1,21 @@
+# audioengine_test
+add_executable(
+  audioengine_test
+  audioengine_test.cpp
+)
+
+target_link_libraries(
+  audioengine_test
+  GTest::gtest_main
+  scratchcpp
+)
+
+gtest_discover_tests(audioengine_test)
+
+if (LIBSCRATCHCPP_AUDIO_SUPPORT)
+    target_compile_definitions(audioengine_test PRIVATE LIBSCRATCHCPP_AUDIO_SUPPORT)
+endif()
+
 # audiooutput_test
 add_executable(
   audiooutput_test

test/audio/audioengine_test.cpp

@@ -0,0 +1,31 @@
+#ifdef LIBSCRATCHCPP_AUDIO_SUPPORT
+#include <audio/internal/audioengine.h>
+#else
+#include <audio/internal/audioenginestub.h>
+#endif
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+TEST(AudioEngineTest, Instance)
+{
+    IAudioEngine *instance = IAudioEngine::instance();
+    ASSERT_TRUE(instance);
+
+#ifdef LIBSCRATCHCPP_AUDIO_SUPPORT
+    ASSERT_TRUE(dynamic_cast<AudioEngine *>(instance));
+#else
+    ASSERT_TRUE(dynamic_cast<AudioEngineStub *>(instance));
+#endif
+}
+
+TEST(AudioEngineTest, Volume)
+{
+    IAudioEngine *engine = IAudioEngine::instance();
+    ASSERT_TRUE(engine);
+    ASSERT_EQ(engine->volume(), 1.0f);
+
+    engine->setVolume(0.86f);
+    ASSERT_EQ(engine->volume(), 0.86f);
+}

test/engine/engine_test.cpp

@@ -14,6 +14,7 @@
 #include <scratch/sound_p.h>
 #include <timermock.h>
 #include <clockmock.h>
+#include <audioenginemock.h>
 #include <audioinputmock.h>
 #include <audiooutputmock.h>
 #include <audioplayermock.h>
@@ -318,6 +319,24 @@ TEST(EngineTest, StopSounds)
     SoundPrivate::audioOutput = nullptr;
 }
 
+TEST(EngineTest, GlobalVolume)
+{
+    Engine engine;
+    ASSERT_EQ(engine.globalVolume(), 100);
+
+    engine.setGlobalVolume(58.3);
+    ASSERT_EQ(std::round(engine.globalVolume() * 100) / 100, 58.3);
+
+    AudioEngineMock audioEngine;
+    engine.m_audioEngine = &audioEngine;
+
+    EXPECT_CALL(audioEngine, volume()).WillOnce(Return(0.275));
+    ASSERT_EQ(engine.globalVolume(), 27.5);
+
+    EXPECT_CALL(audioEngine, setVolume(0.9236));
+    engine.setGlobalVolume(92.36);
+}
+
 TEST(EngineTest, Step)
 {
     Project p("step.sb3");

test/mocks/audioenginemock.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <audio/iaudioengine.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class AudioEngineMock : public IAudioEngine
+{
+    public:
+        MOCK_METHOD(float, volume, (), (const, override));
+        MOCK_METHOD(void, setVolume, (float), (override));
+};

test/mocks/enginemock.h

@@ -24,7 +24,10 @@ class EngineMock : public IEngine
         MOCK_METHOD(void, stopTarget, (Target *, VirtualMachine *), (override));
         MOCK_METHOD(void, initClone, (std::shared_ptr<Sprite>), (override));
         MOCK_METHOD(void, deinitClone, (std::shared_ptr<Sprite>), (override));
+
         MOCK_METHOD(void, stopSounds, (), (override));
+        MOCK_METHOD(double, globalVolume, (), (const, override));
+        MOCK_METHOD(void, setGlobalVolume, (double), (override));
 
         MOCK_METHOD(void, updateMonitors, (), (override));
         MOCK_METHOD(void, step, (), (override));