UVoiceFunctionLibrary 클래스 참조

음성 파일 변환과 명령 문자열 파싱 유틸리티를 제공합니다. 더 자세히 ...

#include <UVoiceFunctionLibrary.h>

UVoiceFunctionLibrary에 대한 상속 다이어그램 :

UVoiceFunctionLibrary에 대한 협력 다이어그램:

정적 Public 멤버 함수
static TArray< uint8 >	ConvertPCM2WAV (const TArray< uint8 > &InPCMData, int32 InSampleRate, int32 InChannel, int32 InBitsPerSample)
	PCM 데이터를 WAV 포맷으로 감쌉니다.
static TArray< uint8 >	ConvertStereoToMono (const TArray< uint8 > &InStereoPCMData)
	스테레오 PCM 데이터를 모노로 변환합니다. (좌우 채널 평균)
static USoundWaveProcedural *	CreateProceduralSoundWaveFromWavData (const TArray< uint8 > &AudioData)
	절차형 사운드 웨이브를 생성해 스트리밍 재생에 사용합니다.
static USoundWave *	CreateSoundWaveFromWavData (const TArray< uint8 > &WavData)
	WAV 데이터를 기반으로 사운드 웨이브 객체를 생성합니다.
static TArray< uint8 >	ResampleAudio (const TArray< uint8 > &InPCMData, int32 InSampleRate, int32 OutSampleRate, int32 InNumChannels)
	PCM 오디오 데이터를 다른 샘플레이트로 리샘플링합니다.
static FString	SaveWavToFile (TArray< uint8 > &InWavData, const FString &InFileName=TEXT(""))
	WAV 데이터를 파일로 저장합니다.

상세한 설명

음성 파일 변환과 명령 문자열 파싱 유틸리티를 제공합니다.

UVoiceFunctionLibrary.h 파일의 14 번째 라인에서 정의되었습니다.

멤버 함수 문서화

ConvertPCM2WAV()

TArray< uint8 > UVoiceFunctionLibrary::ConvertPCM2WAV ( const TArray< uint8 > &  InPCMData, int32  InSampleRate, int32  InChannel, int32  InBitsPerSample  )

static

PCM 데이터를 WAV 포맷으로 감쌉니다.

매개변수

InPCMData	[in] 원본 PCM 바이트 배열입니다.
InSampleRate	[in] 샘플레이트(Hz)입니다.
InChannel	[in] 채널 수입니다.
InBitsPerSample	[in] 샘플당 비트 수입니다.

반환값

WAV 헤더가 포함된 바이트 배열입니다.

UVoiceFunctionLibrary.cpp 파일의 26 번째 라인에서 정의되었습니다.

{
    TArray<uint8> WavData;
 
    const int32 ByteRate   = InSampleRate * InChannel * InBitsPerSample / 8;
    const int32 BlockAlign = InChannel * InBitsPerSample / 8;
    const int32 DataSize   = InPCMData.Num();
    const int32 ChunkSize  = 36 + DataSize;
 
    // RIFF 헤더
    WavData.Append(reinterpret_cast<const uint8*>("RIFF"), 4);
    WavData.Append(reinterpret_cast<const uint8*>(&ChunkSize), 4);
    WavData.Append(reinterpret_cast<const uint8*>("WAVE"), 4);
 
    // fmt chunk
    WavData.Append(reinterpret_cast<const uint8*>("fmt "), 4);
    int32 SubChunk1Size = 16;
    int16 AudioFormat   = 1;
 
    WavData.Append(reinterpret_cast<const uint8*>(&SubChunk1Size), 4);
    WavData.Append(reinterpret_cast<const uint8*>(&AudioFormat), 2);
    WavData.Append(reinterpret_cast<const uint8*>(&InChannel), 2);
    WavData.Append(reinterpret_cast<const uint8*>(&InSampleRate), 4);
    WavData.Append(reinterpret_cast<const uint8*>(&ByteRate), 4);
    WavData.Append(reinterpret_cast<const uint8*>(&BlockAlign), 2);
    WavData.Append(reinterpret_cast<const uint8*>(&InBitsPerSample), 2);
    WavData.Append(reinterpret_cast<const uint8*>("data"), 4);
    WavData.Append(reinterpret_cast<const uint8*>(&DataSize), 4);
 
    WavData.Append(InPCMData);
    return WavData;
}

ConvertStereoToMono()

TArray< uint8 > UVoiceFunctionLibrary::ConvertStereoToMono ( const TArray< uint8 > &  InStereoPCMData )

static

스테레오 PCM 데이터를 모노로 변환합니다. (좌우 채널 평균)

매개변수

InStereoPCMData

