From 3c5649df95f31381f314a766b23748f57f5c4ee1 Mon Sep 17 00:00:00 2001
From: "Pawel.Paprocki" <pawel.paprocki@mudita.com>
Date: Mon, 24 May 2021 18:05:30 +0200
Subject: [PATCH] [EGD-6624] Audio support for linux simulator
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When using simulator user should hear audio output to test apps like
Music Player.

Co-authored-by: Tomasz Krosnowski <tomasz.krosnowski@mudita.com>
Co-authored-by: Piotr Tański <piotr.tanski@mudita.com>
Co-authored-by: Marcin Smoczyński <marcin.smoczynski@mudita.com>
Tested-by: Marcin Smoczyński <marcin.smoczynski@mudita.com>
---
 module-audio/Audio/AbstractStream.hpp         |   2 +-
 module-audio/Audio/AudioDevice.hpp            |   7 +
 module-audio/board/linux/CMakeLists.txt       |   1 +
 module-audio/board/linux/LinuxAudioDevice.cpp | 213 ++++++++++++++++++
 module-audio/board/linux/LinuxAudioDevice.hpp |  73 ++++++
 .../board/linux/LinuxAudioPlatform.cpp        |  10 +-
 .../board/linux/audio/linux_audiocodec.cpp    |   2 +-
 .../service-audio/ServiceAudio.cpp            |   4 +
 8 files changed, 307 insertions(+), 5 deletions(-)
 create mode 100644 module-audio/board/linux/LinuxAudioDevice.cpp
 create mode 100644 module-audio/board/linux/LinuxAudioDevice.hpp

diff --git a/module-audio/Audio/AbstractStream.hpp b/module-audio/Audio/AbstractStream.hpp
index 740b91613703a6b4304761ce1ec8523896054fd8..1e7dd1a1b04c3d6c9bc1f9b0927ecdecf0e0b3dd 100644
--- a/module-audio/Audio/AbstractStream.hpp
+++ b/module-audio/Audio/AbstractStream.hpp
@@ -215,7 +215,7 @@ namespace audio
         [[nodiscard]] virtual auto getInputTraits() const noexcept -> Traits = 0;
 
         /**
-         * @brief Get the traits of the stream's input.
+         * @brief Get the traits of the stream's output.
          *
          * @return Traits
          */
diff --git a/module-audio/Audio/AudioDevice.hpp b/module-audio/Audio/AudioDevice.hpp
index 3dd991753a51249b1e9d5c130a94270fad3ec1da..0166f67c359cac87c28c9d665690509542efbd58 100644
--- a/module-audio/Audio/AudioDevice.hpp
+++ b/module-audio/Audio/AudioDevice.hpp
@@ -43,7 +43,14 @@ namespace audio
             return RetCode::Success;
         }
 
+        /// Set device output volume
+        /// @param vol desired volume from 0 to 10
+        /// @return RetCode::Success if OK, or RetCode::Failure otherwise
         virtual RetCode setOutputVolume(float vol) = 0;
+
+        /// Set device input gain
+        /// @param gain desired input gain from 0 to 100
+        /// @return RetCode::Success if OK, or RetCode::Failure otherwise
         virtual RetCode setInputGain(float gain)   = 0;
 
         auto getSinkFormat() -> AudioFormat override
diff --git a/module-audio/board/linux/CMakeLists.txt b/module-audio/board/linux/CMakeLists.txt
index 656fe7ad8cfd826820aa06f603d425a50dcdc9ed..c0128b803f05a1332cfd4ac8634ed3f73b9e627d 100644
--- a/module-audio/board/linux/CMakeLists.txt
+++ b/module-audio/board/linux/CMakeLists.txt
@@ -3,6 +3,7 @@
 
 set(AUDIO_LINUX_SOURCES
 	LinuxAudioPlatform.cpp
+	LinuxAudioDevice.cpp
 )
 
 add_library(${AUDIO_BOARD_LIBRARY} STATIC ${AUDIO_LINUX_SOURCES})
