UE4 音频频谱转换曲线工具

最新推荐文章于 2023-11-20 14:05:24 发布
最新推荐文章于 2023-11-20 14:05:24 发布
阅读量777 收藏 1
点赞数
分类专栏： Ue4 文章标签： ue4 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t1370620378/article/details/128190760
版权

因为工作上的需求，需要将音频可视化，虽然niagara可以实现音频可视化，但是是全局音频，并且需要在蓝图中使用，所以需要一个工具将频谱图转换为曲线在蓝图中使用。其实ue是提供了一个转换的工具的，但是不知为何是private的无法外部使用，遂将其拷出进行扩展使用。
使用时可能会出现崩溃（使用的工具库的原因），可以多试几次。

使用最后一个函数GetSoundAmplitudeAndFrequencyCurve，即可将频谱图转换为曲线FloatCurve资源。

其他参数不言自明，AmplitudeBuckets, SpectrumWidth两个参数需要注意一下，参数本质的含义注释已经解释了，实际使用中这两个参数决定了曲线有多少个key值（GetAmplitude，CalculateFrequencySpectrum，是以时间为横轴，振幅、频率为纵轴），GetSoundAmplitudeAndFrequencyCurve得到的曲线是以频率为横轴，振幅为纵轴，key数以两者少的key数为准，所以使用时最好两个值相等。

频率图 x时间y频率
频率图 x时间y频率
振幅图 x时间y振幅
在这里插入图片描述
频谱图 x频率y振幅
频率图 x时间y频率

拿到频谱图，可视化使用过程中应该是程序和音频同步放，然后根据时间得到频率和振幅，将频率划分区间，一定频率的区间显示一定频率的振幅。。应该是这样吧大概。

最后，如果重复调用函数生成曲线为空的话，删除原资源重新生成一下就好。

代码使用时注意要引入额外的模块

// Fill out your copyright notice in the Description page of Project Settings.

using UnrealBuildTool;

public class MyProjectEditor : ModuleRules
{
	public MyProjectEditor(ReadOnlyTargetRules Target) : base(Target)
	{
		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
	
		PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "MyProject"});

		PrivateDependencyModuleNames.AddRange(new string[]
		{
			"AssetRegistry", "UnrealEd", "GameProjectGeneration", "ContentBrowser", "EditorScriptingUtilities",
			"SoundVisualizations"
		});
		
		if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
		{
			// VS2015 updated some of the CRT definitions but not all of the Windows SDK has been updated to match.
			// Microsoft provides this shim library to enable building with VS2015 until they fix everything up.
			//@todo: remove when no longer neeeded (no other code changes should be necessary).
			if (Target.WindowsPlatform.bNeedsLegacyStdioDefinitionsLib)
			{
				PublicSystemLibraries.Add("legacy_stdio_definitions.lib");
			}
		}

		AddEngineThirdPartyPrivateStaticDependencies(Target, "Kiss_FFT");

		// Uncomment if you are using Slate UI
		// PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
		
		// Uncomment if you are using online features
		// PrivateDependencyModuleNames.Add("OnlineSubsystem");

		// To include OnlineSubsystemSteam, add it to the plugins section in your uproject file with the Enabled attribute set to true
	}
}


// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "SoundVisualizationStaticsTool.generated.h"

/**
* 
*/
UCLASS()
class USoundVisualizationStaticsTool : public UBlueprintFunctionLibrary
{
GENERATED_BODY()

protected:
static void CalculateFrequencySpectrum(USoundWave* SoundWave, const bool bSplitChannels, const float StartTime, const float TimeLength, const int32 SpectrumWidth, TArray< TArray<float> >& OutSpectrums);

/** Calculates the frequency spectrum for a window of time for the SoundWave
* @param SoundWave - The wave to generate the spectrum for
* @param Channel - The channel of the sound to calculate.  Specify 0 to combine channels together
* @param StartTime - The beginning of the window to calculate the spectrum of
* @param TimeLength - The duration of the window to calculate the spectrum of
* @param SpectrumWidth - How wide the spectrum is.  The total samples in the window are divided evenly across the spectrum width.
* @return OutSpectrum - The resulting spectrum
*/
UFUNCTION(BlueprintCallable, Category="SoundVisualization")
static void CalculateFrequencySpectrum(USoundWave* SoundWave, int32 Channel, float StartTime, float TimeLength, int32 SpectrumWidth, TArray<float>& OutSpectrum);

static void GetAmplitude(USoundWave* SoundWave, const bool bSplitChannels, const float StartTime, const float TimeLength, const int32 AmplitudeBuckets, TArray< TArray<float> >& OutAmplitudes);

/** Gathers the amplitude of the wave data for a window of time for the SoundWave
* @param SoundWave - The wave to get samples from
* @param Channel - The channel of the sound to get.  Specify 0 to combine channels together
* @param StartTime - The beginning of the window to get the amplitude from
* @param TimeLength - The duration of the window to get the amplitude from
* @param AmplitudeBuckets - How many samples to divide the data in to.  The amplitude is averaged from the wave samples for each bucket
* @return OutAmplitudes - The resulting amplitudes
*/
UFUNCTION(BlueprintCallable, Category="SoundVisualization")
static void GetAmplitude(USoundWave* SoundWave, int32 Channel, float StartTime, float TimeLength, int32 AmplitudeBuckets, TArray<float>& OutAmplitudes);

UFUNCTION(BlueprintCallable, Category="SoundVisualization")
static bool GetSoundAmplitudeAndFrequencyCurve(USoundWave* SoundWave, int32 Channel, float StartTime, float TimeLength, int32 AmplitudeBuckets, int32 SpectrumWidth, FString Floder = "SoundData");
};


