Implement sensing_loudness block

Author: adazem009

src/blocks/sensingblocks.cpp

@@ -14,10 +14,13 @@
 #include "sensingblocks.h"
 
 #include "../engine/internal/clock.h"
+#include "audio/audioinput.h"
+#include "audio/iaudioloudness.h"
 
 using namespace libscratchcpp;
 
 IClock *SensingBlocks::clock = nullptr;
+IAudioInput *SensingBlocks::audioInput = nullptr;
 
 std::string SensingBlocks::name() const
 {
@@ -35,6 +38,7 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "sensing_mousex", &compileMouseX);
     engine->addCompileFunction(this, "sensing_mousey", &compileMouseY);
     engine->addCompileFunction(this, "sensing_setdragmode", &compileSetDragMode);
+    engine->addCompileFunction(this, "sensing_loudness", &compileLoudness);
     engine->addCompileFunction(this, "sensing_timer", &compileTimer);
     engine->addCompileFunction(this, "sensing_resettimer", &compileResetTimer);
     engine->addCompileFunction(this, "sensing_of", &compileOf);
@@ -45,6 +49,7 @@ void SensingBlocks::registerBlocks(IEngine *engine)
     engine->addMonitorNameFunction(this, "sensing_mousedown", &mouseDownMonitorName);
     engine->addMonitorNameFunction(this, "sensing_mousex", &mouseXMonitorName);
     engine->addMonitorNameFunction(this, "sensing_mousey", &mouseYMonitorName);
+    engine->addMonitorNameFunction(this, "sensing_loudness", &loudnessMonitorName);
     engine->addMonitorNameFunction(this, "sensing_timer", &timerMonitorName);
     engine->addMonitorNameFunction(this, "sensing_current", &currentMonitorName);
     engine->addMonitorNameFunction(this, "sensing_dayssince2000", &daysSince2000MonitorName);
@@ -156,6 +161,11 @@ void SensingBlocks::compileSetDragMode(Compiler *compiler)
     }
 }
 
+void SensingBlocks::compileLoudness(Compiler *compiler)
+{
+    compiler->addFunctionCall(&loudness);
+}
+
 void SensingBlocks::compileTimer(Compiler *compiler)
 {
     compiler->addFunctionCall(&timer);
@@ -354,6 +364,12 @@ const std::string &SensingBlocks::mouseYMonitorName(Block *block)
     return name;
 }
 
+const std::string &SensingBlocks::loudnessMonitorName(Block *block)
+{
+    static const std::string name = "loudness";
+    return name;
+}
+
 const std::string &SensingBlocks::timerMonitorName(Block *block)
 {
     static const std::string name = "timer";
@@ -453,6 +469,16 @@ unsigned int SensingBlocks::setNotDraggableMode(VirtualMachine *vm)
     return 0;
 }
 
+unsigned int SensingBlocks::loudness(VirtualMachine *vm)
+{
+    if (!audioInput)
+        audioInput = AudioInput::instance().get();
+
+    auto audioLoudness = audioInput->audioLoudness();
+    vm->addReturnValue(audioLoudness->getLoudness());
+    return 0;
+}
+
 unsigned int SensingBlocks::distanceTo(VirtualMachine *vm)
 {
     Sprite *sprite = dynamic_cast<Sprite *>(vm->target());

src/blocks/sensingblocks.h

@@ -12,6 +12,7 @@ namespace libscratchcpp
 {
 
 class Target;
+class IAudioInput;
 
 /*! \brief The SensingBlocks class contains the implementation of sensing blocks. */
 class SensingBlocks : public IBlockSection
@@ -66,6 +67,7 @@ class SensingBlocks : public IBlockSection
         static void compileMouseX(Compiler *compiler);
         static void compileMouseY(Compiler *compiler);
         static void compileSetDragMode(Compiler *compiler);
+        static void compileLoudness(Compiler *compiler);
         static void compileTimer(Compiler *compiler);
         static void compileResetTimer(Compiler *compiler);
         static void compileOf(Compiler *compiler);
@@ -75,6 +77,7 @@ class SensingBlocks : public IBlockSection
         static const std::string &mouseDownMonitorName(Block *block);
         static const std::string &mouseXMonitorName(Block *block);
         static const std::string &mouseYMonitorName(Block *block);
+        static const std::string &loudnessMonitorName(Block *block);
         static const std::string &timerMonitorName(Block *block);
         static const std::string &currentMonitorName(Block *block);
         static const std::string &daysSince2000MonitorName(Block *block);
@@ -87,6 +90,8 @@ class SensingBlocks : public IBlockSection
         static unsigned int setDraggableMode(VirtualMachine *vm);
         static unsigned int setNotDraggableMode(VirtualMachine *vm);
 
+        static unsigned int loudness(VirtualMachine *vm);
+
         static unsigned int distanceTo(VirtualMachine *vm);
         static unsigned int distanceToByIndex(VirtualMachine *vm);
         static unsigned int distanceToMousePointer(VirtualMachine *vm);
@@ -128,6 +133,7 @@ class SensingBlocks : public IBlockSection
         static unsigned int daysSince2000(VirtualMachine *vm);
 
         static IClock *clock;
+        static IAudioInput *audioInput;
 
     private:
         struct Question

test/blocks/sensing_blocks_test.cpp

@@ -9,6 +9,8 @@
 #include <enginemock.h>
 #include <timermock.h>
 #include <clockmock.h>
+#include <audioinputmock.h>
+#include <audioloudnessmock.h>
 
 #include "../common.h"
 #include "blocks/sensingblocks.h"
@@ -129,6 +131,7 @@ TEST_F(SensingBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_mousex", &SensingBlocks::compileMouseX));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_mousey", &SensingBlocks::compileMouseY));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_setdragmode", &SensingBlocks::compileSetDragMode));
+    EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_loudness", &SensingBlocks::compileLoudness));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_timer", &SensingBlocks::compileTimer));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_resettimer", &SensingBlocks::compileResetTimer));
     EXPECT_CALL(m_engineMock, addCompileFunction(m_section.get(), "sensing_of", &SensingBlocks::compileOf));