diff --git a/module-audio/board/linux/LinuxAudioDevice.cpp b/module-audio/board/linux/LinuxAudioDevice.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..313802f0e13b042db1313493e455fbe8163a46bf
--- /dev/null
+++ b/module-audio/board/linux/LinuxAudioDevice.cpp
@@ -0,0 +1,213 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "LinuxAudioDevice.hpp"
+#include <Audio/Stream.hpp>
+#include <module-utils/log/log.hpp>
+
+namespace audio
+{
+    namespace
+    {
+        class PortAudio
+        {
+          public:
+            PortAudio();
+            PortAudio(const PortAudio &) = delete;
+            PortAudio(PortAudio &&)      = delete;
+            PortAudio &operator=(const PortAudio &) = delete;
+            PortAudio &operator=(PortAudio &&) = delete;
+            ~PortAudio() noexcept;
+        };
+
+        PortAudio::PortAudio()
+        {
+            if (const auto errorCode = Pa_Initialize(); errorCode == paNoError) {
+                LOG_INFO("Portaudio initialized successfully");
+            }
+            else {
+                LOG_ERROR("Error (code %d) initiializing Portaudio: %s", errorCode, Pa_GetErrorText(errorCode));
+            }
+        }
+
+        PortAudio::~PortAudio() noexcept
+        {
+            if (const auto errorCode = Pa_Terminate(); errorCode == paNoError) {
+                LOG_INFO("Portaudio terminated successfully");
+            }
+            else {
+                LOG_ERROR("Error (code %d) while terminating Portaudio: %s", errorCode, Pa_GetErrorText(errorCode));
+            }
+        }
+
+        PortAudio portAudio;
+    } // namespace
+
+    LinuxAudioDevice::LinuxAudioDevice()
+        : supportedFormats(
+              audio::AudioFormat::makeMatrix(supportedSampleRates, supportedBitWidths, supportedChannelModes))
+    {}
+
+    LinuxAudioDevice::~LinuxAudioDevice()
+    {
+        if (stream != nullptr) {
+            closeStream();
+        }
+    }
+
+    void LinuxAudioDevice::closeStream()
+    {
+        if (const auto errorCode = Pa_AbortStream(stream); errorCode != paNoError) {
+            LOG_ERROR("Error (code %d) while stopping Portaudio stream: %s", errorCode, Pa_GetErrorText(errorCode));
+        }
+        if (const auto errorCode = Pa_CloseStream(stream); errorCode != paNoError) {
+            LOG_ERROR("Error (code %d) while closing Portaudio stream: %s", errorCode, Pa_GetErrorText(errorCode));
+        }
+    }
+
+    auto LinuxAudioDevice::Start() -> RetCode
+    {
+        if (!isSinkConnected()) {
+            return AudioDevice::RetCode::Failure;
+        }
+        return AudioDevice::RetCode::Success;
+    }
+
+    auto LinuxAudioDevice::Stop() -> RetCode
+    {
+        return AudioDevice::RetCode::Success;
+    }
+
+    auto LinuxAudioDevice::setOutputVolume(float vol) -> RetCode
+    {
+        constexpr auto minVolume = .0f;
+        constexpr auto maxVolume = 10.0f;
+        vol                      = std::clamp(vol, minVolume, maxVolume);
+        volumeFactor             = 1.0f * (vol / maxVolume);
+        return RetCode::Success;
+    }
+
+    auto LinuxAudioDevice::setInputGain([[maybe_unused]] float gain) -> RetCode
+    {
+        return RetCode::Success;
+    }
+
+    auto LinuxAudioDevice::getTraits() const -> Traits
+    {
+        return Traits{};
+    }
+
+    auto LinuxAudioDevice::getSupportedFormats() -> std::vector<audio::AudioFormat>
+    {
+        return supportedFormats;
+    }
+
+    auto LinuxAudioDevice::getSourceFormat() -> audio::AudioFormat
+    {
+        return currentFormat;
+    }
+
+    void LinuxAudioDevice::onDataSend()
+    {
+        audio::Stream::Span dataSpan;
+        Sink::_stream->peek(dataSpan);
+        auto streamData = reinterpret_cast<std::int16_t *>(dataSpan.data);
+        cache.insert(cache.end(), &streamData[0], &streamData[dataSpan.dataSize / sizeof(std::int16_t)]);
+        Sink::_stream->consume();
+    }
+
+    void LinuxAudioDevice::onDataReceive()
+    {}
+
+    void LinuxAudioDevice::enableInput()
+    {}
+
+    void LinuxAudioDevice::enableOutput()
+    {
+        LOG_INFO("Enabling audio output...");
+        if (!isSinkConnected()) {
+            LOG_ERROR("Output stream is not connected!");
+            return;
+        }
+
+        currentFormat                = Sink::_stream->getOutputTraits().format;
+        const auto numOutputChannels = currentFormat.getChannels();
+        auto callback                = [](const void *input,
+                           void *output,
+                           unsigned long frameCount,
+                           const PaStreamCallbackTimeInfo *timeInfo,
+                           PaStreamCallbackFlags statusFlags,
+                           void *userData) -> int {
+            LinuxAudioDevice *dev = static_cast<LinuxAudioDevice *>(userData);
+            return dev->streamCallback(input, output, frameCount, timeInfo, statusFlags);
+        };
+        auto errorCode = Pa_OpenDefaultStream(&stream,
+                                              0,
+                                              numOutputChannels,
+                                              paInt16,
+                                              currentFormat.getSampleRate(),
+                                              paFramesPerBufferUnspecified,
+                                              callback,
+                                              this);
+        if (errorCode != paNoError) {
+            LOG_ERROR("Error (code %d) while creating portaudio stream: %s", errorCode, Pa_GetErrorText(errorCode));
+            return;
+        }
+        if (errorCode = Pa_StartStream(stream); errorCode != paNoError) {
+            LOG_ERROR("Error (code %d) while starting portaudio stream: %s", errorCode, Pa_GetErrorText(errorCode));
+            return;
+        }
+    }
+
+    void LinuxAudioDevice::disableInput()
+    {}
+
+    void LinuxAudioDevice::disableOutput()
+    {
+        LOG_INFO("Disabling audio output...");
+        if (!isSinkConnected()) {
+            LOG_ERROR("Error while stopping Linux Audio Device! Null stream.");
+            return;
+        }
+
+        closeStream();
+        stream        = nullptr;
+        currentFormat = {};
+    }
+
+    int LinuxAudioDevice::streamCallback([[maybe_unused]] const void *input,
+                                         void *output,
+                                         unsigned long frameCount,
+                                         [[maybe_unused]] const PaStreamCallbackTimeInfo *timeInfo,
+                                         [[maybe_unused]] PaStreamCallbackFlags statusFlags)
+    {
+        if (!isSinkConnected()) {
+            return paAbort;
+        }
+
+        const auto expectedBufferSize = frameCount * currentFormat.getChannels();
+        if (!isCacheReady(expectedBufferSize)) {
+            onDataSend();
+        }
+
+        const auto dataReadySize = std::min(expectedBufferSize, cache.size());
+        cacheToOutputBuffer(static_cast<std::int16_t *>(output), dataReadySize);
+
+        return paContinue;
+    }
+
+    bool LinuxAudioDevice::isCacheReady(std::size_t expectedSize) const noexcept
+    {
+        return cache.size() >= expectedSize;
+    }
+
+    void LinuxAudioDevice::cacheToOutputBuffer(std::int16_t *buffer, std::size_t size)
+    {
+        for (size_t i = 0; i < size; ++i) {
+            const auto adjustedValue = static_cast<float>(cache[i]) * volumeFactor;
+            *(buffer)                = static_cast<std::int16_t>(adjustedValue);
+            buffer++;
+        }
+        cache.erase(cache.begin(), cache.begin() + size);
+    }
+} // namespace audio
diff --git a/module-audio/board/linux/LinuxAudioDevice.hpp b/module-audio/board/linux/LinuxAudioDevice.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..341cd043eef4b9683c47ddc8cbc68dc48b21d9ee
--- /dev/null
+++ b/module-audio/board/linux/LinuxAudioDevice.hpp
@@ -0,0 +1,73 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <Audio/AudioDevice.hpp>
+#include <Audio/AudioFormat.hpp>
+
+#include <portaudio.h>
+
+#include <deque>
+
+namespace audio
+{
+    class LinuxAudioDevice : public audio::AudioDevice
+    {
+      public:
+        LinuxAudioDevice();
+        virtual ~LinuxAudioDevice();
+
+        auto Start() -> RetCode override;
+        auto Stop() -> RetCode override;
+
+        /// Set device output volume
+        /// @param vol desired volume from 0 to 10
+        /// @return RetCode::Success if OK, or RetCode::Failure otherwise
+        auto setOutputVolume(float vol) -> RetCode override;
+
+        /// Set device input gain
+        /// @param gain desired input gain from 0 to 100
+        /// @return RetCode::Success if OK, or RetCode::Failure otherwise
+        auto setInputGain(float gain) -> RetCode override;
+
+        auto getTraits() const -> Traits override;
+        auto getSupportedFormats() -> std::vector<audio::AudioFormat> override;
+        auto getSourceFormat() -> audio::AudioFormat override;
+
+        // Endpoint control methods
+        void onDataSend() override;
+        void onDataReceive() override;
+        void enableInput() override;
+        void enableOutput() override;
+        void disableInput() override;
+        void disableOutput() override;
+
+      private:
+        int streamCallback(const void *input,
+                           void *output,
+                           unsigned long frameCount,
+                           const PaStreamCallbackTimeInfo *timeInfo,
+                           PaStreamCallbackFlags statusFlags);
+        bool isCacheReady(std::size_t expectedSize) const noexcept;
+        void cacheToOutputBuffer(std::int16_t *buffer, std::size_t size);
+
+        void closeStream();
+
+        constexpr static std::initializer_list<unsigned int> supportedSampleRates  = {44100, 48000};
+        constexpr static std::initializer_list<unsigned int> supportedBitWidths    = {16};
+        constexpr static std::initializer_list<unsigned int> supportedChannelModes = {1, 2};
+
+        std::vector<audio::AudioFormat> supportedFormats;
+        audio::AudioFormat currentFormat;
+
+        /// pointer to portaudio stream
+        PaStream *stream = nullptr;
+
+        /// Local cache to store data read from Pure stream
+        std::deque<std::int16_t> cache;
+
+        float volumeFactor = 1.0f;
+    };
+
+} // namespace audio
diff --git a/module-audio/board/linux/LinuxAudioPlatform.cpp b/module-audio/board/linux/LinuxAudioPlatform.cpp
index d11e29eb88dc51146416baf2a41366a41ed38f4d..6b0b8f98e7b5ff70855003ba8ec326bed8ff1245 100644
--- a/module-audio/board/linux/LinuxAudioPlatform.cpp
+++ b/module-audio/board/linux/LinuxAudioPlatform.cpp
@@ -1,8 +1,9 @@
-// Copyright (c) 2021, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include <Audio/AudioPlatform.hpp>
 #include <Audio/Profiles/Profile.hpp>
