Merge pull request #534 from scratchcpp/sound_clone

Fix #411: Implement sound cloning

Author: adazem009

include/scratchcpp/sound.h

@@ -32,6 +32,8 @@ class LIBSCRATCHCPP_EXPORT Sound : public Asset
 
         virtual bool isPlaying();
 
+        std::shared_ptr<Sound> clone() const;
+
     protected:
         void processData(unsigned int size, void *data) override;
 

src/audio/iaudioplayer.h

@@ -11,8 +11,13 @@ class IAudioPlayer
         virtual ~IAudioPlayer() { }
 
         virtual bool load(unsigned int size, const void *data, unsigned long sampleRate) = 0;
+        virtual bool loadCopy(IAudioPlayer *player) = 0;
+
+        virtual float volume() const = 0;
         virtual void setVolume(float volume) = 0;
 
+        virtual bool isLoaded() const = 0;
+
         virtual void start() = 0;
         virtual void stop() = 0;
 

src/audio/internal/audioplayer.cpp

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <iostream>
+#include <cassert>
 
 #include "audioplayer.h"
 #include "audioengine.h"
@@ -26,7 +27,7 @@ AudioPlayer::~AudioPlayer()
 
 bool AudioPlayer::load(unsigned int size, const void *data, unsigned long sampleRate)
 {
-    if (!AudioEngine::initialized())
+    if (!AudioEngine::initialized() || m_loaded)
         return false;
 
     ma_engine *engine = AudioEngine::engine();
@@ -55,6 +56,33 @@ bool AudioPlayer::load(unsigned int size, const void *data, unsigned long sample
     return true;
 }
 
+bool AudioPlayer::loadCopy(IAudioPlayer *player)
+{
+    assert(player && dynamic_cast<AudioPlayer *>(player));
+
+    if (!AudioEngine::initialized() || !player || !player->isLoaded())
+        return false;
+
+    ma_engine *engine = AudioEngine::engine();
+
+    AudioPlayer *playerPtr = static_cast<AudioPlayer *>(player);
+    ma_result initResult = ma_sound_init_from_data_source(engine, playerPtr->m_decoder, MA_SOUND_FLAG_DECODE, NULL, m_sound);
+
+    if (initResult != MA_SUCCESS) {
+        std::cerr << "Failed to init sound copy." << std::endl;
+        return false;
+    }
+
+    m_loaded = true;
+    ma_sound_set_volume(m_sound, m_volume);
+    return true;
+}
+
+float AudioPlayer::volume() const
+{
+    return m_volume;
+}
+
 void AudioPlayer::setVolume(float volume)
 {
     m_volume = volume;
@@ -65,6 +93,11 @@ void AudioPlayer::setVolume(float volume)
     ma_sound_set_volume(m_sound, volume);
 }
 
+bool AudioPlayer::isLoaded() const
+{
+    return m_loaded;
+}
+
 void AudioPlayer::start()
 {
     if (!m_loaded)

src/audio/internal/audioplayer.h

@@ -17,8 +17,13 @@ class AudioPlayer : public IAudioPlayer
         ~AudioPlayer();
 
         bool load(unsigned int size, const void *data, unsigned long sampleRate) override;
+        bool loadCopy(IAudioPlayer *player) override;
+
+        float volume() const override;
         void setVolume(float volume) override;
 
+        bool isLoaded() const override;
+
         void start() override;
         void stop() override;
 

src/audio/internal/audioplayerstub.cpp

@@ -13,8 +13,24 @@ bool AudioPlayerStub::load(unsigned int size, const void *data, unsigned long sa
     return true;
 }
 
+bool AudioPlayerStub::loadCopy(IAudioPlayer *player)
+{
+    return true;
+}
+
+float AudioPlayerStub::volume() const
+{
+    return m_volume;
+}
+
 void AudioPlayerStub::setVolume(float volume)
 {
+    m_volume = volume;
+}
+
+bool AudioPlayerStub::isLoaded() const
+{
+    return true;
 }
 
 void AudioPlayerStub::start()

src/audio/internal/audioplayerstub.h

@@ -13,12 +13,20 @@ class AudioPlayerStub : public IAudioPlayer
         AudioPlayerStub();
 
         bool load(unsigned int size, const void *data, unsigned long sampleRate) override;
+        bool loadCopy(IAudioPlayer *player) override;
+
+        float volume() const override;
         void setVolume(float volume) override;
 
+        bool isLoaded() const override;
+
         void start() override;
         void stop() override;
 
         bool isPlaying() const override;
+
+    private:
+        float m_volume = 1;
 };
 
 } // namespace libscratchcpp

src/scratch/sound.cpp

@@ -62,8 +62,24 @@ bool Sound::isPlaying()
     return impl->player->isPlaying();
 }
 