// Fill out your copyright notice in the Description page of Project Settings.


#include "SoundVisualizationStaticsTool.h"

#include <functional>

#include "Audio.h"
#include "ContentBrowserModule.h"
#include "IContentBrowserSingleton.h"
#include "AssetRegistry/AssetRegistryModule.h"
#include "Factories/CurveFactory.h"
#include "Sound/SoundWave.h"
#include "Kiss_FFT/kiss_fft129/tools/kiss_fftnd.h"
#include "Kiss_FFT/kiss_fft129/kiss_fft.h"
// Copyright Epic Games, Inc. All Rights Reserved.

/
// USoundVisualizationStatics

DEFINE_LOG_CATEGORY_STATIC(LogSoundVisualization, Log, All);

void USoundVisualizationStaticsTool::GetAmplitude(USoundWave* SoundWave, int32 Channel, float StartTime, float TimeLength, int32 AmplitudeBuckets, TArray<float>& OutAmplitudes)
{
	OutAmplitudes.Empty();

#if WITH_EDITORONLY_DATA
	if (SoundWave)
	{
		if (Channel >= 0)
		{
			TArray< TArray<float> > Amplitudes;

			GetAmplitude(SoundWave, (Channel != 0), StartTime, TimeLength, AmplitudeBuckets, Amplitudes);

			if(Channel == 0)
			{
				OutAmplitudes = Amplitudes[0];
			}
			else if (Channel <= Amplitudes.Num())
			{
				OutAmplitudes = Amplitudes[Channel-1];
			}
			else
			{
				UE_LOG(LogSoundVisualization, Warning, TEXT("Requested channel %d, sound only has %d channels"), SoundWave->NumChannels);
			}
		}
		else
		{
			UE_LOG(LogSoundVisualization, Warning, TEXT("Invalid Channel (%d)"), Channel);
		}
	}
#else
	UE_LOG(LogSoundVisualization, Warning, TEXT("Get Amplitude does not work for cooked builds yet."));
#endif
}