+#include <board/linux/LinuxAudioDevice.hpp>
 
 #include <memory>
 #include <utility>
@@ -11,7 +12,7 @@ using audio::AudioDevice;
 using audio::AudioDeviceFactory;
 using audio::AudioPlatform;
 
-class DummyAudioFactory : public AudioDeviceFactory
+class LinuxAudioFactory : public AudioDeviceFactory
 {
   public:
     std::shared_ptr<AudioDevice> createCellularAudioDevice() override
@@ -22,11 +23,14 @@ class DummyAudioFactory : public AudioDeviceFactory
   protected:
     std::shared_ptr<AudioDevice> getDevice([[maybe_unused]] const audio::Profile &profile) override
     {
+        if (profile.GetAudioDeviceType() == AudioDevice::Type::Audiocodec) {
+            return std::make_shared<audio::LinuxAudioDevice>();
+        }
         return nullptr;
     }
 };
 
 std::unique_ptr<AudioDeviceFactory> AudioPlatform::GetDeviceFactory()
 {
-    return std::make_unique<DummyAudioFactory>();
+    return std::make_unique<LinuxAudioFactory>();
 }
diff --git a/module-bsp/board/linux/audio/linux_audiocodec.cpp b/module-bsp/board/linux/audio/linux_audiocodec.cpp
index 8f90d29e5cd4b1715c9bb1e69c04acd0a7ce702c..51720106b3a13c23294436d3129cf53581abe4fb 100755
--- a/module-bsp/board/linux/audio/linux_audiocodec.cpp
+++ b/module-bsp/board/linux/audio/linux_audiocodec.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "linux_audiocodec.hpp"
diff --git a/module-services/service-audio/ServiceAudio.cpp b/module-services/service-audio/ServiceAudio.cpp
index d5edb5c12b61837089d2b6c6a3d539868d8931da..bc7c9d8c0c19ebe1e5496971c126ba95127fafd0 100644
--- a/module-services/service-audio/ServiceAudio.cpp
+++ b/module-services/service-audio/ServiceAudio.cpp
@@ -139,6 +139,10 @@ sys::ReturnCodes ServiceAudio::DeinitHandler()
 
 void ServiceAudio::ProcessCloseReason(sys::CloseReason closeReason)
 {
+    if (const auto &activeInputOpt = audioMux.GetActiveInput(); activeInputOpt.has_value()) {
+        const auto activeInput = activeInputOpt.value();
+        activeInput->audio->Stop();
+    }
     sendCloseReadyMessage(this);
 }