+/*! Returns an independent copy of the sound which is valid for as long as the original sound exists. */
+std::shared_ptr<Sound> Sound::clone() const
+{
+    auto sound = std::make_shared<Sound>(name(), id(), dataFormat());
+    sound->setRate(rate());
+    sound->setSampleCount(sampleCount());
+    sound->impl->player->loadCopy(impl->player.get());
+    sound->impl->player->setVolume(impl->player->volume());
+    sound->setData(dataSize(), const_cast<void *>(data()));
+
+    return sound;
+}
+
 void Sound::processData(unsigned int size, void *data)
 {
+    if (impl->player->isLoaded())
+        return;
+
     if (!impl->player->load(size, data, impl->rate))
         std::cerr << "Failed to load sound " << name() << std::endl;
 }

src/scratch/sprite.cpp

@@ -6,6 +6,7 @@
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/costume.h>
+#include <scratchcpp/sound.h>
 #include <scratchcpp/rect.h>
 #include <cassert>
 #include <iostream>
@@ -64,6 +65,11 @@ std::shared_ptr<Sprite> Sprite::clone()
         for (auto list : l)
             clone->addList(list->clone());
 
+        const auto &sounds = this->sounds();
+
+        for (auto sound : sounds)
+            clone->addSound(sound->clone());
+
         clone->setCostumeIndex(costumeIndex());
         clone->setLayerOrder(layerOrder());
         clone->setVolume(volume());

src/scratch/target.cpp

@@ -331,18 +331,12 @@ int Target::findCostume(const std::string &costumeName) const
 /*! Returns the list of sounds. */
 const std::vector<std::shared_ptr<Sound>> &Target::sounds() const
 {
-    if (Target *source = dataSource())
-        return source->sounds();
-
     return impl->sounds;
 }
 
 /*! Adds a sound and returns its index. */
 int Target::addSound(std::shared_ptr<Sound> sound)
 {
-    if (Target *source = dataSource())
-        return source->addSound(sound);
-
     auto it = std::find(impl->sounds.begin(), impl->sounds.end(), sound);
 
     if (it != impl->sounds.end())
@@ -360,9 +354,6 @@ int Target::addSound(std::shared_ptr<Sound> sound)
 /*! Returns the sound at index. */
 std::shared_ptr<Sound> Target::soundAt(int index) const
 {
-    if (Target *source = dataSource())
-        return source->soundAt(index);
-
     if (index < 0 || index >= impl->sounds.size())
         return nullptr;
 
@@ -372,9 +363,6 @@ std::shared_ptr<Sound> Target::soundAt(int index) const
 /*! Returns the index of the sound with the given name. */
 int Target::findSound(const std::string &soundName) const
 {
-    if (Target *source = dataSource())
-        return source->findSound(soundName);
-
     auto it = std::find_if(impl->sounds.begin(), impl->sounds.end(), [soundName](std::shared_ptr<Sound> sound) { return sound->name() == soundName; });
 
     if (it == impl->sounds.end())

test/assets/sound_test.cpp

@@ -60,7 +60,12 @@ TEST_F(SoundTest, ProcessData)
     const char *data = "abc";
     void *dataPtr = const_cast<void *>(static_cast<const void *>(data));
 
-    EXPECT_CALL(*m_player, load(3, dataPtr, 44100));
+    EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(false));
+    EXPECT_CALL(*m_player, load(3, dataPtr, 44100)).WillOnce(Return(true));
+    sound.setData(3, dataPtr);
+
+    EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(true));
+    EXPECT_CALL(*m_player, load).Times(0);
     sound.setData(3, dataPtr);
 }
 
@@ -100,3 +105,31 @@ TEST_F(SoundTest, IsPlaying)
 
     SoundPrivate::audioOutput = nullptr;
 }
+
+TEST_F(SoundTest, Clone)
+{
+    Sound sound("sound1", "a", "wav");
+    sound.setRate(44100);
+    sound.setSampleCount(10000);
+
+    const char *data = "abc";
+    void *dataPtr = const_cast<void *>(static_cast<const void *>(data));
+
+    EXPECT_CALL(*m_player, isLoaded()).WillOnce(Return(false));
+    EXPECT_CALL(*m_player, load(3, dataPtr, 44100)).WillOnce(Return(true));
+    sound.setData(3, dataPtr);
+
+    auto clonePlayer = std::make_shared<AudioPlayerMock>();
+    EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(clonePlayer));
+    EXPECT_CALL(*clonePlayer, loadCopy(m_player.get())).WillOnce(Return(true));
+    EXPECT_CALL(*m_player, volume()).WillOnce(Return(0.45));
+    EXPECT_CALL(*clonePlayer, setVolume(0.45));
+    EXPECT_CALL(*clonePlayer, isLoaded()).WillOnce(Return(true));
+    auto clone = sound.clone();
+    ASSERT_TRUE(clone);
+    ASSERT_EQ(clone->name(), sound.name());
+    ASSERT_EQ(clone->id(), sound.id());
+    ASSERT_EQ(clone->dataFormat(), sound.dataFormat());
+    ASSERT_EQ(clone->rate(), sound.rate());
+    ASSERT_EQ(clone->sampleCount(), sound.sampleCount());
+}