[in] 스테레오 PCM 데이터 (16bit, 2채널)

반환값

모노 PCM 데이터 (16bit, 1채널)

UVoiceFunctionLibrary.cpp 파일의 303 번째 라인에서 정의되었습니다.

{
    // PCM 데이터는 int16 형식 (16bit), 스테레오는 [L0, R0, L1, R1, ...] 형태
    const int32 NumSamples = InStereoPCMData.Num() / sizeof(int16);
 
    if (NumSamples % 2 != 0)
    {
        PRINTLOG(TEXT("[ConvertStereoToMono] Invalid stereo PCM data size (not even number of samples)"));
        return InStereoPCMData;
    }
 
    const int16* InSamples = reinterpret_cast<const int16*>(InStereoPCMData.GetData());
    const int32 NumMonoSamples = NumSamples / 2;
 
    TArray<uint8> MonoPCMData;
    MonoPCMData.Reserve(NumMonoSamples * sizeof(int16));
 
    // 좌우 채널 평균으로 모노 생성
    for (int32 i = 0; i < NumMonoSamples; ++i)
    {
        const int16 LeftSample = InSamples[i * 2];      // 왼쪽 채널
        const int16 RightSample = InSamples[i * 2 + 1]; // 오른쪽 채널
 
        // 평균값 계산 (오버플로우 방지)
        const int32 AverageSample = (static_cast<int32>(LeftSample) + static_cast<int32>(RightSample)) / 2;
        const int16 MonoSample = static_cast<int16>(FMath::Clamp(AverageSample, -32768, 32767));
 
        // 결과 버퍼에 추가
        const uint8* SampleBytes = reinterpret_cast<const uint8*>(&MonoSample);
        MonoPCMData.Append(SampleBytes, sizeof(int16));
    }
 
    PRINTLOG(TEXT("[ConvertStereoToMono] Converted %d stereo samples to %d mono samples"), NumSamples, NumMonoSamples);
    return MonoPCMData;
}

다음을 참조함 : PRINTLOG.

CreateProceduralSoundWaveFromWavData()

USoundWaveProcedural * UVoiceFunctionLibrary::CreateProceduralSoundWaveFromWavData ( const TArray< uint8 > &  AudioData )

static

절차형 사운드 웨이브를 생성해 스트리밍 재생에 사용합니다.

매개변수

AudioData

[in] PCM 데이터입니다.

반환값

생성된 USoundWaveProcedural 객체입니다.

UVoiceFunctionLibrary.cpp 파일의 178 번째 라인에서 정의되었습니다.

{
    // VoiceLogs 폴더에 타임스탬프 형식으로 저장
    const FDateTime Now = FDateTime::Now();
    const FString FileName = FString::Printf(TEXT("TTS_Output_%04d%02d%02d_%02d%02d%02d.wav"),
        Now.GetYear(), Now.GetMonth(), Now.GetDay(),
        Now.GetHour(), Now.GetMinute(), Now.GetSecond()
    );
    const FString FolderPath = FPaths::ProjectSavedDir() / VOICE_LOG;
    IFileManager::Get().MakeDirectory(*FolderPath, true);
    const FString SavePath = FolderPath / FileName;
 
    if (!FFileHelper::SaveArrayToFile(AudioData, *SavePath))
    {
        PRINTLOG(TEXT("TTS WAV 저장 실패"));
        return nullptr;
    }
 
    PRINTLOG(TEXT("TTS WAV 저장 완료: %s"), *SavePath);
 
    if (AudioData.Num() < 44)
    {
        PRINTLOG(TEXT("Invalid WAV data (too small)"));
        return nullptr;
    }
 
    const uint8* RawData = AudioData.GetData();
 
    // --- WAV Header Parsing ---
    uint16 NumChannels = ReadUInt16(RawData, 22);
    uint32 SampleRate = ReadUInt32(RawData, 24);
    uint16 BitsPerSample = ReadUInt16(RawData, 34);
 
    // Find the 'data' chunk, as it's not always at a fixed position.
    int32 DataChunkOffset = 36; // Typically after the 'fmt ' chunk.
    while (DataChunkOffset + 8 < AudioData.Num())
    {
        // Read ChunkID as a 4-character string
        const char* ChunkIDStr = (const char*)(RawData + DataChunkOffset);
 
        if (strncmp(ChunkIDStr, "data", 4) == 0)
        {
            break; // Found it
        }
 
        // If not 'data', skip to the next chunk
        uint32 ChunkSize = ReadUInt32(RawData, DataChunkOffset + 4);
        DataChunkOffset += (8 + ChunkSize);
    }
 
    if (DataChunkOffset + 8 >= AudioData.Num())
    {
        PRINTLOG(TEXT("WAV 'data' chunk not found"));
        return nullptr;
    }
 
    const uint32 DataSize = ReadUInt32(RawData, DataChunkOffset + 4);
    const int32 DataStart = DataChunkOffset + 8;
 
    if (DataStart + (int32)DataSize > AudioData.Num())
    {
        PRINTLOG(TEXT("Invalid WAV data chunk size"));
        return nullptr;
    }
    // --- End of WAV Header Parsing ---
 
    USoundWaveProcedural* SoundWave = NewObject<USoundWaveProcedural>();
    if (!SoundWave)
    {
        PRINTLOG(TEXT("Failed to create USoundWaveProcedural"));
        return nullptr;
    }
 
    // Calculate actual duration for one-shot playback
    const float BytesPerSample = BitsPerSample / 8.0f;
    const float ActualDuration = (float)DataSize / (SampleRate * NumChannels * BytesPerSample);
 
    SoundWave->SetSampleRate(SampleRate);
    SoundWave->NumChannels = NumChannels;
    SoundWave->Duration = ActualDuration;
    SoundWave->SoundGroup = ESoundGroup::SOUNDGROUP_Voice;
    SoundWave->bLooping = false;
 
    // Queue the raw PCM data for playback
    SoundWave->QueueAudio(RawData + DataStart, DataSize);
    return SoundWave;
}

