AudioChannelFormatConverter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
 
#include "Containers/SortedMap.h"
#include "DSP/BufferVectorOperations.h"
 
namespace Audio
{
    class IChannelFormatConverter
    {
        public:
            struct FInputFormat
            {
                int32 NumChannels = 0;
            };
 
            struct FOutputFormat
            {
                int32 NumChannels = 0;
            };
 
            virtual ~IChannelFormatConverter() = default;
 
            virtual const FInputFormat& GetInputFormat() const = 0;
 
            virtual const FOutputFormat& GetOutputFormat() const = 0;
            
            virtual void ProcessAudio(const TArray<FAlignedFloatBuffer>& InInputBuffers, TArray<FAlignedFloatBuffer>& OutOutputBuffers) = 0;
    };
 
 
    class FBaseChannelFormatConverter : public IChannelFormatConverter
    {
 
        public:
            struct FChannelMixEntry
            {
                int32 InputChannelIndex = 0;
 
                int32 OutputChannelIndex = 0;
 
                float Gain = 0.f;
            };
 
            SIGNALPROCESSING_API virtual ~FBaseChannelFormatConverter();
 
            SIGNALPROCESSING_API const FInputFormat& GetInputFormat() const override;
 
            SIGNALPROCESSING_API const FOutputFormat& GetOutputFormat() const override;
 
            SIGNALPROCESSING_API void SetOutputGain(float InOutputGain, bool bFadeToGain=true);
 
            SIGNALPROCESSING_API void SetMixGain(const FChannelMixEntry& InEntry, bool bFadeToGain=true);
 
            SIGNALPROCESSING_API void SetMixGain(int32 InInputChannelIndex, int32 InOutputChannelIndex, float InGain, bool bFadeToGain=true);
 
            SIGNALPROCESSING_API float GetTargetMixGain(int32 InInputChannelIndex, int32 InOutputChannelIndex) const;
 
            SIGNALPROCESSING_API float GetTargetOutputGain() const;
 
            SIGNALPROCESSING_API void ProcessAudio(const TArray<FAlignedFloatBuffer>& InInputBuffers, TArray<FAlignedFloatBuffer>& OutOutputBuffers) override;
 
 
            static SIGNALPROCESSING_API TUniquePtr<FBaseChannelFormatConverter> CreateBaseFormatConverter(const FInputFormat& InInputFormat, const FOutputFormat& InOutputFormat, TArrayView<const FChannelMixEntry> InMixEntries, int32 InNumFramesPerCall);
 
        protected:
 
            SIGNALPROCESSING_API FBaseChannelFormatConverter(const FInputFormat& InInputFormat, const FOutputFormat& InOutputFormat, TArrayView<const FChannelMixEntry> InMixEntries, int32 InNumFramesPerCall);
 
        private:
 
            // Output gain state holds current and next gain levels. 
            struct FOutputGainState
            {
                float Gain = 1.f;
                float NextGain = 0.f;
                bool bFadeToNextGain = false;
            };
 
            // Channel mix entry holds current and next gain levels for a mix entry.
            struct FChannelMixState : FChannelMixEntry
            {
                FChannelMixState() = default;
 
                FChannelMixState(const FChannelMixEntry& InEntry)
                :   FChannelMixEntry(InEntry)
                {
                }
 
                bool bFadeToNextGain = false;
                float NextGain = 0.f;
            };
 
            // Channel mix key is used to lookup entries from a TSortedMap
            struct FChannelMixKey
            {
                const int32 InputChannelIndex = 0;
                const int32 OutputChannelIndex = 0;
 
                FChannelMixKey(int32 InInputChannelIndex, int32 InOutputChannelIndex)
                :   InputChannelIndex(InInputChannelIndex)
                ,   OutputChannelIndex(InOutputChannelIndex)
                {
                }
 
                FChannelMixKey(const FChannelMixEntry& InEntry)
                :   InputChannelIndex(InEntry.InputChannelIndex)
                ,   OutputChannelIndex(InEntry.OutputChannelIndex)
                {
                }
 
                // Operator needed for using in a TSortedMap
                friend bool operator<(const FChannelMixKey& InLHS, const FChannelMixKey& InRHS)
                {
                    if (InLHS.InputChannelIndex == InRHS.InputChannelIndex)
                    {
                        return InLHS.OutputChannelIndex < InRHS.OutputChannelIndex;
                    }
 
                    return InLHS.InputChannelIndex < InRHS.InputChannelIndex;
                }
            };
 
            // The input audio format
            FInputFormat InputFormat;
 
            // The output audio format. 
            FOutputFormat OutputFormat;
 
            // Gain states 
            FOutputGainState OutputGainState;
            TSortedMap<FChannelMixKey, FChannelMixState> ChannelMixStates;
 
            int32 NumFramesPerCall;
    };
}