Implement audio playback

Author: adazem009

include/scratchcpp/sound.h

@@ -17,13 +17,22 @@ class LIBSCRATCHCPP_EXPORT Sound : public Asset
     public:
         Sound(const std::string &name, const std::string &id, const std::string &format);
         Sound(const Sound &) = delete;
+        virtual ~Sound() { }
 
         int rate() const;
         void setRate(int newRate);
 
         int sampleCount() const;
         void setSampleCount(int newSampleCount);
 
+        virtual void start();
+        virtual void stop();
+
+        virtual bool isPlaying();
+
+    protected:
+        void processData(unsigned int size, void *data) override;
+
     private:
         spimpl::unique_impl_ptr<SoundPrivate> impl;
 };

src/scratch/sound.cpp

@@ -1,8 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <scratchcpp/sound.h>
+#include <iostream>
 
 #include "sound_p.h"
+#include "audio/audioplayerfactory.h"
 
 using namespace libscratchcpp;
 
@@ -36,3 +38,27 @@ void Sound::setSampleCount(int newSampleCount)
 {
     impl->sampleCount = newSampleCount;
 }
+
+/*! Starts the playback of the sound. */
+void Sound::start()
+{
+    impl->player->start();
+}
+
+/*! Stops the playback of the sound. */
+void Sound::stop()
+{
+    impl->player->stop();
+}
+
+/*! Returns true if the sound is being played. */
+bool Sound::isPlaying()
+{
+    return impl->player->isPlaying();
+}
+
+void Sound::processData(unsigned int size, void *data)
+{
+    if (!impl->player->load(size, data, impl->rate))
+        std::cerr << "Failed to load sound " << name() << std::endl;
+}

src/scratch/sound_p.cpp

@@ -1,9 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "sound_p.h"
+#include "audio/audioplayerfactory.h"
 
 using namespace libscratchcpp;
 
+IAudioPlayerFactory *SoundPrivate::playerFactory = nullptr;
+
 SoundPrivate::SoundPrivate()
 {
+    // NOTE: playerFactory must be initialized in the constructor to avoid static initialization order fiasco
+    if (!playerFactory)
+        playerFactory = AudioPlayerFactory::instance().get();
+
+    player = playerFactory->create();
 }

src/scratch/sound_p.h

@@ -4,6 +4,9 @@
 
 #include <string>
 
+#include "audio/iaudioplayerfactory.h"
+#include "audio/iaudioplayer.h"
+
 namespace libscratchcpp
 {
 
@@ -14,6 +17,8 @@ struct SoundPrivate
 
         int rate = 0;
         int sampleCount = 0;
+        static IAudioPlayerFactory *playerFactory;
+        std::shared_ptr<IAudioPlayer> player = nullptr;
 };
 
 } // namespace libscratchcpp

test/assets/CMakeLists.txt

@@ -39,7 +39,9 @@ add_executable(
 target_link_libraries(
   sound_test
   GTest::gtest_main
+  GTest::gmock_main
   scratchcpp
+  scratchcpp_mocks
 )
 
 gtest_discover_tests(sound_test)

test/assets/sound_test.cpp

@@ -1,10 +1,31 @@
 #include <scratchcpp/sound.h>
+#include <scratch/sound_p.h>
+#include <audioplayerfactorymock.h>
+#include <audioplayermock.h>
 
 #include "../common.h"
 
 using namespace libscratchcpp;
 
-TEST(SoundTest, Constructors)
+using ::testing::Return;
+
+class SoundTest : public testing::Test
+{
+    public:
+        void SetUp() override
+        {
+            m_player = std::make_shared<AudioPlayerMock>();
+            SoundPrivate::playerFactory = &m_playerFactory;
+            EXPECT_CALL(m_playerFactory, create()).WillOnce(Return(m_player));
+        }
+
+        void TearDown() override { SoundPrivate::playerFactory = nullptr; }
+
+        AudioPlayerFactoryMock m_playerFactory;
+        std::shared_ptr<AudioPlayerMock> m_player;
+};
+
+TEST_F(SoundTest, Constructors)
 {
     Sound sound("sound1", "a", "wav");
     ASSERT_EQ(sound.id(), "a");
@@ -15,18 +36,59 @@ TEST(SoundTest, Constructors)
     ASSERT_EQ(sound.sampleCount(), 0);
 }
 
-TEST(SoundTest, Rate)
+TEST_F(SoundTest, Rate)
 {
     Sound sound("sound1", "a", "wav");
 
     sound.setRate(2);
     ASSERT_EQ(sound.rate(), 2);
 }
 
-TEST(SoundTest, SampleCount)
+TEST_F(SoundTest, SampleCount)
 {
     Sound sound("sound1", "a", "wav");
 
     sound.setSampleCount(10);
     ASSERT_EQ(sound.sampleCount(), 10);
 }
+
+TEST_F(SoundTest, ProcessData)
+{
+    Sound sound("sound1", "a", "wav");
+    sound.setRate(44100);
+
+    const char *data = "abc";
+    void *dataPtr = const_cast<void *>(static_cast<const void *>(data));
+
+    EXPECT_CALL(*m_player, load(3, dataPtr, 44100));
+    sound.setData(3, dataPtr);
+}
+
+TEST_F(SoundTest, Start)
+{
+    Sound sound("sound1", "a", "wav");
+
+    EXPECT_CALL(*m_player, start());
+    sound.start();
+}
+
+TEST_F(SoundTest, Stop)
+{
+    Sound sound("sound1", "a", "wav");
+
+    EXPECT_CALL(*m_player, stop());
+    sound.stop();
+}
+
+TEST_F(SoundTest, IsPlaying)
+{
+    Sound sound("sound1", "a", "wav");
+
+    EXPECT_CALL(*m_player, isPlaying()).WillOnce(Return(true));
+    ASSERT_TRUE(sound.isPlaying());
+
+    EXPECT_CALL(*m_player, isPlaying()).WillOnce(Return(false));
+    ASSERT_FALSE(sound.isPlaying());
+
+    SoundPrivate::playerFactory = nullptr;
+}

test/mocks/audioplayerfactorymock.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <audio/iaudioplayerfactory.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class AudioPlayerFactoryMock : public IAudioPlayerFactory
+{
+    public:
+        MOCK_METHOD(std::shared_ptr<IAudioPlayer>, create, (), (const, override));
+};

test/mocks/audioplayermock.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <audio/iaudioplayer.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class AudioPlayerMock : public IAudioPlayer
+{
+    public:
+        MOCK_METHOD(bool, load, (unsigned int, const void *, unsigned long), (override));
+
+        MOCK_METHOD(void, start, (), (override));
+        MOCK_METHOD(void, stop, (), (override));
+
+        MOCK_METHOD(bool, isPlaying, (), (override, const));
+};