다음을 참조함 : PRINTLOG, ReadUInt16(), ReadUInt32(), VOICE_LOG.

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

CreateSoundWaveFromWavData()

USoundWave * UVoiceFunctionLibrary::CreateSoundWaveFromWavData ( const TArray< uint8 > &  WavData )

static

WAV 데이터를 기반으로 사운드 웨이브 객체를 생성합니다.

매개변수

WavData

[in] WAV 형식의 바이트 배열입니다.

반환값

재생 가능한 USoundWave 객체입니다.

UVoiceFunctionLibrary.cpp 파일의 102 번째 라인에서 정의되었습니다.

{
    if (WavData.Num() < 44)
    {
        PRINTLOG( TEXT("Invalid WAV data (too small)"));
        return nullptr;
    }
 
    const uint8* RawData = WavData.GetData();
 
    // WAV Header Parsing
    // ChunkID "RIFF" (0~3)
    // Format "WAVE" (8~11)
    // Subchunk1ID "fmt " (12~15)
    // AudioFormat, NumChannels, SampleRate, ByteRate, BlockAlign, BitsPerSample
    uint16 AudioFormat  = ReadUInt16(RawData, 20);
    uint16 NumChannels  = ReadUInt16(RawData, 22);
    uint32 SampleRate   = ReadUInt32(RawData, 24);
    uint16 BitsPerSample = ReadUInt16(RawData, 34);
 
    // Subchunk2ID "data"는 고정 위치가 아니므로 탐색
    int32 DataChunkOffset = 36;
    while (DataChunkOffset + 8 < WavData.Num())
    {
        uint32 ChunkID =
            RawData[DataChunkOffset] |
            (RawData[DataChunkOffset + 1] << 8) |
            (RawData[DataChunkOffset + 2] << 16) |
            (RawData[DataChunkOffset + 3] << 24);
 
        uint32 ChunkSize = ReadUInt32(RawData, DataChunkOffset + 4);
 
        // 'data' 체크
        if (ChunkID == 'atad') // 'data'를 리틀엔디언 'atad'로 읽음
        {
            break;
        }
 
        // 다음 Chunk로 이동
        DataChunkOffset += (8 + ChunkSize);
    }
 
    if (DataChunkOffset + 8 >= WavData.Num())
    {
        PRINTLOG( TEXT("WAV data chunk not found"));
        return nullptr;
    }
 
    const int32 DataStart = DataChunkOffset + 8;
    const int32 DataSize = WavData.Num() - DataStart;
 
    // SoundWave 생성
    USoundWave* SoundWave = NewObject<USoundWave>();
    if (!SoundWave)
    {
        PRINTLOG( TEXT("Failed to create USoundWave"));
        return nullptr;
    }
 
    SoundWave->SoundGroup = ESoundGroup::SOUNDGROUP_Voice;
    SoundWave->DecompressionType = EDecompressionType::DTYPE_Procedural;
    SoundWave->bLooping = false;
 
    SoundWave->NumChannels   = NumChannels;
    SoundWave->Duration      = (float)DataSize / (SampleRate * NumChannels * (BitsPerSample / 8));
    SoundWave->SetSampleRate(SampleRate);
    SoundWave->RawPCMDataSize = DataSize;
 
    // RawPCMData에 복사
    uint8* PCMData = (uint8*)FMemory::Malloc(DataSize);
    FMemory::Memcpy(PCMData, RawData + DataStart, DataSize);
    SoundWave->RawPCMData = PCMData;
 
    return SoundWave;
}

