166 lines
4.4 KiB
C++
166 lines
4.4 KiB
C++
#include "ChannelInterface.h"
|
|
#include "AudioBuffer.h"
|
|
#include "ChannelNode.h"
|
|
#include "Singleton/MixerList.h"
|
|
#include "Mixer/MixerTrack.h"
|
|
|
|
FChannelInterface::FChannelInterface(int32 InputChannelNum, int32 OutputChannelNum)
|
|
{
|
|
const int32 InputNodeNum = InputChannelNum / 2;
|
|
const int32 OutputNodeNum = OutputChannelNum / 2;
|
|
FNullChannelNode* NullNode = FNullChannelNode::Get();
|
|
|
|
InputHeaders.AddZeroed(InputChannelNum);
|
|
OutputHeaders.AddZeroed(OutputChannelNum);
|
|
|
|
for (int i = 0; i < InputNodeNum; ++i)
|
|
{
|
|
InputChannelNodes.Add(NullNode);
|
|
SetInputChannel(i, NullNode);
|
|
}
|
|
|
|
for (int i = 0; i < OutputNodeNum; ++i)
|
|
{
|
|
OutputChannelNodes.Add(NullNode);
|
|
SetOutputChannel(i, NullNode);
|
|
}
|
|
}
|
|
|
|
void FChannelInterface::SetInputChannel(int32 NodeIndex, FChannelNode* Node)
|
|
{
|
|
if (!InputChannelNodes.IsValidIndex(NodeIndex))
|
|
return;
|
|
InputChannelNodes[NodeIndex] = Node;
|
|
|
|
const TArray<float*>& NodeHeaders = Node->GetChannelHeaders();
|
|
|
|
InputHeaders[NodeIndex * 2 + 0] = NodeHeaders[0];
|
|
InputHeaders[NodeIndex * 2 + 1] = NodeHeaders[1];
|
|
FMixerList::Get().RequestBuildProcessNode();
|
|
}
|
|
|
|
void FChannelInterface::SetOutputChannel(int32 NodeIndex, FChannelNode* Node)
|
|
{
|
|
if (!OutputChannelNodes.IsValidIndex(NodeIndex))
|
|
return;
|
|
OutputChannelNodes[NodeIndex] = Node;
|
|
|
|
const TArray<float*>& NodeHeaders = Node->GetChannelHeaders();
|
|
OutputHeaders[NodeIndex * 2 + 0] = NodeHeaders[0];
|
|
OutputHeaders[NodeIndex * 2 + 1] = NodeHeaders[1];
|
|
FMixerList::Get().RequestBuildProcessNode();
|
|
}
|
|
|
|
void FChannelInterface::SetInputChannel(const TArray<FChannelNode*>& Nodes, int32 Offset)
|
|
{
|
|
const int32 InputNum = FMath::Min(Nodes.Num() - Offset, InputChannelNodes.Num());
|
|
for (int i = 0; i < InputNum; ++i)
|
|
{
|
|
SetInputChannel(i + Offset, Nodes[i]);
|
|
}
|
|
}
|
|
|
|
void FChannelInterface::SetOutputChannel(const TArray<FChannelNode*>& Nodes, int32 Offset)
|
|
{
|
|
const int32 OutputNum = FMath::Min(Nodes.Num() - Offset, OutputChannelNodes.Num());
|
|
for (int i = 0; i < OutputNum; ++i)
|
|
{
|
|
SetOutputChannel(i + Offset, Nodes[i]);
|
|
}
|
|
}
|
|
|
|
int32 FChannelInterface::GetInputNodeIndex(FChannelNode* Node)
|
|
{
|
|
for (int32 i = 0; i < InputChannelNodes.Num(); ++i)
|
|
{
|
|
if (InputChannelNodes[i] == Node)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int32 FChannelInterface::GetOutputNodeIndex(FChannelNode* Node)
|
|
{
|
|
for (int32 i = 0; i < OutputChannelNodes.Num(); ++i)
|
|
{
|
|
if (OutputChannelNodes[i] == Node)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void FChannelInterface::SetInputChannelNodeName(int32 NodeIndex, int32 Channel, FName Name)
|
|
{
|
|
TMap<int32, FName>& Names = InputChannelNodeNames.FindOrAdd(NodeIndex);
|
|
Names.Add(Channel, Name);
|
|
}
|
|
|
|
void FChannelInterface::SetOutputChannelNodeName(int32 NodeIndex, int32 Channel, FName Name)
|
|
{
|
|
TMap<int32, FName>& Names = OutputChannelNodeNames.FindOrAdd(NodeIndex);
|
|
Names.Add(Channel, Name);
|
|
}
|
|
|
|
TMap<int32, FName> FChannelInterface::GetInputChannelNodeName(int32 NodeIndex)
|
|
{
|
|
const auto* Name = InputChannelNodeNames.Find(NodeIndex);
|
|
if (!Name)
|
|
return {};
|
|
return *Name;
|
|
}
|
|
|
|
TMap<int32, FName> FChannelInterface::GetOutputChannelNodeName(int32 NodeIndex)
|
|
{
|
|
const auto* Name = OutputChannelNodeNames.Find(NodeIndex);
|
|
if (!Name)
|
|
return {};
|
|
return *Name;
|
|
}
|
|
|
|
TMap<int32, FName> FChannelInterface::GetInputChannelNodeName(FChannelNode* Node)
|
|
{
|
|
return GetInputChannelNodeName(GetInputNodeIndex(Node));
|
|
}
|
|
|
|
TMap<int32, FName> FChannelInterface::GetOutputChannelNodeName(FChannelNode* Node)
|
|
{
|
|
return GetOutputChannelNodeName(GetOutputNodeIndex(Node));
|
|
}
|
|
|
|
void FChannelInterface::RemoveTrack(FMixerTrack* Track)
|
|
{
|
|
for (int32 i = 0; i < InputChannelNodes.Num(); ++i)
|
|
{
|
|
if (InputChannelNodes[i]->NodeType == EChannelNodeType::MixerNode)
|
|
{
|
|
FMixerChannelNode* MixerChannelNode = static_cast<FMixerChannelNode*>(InputChannelNodes[i]);
|
|
if (MixerChannelNode->GetTrack() == Track)
|
|
{
|
|
SetInputChannel(i, FNullChannelNode::Get());
|
|
}
|
|
}
|
|
}
|
|
for (int32 i = 0; i < OutputChannelNodes.Num(); ++i)
|
|
{
|
|
if (OutputChannelNodes[i]->NodeType == EChannelNodeType::MixerNode)
|
|
{
|
|
FMixerChannelNode* MixerChannelNode = static_cast<FMixerChannelNode*>(OutputChannelNodes[i]);
|
|
if (MixerChannelNode->GetTrack() == Track)
|
|
{
|
|
SetOutputChannel(i, FNullChannelNode::Get());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
FMixerChannelInterface::FMixerChannelInterface(FMixerTrack* InMixerTrack) : FChannelInterface(0, 2), MixerTrack(InMixerTrack)
|
|
{
|
|
FMixerChannelNode* Node = new FMixerChannelNode(this, MixerTrack, 0);
|
|
SetOutputChannel(0, Node);
|
|
}
|
|
|
|
FMixerChannelInterface::~FMixerChannelInterface()
|
|
{
|
|
delete OutputChannelNodes[0];
|
|
}
|