bool USoundVisualizationStaticsTool::GetSoundAmplitudeAndFrequencyCurve(USoundWave* SoundWave, int32 Channel,
	float StartTime, float TimeLength, int32 AmplitudeBuckets, int32 SpectrumWidth, FString Floder)
{
	if (AmplitudeBuckets == 0 || SpectrumWidth == 0 || SoundWave == nullptr)
	{
		return false;
	}

	TArray<float> AmplitudeData;
	TArray<float> FrequencyData;
	
	GetAmplitude(SoundWave, Channel, StartTime, TimeLength, AmplitudeBuckets, AmplitudeData);
	CalculateFrequencySpectrum(SoundWave, Channel, StartTime, TimeLength, SpectrumWidth, FrequencyData);

	FAssetRegistryModule* const AssetRegistryModule = FModuleManager::Get().GetModulePtr<FAssetRegistryModule>("AssetRegistry");
	IAssetRegistry& AssetRegistry = AssetRegistryModule->GetRegistry();

	FString Path = "/Game";
	if (Floder.Len() != 0)
	{
		Path = Path / Floder;
	}

	FPlatformFileManager::Get().GetPlatformFile().CreateDirectoryTree(* FPaths::ConvertRelativePathToFull(Path));

	const FString AmplitudeName = "CF_" + SoundWave->GetName() + "_Amp";
	const FString FrequencyName = "CF_" + SoundWave->GetName() + "_Fre";
	const FString AmpAFreName = "CF_" + SoundWave->GetName() + "_FreAmp";
	const FString AmplitudePackage = Path / AmplitudeName;
	const FString FrequencyPackage = Path / FrequencyName;
	const FString AmpAFrePackage = Path / AmpAFreName;
	
	UPackage* AmpPackage = CreatePackage(*AmplitudePackage);
	UPackage* FrePackage = CreatePackage(*FrequencyPackage);
	UPackage* AmpAFrePack = CreatePackage(*AmpAFrePackage);
	
	UCurveFloatFactory* CurveFloatFactory = NewObject<UCurveFloatFactory>();
	CurveFloatFactory->SupportedClass = UCurveFloat::StaticClass();
	
	auto GeneratedImpl = [&](UPackage* Package, const FString& ResName, const TArray<float>& Data,
		std::function<void(UCurveFloat*, int Index)> Func)
	{
		UCurveFloat* CurveFloat = Cast<UCurveFloat>(CurveFloatFactory->FactoryCreateNew(UCurveFloat::StaticClass(),
			Package, *ResName, RF_Standalone | RF_Public, nullptr, nullptr));
	
		for (int i = 0; i < Data.Num(); ++i)
		{
			//const float Key = i * TimeSplit;
			//CurveFloat->FloatCurve.AddKey(Key, Data[i]);
			Func(CurveFloat, i);
		}

		AssetRegistry.AssetCreated(CurveFloat);
		Package->SetDirtyFlag(true);
		CurveFloat->MarkPackageDirty();
		CurveFloat->PostEditChange();
	
		TArray<UObject*> Assets;
		Assets.Add(CurveFloat);

		FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().LoadModuleChecked<FContentBrowserModule>("ContentBrowser");
		ContentBrowserModule.Get().SyncBrowserToAssets(Assets);
	};
	
	const float TimeSplit_Amp = (TimeLength - StartTime) / AmplitudeBuckets;
	const float TimeSplit_Frq = (TimeLength - StartTime) / SpectrumWidth;
	
	GeneratedImpl(AmpPackage, AmplitudeName, AmplitudeData, [&](UCurveFloat* CurveFloat, int Index)
	{
		CurveFloat->FloatCurve.AddKey(TimeSplit_Amp * Index, AmplitudeData[Index]);
	});
	GeneratedImpl(FrePackage, FrequencyName, FrequencyData, [&](UCurveFloat* CurveFloat, int Index)
	{
		CurveFloat->FloatCurve.AddKey(TimeSplit_Frq * Index, FrequencyData[Index]);
	});
	GeneratedImpl(AmpAFrePack, AmpAFreName, FrequencyData, [&](UCurveFloat* CurveFloat, int Index)
	{
		if (FrequencyData.IsValidIndex(Index) && AmplitudeData.IsValidIndex(Index))
			CurveFloat->FloatCurve.AddKey(FrequencyData[Index], AmplitudeData[Index]);
	});
	return true;
}


