portaudioservice.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Audio includes
#include <audio/service/audioservice.h>
#include <audio/utility/safeptr.h>
 
// Nap includes
#include <nap/service.h>
#include <utility/threading.h>
 
// third party includes
#include <portaudio.h>
 
 
namespace nap
{
    namespace audio
    {
 
        // Forward declarations
        class PortAudioService;
 
        class NAPAPI PortAudioServiceConfiguration : public ServiceConfiguration
        {
            RTTI_ENABLE(ServiceConfiguration)
        public:
            virtual rtti::TypeInfo getServiceType() const   { return RTTI_OF(PortAudioService); }
 
            struct NAPAPI DeviceSettings
            {
                std::string mHostApi = "";
 
                std::string mInputDevice = "";
 
                std::string mOutputDevice = "";
 
                int mInputChannelCount = 1;
 
                int mOutputChannelCount = 2;
 
                bool mDisableInput = false;
 
                bool mDisableOutput = false;
 
                float mSampleRate = 44100;
 
                int mBufferSize = 1024;
 
                int mInternalBufferSize = 1024;
            };
 
            DeviceSettings mDeviceSettings;
 
            bool mAllowChannelCountFailure = true;
 
            bool mAllowDeviceFailure = true;
        };
 
        class NAPAPI PortAudioService final : public Service
        {
            RTTI_ENABLE(nap::Service)
 
        public:
            PortAudioService(ServiceConfiguration* configuration);
 
            ~PortAudioService() = default;
 
            void registerObjectCreators(rtti::Factory& factory) override;
 
            bool init(nap::utility::ErrorState& errorState) override;
 
             void shutdown() override;
 
             void preShutdown() override;
 
            NodeManager& getNodeManager() { return mAudioService->getNodeManager(); }
 
            bool getAllowChannelCountFailure() { return getConfiguration<PortAudioServiceConfiguration>()->mAllowChannelCountFailure; }
 
            unsigned int getHostApiCount();
 
            const PaHostApiInfo& getHostApiInfo(unsigned int hostApiIndex);
 
            std::vector<const PaHostApiInfo*> getHostApis();
 
            std::string getHostApiName(unsigned int hostApiIndex);
 
            unsigned int getDeviceCount(unsigned int hostApiIndex);
 
            const PaDeviceInfo& getDeviceInfo(unsigned int hostApiIndex, unsigned int localDeviceIndex);
 
            const PaDeviceInfo& getDeviceInfo(unsigned int deviceIndex);
 
            std::vector<const PaDeviceInfo*> getDevices(unsigned int hostApiIndex);
 
            void printDevices();
 
            std::string getDeviceName(unsigned int hostApiIndex, unsigned int localDeviceIndex);
 
            int getInputDeviceIndex(int hostApiIndex, const std::string& device);
 
            int getOutputDeviceIndex(int hostApiIndex, const std::string& device);
 
            int getDeviceIndex(int hostApiIndex, int hostApiDeviceIndex);
 
            int getHostApiIndex(const std::string& hostApi);
 
            int getCurrentHostApiIndex() const { return mHostApiIndex; }
 
            int getCurrentInputDeviceIndex() const { return mInputDeviceIndex; }
 
            int getCurrentOutputDeviceIndex() const { return mOutputDeviceIndex; }
 
            int getCurrentBufferSize() const { return getConfiguration<PortAudioServiceConfiguration>()->mDeviceSettings.mBufferSize; }
 
            bool openStream(const PortAudioServiceConfiguration::DeviceSettings& settings, utility::ErrorState& errorState);
 
            const PortAudioServiceConfiguration::DeviceSettings& getDeviceSettings() const;
 
            bool closeStream(utility::ErrorState& errorState);
 
            bool start(utility::ErrorState& errorState);
 
            bool stop(utility::ErrorState& errorState);
 
            bool isOpened() { return mStream != nullptr; }
 
            bool isActive();
 
            const std::string& getErrorMessage() const { return mErrorMessage; }
 
        private:
            bool _openStream(const PortAudioServiceConfiguration::DeviceSettings& settings, utility::ErrorState& errorState);
 
            bool openStream(utility::ErrorState& errorState);
 
            /*
             * Verifies if the ammounts of input and output channels specified in the configuration are supported on the given devices. If so, @inputDeviceIndex and @outputDeviceIndex will be set to these. If not and @mAllowChannelCountFailure is set to true, it will return the maximum numbers of channels of the selected devices instead. If @mAllowChannelCountFailure is false initialization will fail.
             */
            bool checkChannelCounts(int inputDeviceIndex, int outputDeviceIndex, int& inputChannelCount,
                                    int& outputChannelCount, utility::ErrorState& errorState);
 
        private:
            PaStream* mStream = nullptr; // Pointer to the stream managed by portaudio.
            int mHostApiIndex = -1; // The actual host Api being used.
            int mInputDeviceIndex = -1; // The actual input device being used, if any.
            int mOutputDeviceIndex = -1; // The actual output device being used, if any.
            bool mPortAudioInitialized = false; // If port audio is initialized
            bool mMpg123Initialized    = false; // If mpg123 is initialized
 
            std::string mErrorMessage = ""; // Holds the error message if public openStream() method was called unsuccesfully.
 
            audio::AudioService* mAudioService = nullptr;
        };
    }
}