@@ -139,6 +142,7 @@ TEST_F(SensingBlocksTest, RegisterBlocks)
     EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_mousedown", &SensingBlocks::mouseDownMonitorName));
     EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_mousex", &SensingBlocks::mouseXMonitorName));
     EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_mousey", &SensingBlocks::mouseYMonitorName));
+    EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_loudness", &SensingBlocks::loudnessMonitorName));
     EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_timer", &SensingBlocks::timerMonitorName));
     EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_current", &SensingBlocks::currentMonitorName));
     EXPECT_CALL(m_engineMock, addMonitorNameFunction(m_section.get(), "sensing_dayssince2000", &SensingBlocks::daysSince2000MonitorName));
@@ -741,6 +745,65 @@ TEST_F(SensingBlocksTest, SetDragModeImpl)
     ASSERT_FALSE(sprite.draggable());
 }
 
+TEST_F(SensingBlocksTest, Loudness)
+{
+    Compiler compiler(&m_engineMock);
+
+    auto block = std::make_shared<Block>("a", "sensing_loudness");
+
+    EXPECT_CALL(m_engineMock, functionIndex(&SensingBlocks::loudness)).WillOnce(Return(0));
+    compiler.init();
+
+    compiler.setBlock(block);
+    SensingBlocks::compileLoudness(&compiler);
+
+    compiler.end();
+
+    ASSERT_EQ(compiler.bytecode(), std::vector<unsigned int>({ vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT }));
+    ASSERT_TRUE(compiler.constValues().empty());
+}
+
+TEST_F(SensingBlocksTest, LoudnessMonitorName)
+{
+    ASSERT_EQ(SensingBlocks::loudnessMonitorName(nullptr), "loudness");
+}
+
+TEST_F(SensingBlocksTest, LoudnessImpl)
+{
+    static unsigned int bytecode[] = { vm::OP_START, vm::OP_EXEC, 0, vm::OP_HALT };
+    static BlockFunc functions[] = { &SensingBlocks::loudness };
+
+    VirtualMachine vm(nullptr, &m_engineMock, nullptr);
+    vm.setFunctions(functions);
+
+    vm.setBytecode(bytecode);
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+
+    AudioInputMock audioInput;
+    auto audioLoudness = std::make_shared<AudioLoudnessMock>();
+    SensingBlocks::audioInput = &audioInput;
+
+    EXPECT_CALL(audioInput, audioLoudness()).WillOnce(Return(audioLoudness));
+    EXPECT_CALL(*audioLoudness, getLoudness()).WillOnce(Return(-1));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toDouble(), -1);
+
+    EXPECT_CALL(audioInput, audioLoudness()).WillOnce(Return(audioLoudness));
+    EXPECT_CALL(*audioLoudness, getLoudness()).WillOnce(Return(62));
+    vm.reset();
+    vm.run();
+
+    ASSERT_EQ(vm.registerCount(), 1);
+    ASSERT_EQ(vm.getInput(0, 1)->toDouble(), 62);
+
+    SensingBlocks::audioInput = nullptr;
+}
+
 TEST_F(SensingBlocksTest, Timer)
 {
     Compiler compiler(&m_engineMock);