774 lines
23 KiB
C++
774 lines
23 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "MetaHumanMediaSourceWidget.h"
|
|
#include "MetaHumanStringCombo.h"
|
|
#include "MetaHumanPipelineMediaPlayerNode.h"
|
|
#include "MetaHumanLocalLiveLinkSourceBlueprint.h"
|
|
|
|
#include "AssetRegistry/AssetRegistryModule.h"
|
|
#include "Widgets/Input/SNumericEntryBox.h"
|
|
|
|
#if WITH_EDITOR
|
|
#include "DetailLayoutBuilder.h"
|
|
#endif
|
|
|
|
#define LOCTEXT_NAMESPACE "MetaHumanLocalLiveLinkSource"
|
|
|
|
|
|
|
|
class SMetaHumanMediaSourceWidgetImpl : public SCompoundWidget
|
|
{
|
|
public:
|
|
|
|
SLATE_BEGIN_ARGS(SMetaHumanMediaSourceWidgetImpl) {}
|
|
SLATE_END_ARGS()
|
|
|
|
void Construct(const FArguments& InArgs, SMetaHumanMediaSourceWidget::EMediaType InMediaType);
|
|
|
|
void OnAssetsAddedOrDeleted(TConstArrayView<FAssetData> InAssets);
|
|
void OnAssetRenamed(const FAssetData& InAsset, const FString& InOldObjectPath);
|
|
void PopulateDevices();
|
|
|
|
SMetaHumanMediaSourceWidget::EMediaType MediaType;
|
|
|
|
TMap<FString, FMetaHumanLiveLinkVideoDevice> VideoDevices;
|
|
TMap<FString, FMetaHumanLiveLinkVideoTrack> VideoTracks;
|
|
TMap<FString, FMetaHumanLiveLinkVideoFormat> VideoTrackFormats;
|
|
|
|
TArray<SMetaHumanStringCombo::FComboItemType> VideoDeviceItems;
|
|
TArray<SMetaHumanStringCombo::FComboItemType> VideoTrackItems;
|
|
TArray<SMetaHumanStringCombo::FComboItemType> VideoTrackFormatItems;
|
|
bool bVideoTrackFormatItemsFiltered = true;
|
|
|
|
TSharedPtr<SMetaHumanStringCombo> VideoDeviceCombo;
|
|
TSharedPtr<SMetaHumanStringCombo> VideoTrackCombo;
|
|
TSharedPtr<SMetaHumanStringCombo> VideoTrackFormatCombo;
|
|
|
|
void OnVideoDeviceSelected(SMetaHumanStringCombo::FComboItemType InItem);
|
|
void OnVideoTrackSelected(SMetaHumanStringCombo::FComboItemType InItem);
|
|
void OnVideoTrackFormatSelected(SMetaHumanStringCombo::FComboItemType InItem);
|
|
|
|
TMap<FString, FMetaHumanLiveLinkAudioDevice> AudioDevices;
|
|
TMap<FString, FMetaHumanLiveLinkAudioTrack> AudioTracks;
|
|
TMap<FString, FMetaHumanLiveLinkAudioFormat> AudioTrackFormats;
|
|
|
|
TArray<SMetaHumanStringCombo::FComboItemType> AudioDeviceItems;
|
|
TArray<SMetaHumanStringCombo::FComboItemType> AudioTrackItems;
|
|
TArray<SMetaHumanStringCombo::FComboItemType> AudioTrackFormatItems;
|
|
|
|
TSharedPtr<SMetaHumanStringCombo> AudioDeviceCombo;
|
|
TSharedPtr<SMetaHumanStringCombo> AudioTrackCombo;
|
|
TSharedPtr<SMetaHumanStringCombo> AudioTrackFormatCombo;
|
|
|
|
void OnAudioDeviceSelected(SMetaHumanStringCombo::FComboItemType InItem);
|
|
void OnAudioTrackSelected(SMetaHumanStringCombo::FComboItemType InItem);
|
|
void OnAudioTrackFormatSelected(SMetaHumanStringCombo::FComboItemType InItem);
|
|
|
|
TSharedPtr<SCheckBox> AdvancedCheckBox;
|
|
|
|
TSharedPtr<SCheckBox> FilteredWidget;
|
|
TSharedPtr<SNumericEntryBox<float>> StartTimeoutWidget;
|
|
TSharedPtr<SNumericEntryBox<float>> FormatWaitTimeWidget;
|
|
TSharedPtr<SNumericEntryBox<float>> SampleTimeoutWidget;
|
|
|
|
bool CanCreate() const;
|
|
|
|
double StartTimeout = 5;
|
|
double FormatWaitTime = 0.1;
|
|
double SampleTimeout = 5;
|
|
|
|
bool IsBundle() const;
|
|
EVisibility GetTrackVisibility() const;
|
|
bool IsTrackEnabled() const;
|
|
FText GetTrackTooltip() const;
|
|
EVisibility GetAdvancedVisibility() const;
|
|
|
|
FMetaHumanMediaSourceCreateParams GetCreateParams() const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void SMetaHumanMediaSourceWidgetImpl::Construct(const FArguments& InArgs, SMetaHumanMediaSourceWidget::EMediaType InMediaType)
|
|
{
|
|
const FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
|
|
|
|
AssetRegistryModule.Get().OnAssetsAdded().AddSP(this, &SMetaHumanMediaSourceWidgetImpl::OnAssetsAddedOrDeleted);
|
|
AssetRegistryModule.Get().OnAssetsRemoved().AddSP(this, &SMetaHumanMediaSourceWidgetImpl::OnAssetsAddedOrDeleted);
|
|
AssetRegistryModule.Get().OnAssetRenamed().AddSP(this, &SMetaHumanMediaSourceWidgetImpl::OnAssetRenamed);
|
|
|
|
MediaType = InMediaType;
|
|
|
|
VideoDeviceCombo = SNew(SMetaHumanStringCombo, &VideoDeviceItems)
|
|
.OnItemSelected(this, &SMetaHumanMediaSourceWidgetImpl::OnVideoDeviceSelected);
|
|
|
|
VideoTrackCombo = SNew(SMetaHumanStringCombo, &VideoTrackItems)
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackVisibility)
|
|
.IsEnabled(this, &SMetaHumanMediaSourceWidgetImpl::IsTrackEnabled)
|
|
.ToolTipText(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackTooltip)
|
|
.OnItemSelected(this, &SMetaHumanMediaSourceWidgetImpl::OnVideoTrackSelected);
|
|
|
|
VideoTrackFormatCombo = SNew(SMetaHumanStringCombo, &VideoTrackFormatItems)
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackVisibility)
|
|
.IsEnabled(this, &SMetaHumanMediaSourceWidgetImpl::IsTrackEnabled)
|
|
.ToolTipText(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackTooltip)
|
|
.OnItemSelected(this, &SMetaHumanMediaSourceWidgetImpl::OnVideoTrackFormatSelected);
|
|
|
|
AudioDeviceCombo = SNew(SMetaHumanStringCombo, &AudioDeviceItems)
|
|
.OnItemSelected(this, &SMetaHumanMediaSourceWidgetImpl::OnAudioDeviceSelected);
|
|
|
|
AudioTrackCombo = SNew(SMetaHumanStringCombo, &AudioTrackItems)
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackVisibility)
|
|
.IsEnabled(this, &SMetaHumanMediaSourceWidgetImpl::IsTrackEnabled)
|
|
.ToolTipText(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackTooltip)
|
|
.OnItemSelected(this, &SMetaHumanMediaSourceWidgetImpl::OnAudioTrackSelected);
|
|
|
|
AudioTrackFormatCombo = SNew(SMetaHumanStringCombo, &AudioTrackFormatItems)
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackVisibility)
|
|
.IsEnabled(this, &SMetaHumanMediaSourceWidgetImpl::IsTrackEnabled)
|
|
.ToolTipText(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackTooltip)
|
|
.OnItemSelected(this, &SMetaHumanMediaSourceWidgetImpl::OnAudioTrackFormatSelected);
|
|
|
|
AdvancedCheckBox = SNew(SCheckBox);
|
|
|
|
FilteredWidget = SNew(SCheckBox)
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetAdvancedVisibility)
|
|
.ToolTipText(LOCTEXT("FilteredTooltip", "Filter the formats to show only the most relevant ones"))
|
|
.IsChecked_Lambda([this]()
|
|
{
|
|
return bVideoTrackFormatItemsFiltered ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
|
|
})
|
|
.OnCheckStateChanged_Lambda([this](ECheckBoxState InState)
|
|
{
|
|
bVideoTrackFormatItemsFiltered = (InState == ECheckBoxState::Checked);
|
|
|
|
OnVideoTrackSelected(VideoTrackCombo->CurrentItem);
|
|
});
|
|
|
|
StartTimeoutWidget = SNew(SNumericEntryBox<float>)
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetAdvancedVisibility)
|
|
#if WITH_EDITOR
|
|
.Font(IDetailLayoutBuilder::GetDetailFont())
|
|
#endif
|
|
.ToolTipText(LOCTEXT("StartTimeoutTooltip", "Timeout for waiting for media to open"))
|
|
.Value_Lambda([this]()
|
|
{
|
|
return StartTimeout;
|
|
})
|
|
.OnValueCommitted_Lambda([this](float InValue, ETextCommit::Type)
|
|
{
|
|
StartTimeout = InValue;
|
|
});
|
|
|
|
FormatWaitTimeWidget = SNew(SNumericEntryBox<float>)
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetAdvancedVisibility)
|
|
#if WITH_EDITOR
|
|
.Font(IDetailLayoutBuilder::GetDetailFont())
|
|
#endif
|
|
.ToolTipText(LOCTEXT("FormatWaitTimeTooltip", "Time to wait for format changes to take effect"))
|
|
.Value_Lambda([this]()
|
|
{
|
|
return FormatWaitTime;
|
|
})
|
|
.OnValueCommitted_Lambda([this](float InValue, ETextCommit::Type)
|
|
{
|
|
FormatWaitTime = InValue;
|
|
});
|
|
|
|
SampleTimeoutWidget = SNew(SNumericEntryBox<float>)
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetAdvancedVisibility)
|
|
#if WITH_EDITOR
|
|
.Font(IDetailLayoutBuilder::GetDetailFont())
|
|
#endif
|
|
.ToolTipText(LOCTEXT("SampleTimeoutTooltip", "Timeout for waiting on first media sample to arrive"))
|
|
.Value_Lambda([this]()
|
|
{
|
|
return SampleTimeout;
|
|
})
|
|
.OnValueCommitted_Lambda([this](float InValue, ETextCommit::Type)
|
|
{
|
|
SampleTimeout = InValue;
|
|
});
|
|
|
|
PopulateDevices();
|
|
|
|
const float Padding = 5;
|
|
const float FirstColWidth = 140;
|
|
|
|
TSharedPtr<SVerticalBox> Layout = SNew(SVerticalBox);
|
|
|
|
if (MediaType == SMetaHumanMediaSourceWidget::EMediaType::Video || MediaType == SMetaHumanMediaSourceWidget::EMediaType::VideoAndAudio)
|
|
{
|
|
Layout->AddSlot()
|
|
.AutoHeight()
|
|
[
|
|
SNew(SVerticalBox)
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("VideoDevice", "Video Device"))
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
VideoDeviceCombo.ToSharedRef()
|
|
]
|
|
]
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("VideoTrack", "Video Track"))
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackVisibility)
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
VideoTrackCombo.ToSharedRef()
|
|
]
|
|
]
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("VideoTrackFormat", "Video Track Format"))
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackVisibility)
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
VideoTrackFormatCombo.ToSharedRef()
|
|
]
|
|
]
|
|
];
|
|
}
|
|
|
|
if (MediaType == SMetaHumanMediaSourceWidget::EMediaType::Audio || MediaType == SMetaHumanMediaSourceWidget::EMediaType::VideoAndAudio)
|
|
{
|
|
Layout->AddSlot()
|
|
.AutoHeight()
|
|
[
|
|
SNew(SVerticalBox)
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("AudioDevice", "Audio Device"))
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
AudioDeviceCombo.ToSharedRef()
|
|
]
|
|
]
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("AudioTrack", "Audio Track"))
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackVisibility)
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
AudioTrackCombo.ToSharedRef()
|
|
]
|
|
]
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("AudioTrackFormat", "Audio Track Format"))
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetTrackVisibility)
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
AudioTrackFormatCombo.ToSharedRef()
|
|
]
|
|
]
|
|
];
|
|
}
|
|
|
|
Layout->AddSlot()
|
|
.AutoHeight()
|
|
[
|
|
SNew(SVerticalBox)
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("Advanced", "Advanced"))
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.VAlign(VAlign_Top)
|
|
.AutoWidth()
|
|
[
|
|
AdvancedCheckBox.ToSharedRef()
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.Padding(Padding * 6, 0)
|
|
.AutoWidth()
|
|
[
|
|
SNew(SVerticalBox)
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("Filtered", "Filter Format List"))
|
|
.ToolTipText(LOCTEXT("FilteredTooltip", "Filter the formats to show only the most relevant ones"))
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetAdvancedVisibility)
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
FilteredWidget.ToSharedRef()
|
|
]
|
|
]
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("StartTimeout", "Start Timeout"))
|
|
.ToolTipText(LOCTEXT("StartTimeoutTooltip", "Timeout for waiting for media to open"))
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetAdvancedVisibility)
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
StartTimeoutWidget.ToSharedRef()
|
|
]
|
|
]
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("FormatWaitTime", "Format Wait Time"))
|
|
.ToolTipText(LOCTEXT("FormatWaitTimeTooltip", "Time to wait for format changes to take effect"))
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetAdvancedVisibility)
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
FormatWaitTimeWidget.ToSharedRef()
|
|
]
|
|
]
|
|
+ SVerticalBox::Slot()
|
|
.Padding(Padding)
|
|
.AutoHeight()
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SNew(STextBlock)
|
|
.Text(LOCTEXT("SampleTimeout", "Sample Timeout"))
|
|
.ToolTipText(LOCTEXT("SampleTimeoutTooltip", "Timeout for waiting on first media sample to arrive"))
|
|
.Visibility(this, &SMetaHumanMediaSourceWidgetImpl::GetAdvancedVisibility)
|
|
.MinDesiredWidth(FirstColWidth)
|
|
]
|
|
+ SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
[
|
|
SampleTimeoutWidget.ToSharedRef()
|
|
]
|
|
]
|
|
]
|
|
]
|
|
];
|
|
|
|
ChildSlot
|
|
[
|
|
Layout.ToSharedRef()
|
|
];
|
|
}
|
|
|
|
void SMetaHumanMediaSourceWidgetImpl::OnAssetsAddedOrDeleted(TConstArrayView<FAssetData> InAssets)
|
|
{
|
|
PopulateDevices();
|
|
}
|
|
|
|
void SMetaHumanMediaSourceWidgetImpl::OnAssetRenamed(const FAssetData& InAsset, const FString& InOldObjectPath)
|
|
{
|
|
PopulateDevices();
|
|
}
|
|
|
|
void SMetaHumanMediaSourceWidgetImpl::PopulateDevices()
|
|
{
|
|
VideoDevices.Reset();
|
|
VideoDeviceItems.Reset();
|
|
|
|
TArray<FMetaHumanLiveLinkVideoDevice> VideoDevicesArray;
|
|
UMetaHumanLocalLiveLinkSourceBlueprint::GetVideoDevices(VideoDevicesArray);
|
|
|
|
for (const FMetaHumanLiveLinkVideoDevice& VideoDevice : VideoDevicesArray)
|
|
{
|
|
VideoDevices.Add(VideoDevice.Url, VideoDevice);
|
|
VideoDeviceItems.Add(MakeShared<TPair<FString, FString>>(VideoDevice.Name, VideoDevice.Url));
|
|
}
|
|
|
|
VideoDeviceCombo->RefreshOptions();
|
|
|
|
OnVideoDeviceSelected(VideoDeviceItems.IsEmpty() ? nullptr : VideoDeviceItems[0]);
|
|
|
|
|
|
AudioDevices.Reset();
|
|
AudioDeviceItems.Reset();
|
|
|
|
TArray<FMetaHumanLiveLinkAudioDevice> AudioDevicesArray;
|
|
UMetaHumanLocalLiveLinkSourceBlueprint::GetAudioDevices(AudioDevicesArray);
|
|
|
|
for (const FMetaHumanLiveLinkAudioDevice& AudioDevice : AudioDevicesArray)
|
|
{
|
|
AudioDevices.Add(AudioDevice.Url, AudioDevice);
|
|
AudioDeviceItems.Add(MakeShared<TPair<FString, FString>>(AudioDevice.Name, AudioDevice.Url));
|
|
}
|
|
|
|
AudioDeviceCombo->RefreshOptions();
|
|
|
|
OnAudioDeviceSelected(AudioDeviceItems.IsEmpty() ? nullptr : AudioDeviceItems[0]);
|
|
}
|
|
|
|
void SMetaHumanMediaSourceWidgetImpl::OnVideoDeviceSelected(SMetaHumanStringCombo::FComboItemType InItem)
|
|
{
|
|
VideoDeviceCombo->CurrentItem = InItem;
|
|
|
|
VideoTracks.Reset();
|
|
VideoTrackItems.Reset();
|
|
|
|
if (InItem)
|
|
{
|
|
TArray<FMetaHumanLiveLinkVideoTrack> VideoTracksArray;
|
|
bool bTimedOut = false;
|
|
UMetaHumanLocalLiveLinkSourceBlueprint::GetVideoTracks(VideoDevices[InItem->Value], VideoTracksArray, bTimedOut);
|
|
|
|
for (const FMetaHumanLiveLinkVideoTrack& VideoTrack : VideoTracksArray)
|
|
{
|
|
VideoTracks.Add(FString::FromInt(VideoTrack.Index), VideoTrack);
|
|
VideoTrackItems.Add(MakeShared<TPair<FString, FString>>(VideoTrack.Name, FString::FromInt(VideoTrack.Index)));
|
|
}
|
|
}
|
|
|
|
VideoTrackCombo->RefreshOptions();
|
|
|
|
if (VideoTrackItems.IsEmpty())
|
|
{
|
|
OnVideoTrackSelected(nullptr);
|
|
}
|
|
else
|
|
{
|
|
for (int32 VideoTrack = 0; VideoTrack < VideoTrackItems.Num(); ++VideoTrack)
|
|
{
|
|
OnVideoTrackSelected(VideoTrackItems[VideoTrack]);
|
|
|
|
if (!VideoTrackFormatItems.IsEmpty())
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SMetaHumanMediaSourceWidgetImpl::OnVideoTrackSelected(SMetaHumanStringCombo::FComboItemType InItem)
|
|
{
|
|
VideoTrackCombo->CurrentItem = InItem;
|
|
|
|
VideoTrackFormats.Reset();
|
|
VideoTrackFormatItems.Reset();
|
|
|
|
if (InItem)
|
|
{
|
|
TArray<FMetaHumanLiveLinkVideoFormat> VideoFormatsArray;
|
|
bool bTimedOut = false;
|
|
UMetaHumanLocalLiveLinkSourceBlueprint::GetVideoFormats(VideoTracks[InItem->Value], VideoFormatsArray, bTimedOut, bVideoTrackFormatItemsFiltered);
|
|
|
|
for (const FMetaHumanLiveLinkVideoFormat& VideoFormat : VideoFormatsArray)
|
|
{
|
|
VideoTrackFormats.Add(FString::FromInt(VideoFormat.Index), VideoFormat);
|
|
VideoTrackFormatItems.Add(MakeShared<TPair<FString, FString>>(VideoFormat.Name, FString::FromInt(VideoFormat.Index)));
|
|
}
|
|
}
|
|
|
|
VideoTrackFormatCombo->RefreshOptions();
|
|
|
|
OnVideoTrackFormatSelected(VideoTrackFormatItems.IsEmpty() ? nullptr : VideoTrackFormatItems[0]);
|
|
}
|
|
|
|
void SMetaHumanMediaSourceWidgetImpl::OnVideoTrackFormatSelected(SMetaHumanStringCombo::FComboItemType InItem)
|
|
{
|
|
VideoTrackFormatCombo->CurrentItem = InItem;
|
|
}
|
|
|
|
void SMetaHumanMediaSourceWidgetImpl::OnAudioDeviceSelected(SMetaHumanStringCombo::FComboItemType InItem)
|
|
{
|
|
AudioDeviceCombo->CurrentItem = InItem;
|
|
|
|
AudioTracks.Reset();
|
|
AudioTrackItems.Reset();
|
|
|
|
if (InItem)
|
|
{
|
|
TArray<FMetaHumanLiveLinkAudioTrack> AudioTracksArray;
|
|
bool bTimedOut = false;
|
|
UMetaHumanLocalLiveLinkSourceBlueprint::GetAudioTracks(AudioDevices[InItem->Value], AudioTracksArray, bTimedOut);
|
|
|
|
for (const FMetaHumanLiveLinkAudioTrack& AudioTrack : AudioTracksArray)
|
|
{
|
|
AudioTracks.Add(FString::FromInt(AudioTrack.Index), AudioTrack);
|
|
AudioTrackItems.Add(MakeShared<TPair<FString, FString>>(AudioTrack.Name, FString::FromInt(AudioTrack.Index)));
|
|
}
|
|
}
|
|
|
|
AudioTrackCombo->RefreshOptions();
|
|
|
|
OnAudioTrackSelected(AudioTrackItems.IsEmpty() ? nullptr : AudioTrackItems[0]);
|
|
}
|
|
|
|
void SMetaHumanMediaSourceWidgetImpl::OnAudioTrackSelected(SMetaHumanStringCombo::FComboItemType InItem)
|
|
{
|
|
AudioTrackCombo->CurrentItem = InItem;
|
|
|
|
AudioTrackFormats.Reset();
|
|
AudioTrackFormatItems.Reset();
|
|
|
|
if (InItem)
|
|
{
|
|
TArray<FMetaHumanLiveLinkAudioFormat> AudioFormatsArray;
|
|
bool bTimedOut = false;
|
|
UMetaHumanLocalLiveLinkSourceBlueprint::GetAudioFormats(AudioTracks[InItem->Value], AudioFormatsArray, bTimedOut);
|
|
|
|
for (const FMetaHumanLiveLinkAudioFormat& AudioFormat : AudioFormatsArray)
|
|
{
|
|
AudioTrackFormats.Add(FString::FromInt(AudioFormat.Index), AudioFormat);
|
|
AudioTrackFormatItems.Add(MakeShared<TPair<FString, FString>>(AudioFormat.Name, FString::FromInt(AudioFormat.Index)));
|
|
}
|
|
}
|
|
|
|
AudioTrackFormatCombo->RefreshOptions();
|
|
|
|
OnAudioTrackFormatSelected(AudioTrackFormatItems.IsEmpty() ? nullptr : AudioTrackFormatItems[0]);
|
|
}
|
|
|
|
void SMetaHumanMediaSourceWidgetImpl::OnAudioTrackFormatSelected(SMetaHumanStringCombo::FComboItemType InItem)
|
|
{
|
|
AudioTrackFormatCombo->CurrentItem = InItem;
|
|
}
|
|
|
|
bool SMetaHumanMediaSourceWidgetImpl::CanCreate() const
|
|
{
|
|
if (MediaType == SMetaHumanMediaSourceWidget::EMediaType::Video || MediaType == SMetaHumanMediaSourceWidget::EMediaType::VideoAndAudio)
|
|
{
|
|
return VideoDeviceCombo->CurrentItem.IsValid() && (IsBundle() || (VideoTrackCombo->CurrentItem.IsValid() && VideoTrackFormatCombo->CurrentItem.IsValid()));
|
|
}
|
|
else
|
|
{
|
|
return AudioDeviceCombo->CurrentItem.IsValid() && (IsBundle() || (AudioTrackCombo->CurrentItem.IsValid() && AudioTrackFormatCombo->CurrentItem.IsValid()));
|
|
}
|
|
}
|
|
|
|
bool SMetaHumanMediaSourceWidgetImpl::IsBundle() const
|
|
{
|
|
SMetaHumanStringCombo::FComboItemType CurrentItem;
|
|
|
|
if (MediaType == SMetaHumanMediaSourceWidget::EMediaType::Video || MediaType == SMetaHumanMediaSourceWidget::EMediaType::VideoAndAudio)
|
|
{
|
|
CurrentItem = VideoDeviceCombo->CurrentItem;
|
|
}
|
|
else
|
|
{
|
|
CurrentItem = AudioDeviceCombo->CurrentItem;
|
|
}
|
|
|
|
return CurrentItem.IsValid() ? CurrentItem->Value.StartsWith(UE::MetaHuman::Pipeline::FMediaPlayerNode::BundleURL) : false;
|
|
}
|
|
|
|
EVisibility SMetaHumanMediaSourceWidgetImpl::GetTrackVisibility() const
|
|
{
|
|
return EVisibility::Visible;
|
|
}
|
|
|
|
EVisibility SMetaHumanMediaSourceWidgetImpl::GetAdvancedVisibility() const
|
|
{
|
|
return EVisibility::Visible;
|
|
}
|
|
|
|
bool SMetaHumanMediaSourceWidgetImpl::IsTrackEnabled() const
|
|
{
|
|
return !IsBundle();
|
|
}
|
|
|
|
FText SMetaHumanMediaSourceWidgetImpl::GetTrackTooltip() const
|
|
{
|
|
return IsBundle() ? LOCTEXT("DisabledBundle", "Disabled for Media Bundles") : FText();
|
|
}
|
|
|
|
FMetaHumanMediaSourceCreateParams SMetaHumanMediaSourceWidgetImpl::GetCreateParams() const
|
|
{
|
|
FMetaHumanMediaSourceCreateParams CreateParams;
|
|
|
|
CreateParams.VideoName = VideoDeviceCombo->CurrentItem.IsValid() ? VideoDeviceCombo->CurrentItem->Key : TEXT("");
|
|
CreateParams.VideoURL = VideoDeviceCombo->CurrentItem.IsValid() ? VideoDeviceCombo->CurrentItem->Value : TEXT("");
|
|
CreateParams.VideoTrack = VideoTrackCombo->CurrentItem.IsValid() ? FCString::Atoi(*VideoTrackCombo->CurrentItem->Value) : -1;
|
|
CreateParams.VideoTrackFormat = VideoTrackFormatCombo->CurrentItem.IsValid() ? FCString::Atoi(*VideoTrackFormatCombo->CurrentItem->Value) : -1;
|
|
CreateParams.VideoTrackFormatName = VideoTrackFormatCombo->CurrentItem.IsValid() ? VideoTrackFormatCombo->CurrentItem->Key : TEXT("");
|
|
|
|
CreateParams.AudioName = AudioDeviceCombo->CurrentItem.IsValid() ? AudioDeviceCombo->CurrentItem->Key : TEXT("");
|
|
CreateParams.AudioURL = AudioDeviceCombo->CurrentItem.IsValid() ? AudioDeviceCombo->CurrentItem->Value : TEXT("");
|
|
CreateParams.AudioTrack = AudioTrackCombo->CurrentItem.IsValid() ? FCString::Atoi(*AudioTrackCombo->CurrentItem->Value) : -1;
|
|
CreateParams.AudioTrackFormat = AudioTrackFormatCombo->CurrentItem.IsValid() ? FCString::Atoi(*AudioTrackFormatCombo->CurrentItem->Value) : -1;
|
|
CreateParams.AudioTrackFormatName = AudioTrackFormatCombo->CurrentItem.IsValid() ? AudioTrackFormatCombo->CurrentItem->Key : TEXT("");
|
|
|
|
CreateParams.StartTimeout = StartTimeout;
|
|
CreateParams.FormatWaitTime = FormatWaitTime;
|
|
CreateParams.SampleTimeout = SampleTimeout;
|
|
|
|
return CreateParams;
|
|
}
|
|
|
|
|
|
|
|
void SMetaHumanMediaSourceWidget::Construct(const FArguments& InArgs, EMediaType InMediaType)
|
|
{
|
|
Impl = SNew(SMetaHumanMediaSourceWidgetImpl, InMediaType);
|
|
|
|
ChildSlot
|
|
[
|
|
Impl.ToSharedRef()
|
|
];
|
|
}
|
|
|
|
bool SMetaHumanMediaSourceWidget::CanCreate() const
|
|
{
|
|
return Impl->CanCreate();
|
|
}
|
|
|
|
FMetaHumanMediaSourceCreateParams SMetaHumanMediaSourceWidget::GetCreateParams() const
|
|
{
|
|
return Impl->GetCreateParams();
|
|
}
|
|
|
|
TSharedPtr<SWidget> SMetaHumanMediaSourceWidget::GetWidget(EWidgetType InWidgetType) const
|
|
{
|
|
TSharedPtr<SWidget> Widget;
|
|
|
|
switch (InWidgetType)
|
|
{
|
|
case EWidgetType::VideoDevice:
|
|
Widget = Impl->VideoDeviceCombo;
|
|
break;
|
|
|
|
case EWidgetType::VideoTrack:
|
|
Widget = Impl->VideoTrackCombo;
|
|
break;
|
|
|
|
case EWidgetType::VideoTrackFormat:
|
|
Widget = Impl->VideoTrackFormatCombo;
|
|
break;
|
|
|
|
case EWidgetType::AudioDevice:
|
|
Widget = Impl->AudioDeviceCombo;
|
|
break;
|
|
|
|
case EWidgetType::AudioTrack:
|
|
Widget = Impl->AudioTrackCombo;
|
|
break;
|
|
|
|
case EWidgetType::AudioTrackFormat:
|
|
Widget = Impl->AudioTrackFormatCombo;
|
|
break;
|
|
|
|
case EWidgetType::Filtered:
|
|
Widget = Impl->FilteredWidget;
|
|
break;
|
|
|
|
case EWidgetType::StartTimeout:
|
|
Widget = Impl->StartTimeoutWidget;
|
|
break;
|
|
|
|
case EWidgetType::FormatWaitTime:
|
|
Widget = Impl->FormatWaitTimeWidget;
|
|
break;
|
|
|
|
case EWidgetType::SampleTimeout:
|
|
Widget = Impl->SampleTimeoutWidget;
|
|
break;
|
|
|
|
default:
|
|
check(false);
|
|
break;
|
|
}
|
|
|
|
return Widget;
|
|
}
|
|
|
|
void SMetaHumanMediaSourceWidget::Repopulate()
|
|
{
|
|
Impl->PopulateDevices();
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|