DeinterleaveView.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
 
namespace Audio
{
    template <typename T>
    class TDeinterleaveView
    {
        friend class TChannelIterator;
 
    public:
 
        template<typename InAllocator = FDefaultAllocator>
        class TChannel
        {
            public:
                TArray<T, InAllocator>& Values;
                const int32 ChannelIndex;
 
                TChannel(TArray<T, InAllocator>& InValues, const int32 InChannelIndex)
                :   Values(InValues)
                ,   ChannelIndex(InChannelIndex)
                {}
        };
 
        template<typename InAllocator = FDefaultAllocator>
        class TChannelIterator
        {
            TDeinterleaveView<T> DeinterleaveView;
            TArray<T, InAllocator>& ArrayToFill;
            int32 ChannelIndex;
 
        public:
 
            static const int32 ChannelIndexEnd = INDEX_NONE;
 
            TChannelIterator(TDeinterleaveView<T> InDeinterleaveView, TArray<T, InAllocator>& InArrayToFill, int32 InChannelIndex)
            :   DeinterleaveView(InDeinterleaveView)
            ,   ArrayToFill(InArrayToFill)
            ,   ChannelIndex(InChannelIndex)
            {
                if (ChannelIndex >= DeinterleaveView.NumChannels)
                {
                    // Channel index is more than number of total channels
                    ChannelIndex = ChannelIndexEnd;
                }
 
 
            }
 
            TChannelIterator& operator++()
            {
                if (ChannelIndex != ChannelIndexEnd)
                {
                    ChannelIndex++;
                    if (ChannelIndex >= DeinterleaveView.NumChannels)
                    {
                        ChannelIndex = ChannelIndexEnd;
                    }
                }
                return *this;
            }
 
            bool operator!=(const TChannelIterator& Other) const
            {
                return Other.ChannelIndex != ChannelIndex;
            }
 
            int32 GetChannelIndex() const
            {
                return ChannelIndex;
            }
 
            TChannel<InAllocator> operator*()
            {
                if (ChannelIndex == ChannelIndexEnd)
                {
                    ArrayToFill.Reset(DeinterleaveView.NumElementsPerChannel);
                }
                else
                {
                    // prepare the array
                    ArrayToFill.Reset(DeinterleaveView.NumElementsPerChannel);
                    if (DeinterleaveView.NumElementsPerChannel > 0)
                    {
                        ArrayToFill.AddUninitialized(DeinterleaveView.NumElementsPerChannel);
                    }
 
                    // Fill array with deinterleave data
                    T* ArrayToFillData = ArrayToFill.GetData();
                    const T* InterleavedData = DeinterleaveView.InterleavedArray.GetData();
 
                    int32 InterleavedPos = ChannelIndex;
                    for (int32 OutPos = 0; OutPos < DeinterleaveView.NumElementsPerChannel; OutPos++, InterleavedPos += DeinterleaveView.NumChannels)
                    {
                        ArrayToFillData[OutPos] = InterleavedData[InterleavedPos];
                    }
                }
 
 
                // Create and return channel
                return TChannel<InAllocator>(ArrayToFill, ChannelIndex);
            }
        };
 
        TDeinterleaveView(TArrayView<const T> InInterleavedArray, int32 InNumChannels)
        :   InterleavedArray(InInterleavedArray)
        ,   NumChannels(InNumChannels)
        ,   NumElementsPerChannel(0)
        {
            check(InterleavedArray.Num() % NumChannels == 0);
 
            NumElementsPerChannel = InterleavedArray.Num() / NumChannels;
        }
 
        template <typename InAllocator = FDefaultAllocator>
        TChannelIterator<InAllocator> begin(TArray<T, InAllocator>& InArrayToFill) const
        {
            return TChannelIterator<InAllocator>(*this, InArrayToFill, 0);
        }
 
        template <typename InAllocator = FDefaultAllocator>
        TChannelIterator<InAllocator> end(TArray<T, InAllocator>& InArrayToFill) const
        {
            return TChannelIterator<InAllocator>(*this, InArrayToFill, TChannelIterator<InAllocator>::ChannelIndexEnd);
        }
 
    private:
        // view to interleaved data
        TArrayView<const T> InterleavedArray;
 
        int32 NumChannels;
        int32 NumElementsPerChannel;
    };
 
    template <typename T, typename InAllocator = FDefaultAllocator> 
    class TAutoDeinterleaveView : public TDeinterleaveView<T>
    {
        TArray<T, InAllocator>& ArrayToFill;
 
        typedef typename TDeinterleaveView<T>::template TChannelIterator<InAllocator> TAutoChannelIterator;
 
    public:
        TAutoDeinterleaveView(TArrayView<const T> InInterleavedArray, TArray<T, InAllocator>& InArrayToFill, int32 InNumChannels)
        :   TDeinterleaveView<T>(InInterleavedArray, InNumChannels)
        ,   ArrayToFill(InArrayToFill)
        {}
 
        TAutoChannelIterator begin() 
        {
            return TDeinterleaveView<T>::template begin<InAllocator>(ArrayToFill);
        }
 
        TAutoChannelIterator end()
        {
            return TDeinterleaveView<T>::template end<InAllocator>(ArrayToFill);
        }
    };
}