test/audio/CMakeLists.txt

@@ -33,3 +33,20 @@ gtest_discover_tests(audioinput_test)
 if (LIBSCRATCHCPP_AUDIO_SUPPORT)
     target_compile_definitions(audioinput_test PRIVATE LIBSCRATCHCPP_AUDIO_SUPPORT)
 endif()
+
+if(LIBSCRATCHCPP_AUDIO_SUPPORT)
+    # audioplayer_test
+    add_executable(
+      audioplayer_test
+      audioplayer_test.cpp
+    )
+
+    target_link_libraries(
+      audioplayer_test
+      GTest::gtest_main
+      scratchcpp
+    )
+
+    gtest_discover_tests(audioplayer_test)
+    target_compile_definitions(audioplayer_test PRIVATE LIBSCRATCHCPP_AUDIO_SUPPORT)
+endif()

test/audio/audioplayer_test.cpp

@@ -0,0 +1,14 @@
+#include <audio/internal/audioplayer.h>
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+TEST(AudioPlayerTest, Volume)
+{
+    AudioPlayer player;
+    ASSERT_EQ(player.volume(), 1);
+
+    player.setVolume(0.86f);
+    ASSERT_EQ(player.volume(), 0.86f);
+}

test/engine/engine_test.cpp

@@ -261,6 +261,9 @@ TEST(EngineTest, StopSounds)
     auto player3 = std::make_shared<AudioPlayerMock>();
     SoundPrivate::audioOutput = &factory;
     EXPECT_CALL(factory, createAudioPlayer()).WillOnce(Return(player1)).WillOnce(Return(player2)).WillOnce(Return(player3));
+    EXPECT_CALL(*player1, isLoaded).WillOnce(Return(false));
+    EXPECT_CALL(*player2, isLoaded).WillOnce(Return(false));
+    EXPECT_CALL(*player3, isLoaded).WillOnce(Return(false));
     EXPECT_CALL(*player1, load).WillOnce(Return(true));
     EXPECT_CALL(*player2, load).WillOnce(Return(true));
     EXPECT_CALL(*player3, load).WillOnce(Return(true));

test/mocks/audioplayermock.h

@@ -9,8 +9,13 @@ class AudioPlayerMock : public IAudioPlayer
 {
     public:
         MOCK_METHOD(bool, load, (unsigned int, const void *, unsigned long), (override));
+        MOCK_METHOD(bool, loadCopy, (IAudioPlayer *), (override));
+
+        MOCK_METHOD(float, volume, (), (const, override));
         MOCK_METHOD(void, setVolume, (float), (override));
 
+        MOCK_METHOD(bool, isLoaded, (), (const, override));
+
         MOCK_METHOD(void, start, (), (override));
         MOCK_METHOD(void, stop, (), (override));
 

test/scratch_classes/sprite_test.cpp

@@ -3,6 +3,7 @@
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/costume.h>
+#include <scratchcpp/sound.h>
 #include <scratchcpp/rect.h>
 #include <scratchcpp/project.h>
 #include <enginemock.h>
@@ -63,6 +64,12 @@ TEST(SpriteTest, Clone)
     sprite.addVariable(var2);
     auto c1 = std::make_shared<Costume>("costume1", "", "svg");
     sprite.addCostume(c1);
+    auto s1 = std::make_shared<Sound>("sound1", "a", "wav");
+    auto s2 = std::make_shared<Sound>("sound2", "b", "wav");
+    auto s3 = std::make_shared<Sound>("sound3", "c", "wav");
+    sprite.addSound(s1);
+    sprite.addSound(s2);
+    sprite.addSound(s3);
 
     auto list1 = std::make_shared<List>("c", "list1");
     list1->push_back("item1");
@@ -111,6 +118,14 @@ TEST(SpriteTest, Clone)
         ASSERT_EQ(*clone->listAt(1), std::deque<Value>({ "test" }));
         ASSERT_EQ(clone->listAt(1)->target(), clone);
 
+        ASSERT_EQ(clone->sounds().size(), 3);
+        ASSERT_EQ(clone->soundAt(0)->id(), "a");
+        ASSERT_EQ(clone->soundAt(0)->name(), "sound1");
+        ASSERT_EQ(clone->soundAt(0)->dataFormat(), "wav");
+        ASSERT_EQ(clone->soundAt(2)->id(), "c");
+        ASSERT_EQ(clone->soundAt(2)->name(), "sound3");
+        ASSERT_EQ(clone->soundAt(2)->dataFormat(), "wav");
+
         ASSERT_EQ(clone->costumeIndex(), 1);
         ASSERT_EQ(clone->layerOrder(), 5);
         ASSERT_EQ(clone->volume(), 50);