void USoundVisualizationStaticsTool::GetAmplitude(USoundWave* SoundWave, const bool bSplitChannels, const float StartTime, const float TimeLength, const int32 AmplitudeBuckets, TArray< TArray<float> >& OutAmplitudes)
{

	OutAmplitudes.Empty();

#if WITH_EDITORONLY_DATA
	const int32 NumChannels = SoundWave->NumChannels;
	if (AmplitudeBuckets > 0 && NumChannels > 0)
	{
		// Setup the output data
		OutAmplitudes.AddZeroed((bSplitChannels ? NumChannels : 1));
		for (int32 ChannelIndex = 0; ChannelIndex < OutAmplitudes.Num(); ++ChannelIndex)
		{
			OutAmplitudes[ChannelIndex].AddZeroed(AmplitudeBuckets);
		}

		// check if there is any raw sound data
		if( SoundWave->RawData.GetBulkDataSize() > 0 )
		{
			// Lock raw wave data.
			uint8* RawWaveData = ( uint8* )SoundWave->RawData.Lock( LOCK_READ_ONLY );
			int32 RawDataSize = SoundWave->RawData.GetBulkDataSize();
			FWaveModInfo WaveInfo;

			// parse the wave data
			if( WaveInfo.ReadWaveHeader( RawWaveData, RawDataSize, 0 ) )
			{
				uint32 SampleCount = 0;
				uint32 SampleCounts[10] = {0};

				uint32 FirstSample = *WaveInfo.pSamplesPerSec * StartTime;
				uint32 LastSample = *WaveInfo.pSamplesPerSec * (StartTime + TimeLength);

				if (NumChannels <= 2)
				{
					SampleCount = WaveInfo.SampleDataSize / (2 * NumChannels);
				}
				else
				{
					for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
					{
						SampleCounts[ChannelIndex] = (SoundWave->ChannelSizes[ChannelIndex] / 2);
						SampleCount = FMath::Max(SampleCount, SampleCounts[ChannelIndex]);
						SampleCounts[ChannelIndex] -= FirstSample;
					}
				}

				FirstSample = FMath::Min(SampleCount, FirstSample);
				LastSample = FMath::Min(SampleCount, LastSample);

				const int16* SamplePtr = reinterpret_cast<const int16*>(WaveInfo.SampleDataStart);
				if (NumChannels <= 2)
				{
					SamplePtr += FirstSample;
				}

				uint32 SamplesPerAmplitude = (LastSample - FirstSample) / AmplitudeBuckets;
				uint32 ExcessSamples = (LastSample - FirstSample) % AmplitudeBuckets;

				for (int32 AmplitudeIndex = 0; AmplitudeIndex < AmplitudeBuckets; ++AmplitudeIndex)
				{
					if (NumChannels <= 2)
					{
						int64 SampleSum[2] = {0};
						uint32 SamplesToRead = SamplesPerAmplitude + (ExcessSamples-- > 0 ? 1 : 0);
						for (uint32 SampleIndex = 0; SampleIndex < SamplesToRead; ++SampleIndex)
						{
							for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
							{
								SampleSum[ChannelIndex] += FMath::Abs(*SamplePtr);
								SamplePtr++;
							}
						}
						for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
						{
							OutAmplitudes[(bSplitChannels ? ChannelIndex : 0)][AmplitudeIndex] = SampleSum[ChannelIndex] / (float)SamplesToRead;
						}
					}
					else
					{
						uint32 SamplesRead = 0;
						int64 SampleSum = 0;
						uint32 SamplesToRead = SamplesPerAmplitude + (ExcessSamples-- > 0 ? 1 : 0);
						for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
						{
							uint32 SamplesToReadForChannel = FMath::Min(SamplesToRead, SampleCounts[ChannelIndex]);

							if (SamplesToReadForChannel > 0)
							{
								if (bSplitChannels)
								{
									SampleSum = 0;
								}

								for (uint32 SampleIndex = 0; SampleIndex < SamplesToReadForChannel; ++SampleIndex)
								{
									SampleSum += FMath::Abs(*(SamplePtr + FirstSample + SampleIndex + SoundWave->ChannelOffsets[ChannelIndex] / 2));
								}

								if (bSplitChannels)
								{
									OutAmplitudes[ChannelIndex][AmplitudeIndex] = SampleSum / (float)SamplesToReadForChannel;
								}
								SamplesRead += SamplesToReadForChannel;
								SampleCounts[ChannelIndex] -= SamplesToReadForChannel;
							}
						}

						if (!bSplitChannels)
						{
							OutAmplitudes[0][AmplitudeIndex] = SampleSum / (float)SamplesRead;
						}

						FirstSample += SamplesToRead;
					}
				}
			}

			SoundWave->RawData.Unlock();
		}
	}
#else
	UE_LOG(LogSoundVisualization, Warning, TEXT("Get Amplitude does not work for cooked builds yet."));
#endif
}

void USoundVisualizationStaticsTool::CalculateFrequencySpectrum(USoundWave* SoundWave, int32 Channel, float StartTime, float TimeLength, int32 SpectrumWidth, TArray<float>& OutSpectrum)
{
	OutSpectrum.Empty();

#if WITH_EDITORONLY_DATA
	if (SoundWave)
	{
		if (SpectrumWidth <= 0)
		{
			UE_LOG(LogSoundVisualization, Warning, TEXT("Invalid SpectrumWidth (%d)"), SpectrumWidth);
		}
		else if (Channel < 0)
		{
			UE_LOG(LogSoundVisualization, Warning, TEXT("Invalid Channel (%d)"), Channel);
		}
		else
		{
			TArray< TArray<float> > Spectrums;

			CalculateFrequencySpectrum(SoundWave, (Channel != 0), StartTime, TimeLength, SpectrumWidth, Spectrums);

			if(Channel == 0)
			{
				OutSpectrum = Spectrums[0];
			}
			else if (Channel <= Spectrums.Num())
			{
				OutSpectrum = Spectrums[Channel-1];
			}
			else
			{
				UE_LOG(LogSoundVisualization, Warning, TEXT("Requested channel %d, sound only has %d channels"), SoundWave->NumChannels);
			}
		}
	}
#else	
	UE_LOG(LogSoundVisualization, Warning, TEXT("Calculate Frequency Spectrum does not work for cooked builds yet."));
#endif
}