다음을 참조함 : PRINTLOG, ReadUInt16(), ReadUInt32().

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

ResampleAudio()

TArray< uint8 > UVoiceFunctionLibrary::ResampleAudio ( const TArray< uint8 > &  InPCMData, int32  InSampleRate, int32  OutSampleRate, int32  InNumChannels  )

static

PCM 오디오 데이터를 다른 샘플레이트로 리샘플링합니다.

매개변수

InPCMData	[in] 원본 PCM 데이터 (16bit)
InSampleRate	[in] 원본 샘플레이트
OutSampleRate	[in] 목표 샘플레이트
InNumChannels	[in] 채널 수

반환값

리샘플링된 PCM 데이터

UVoiceFunctionLibrary.cpp 파일의 266 번째 라인에서 정의되었습니다.

{
    if (InSampleRate == OutSampleRate)
        return InPCMData;
 
    // PCM 데이터는 int16 형식
    const int32 NumSamples = InPCMData.Num() / sizeof(int16);
    const int16* InSamples = reinterpret_cast<const int16*>(InPCMData.GetData());
 
    // 리샘플링 비율 계산
    const double ResampleRatio = static_cast<double>(OutSampleRate) / static_cast<double>(InSampleRate);
    const int32 OutNumSamples = FMath::CeilToInt(NumSamples * ResampleRatio);
 
    TArray<uint8> OutPCMData;
    OutPCMData.Reserve(OutNumSamples * sizeof(int16));
 
    // Linear interpolation 리샘플링
    for (int32 i = 0; i < OutNumSamples; ++i)
    {
        const double SourceIndex = i / ResampleRatio;
        const int32 Index0 = FMath::FloorToInt(SourceIndex);
        const int32 Index1 = FMath::Min(Index0 + 1, NumSamples - 1);
        const double Fraction = SourceIndex - Index0;
 
        // Linear interpolation
        const int16 Sample0 = InSamples[Index0];
        const int16 Sample1 = InSamples[Index1];
        const int16 InterpolatedSample = FMath::RoundToInt(Sample0 + (Sample1 - Sample0) * Fraction);
 
        // 결과 버퍼에 추가
        const uint8* SampleBytes = reinterpret_cast<const uint8*>(&InterpolatedSample);
        OutPCMData.Append(SampleBytes, sizeof(int16));
    }
 
    return OutPCMData;
}

SaveWavToFile()

FString UVoiceFunctionLibrary::SaveWavToFile ( TArray< uint8 > &  InWavData, const FString &  InFileName = TEXT("")  )

static

WAV 데이터를 파일로 저장합니다.

매개변수

InWavData	[in,out] 저장할 WAV 데이터입니다.
InFileName	[in] 저장할 파일 이름(비어있으면 임시 파일 생성)입니다.

반환값

실제 저장된 파일 경로입니다.

UVoiceFunctionLibrary.cpp 파일의 64 번째 라인에서 정의되었습니다.

{
    if (InWavData.Num() == 0)
    {
        PRINTLOG( TEXT("WavData is empty, nothing to save."));
        return FString();
    }
 
    FString FileName = InFileName;
    if (FileName.IsEmpty())
    {
        // 날짜 기반 파일명 생성
        const FDateTime Now = FDateTime::Now();
        FileName = FString::Printf(TEXT("Voice_%04d%02d%02d_%02d%02d%02d.wav"),
            Now.GetYear(), Now.GetMonth(), Now.GetDay(),
            Now.GetHour(), Now.GetMinute(), Now.GetSecond()
        );
    }
 
    FString FolderPath = FPaths::ProjectSavedDir() / VOICE_LOG;
    // 폴더 없으면 생성
    IFileManager::Get().MakeDirectory(*FolderPath, true);
 
    FString FullPath = FolderPath / FileName;
    if (FFileHelper::SaveArrayToFile(InWavData, *FullPath))
    {
        // 절대 경로로 변환하여 반환
        FString AbsolutePath = FPaths::ConvertRelativePathToFull(FullPath);
        PRINTLOG( TEXT("Saved WAV file: %s"), *AbsolutePath);
        return AbsolutePath;
    }
    else
    {
        PRINTLOG( TEXT("Failed to save WAV file: %s"), *FullPath);
        return FString();
    }
}

다음을 참조함 : PRINTLOG, VOICE_LOG.

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• Source/Onepiece/Voice/Public/UVoiceFunctionLibrary.h
• Source/Onepiece/Voice/Private/UVoiceFunctionLibrary.cpp