float GetFFTInValue(const int16 SampleValue, const int16 SampleIndex, const int16 SampleCount)
{
	float FFTValue = SampleValue;

	// Apply the Hann window
	FFTValue *= 0.5f * (1 - FMath::Cos(2 * PI * SampleIndex / (SampleCount - 1)));

	return FFTValue;
}

void USoundVisualizationStaticsTool::CalculateFrequencySpectrum(USoundWave* SoundWave, const bool bSplitChannels, const float StartTime, const float TimeLength, const int32 SpectrumWidth, TArray< TArray<float> >& OutSpectrums)
{

	OutSpectrums.Empty();

#if WITH_EDITORONLY_DATA
	const int32 NumChannels = SoundWave->NumChannels;
	if (SpectrumWidth > 0 && NumChannels > 0)
	{
		// Setup the output data
		OutSpectrums.AddZeroed((bSplitChannels ? NumChannels : 1));
		for (int32 ChannelIndex = 0; ChannelIndex < OutSpectrums.Num(); ++ChannelIndex)
		{
			OutSpectrums[ChannelIndex].AddZeroed(SpectrumWidth);
		}

		// check if there is any raw sound data
		if( SoundWave->RawData.GetBulkDataSize() > 0 )
		{
			// Lock raw wave data.
			uint8* RawWaveData = ( uint8* )SoundWave->RawData.Lock( LOCK_READ_ONLY );
			int32 RawDataSize = SoundWave->RawData.GetBulkDataSize();
			FWaveModInfo WaveInfo;

			// parse the wave data
			if( WaveInfo.ReadWaveHeader( RawWaveData, RawDataSize, 0 ) )
			{
				int32 SampleCount = 0;
				int32 SampleCounts[10] = {0};

				int32 FirstSample = *WaveInfo.pSamplesPerSec * StartTime;
				int32 LastSample = *WaveInfo.pSamplesPerSec * (StartTime + TimeLength);

				if (NumChannels <= 2)
				{
					SampleCount = WaveInfo.SampleDataSize / (2 * NumChannels);
				}
				else
				{
					for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
					{
						SampleCounts[ChannelIndex] = (SoundWave->ChannelSizes[ChannelIndex] / 2);
						SampleCount = FMath::Max(SampleCount, SampleCounts[ChannelIndex]);
						SampleCounts[ChannelIndex] -= FirstSample;
					}
				}

				FirstSample = FMath::Min(SampleCount, FirstSample);
				LastSample = FMath::Min(SampleCount, LastSample);

				int32 SamplesToRead = LastSample - FirstSample;

				if (SamplesToRead > 0)
				{
					// Shift the window enough so that we get a power of 2
					int32 PoT = 2;
					while (SamplesToRead > PoT) PoT *= 2;
					FirstSample = FMath::Max(0, FirstSample - (PoT - SamplesToRead) / 2);
					SamplesToRead = PoT;
					LastSample = FirstSample + SamplesToRead;
					if (LastSample > SampleCount)
					{
						FirstSample = LastSample - SamplesToRead;
					}
					if (FirstSample < 0)
					{
						// If we get to this point we can't create a reasonable window so just give up
						SoundWave->RawData.Unlock();
						return;
					}

					kiss_fft_cpx* buf[10] = { 0 }; 
					kiss_fft_cpx* out[10] = { 0 };

					int32 Dims[1] = { SamplesToRead };
					kiss_fftnd_cfg stf = kiss_fftnd_alloc(Dims, 1, 0, NULL, NULL);


					const int16* SamplePtr = reinterpret_cast<const int16*>(WaveInfo.SampleDataStart);
					if (NumChannels <= 2)
					{
						for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
						{
							buf[ChannelIndex] = (kiss_fft_cpx *)KISS_FFT_MALLOC(sizeof(kiss_fft_cpx) * SamplesToRead);
							out[ChannelIndex] = (kiss_fft_cpx *)KISS_FFT_MALLOC(sizeof(kiss_fft_cpx) * SamplesToRead);
						}

						SamplePtr += (FirstSample * NumChannels);

						for (int32 SampleIndex = 0; SampleIndex < SamplesToRead; ++SampleIndex)
						{
							for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
							{
								buf[ChannelIndex][SampleIndex].r = GetFFTInValue(*SamplePtr, SampleIndex, SamplesToRead);
								buf[ChannelIndex][SampleIndex].i = 0.f;

								SamplePtr++;
							}
						}
					}
					else
					{
						for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
						{
							// Drop this channel out if there isn't the power of 2 number of samples available
							if (SampleCounts[ChannelIndex] >= SamplesToRead)
							{
								buf[ChannelIndex] = (kiss_fft_cpx *)KISS_FFT_MALLOC(sizeof(kiss_fft_cpx) * SamplesToRead);
								out[ChannelIndex] = (kiss_fft_cpx *)KISS_FFT_MALLOC(sizeof(kiss_fft_cpx) * SamplesToRead);

								for (int32 SampleIndex = 0; SampleIndex < SamplesToRead; ++SampleIndex)
								{
									buf[ChannelIndex][SampleIndex].r = GetFFTInValue(*(SamplePtr + FirstSample + SampleIndex + SoundWave->ChannelOffsets[ChannelIndex] / 2), SampleIndex, SamplesToRead);
									buf[ChannelIndex][SampleIndex].i = 0.f;
								}
							}
						}
					}

					for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
					{
						if (buf[ChannelIndex])
						{
							kiss_fftnd(stf, buf[ChannelIndex], out[ChannelIndex]);
						}
					}

					int32 SamplesPerSpectrum = SamplesToRead / (2 * SpectrumWidth);
					int32 ExcessSamples = SamplesToRead % (2 * SpectrumWidth);

					int32 FirstSampleForSpectrum = 1;
					for (int32 SpectrumIndex = 0; SpectrumIndex < SpectrumWidth; ++SpectrumIndex)
					{
						static bool doLog = false;

						int32 SamplesRead = 0;
						double SampleSum = 0;
						int32 SamplesForSpectrum = SamplesPerSpectrum + (ExcessSamples-- > 0 ? 1 : 0);
						if (doLog) UE_LOG(LogSoundVisualization, Log, TEXT("----"));
						for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
						{
							if (out[ChannelIndex])
							{
								if (bSplitChannels)
								{
									SampleSum = 0;
								}

								for (int32 SampleIndex = 0; SampleIndex < SamplesForSpectrum; ++SampleIndex)
								{
									float PostScaledR = out[ChannelIndex][FirstSampleForSpectrum + SampleIndex].r * 2.f / SamplesToRead;
									float PostScaledI = out[ChannelIndex][FirstSampleForSpectrum + SampleIndex].i * 2.f / SamplesToRead;
									//float Val = FMath::Sqrt(FMath::Square(PostScaledR) + FMath::Square(PostScaledI));
									float Val = 10.f * FMath::LogX(10.f, FMath::Square(PostScaledR) + FMath::Square(PostScaledI));
									if (doLog) UE_LOG(LogSoundVisualization, Log, TEXT("%.2f"), Val);
									SampleSum += Val;
								}

								if (bSplitChannels)
								{
									OutSpectrums[ChannelIndex][SpectrumIndex] = (float)(SampleSum / SamplesForSpectrum);
								}
								SamplesRead += SamplesForSpectrum;
							}
						}

						if (!bSplitChannels)
						{
							OutSpectrums[0][SpectrumIndex] = (float)(SampleSum / SamplesRead);
						}

						FirstSampleForSpectrum += SamplesForSpectrum;
					}

					KISS_FFT_FREE(stf);
					for (int32 ChannelIndex = 0; ChannelIndex < NumChannels; ++ChannelIndex)
					{
						if (buf[ChannelIndex])
						{
							KISS_FFT_FREE(buf[ChannelIndex]);
							KISS_FFT_FREE(out[ChannelIndex]);
						}
					}
				}
			}

			SoundWave->RawData.Unlock();
		}
	}
#else
	UE_LOG(LogSoundVisualization, Warning, TEXT("Calculate Frequency Spectrum does not work for cooked builds yet."));
#endif
}

个人总结，不足之处见谅，欢迎指点。

什么时候才能坚持做好一件事啊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mixamo动画转化到UE4工具.rar
01-05
Mixamo动画转化到UE4工具.rar
ue4 音频可视化插件
12-01
ue4中实现ogg音频读取，可用于制作ktvvr等音频可视化项目
UE4批量打包PAK文件工具源码
12-19
UE4批量打包PAK文件工具，可以多选文件打包，也可以直接打包文件夹工具的源码，可直接运行的工具查看https://download.csdn.net/download/weixin_43872129/12354756
UE4&5解包游戏资源的工具
02-26
帮助用户解包UE4&5游戏资源的工具
声音加速_最终幻想7：重制版的美妙声音
weixin_35373786的博客
01-09 1105
访问 https://locationsound.cn看近2000篇影视录音内容SQUARE ENIX公司最近为PS4 发布了《最终幻想7:重制版》，这是1997年发行的深受喜爱的RPG经典游戏的更新和重新构想的版本，并且本作的拥趸们都喜欢它绝妙的配乐和视觉效果。重制版并没有严格地讲述原版故事。相反，这是一个更深入的探索，分部分讲述。因此，第1部分关注Midgar；第2部分(现已全面开发...
关于SU（SeismicUnix）的使用——数字信号处理部分
WangCY的博客
10-18 6248
一、绘制频谱曲线 首先我们需要一个数据，我们构造出一个模拟单炮数据data.su 用suwind将数据变成单道数据,这里我从单炮数据中抽取关键字tracl=60的数据 ： suwind&amp;amp;amp;amp;amp;lt;data.su key=tracl max=60 min= 60&amp;amp;amp;amp;amp;gt;singleline.su 对singleline.su作傅里叶变换（sufft），将振幅谱显示出来即可。命令行代码如下： suff..
根据音频绘制频谱
最新发布
weixin_42448623的博客
11-20 717
注意：在有些设备（iphone7）上，录音和播放不能同时进行, 在一些iphone上 同时进行回导致 播放声音音量较小。注意：在有些设备上，
ue4 播放程序化生成的声音
pzh的博客
10-28 3193
首先了解音频有几个重要的概念: 采样频率：每秒钟采样次数,采样率越高，数字波形的形状越接近原始模拟波形，通常的采用频率有22050，44100，48000，96000 采样位数：采样声波时，为每个采样指定最接近原始声波振幅的振幅值。 采样位数提高可提供更多可能的振幅值，产生更大的动态范围、更低的噪声基准和更高的保真度。通常的采样位数有8bit，16bit，24bit，32bit。 通道数：即...
用 python 对音乐（音频）进行处理，画出相应的音谱图
郑德帅
02-26 1万+
将一段wav格式的音频转换成音谱图，最终实现效果如下 整体过程思路： 1.导模块，相应模块自行安装 import wave as we import matplotlib.pyplot as plt import numpy as np from scipy.io import wavfile 2. 对音频文件进行处理 filename = '1.wav' ...
UE基础篇六：音频
yuchenwuhen的专栏
11-17 395
动画通知允许您在动画中的特定点触发事件。您可以通过许多不同的方式使用它们。例如，您可以创建一个通知来产生粒子效果。在这个游戏中，松饼一落地就会出现重启按钮。但是，使用通知，您可以让它出现在死亡动画的结尾。在本教程中，您将动画通知在每只脚触地时播放声音。Sound Cue 是一种资产，可让您操纵多种声音并将它们组合起来。然后，您可以将 Sound Cue 视为它自己的声音。在任何可以使用常规声音的地方，您都可以使用 Sound Cue。
Mixamo动画重定向工具（直接转换成UE4骨骼匹配动画）
11-20
Mixamo动画重定向工具（直接转换成UE4骨骼匹配动画） 教程详见我的博客：https://blog.csdn.net/ttm2d/article/details/121440749
UNREAL ENGINE 4.12 正式发布！下载地址
LANGZI7758521的专栏
07-09 1万+
UNREAL ENGINE 4.12 正式发布！ Alexander Paschall 在 June 1, 2016 | 功能新闻社区 Share on Facebook Share on Twitter Share on Google+ Share on LinkedIn 此版本内含虚幻引擎 4 的数百个更新，以及 GitHub 虚幻引擎开发者社区提交的 1
【UE】场景内播放视频、音频
ChaoChao66666的博客
03-23 1796
游戏运行时能够播放视频和音频，音频会随着玩家接近播放源的远近调整音量大小
UE4 音频学习笔记
liuzhimu2018的博客
11-30 3382
UE4音频的要求和规范 1，音频文件需要十六位，采样率可以任选 2，支持的格式有WAV， AIFF， FLAC，Ogg Voribis，WAV是最常用的。 3，UE4支持环绕声格式5.1或者Ambisonic 4，在进行音频制作之前要先进行规划，首先要对文件进行分类，然后设置文件的命名规范，通过使用统一的命名规范，可以在后期管理过程中，以及在制作过程中很方便的进行控制。 制作环境音效 1，在制作环境音效的时候可以直接把一个SoundWave拖入到场景中，可以不使用SoundCue 2，环境音效一般都会有根据
UE4 音频可视化
walsyker的博客
02-06 793
2021-2-6 注意导入音频格式为wav，勾选分析FFT；
音频特征---波形图
热门推荐
booklijian的专栏
06-26 2万+
音频信号（Audio）是带有语音、音乐和音效的有规律的声波的频率、幅度变化的信息载体。根据声波的特征，可以把音频信息分类为规则音频和不规则声音。规则音频可视为一种连续变化的模拟信号，并使用一条连续的曲线（即声波）来表示。 当前人工智能日益成熟并在越来越多的领域获得应用，其中语音识别，音频鉴别等就是其中一个很重要的应用领域。这些核心算法的第一步都是需要将音频文件数据化，提取其中的音频特征。本文主要以其中的一个基本特征 波形为例来进行介绍。在此之前，我们首先来了解音频的一些基本概念...
【Audio音频兴趣拓展】如何调试频响曲线？
crow_ch的博客
01-06 2838
（1）获取通过调试记录1生成标准标准频率和响度的音频文件的方法获取常用的频率的0dB文件，常用频率有500Hz, 800Hz ,1000Hz,2000Hz,5000Hz,10KHz,15KHz （2）持续播放特定频率0dB音源输出，在外放端搭起滤波器，并使用示波器显示实时波形，分析其幅度：是否削波；是否出现毛刺杂音等。 （3）针对（2）测得的特定频率与幅度对应关系，调整音频曲线。 附加小...
Qt/C++编写音频播放示例（带音频曲线/振幅/传输/录制等）
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
11-03 1167
1. 自动计算音频振幅，绘制音频振幅曲线和音频数据曲线。 2. 支持音频录制，可选音频输入设备、采样频率、通道等参数，Qt5默认保存wav格式，Qt6默认保存mp3格式，Qt6可选wma、aac等格式。 3. 提供音频发送示例，将采集到的音频数据通过TCP或UDP发出去。 4. 提供音频接收示例，将网络TCP或UDP收到的音频数据播放出来。 5. 音频发送和接收，相当于语音对讲，响应延迟小于0.2s，实时性极高。 6. 可以编译成手机版本，形成手机和电脑等端语音对讲功能。 7. 可以拓展作为视频监控的语音对
UE4 好玩的插件推荐----------eXi's Sound Visualization Plugin
m0_37376873的博客
09-17 1966
关于音乐可视化，编辑器插件中就有官方推出的声音可视化的插件。可惜功能实在太少，新手用起来很蹩脚。某日在国外虚幻4论坛上了发现了这款EXI大佬做的声音可视化的插件，用了之后倍感舒服，特此来推荐下 附上插件的github上地址：HTTPS：//github.com/eXifreXi/eXiSoundVis 这个插件只接受ogg格式音乐文件，wave格式会使客户端崩溃（我使用的事4.19） 这是音...
ue4相机速度变化曲线
06-03
在UE4中，相机速度的变化曲线可以使用相机的插值器来控制。以下是一些示例代码，可以在相机移动时应用这些插值器。 1. 匀速运动： ```cpp FVector NewLocation = FMath::Lerp(CurrentLocation, TargetLocation, DeltaTime * Speed); ``` 2. 缓慢加速，然后匀速行驶，最后缓慢减速： ```cpp float CurrentSpeed = FMath::FInterpTo(CurrentSpeed, Speed, DeltaTime, Acceleration); FVector NewLocation = CurrentLocation + ForwardVector * CurrentSpeed * DeltaTime; ``` 其中，Acceleration 是加速度，可以根据需要进行调整。 3. 弹性运动： ```cpp float Spring = 100.0f; float Damping = 20.0f; FVector Velocity = (TargetLocation - CurrentLocation) * Spring - CameraVelocity * Damping; FVector NewLocation = CurrentLocation + Velocity * DeltaTime; CameraVelocity += Velocity * DeltaTime; ``` 其中，Spring 是弹性系数，Damping 是阻尼系数。这种方式可以模拟相机的弹性运动，效果比较自然。 以上是一些常见的相机速度变化曲线，可以根据需要进行调整和组合。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值